diff --git a/opencl/source/api/api.cpp b/opencl/source/api/api.cpp
index 0fdcdb0e25..e57d9643ba 100644
--- a/opencl/source/api/api.cpp
+++ b/opencl/source/api/api.cpp
@@ -1344,16 +1344,32 @@ cl_program CL_API_CALL clCreateProgramWithBinary(cl_context context,
                    "lengths", lengths,
                    "binaries", binaries,
                    "binaryStatus", binaryStatus);
-    retVal = validateObjects(context, deviceList, *deviceList, binaries, *binaries, lengths, *lengths);
+    Context *pContext = nullptr;
+    retVal = validateObjects(WithCastToInternal(context, &pContext), deviceList, numDevices, binaries, lengths);
     cl_program program = nullptr;
+    ClDeviceVector deviceVector;
+
+    if (retVal == CL_SUCCESS) {
+        for (auto i = 0u; i < numDevices; i++) {
+            auto device = castToObject<ClDevice>(deviceList[i]);
+            if (!device || !pContext->isDeviceAssociated(*device)) {
+                retVal = CL_INVALID_DEVICE;
+                break;
+            }
+            if (lengths[i] == 0 || binaries[i] == nullptr) {
+                retVal = CL_INVALID_VALUE;
+                break;
+            }
+            deviceVector.push_back(device);
+        }
+    }
 
     NEO::FileLoggerInstance().dumpBinaryProgram(numDevices, lengths, binaries);
 
     if (CL_SUCCESS == retVal) {
         program = Program::create(
-            context,
-            numDevices,
-            deviceList,
+            pContext,
+            deviceVector,
             lengths,
             binaries,
             binaryStatus,
diff --git a/opencl/source/program/create.cpp b/opencl/source/program/create.cpp
index 2161d01b0d..67a9ef9ada 100644
--- a/opencl/source/program/create.cpp
+++ b/opencl/source/program/create.cpp
@@ -15,7 +15,7 @@ namespace ProgramFunctions {
 CreateFromILFunc createFromIL = Program::createFromIL<Program>;
 } // namespace ProgramFunctions
 
-template Program *Program::create<Program>(cl_context, cl_uint, const cl_device_id *, const size_t *, const unsigned char **, cl_int *, cl_int &);
+template Program *Program::create<Program>(Context *, const ClDeviceVector &, const size_t *, const unsigned char **, cl_int *, cl_int &);
 template Program *Program::create<Program>(cl_context, cl_uint, const char **, const size_t *, cl_int &);
 template Program *Program::create<Program>(const char *, Context *, ClDevice &, bool, cl_int *);
 template Program *Program::create<Program>(const char *, Context *, Device &, bool, cl_int *);
diff --git a/opencl/source/program/create.inl b/opencl/source/program/create.inl
index 16d01f0cd1..1d132f26da 100644
--- a/opencl/source/program/create.inl
+++ b/opencl/source/program/create.inl
@@ -21,23 +21,23 @@ namespace NEO {
 
 template <typename T>
 T *Program::create(
-    cl_context context,
-    cl_uint numDevices,
-    const cl_device_id *deviceList,
+    Context *pContext,
+    const ClDeviceVector &deviceVector,
     const size_t *lengths,
     const unsigned char **binaries,
     cl_int *binaryStatus,
     cl_int &errcodeRet) {
-    auto pContext = castToObject<Context>(context);
-    DEBUG_BREAK_IF(!pContext);
-
-    auto device = pContext->getDevice(0);
-    ClDeviceVector deviceVector;
-    deviceVector.push_back(device);
     auto program = new T(pContext, false, deviceVector);
 
-    auto retVal = program->createProgramFromBinary(binaries[0], lengths[0], device->getRootDeviceIndex());
+    cl_int retVal = CL_INVALID_PROGRAM;
 
+    for (auto i = 0u; i < deviceVector.size(); i++) {
+        auto device = deviceVector[i];
+        retVal = program->createProgramFromBinary(binaries[i], lengths[i], device->getRootDeviceIndex());
+        if (retVal != CL_SUCCESS) {
+            break;
+        }
+    }
     program->createdFrom = CreatedFrom::BINARY;
 
     if (binaryStatus) {
diff --git a/opencl/source/program/get_info.cpp b/opencl/source/program/get_info.cpp
index ebaf1abfed..132b9cf2b8 100644
--- a/opencl/source/program/get_info.cpp
+++ b/opencl/source/program/get_info.cpp
@@ -31,8 +31,8 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
     size_t numKernels;
     cl_context clContext = context;
     cl_uint clFalse = CL_FALSE;
-    auto rootDeviceIndex = pDevice->getRootDeviceIndex();
     std::vector<cl_device_id> devicesToExpose;
+    StackVec<size_t, 1> binarySizes;
 
     switch (paramName) {
     case CL_PROGRAM_CONTEXT:
@@ -40,25 +40,39 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
         retSize = srcSize = sizeof(clContext);
         break;
 
-    case CL_PROGRAM_BINARIES:
-        packDeviceBinary(rootDeviceIndex);
-        pSrc = buildInfos[rootDeviceIndex].packedDeviceBinary.get();
-        retSize = sizeof(void **);
-        srcSize = buildInfos[rootDeviceIndex].packedDeviceBinarySize;
-        if (paramValue != nullptr) {
-            if (paramValueSize < retSize) {
-                retVal = CL_INVALID_VALUE;
-                break;
-            }
-            paramValueSize = srcSize;
-            paramValue = *(void **)paramValue;
+    case CL_PROGRAM_BINARIES: {
+        auto requiredSize = clDevices.size() * sizeof(const unsigned char **);
+        if (!paramValue) {
+            retSize = requiredSize;
+            srcSize = 0u;
+            break;
         }
-        break;
+        if (paramValueSize < requiredSize) {
+            retVal = CL_INVALID_VALUE;
+            break;
+        }
+        auto outputBinaries = reinterpret_cast<unsigned char **>(paramValue);
+        for (auto i = 0u; i < clDevices.size(); i++) {
+            if (outputBinaries[i] == nullptr) {
+                continue;
+            }
+            auto rootDeviceIndex = clDevices[i]->getRootDeviceIndex();
+            auto binarySize = buildInfos[rootDeviceIndex].packedDeviceBinarySize;
+            memcpy_s(outputBinaries[i], binarySize, buildInfos[rootDeviceIndex].packedDeviceBinary.get(), binarySize);
+        }
+        GetInfo::setParamValueReturnSize(paramValueSizeRet, requiredSize, GetInfoStatus::SUCCESS);
+        return CL_SUCCESS;
+    } break;
 
     case CL_PROGRAM_BINARY_SIZES:
-        packDeviceBinary(rootDeviceIndex);
-        pSrc = &buildInfos[rootDeviceIndex].packedDeviceBinarySize;
-        retSize = srcSize = sizeof(size_t *);
+        for (auto i = 0u; i < clDevices.size(); i++) {
+            auto rootDeviceIndex = clDevices[i]->getRootDeviceIndex();
+            packDeviceBinary(rootDeviceIndex);
+            binarySizes.push_back(buildInfos[rootDeviceIndex].packedDeviceBinarySize);
+        }
+
+        pSrc = binarySizes.data();
+        retSize = srcSize = binarySizes.size() * sizeof(cl_device_id);
         break;
 
     case CL_PROGRAM_KERNEL_NAMES:
diff --git a/opencl/source/program/program.h b/opencl/source/program/program.h
index 1ee6b0d8d4..bb918e05ea 100644
--- a/opencl/source/program/program.h
+++ b/opencl/source/program/program.h
@@ -83,9 +83,8 @@ class Program : public BaseObject<_cl_program> {
     // Create program from binary
     template <typename T = Program>
     static T *create(
-        cl_context context,
-        cl_uint numDevices,
-        const cl_device_id *deviceList,
+        Context *pContext,
+        const ClDeviceVector &deviceVector,
         const size_t *lengths,
         const unsigned char **binaries,
         cl_int *binaryStatus,
@@ -132,7 +131,7 @@ class Program : public BaseObject<_cl_program> {
                            size_t length,
                            cl_int &errcodeRet);
 
-    Program(Context *context, bool isBuiltIn, const ClDeviceVector &clDevices);
+    Program(Context *context, bool isBuiltIn, const ClDeviceVector &clDevicesIn);
     ~Program() override;
 
     Program(const Program &) = delete;
diff --git a/opencl/test/unit_test/api/cl_create_program_with_binary_tests.inl b/opencl/test/unit_test/api/cl_create_program_with_binary_tests.inl
index 4a49a423d5..bea52ecbaf 100644
--- a/opencl/test/unit_test/api/cl_create_program_with_binary_tests.inl
+++ b/opencl/test/unit_test/api/cl_create_program_with_binary_tests.inl
@@ -66,6 +66,115 @@ TEST_F(clCreateProgramWithBinaryTests, GivenCorrectParametersWhenCreatingProgram
     EXPECT_EQ(nullptr, pProgram);
 }
 
+TEST_F(clCreateProgramWithBinaryTests, GivenInvalidInputWhenCreatingProgramWithBinaryThenInvalidValueErrorIsReturned) {
+    cl_program pProgram = nullptr;
+    cl_int binaryStatus = CL_INVALID_VALUE;
+    size_t binarySize = 0;
+    std::string testFile;
+    retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
+
+    ASSERT_EQ(true, fileExists(testFile));
+
+    auto pBinary = loadDataFromFile(
+        testFile.c_str(),
+        binarySize);
+
+    ASSERT_NE(0u, binarySize);
+    ASSERT_NE(nullptr, pBinary);
+
+    const unsigned char *validBinaries[] = {reinterpret_cast<const unsigned char *>(pBinary.get()), reinterpret_cast<const unsigned char *>(pBinary.get())};
+    const unsigned char *invalidBinaries[] = {reinterpret_cast<const unsigned char *>(pBinary.get()), nullptr};
+    size_t validSizeBinaries[] = {binarySize, binarySize};
+    size_t invalidSizeBinaries[] = {binarySize, 0};
+
+    cl_device_id devicesForProgram[] = {testedClDevice, testedClDevice};
+
+    pProgram = clCreateProgramWithBinary(
+        pContext,
+        2,
+        devicesForProgram,
+        validSizeBinaries,
+        invalidBinaries,
+        &binaryStatus,
+        &retVal);
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+    EXPECT_EQ(nullptr, pProgram);
+
+    retVal = CL_INVALID_PROGRAM;
+
+    pProgram = clCreateProgramWithBinary(
+        pContext,
+        2,
+        devicesForProgram,
+        invalidSizeBinaries,
+        validBinaries,
+        &binaryStatus,
+        &retVal);
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+    EXPECT_EQ(nullptr, pProgram);
+
+    pProgram = clCreateProgramWithBinary(
+        pContext,
+        2,
+        devicesForProgram,
+        validSizeBinaries,
+        validBinaries,
+        &binaryStatus,
+        &retVal);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_NE(nullptr, pProgram);
+
+    clReleaseProgram(pProgram);
+}
+
+TEST_F(clCreateProgramWithBinaryTests, GivenDeviceNotAssociatedWithContextWhenCreatingProgramWithBinaryThenInvalidDeviceErrorIsReturned) {
+    cl_program pProgram = nullptr;
+    cl_int binaryStatus = CL_INVALID_VALUE;
+    size_t binarySize = 0;
+    std::string testFile;
+    retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
+
+    ASSERT_EQ(true, fileExists(testFile));
+
+    auto pBinary = loadDataFromFile(
+        testFile.c_str(),
+        binarySize);
+
+    ASSERT_NE(0u, binarySize);
+    ASSERT_NE(nullptr, pBinary);
+
+    const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(pBinary.get())};
+
+    MockClDevice invalidDevice(new MockDevice());
+
+    cl_device_id devicesForProgram[] = {&invalidDevice};
+
+    pProgram = clCreateProgramWithBinary(
+        pContext,
+        1,
+        devicesForProgram,
+        &binarySize,
+        binaries,
+        &binaryStatus,
+        &retVal);
+    EXPECT_EQ(CL_INVALID_DEVICE, retVal);
+    EXPECT_EQ(nullptr, pProgram);
+
+    retVal = CL_INVALID_PROGRAM;
+    devicesForProgram[0] = nullptr;
+
+    pProgram = clCreateProgramWithBinary(
+        pContext,
+        1,
+        devicesForProgram,
+        &binarySize,
+        binaries,
+        &binaryStatus,
+        &retVal);
+    EXPECT_EQ(CL_INVALID_DEVICE, retVal);
+    EXPECT_EQ(nullptr, pProgram);
+}
+
 TEST_F(clCreateProgramWithILTests, GivenInvalidContextWhenCreatingProgramWithIlThenInvalidContextErrorIsReturned) {
     const uint32_t spirv[16] = {0x03022307};
 
diff --git a/opencl/test/unit_test/api/cl_get_program_info_tests.inl b/opencl/test/unit_test/api/cl_get_program_info_tests.inl
index 6dfc7e6b5b..4882525949 100644
--- a/opencl/test/unit_test/api/cl_get_program_info_tests.inl
+++ b/opencl/test/unit_test/api/cl_get_program_info_tests.inl
@@ -168,6 +168,157 @@ TEST_F(clGetProgramInfoTests, GivenIlWhenBuildingProgramThenGetProgramInfoReturn
     EXPECT_EQ(CL_SUCCESS, retVal);
 }
 
+TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBinaryWhenGettingDevicesThenCorrectDevicesAreReturned) {
+    MockUnrestrictiveContextMultiGPU context;
+
+    auto numDevicesForProgram = 2u;
+    cl_device_id devicesForProgram[] = {context.getDevice(1), context.getDevice(3)};
+
+    std::unique_ptr<char[]> pBinary0 = nullptr;
+    std::unique_ptr<char[]> pBinary1 = nullptr;
+    size_t binarySize0 = 0;
+    size_t binarySize1 = 0;
+    std::string testFile;
+    retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
+
+    pBinary0 = loadDataFromFile(
+        testFile.c_str(),
+        binarySize0);
+
+    retrieveBinaryKernelFilename(testFile, "copy_buffer_to_image_", ".bin");
+
+    pBinary1 = loadDataFromFile(
+        testFile.c_str(),
+        binarySize1);
+    ASSERT_NE(0u, binarySize0);
+    ASSERT_NE(0u, binarySize1);
+    ASSERT_NE(nullptr, pBinary0);
+    ASSERT_NE(nullptr, pBinary1);
+
+    EXPECT_NE(binarySize0, binarySize1);
+
+    const unsigned char *binaries[] = {reinterpret_cast<const unsigned char *>(pBinary0.get()), reinterpret_cast<const unsigned char *>(pBinary1.get())};
+    size_t sizeBinaries[] = {binarySize0, binarySize1};
+
+    cl_program pProgram = nullptr;
+
+    cl_int retVal = CL_INVALID_PROGRAM;
+    cl_int binaryStaus = CL_INVALID_PROGRAM;
+
+    pProgram = clCreateProgramWithBinary(
+        &context,
+        numDevicesForProgram,
+        devicesForProgram,
+        sizeBinaries,
+        binaries,
+        &binaryStaus,
+        &retVal);
+
+    EXPECT_NE(nullptr, pProgram);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    cl_uint numDevices;
+    retVal = clGetProgramInfo(pProgram, CL_PROGRAM_NUM_DEVICES, sizeof(numDevices), &numDevices, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_EQ(numDevicesForProgram, numDevices);
+
+    cl_device_id programDevices[2] = {};
+
+    retVal = clGetProgramInfo(pProgram, CL_PROGRAM_DEVICES, numDevices * sizeof(cl_device_id), programDevices, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    for (auto i = 0u; i < numDevices; i++) {
+        EXPECT_EQ(devicesForProgram[i], programDevices[i]);
+    }
+
+    retVal = clReleaseProgram(pProgram);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(clGetProgramInfoTest, GivenMultiDeviceProgramCreatedWithBinaryWhenGettingBinariesThenCorrectBinariesAreReturned) {
+    MockUnrestrictiveContextMultiGPU context;
+
+    auto numDevicesForProgram = 2u;
+    cl_device_id devicesForProgram[] = {context.getDevice(1), context.getDevice(3)};
+
+    std::unique_ptr<char[]> pBinary0 = nullptr;
+    std::unique_ptr<char[]> pBinary1 = nullptr;
+    size_t binarySize0 = 0;
+    size_t binarySize1 = 0;
+    std::string testFile;
+    retrieveBinaryKernelFilename(testFile, "CopyBuffer_simd16_", ".bin");
+
+    pBinary0 = loadDataFromFile(
+        testFile.c_str(),
+        binarySize0);
+
+    retrieveBinaryKernelFilename(testFile, "copy_buffer_to_image_", ".bin");
+
+    pBinary1 = loadDataFromFile(
+        testFile.c_str(),
+        binarySize1);
+    ASSERT_NE(0u, binarySize0);
+    ASSERT_NE(0u, binarySize1);
+    ASSERT_NE(nullptr, pBinary0);
+    ASSERT_NE(nullptr, pBinary1);
+
+    EXPECT_NE(binarySize0, binarySize1);
+
+    const unsigned char *binaries[] = {reinterpret_cast<const unsigned char *>(pBinary0.get()), reinterpret_cast<const unsigned char *>(pBinary1.get())};
+    size_t sizeBinaries[] = {binarySize0, binarySize1};
+
+    cl_program pProgram = nullptr;
+
+    cl_int retVal = CL_INVALID_PROGRAM;
+    cl_int binaryStaus = CL_INVALID_PROGRAM;
+
+    pProgram = clCreateProgramWithBinary(
+        &context,
+        numDevicesForProgram,
+        devicesForProgram,
+        sizeBinaries,
+        binaries,
+        &binaryStaus,
+        &retVal);
+
+    EXPECT_NE(nullptr, pProgram);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    size_t programBinarySizes[2] = {};
+    retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARY_SIZES, numDevicesForProgram * sizeof(size_t), programBinarySizes, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    for (auto i = 0u; i < numDevicesForProgram; i++) {
+        EXPECT_EQ(sizeBinaries[i], programBinarySizes[i]);
+    }
+
+    auto programBinary0 = std::make_unique<unsigned char[]>(binarySize0);
+    memset(programBinary0.get(), 0, binarySize0);
+
+    auto programBinary1 = std::make_unique<unsigned char[]>(binarySize1);
+    memset(programBinary1.get(), 0, binarySize1);
+
+    unsigned char *programBinaries[] = {programBinary0.get(), programBinary1.get()};
+
+    retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARIES, numDevicesForProgram * sizeof(unsigned char *), programBinaries, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    for (auto i = 0u; i < numDevicesForProgram; i++) {
+        for (auto j = 0u; j < programBinarySizes[i]; j++) {
+            EXPECT_EQ(programBinaries[i][j], binaries[i][j]);
+        }
+    }
+
+    memset(programBinary1.get(), 0, binarySize1);
+    programBinaries[0] = nullptr;
+
+    retVal = clGetProgramInfo(pProgram, CL_PROGRAM_BINARIES, numDevicesForProgram * sizeof(unsigned char *), programBinaries, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    for (auto j = 0u; j < programBinarySizes[1]; j++) {
+        EXPECT_EQ(programBinaries[1][j], binaries[1][j]);
+    }
+
+    retVal = clReleaseProgram(pProgram);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
 TEST_F(clGetProgramInfoTests, GivenSPIRVProgramWhenGettingProgramSourceThenReturnNullString) {
     const size_t binarySize = 16;
     const uint32_t spirv[binarySize] = {0x03022307};
diff --git a/opencl/test/unit_test/aub_tests/fixtures/run_kernel_fixture.h b/opencl/test/unit_test/aub_tests/fixtures/run_kernel_fixture.h
index 12d6abdd03..8d8646f964 100644
--- a/opencl/test/unit_test/aub_tests/fixtures/run_kernel_fixture.h
+++ b/opencl/test/unit_test/aub_tests/fixtures/run_kernel_fixture.h
@@ -63,13 +63,11 @@ class RunKernelFixture : public CommandEnqueueAUBFixture {
         EXPECT_NE(nullptr, pSource);
 
         Program *pProgram = nullptr;
-        const cl_device_id device = pClDevice;
 
         const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(pSource.get())};
         pProgram = Program::create(
             context,
-            1,
-            &device,
+            context->getDevices(),
             &sourceSize,
             binaries,
             nullptr,
diff --git a/opencl/test/unit_test/context/driver_diagnostics_tests.h b/opencl/test/unit_test/context/driver_diagnostics_tests.h
index 9a6761ce7c..e2e3e74126 100644
--- a/opencl/test/unit_test/context/driver_diagnostics_tests.h
+++ b/opencl/test/unit_test/context/driver_diagnostics_tests.h
@@ -221,8 +221,8 @@ struct PerformanceHintEnqueueKernelTest : public PerformanceHintEnqueueTest,
 
     void SetUp() override {
         PerformanceHintEnqueueTest::SetUp();
-        cl_device_id device = pPlatform->getClDevice(0);
-        CreateProgramFromBinary(context, &device, "CopyBuffer_simd32");
+        CreateProgramFromBinary(context, context->getDevices(), "CopyBuffer_simd32");
+        cl_device_id device = context->getDevice(0);
         retVal = pProgram->build(1, &device, nullptr, nullptr, nullptr, false);
         ASSERT_EQ(CL_SUCCESS, retVal);
         kernel = Kernel::create<MockKernel>(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal);
@@ -258,7 +258,7 @@ struct PerformanceHintEnqueueKernelPrintfTest : public PerformanceHintEnqueueTes
     void SetUp() override {
         PerformanceHintEnqueueTest::SetUp();
         cl_device_id device = pPlatform->getClDevice(0);
-        CreateProgramFromBinary(context, &device, "printf");
+        CreateProgramFromBinary(context, context->getDevices(), "printf");
         retVal = pProgram->build(1, &device, nullptr, nullptr, nullptr, false);
         ASSERT_EQ(CL_SUCCESS, retVal);
         kernel = Kernel::create(pProgram, *pProgram->getKernelInfo("test"), &retVal);
diff --git a/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h b/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
index 5ff09aee42..da3a618ce4 100644
--- a/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
+++ b/opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
@@ -43,8 +43,8 @@ struct HelloWorldKernelFixture : public ProgramFixture {
             pTestFilename->append(std::to_string(simd));
         }
 
-        cl_device_id device = pDevice;
-        pContext = Context::create<MockContext>(nullptr, ClDeviceVector(&device, 1), nullptr, nullptr, retVal);
+        auto deviceVector = toClDeviceVector(*pDevice);
+        pContext = Context::create<MockContext>(nullptr, deviceVector, nullptr, nullptr, retVal);
         ASSERT_EQ(CL_SUCCESS, retVal);
         ASSERT_NE(nullptr, pContext);
 
@@ -56,18 +56,20 @@ struct HelloWorldKernelFixture : public ProgramFixture {
 
             CreateProgramFromBinary(
                 pContext,
-                &device,
+                deviceVector,
                 *pTestFilename,
                 optionsToProgram);
         } else {
             CreateProgramFromBinary(
                 pContext,
-                &device,
+                deviceVector,
                 *pTestFilename);
         }
 
         ASSERT_NE(nullptr, pProgram);
 
+        cl_device_id device = pDevice;
+
         retVal = pProgram->build(
             1,
             &device,
diff --git a/opencl/test/unit_test/fixtures/program_fixture.cpp b/opencl/test/unit_test/fixtures/program_fixture.cpp
index c86a30780d..64c0758de4 100644
--- a/opencl/test/unit_test/fixtures/program_fixture.cpp
+++ b/opencl/test/unit_test/fixtures/program_fixture.cpp
@@ -41,8 +41,8 @@ void ProgramFixture::CreateProgramWithSource(cl_context context,
     ASSERT_EQ(CL_SUCCESS, retVal);
 }
 
-void ProgramFixture::CreateProgramFromBinary(cl_context context,
-                                             cl_device_id *pDeviceList,
+void ProgramFixture::CreateProgramFromBinary(Context *pContext,
+                                             const ClDeviceVector &deviceVector,
                                              const std::string &binaryFileName,
                                              cl_int &retVal,
                                              const std::string &options) {
@@ -59,24 +59,23 @@ void ProgramFixture::CreateProgramFromBinary(cl_context context,
     ASSERT_NE(nullptr, knownSource);
 
     pProgram = Program::create<MockProgram>(
-        context,
-        1,
-        pDeviceList,
+        pContext,
+        deviceVector,
         &knownSourceSize,
         (const unsigned char **)&knownSource,
         nullptr,
         retVal);
 }
 
-void ProgramFixture::CreateProgramFromBinary(cl_context pContext,
-                                             cl_device_id *pDeviceList,
+void ProgramFixture::CreateProgramFromBinary(Context *pContext,
+                                             const ClDeviceVector &deviceVector,
                                              const std::string &binaryFileName,
                                              const std::string &options) {
     Cleanup();
     cl_int retVal = CL_SUCCESS;
     CreateProgramFromBinary(
         pContext,
-        pDeviceList,
+        deviceVector,
         binaryFileName,
         retVal,
         options);
diff --git a/opencl/test/unit_test/fixtures/program_fixture.h b/opencl/test/unit_test/fixtures/program_fixture.h
index f74c8e3235..374de9b240 100644
--- a/opencl/test/unit_test/fixtures/program_fixture.h
+++ b/opencl/test/unit_test/fixtures/program_fixture.h
@@ -18,14 +18,14 @@ namespace NEO {
 
 class ProgramFixture {
   public:
-    void CreateProgramFromBinary(cl_context context,
-                                 cl_device_id *pDeviceList,
+    void CreateProgramFromBinary(Context *pContext,
+                                 const ClDeviceVector &deviceVector,
                                  const std::string &binaryFileName,
                                  cl_int &retVal,
                                  const std::string &options = "");
 
-    void CreateProgramFromBinary(cl_context pContext,
-                                 cl_device_id *pDeviceList,
+    void CreateProgramFromBinary(Context *pContext,
+                                 const ClDeviceVector &deviceVector,
                                  const std::string &binaryFileName,
                                  const std::string &options = "");
 
diff --git a/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h b/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
index b17d4ca908..25d1463771 100644
--- a/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
+++ b/opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
@@ -91,13 +91,14 @@ class SimpleArgKernelFixture : public ProgramFixture {
         }
 
         cl_device_id device = pDevice;
-        pContext = Context::create<MockContext>(nullptr, ClDeviceVector(&device, 1), nullptr, nullptr, retVal);
+        auto deviceVector = toClDeviceVector(*pDevice);
+        pContext = Context::create<MockContext>(nullptr, deviceVector, nullptr, nullptr, retVal);
         ASSERT_EQ(CL_SUCCESS, retVal);
         ASSERT_NE(nullptr, pContext);
 
         CreateProgramFromBinary(
             pContext,
-            &device,
+            deviceVector,
             testFile);
         ASSERT_NE(nullptr, pProgram);
 
@@ -145,11 +146,10 @@ class SimpleArgNonUniformKernelFixture : public ProgramFixture {
         ProgramFixture::SetUp();
 
         cl_device_id deviceId = device;
-        cl_context clContext = context;
 
         CreateProgramFromBinary(
-            clContext,
-            &deviceId,
+            context,
+            context->getDevices(),
             "simple_nonuniform",
             "-cl-std=CL2.0");
         ASSERT_NE(nullptr, pProgram);
@@ -193,11 +193,10 @@ class SimpleKernelFixture : public ProgramFixture {
         ProgramFixture::SetUp();
 
         cl_device_id deviceId = device;
-        cl_context clContext = context;
         std::string programName("simple_kernels");
         CreateProgramFromBinary(
-            clContext,
-            &deviceId,
+            context,
+            toClDeviceVector(*device),
             programName);
         ASSERT_NE(nullptr, pProgram);
 
@@ -249,13 +248,12 @@ class SimpleKernelStatelessFixture : public ProgramFixture {
     void SetUp(ClDevice *device, Context *context) {
         ProgramFixture::SetUp();
         cl_device_id deviceId = device;
-        cl_context clContext = context;
         DebugManager.flags.DisableStatelessToStatefulOptimization.set(true);
         DebugManager.flags.EnableStatelessToStatefulBufferOffsetOpt.set(false);
 
         CreateProgramFromBinary(
-            clContext,
-            &deviceId,
+            context,
+            toClDeviceVector(*device),
             "stateless_kernel");
         ASSERT_NE(nullptr, pProgram);
 
@@ -300,10 +298,9 @@ class BindlessKernelFixture : public ProgramFixture {
     void createKernel(const std::string &programName, const std::string &kernelName) {
         DebugManager.flags.UseBindlessMode.set(1);
         cl_device_id deviceId = deviceCl;
-        cl_context clContext = contextCl;
         CreateProgramFromBinary(
-            clContext,
-            &deviceId,
+            contextCl,
+            contextCl->getDevices(),
             programName);
         ASSERT_NE(nullptr, pProgram);
 
diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp
index fff4ae4f6a..04df447023 100644
--- a/opencl/test/unit_test/kernel/kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_tests.cpp
@@ -346,7 +346,7 @@ typedef Test<KernelFromBinaryTest> KernelFromBinaryTests;
 TEST_F(KernelFromBinaryTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKernelArgsIsReturned) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "kernel_num_args");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_num_args");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -389,7 +389,7 @@ TEST_F(KernelFromBinaryTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKerne
 TEST_F(KernelFromBinaryTests, WhenRegularKernelIsCreatedThenItIsNotBuiltIn) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "simple_kernels");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_kernels");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -424,7 +424,7 @@ TEST_F(KernelFromBinaryTests, WhenRegularKernelIsCreatedThenItIsNotBuiltIn) {
 TEST_F(KernelFromBinaryTests, givenArgumentDeclaredAsConstantWhenKernelIsCreatedThenArgumentIsMarkedAsReadOnly) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "simple_kernels");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_kernels");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
diff --git a/opencl/test/unit_test/program/program_from_binary.h b/opencl/test/unit_test/program/program_from_binary.h
index 7332b15b9d..513917e0fa 100644
--- a/opencl/test/unit_test/program/program_from_binary.h
+++ b/opencl/test/unit_test/program/program_from_binary.h
@@ -39,9 +39,9 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
         ProgramFixture::SetUp();
 
         if (options.size())
-            CreateProgramFromBinary(pContext, &device, BinaryFileName, options);
+            CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName, options);
         else
-            CreateProgramFromBinary(pContext, &device, BinaryFileName);
+            CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
     }
 
     void TearDown() override {
diff --git a/opencl/test/unit_test/program/program_nonuniform.cpp b/opencl/test/unit_test/program/program_nonuniform.cpp
index 8107430db2..b2611f7707 100644
--- a/opencl/test/unit_test/program/program_nonuniform.cpp
+++ b/opencl/test/unit_test/program/program_nonuniform.cpp
@@ -184,8 +184,8 @@ class ProgramNonUniformTest : public ContextFixture,
 TEST_F(ProgramNonUniformTest, GivenCl21WhenExecutingKernelWithNonUniformThenEnqueueSucceeds) {
     REQUIRE_OCL_21_OR_SKIP(defaultHwInfo);
 
-    CreateProgramFromBinary(pContext, &device, "kernel_data_param");
-    auto mockProgram = (MockProgram *)pProgram;
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
+    auto mockProgram = pProgram;
     ASSERT_NE(nullptr, mockProgram);
 
     mockProgram->setBuildOptions("-cl-std=CL2.1");
@@ -226,7 +226,7 @@ TEST_F(ProgramNonUniformTest, GivenCl21WhenExecutingKernelWithNonUniformThenEnqu
 TEST_F(ProgramNonUniformTest, GivenCl20WhenExecutingKernelWithNonUniformThenEnqueueSucceeds) {
     REQUIRE_OCL_21_OR_SKIP(defaultHwInfo);
 
-    CreateProgramFromBinary(pContext, &device, "kernel_data_param");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
     auto mockProgram = pProgram;
     ASSERT_NE(nullptr, mockProgram);
 
@@ -266,7 +266,7 @@ TEST_F(ProgramNonUniformTest, GivenCl20WhenExecutingKernelWithNonUniformThenEnqu
 }
 
 TEST_F(ProgramNonUniformTest, GivenCl12WhenExecutingKernelWithNonUniformThenInvalidWorkGroupSizeIsReturned) {
-    CreateProgramFromBinary(pContext, &device, "kernel_data_param");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
     auto mockProgram = pProgram;
     ASSERT_NE(nullptr, mockProgram);
 
diff --git a/opencl/test/unit_test/program/program_tests.cpp b/opencl/test/unit_test/program/program_tests.cpp
index 31a6c2b6d5..ceea5d6eb8 100644
--- a/opencl/test/unit_test/program/program_tests.cpp
+++ b/opencl/test/unit_test/program/program_tests.cpp
@@ -254,9 +254,8 @@ TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingNumKern
     size_t paramValue = 0;
     size_t paramValueSize = sizeof(paramValue);
     size_t paramValueSizeRet = 0;
-    cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, BinaryFileName);
+    CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
     MockProgram *p = pProgram;
     p->setBuildStatus(CL_BUILD_NONE);
 
@@ -311,9 +310,8 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
 TEST_P(ProgramFromBinaryTest, GivenProgramWithNoExecutableCodeWhenGettingKernelNamesThenInvalidProgramExecutableErrorIsReturned) {
     size_t paramValueSize = sizeof(size_t *);
     size_t paramValueSizeRet = 0;
-    cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, BinaryFileName);
+    CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
     MockProgram *p = pProgram;
     p->setBuildStatus(CL_BUILD_NONE);
 
@@ -371,10 +369,7 @@ TEST_P(ProgramFromBinaryTest, GivenCorruptedDeviceWhenGettingBuildStatusThenInva
     size_t paramValueSize = sizeof(buildStatus);
     size_t paramValueSizeRet = 0;
 
-    cl_device_id device = pClDevice;
-    CreateProgramFromBinary(pContext, &device, BinaryFileName);
-    MockProgram *p = pProgram;
-    p->setDevice(&pClDevice->getDevice());
+    CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
 
     retVal = pProgram->getBuildInfo(
         reinterpret_cast<ClDevice *>(pContext),
@@ -615,7 +610,7 @@ TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlo
     EXPECT_EQ(globalVarSize, 0u);
 
     // Set GlobalVariableTotalSize as 1024
-    CreateProgramFromBinary(pContext, &device, BinaryFileName);
+    CreateProgramFromBinary(pContext, pContext->getDevices(), BinaryFileName);
     MockProgram *p = pProgram;
     ProgramInfo programInfo;
 
@@ -1426,7 +1421,7 @@ class CommandStreamReceiverMock : public UltCommandStreamReceiver<FamilyType> {
 HWTEST_F(PatchTokenTests, givenKernelRequiringConstantAllocationWhenMakeResidentIsCalledThenConstantAllocationIsMadeResident) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "test_constant_memory");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "test_constant_memory");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -1495,7 +1490,7 @@ HWTEST_F(PatchTokenTests, givenKernelRequiringConstantAllocationWhenMakeResident
 TEST_F(PatchTokenTests, WhenBuildingProgramThenGwsIsSet) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "kernel_data_param");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -1519,7 +1514,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenGwsIsSet) {
 TEST_F(PatchTokenTests, WhenBuildingProgramThenLwsIsSet) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "kernel_data_param");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -1554,7 +1549,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenConstantKernelArgsAreAvailable) {
     // PATCH_TOKEN_STATELESS_CONSTANT_MEMORY_OBJECT_KERNEL_ARGUMENT
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "test_basic_constant");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "test_basic_constant");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -1597,7 +1592,7 @@ TEST_F(PatchTokenTests, GivenVmeKernelWhenBuildingKernelThenArgAvailable) {
     // PATCH_TOKEN_INLINE_VME_SAMPLER_INFO token indicates a VME kernel.
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "vme_kernels");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "vme_kernels");
 
     ASSERT_NE(nullptr, pProgram);
     retVal = pProgram->build(
@@ -1652,9 +1647,8 @@ TEST(ProgramFromBinaryTests, givenBinaryWithInvalidICBEThenErrorIsReturned) {
     {
         const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(&binHeader)};
         MockContext context;
-        cl_device_id deviceId = context.getDevice(0);
 
-        std::unique_ptr<Program> pProgram(Program::create<Program>(&context, 0, &deviceId, &binSize, binaries, nullptr, retVal));
+        std::unique_ptr<Program> pProgram(Program::create<Program>(&context, context.getDevices(), &binSize, binaries, nullptr, retVal));
         EXPECT_EQ(nullptr, pProgram.get());
         EXPECT_EQ(CL_INVALID_BINARY, retVal);
     }
@@ -1714,7 +1708,7 @@ using ProgramWithDebugSymbolsTests = Test<ProgramSimpleFixture>;
 TEST_F(ProgramWithDebugSymbolsTests, GivenProgramCreatedWithDashGOptionWhenGettingProgramBinariesThenDebugDataIsIncluded) {
     cl_device_id device = pClDevice;
 
-    CreateProgramFromBinary(pContext, &device, "CopyBuffer_simd16", "-g");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "CopyBuffer_simd16", "-g");
 
     ASSERT_NE(nullptr, pProgram);
 
@@ -2369,10 +2363,9 @@ TEST_F(ProgramTests, givenProgramCreatedFromIntermediateBinaryRepresentationWhen
     const uint32_t spirv[16] = {0x03022307};
     cl_int errCode = 0;
     cl_device_id deviceId = pClDevice;
-    cl_context ctx = pContext;
     size_t lengths = sizeof(spirv);
     const unsigned char *binaries[1] = {reinterpret_cast<const unsigned char *>(spirv)};
-    auto prog = Program::create<MockProgram>(ctx, 1U, &deviceId, &lengths, binaries, nullptr, errCode);
+    auto prog = Program::create<MockProgram>(pContext, pContext->getDevices(), &lengths, binaries, nullptr, errCode);
     ASSERT_NE(nullptr, prog);
     auto debugVars = NEO::getIgcDebugVars();
     debugVars.forceBuildFailure = true;
@@ -2911,7 +2904,7 @@ TEST_F(ProgramBinTest, givenPrintProgramBinaryProcessingTimeSetWhenBuildProgramT
     testing::internal::CaptureStdout();
 
     cl_device_id device = pClDevice;
-    CreateProgramFromBinary(pContext, &device, "kernel_data_param");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "kernel_data_param");
 
     auto retVal = pProgram->build(
         1,
diff --git a/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp b/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
index 224cbb3da8..442d85f060 100644
--- a/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
+++ b/opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
@@ -52,8 +52,8 @@ class ProgramWithBlockKernelsTest : public ContextFixture,
 };
 
 TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuildingThenKernelInfosHaveCorrectNames) {
-    CreateProgramFromBinary(pContext, &device, "simple_block_kernel", "-cl-std=CL2.0");
-    auto mockProgram = (MockProgram *)pProgram;
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
+    auto mockProgram = pProgram;
     ASSERT_NE(nullptr, mockProgram);
 
     retVal = mockProgram->build(
@@ -91,7 +91,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuil
 }
 
 TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLinkedThenBlockKernelsAreSeparated) {
-    CreateProgramFromBinary(pContext, &device, "simple_block_kernel", "-cl-std=CL2.0");
+    CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
     const char *buildOptions = "-cl-std=CL2.0";
 
     overwriteBuiltInBinaryName(
@@ -101,7 +101,7 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsLink
     ASSERT_NE(nullptr, pProgram);
 
     EXPECT_EQ(CL_SUCCESS, retVal);
-    Program *programLinked = new Program(pContext, false, toClDeviceVector(*pPlatform->getClDevice(0)));
+    Program *programLinked = new Program(pContext, false, pContext->getDevices());
     cl_program program = pProgram;
 
     retVal = pProgram->compile(1, &device, buildOptions, 0, nullptr, nullptr, nullptr, nullptr);