Report failure given Compiler Library Load failed for L0

- Return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE given the Compiler
  cannot be loaded.
- Print dlopen and LoadLibrary error strings given Debug Print Messages
  are enabled.

Related-To: LOCI-1313

Signed-off-by: Spruit, Neil R <[email protected]>

Author: nrspruit

level_zero/core/source/device/device.h

@@ -106,7 +106,7 @@ struct Device : _ze_device_handle_t {
 
     inline ze_device_handle_t toHandle() { return this; }
 
-    static Device *create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint32_t currentDeviceMask, bool isSubDevice);
+    static Device *create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint32_t currentDeviceMask, bool isSubDevice, ze_result_t *returnValue);
 
     virtual NEO::PreemptionMode getDevicePreemptionMode() const = 0;
     virtual const NEO::DeviceInfo &getDeviceInfo() const = 0;

level_zero/core/source/device/device_imp.cpp

@@ -587,7 +587,7 @@ uint32_t DeviceImp::getMaxNumHwThreads() const { return maxNumHwThreads; }
 
 const NEO::HardwareInfo &DeviceImp::getHwInfo() const { return neoDevice->getHardwareInfo(); }
 
-Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint32_t currentDeviceMask, bool isSubDevice) {
+Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint32_t currentDeviceMask, bool isSubDevice, ze_result_t *returnValue) {
     auto device = new DeviceImp;
     UNRECOVERABLE_IF(device == nullptr);
 
@@ -629,7 +629,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
             ze_device_handle_t subDevice = Device::create(driverHandle,
                                                           device->neoDevice->getDeviceById(i),
                                                           0,
-                                                          true);
+                                                          true, returnValue);
             if (subDevice == nullptr) {
                 return nullptr;
             }
@@ -646,6 +646,8 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
             auto sipType = NEO::SipKernel::getSipKernelType(hwInfo.platform.eRenderCoreFamily, neoDevice->getDebugger());
             NEO::initSipKernel(sipType, *neoDevice);
         }
+    } else {
+        *returnValue = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
     }
 
     auto supportDualStorageSharedMemory = neoDevice->getMemoryManager()->isLocalMemorySupported(device->neoDevice->getRootDeviceIndex());
@@ -660,10 +662,10 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
         cmdQueueDesc.flags = 0;
         cmdQueueDesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
         cmdQueueDesc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
-        ze_result_t returnValue = ZE_RESULT_SUCCESS;
+        ze_result_t resultValue = ZE_RESULT_SUCCESS;
         device->pageFaultCommandList =
             CommandList::createImmediate(
-                device->neoDevice->getHardwareInfo().platform.eProductFamily, device, &cmdQueueDesc, true, NEO::EngineGroupType::RenderCompute, returnValue);
+                device->neoDevice->getHardwareInfo().platform.eProductFamily, device, &cmdQueueDesc, true, NEO::EngineGroupType::RenderCompute, resultValue);
     }
 
     if (device->getSourceLevelDebugger()) {

level_zero/core/source/driver/driver.cpp

@@ -55,7 +55,7 @@ void DriverImp::initialize(ze_result_t *result) {
     auto neoDevices = NEO::DeviceFactory::createDevices(*executionEnvironment);
     executionEnvironment->decRefInternal();
     if (!neoDevices.empty()) {
-        GlobalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables);
+        GlobalDriverHandle = DriverHandle::create(std::move(neoDevices), envVariables, result);
         if (GlobalDriverHandle != nullptr) {
             *result = ZE_RESULT_SUCCESS;
 

level_zero/core/source/driver/driver_handle.h

@@ -86,7 +86,7 @@ struct DriverHandle : _ze_driver_handle_t {
     DriverHandle &operator=(const DriverHandle &) = delete;
     DriverHandle &operator=(DriverHandle &&) = delete;
 
-    static DriverHandle *create(std::vector<std::unique_ptr<NEO::Device>> devices, const L0EnvVariables &envVariables);
+    static DriverHandle *create(std::vector<std::unique_ptr<NEO::Device>> devices, const L0EnvVariables &envVariables, ze_result_t *returnValue);
 };
 
 } // namespace L0

level_zero/core/source/driver/driver_handle_imp.cpp

@@ -202,6 +202,7 @@ ze_result_t DriverHandleImp::initialize(std::vector<std::unique_ptr<NEO::Device>
 
     bool multiOsContextDriver = false;
     for (auto &neoDevice : neoDevices) {
+        ze_result_t returnValue = ZE_RESULT_SUCCESS;
         if (!neoDevice->getHardwareInfo().capabilityTable.levelZeroSupported) {
             continue;
         }
@@ -226,10 +227,13 @@ ze_result_t DriverHandleImp::initialize(std::vector<std::unique_ptr<NEO::Device>
         this->deviceBitfields.insert({neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield()});
 
         auto pNeoDevice = neoDevice.release();
-        auto device = Device::create(this, pNeoDevice, pNeoDevice->getExecutionEnvironment()->rootDeviceEnvironments[pNeoDevice->getRootDeviceIndex()]->deviceAffinityMask, false);
+        auto device = Device::create(this, pNeoDevice, pNeoDevice->getExecutionEnvironment()->rootDeviceEnvironments[pNeoDevice->getRootDeviceIndex()]->deviceAffinityMask, false, &returnValue);
         this->devices.push_back(device);
 
         multiOsContextDriver |= device->isMultiDeviceCapable();
+        if (returnValue != ZE_RESULT_SUCCESS) {
+            return returnValue;
+        }
     }
 
     if (this->devices.size() == 0) {
@@ -254,7 +258,7 @@ ze_result_t DriverHandleImp::initialize(std::vector<std::unique_ptr<NEO::Device>
     return ZE_RESULT_SUCCESS;
 }
 
-DriverHandle *DriverHandle::create(std::vector<std::unique_ptr<NEO::Device>> devices, const L0EnvVariables &envVariables) {
+DriverHandle *DriverHandle::create(std::vector<std::unique_ptr<NEO::Device>> devices, const L0EnvVariables &envVariables, ze_result_t *returnValue) {
     DriverHandleImp *driverHandle = new DriverHandleImp;
     UNRECOVERABLE_IF(nullptr == driverHandle);
 
@@ -264,6 +268,7 @@ DriverHandle *DriverHandle::create(std::vector<std::unique_ptr<NEO::Device>> dev
     ze_result_t res = driverHandle->initialize(std::move(devices));
     if (res != ZE_RESULT_SUCCESS) {
         delete driverHandle;
+        *returnValue = res;
         return nullptr;
     }
 

level_zero/core/test/unit_tests/fixtures/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2020 Intel Corporation
+# Copyright (C) 2020-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -15,7 +15,7 @@ set(L0_FIXTURES_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/module_fixture.h
 )
 
-add_library(${TARGET_NAME} OBJECT ${L0_FIXTURES_SOURCES})
+add_library(${TARGET_NAME} OBJECT ${L0_FIXTURES_SOURCES} ${IGDRCL_SRCS_tests_compiler_mocks})
 
 target_include_directories(${TARGET_NAME} PRIVATE
                            $<TARGET_PROPERTY:gmock-gtest,INTERFACE_INCLUDE_DIRECTORIES>

level_zero/core/test/unit_tests/fixtures/device_fixture.h

@@ -12,6 +12,8 @@
 #include "shared/test/common/helpers/default_hw_info.h"
 #include "shared/test/common/mocks/mock_device.h"
 
+#include "opencl/test/unit_test/mocks/mock_compilers.h"
+
 #include "level_zero/core/source/context/context_imp.h"
 #include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
 
@@ -22,6 +24,7 @@ struct Device;
 namespace ult {
 
 struct DeviceFixture {
+    NEO::MockCompilerEnableGuard compilerMock = NEO::MockCompilerEnableGuard(true);
     virtual void SetUp();    // NOLINT(readability-identifier-naming)
     virtual void TearDown(); // NOLINT(readability-identifier-naming)
 
@@ -32,6 +35,7 @@ struct DeviceFixture {
 };
 
 struct MultiDeviceFixture {
+    NEO::MockCompilerEnableGuard compilerMock = NEO::MockCompilerEnableGuard(true);
     virtual void SetUp();    // NOLINT(readability-identifier-naming)
     virtual void TearDown(); // NOLINT(readability-identifier-naming)
 

level_zero/core/test/unit_tests/fixtures/host_pointer_manager_fixture.h

@@ -13,6 +13,8 @@
 #include "shared/test/common/helpers/default_hw_info.h"
 #include "shared/test/common/mocks/mock_device.h"
 
+#include "opencl/source/os_interface/os_inc_base.h"
+#include "opencl/test/unit_test/mocks/mock_compilers.h"
 #include "opencl/test/unit_test/mocks/mock_memory_operations_handler.h"
 
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
@@ -25,6 +27,7 @@ namespace ult {
 
 struct HostPointerManagerFixure {
     void SetUp() {
+        NEO::MockCompilerEnableGuard mock(true);
         NEO::DeviceVector devices;
         neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
         auto mockBuiltIns = new MockBuiltins();

level_zero/core/test/unit_tests/fixtures/module_fixture.h

@@ -14,6 +14,7 @@
 #include "shared/test/common/mocks/mock_graphics_allocation.h"
 
 #include "opencl/source/program/kernel_info.h"
+#include "opencl/test/unit_test/mocks/mock_compilers.h"
 #include "opencl/test/unit_test/mocks/mock_memory_manager.h"
 
 #include "level_zero/core/source/module/module.h"
@@ -172,6 +173,7 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
 
 struct ModuleFixture : public DeviceFixture {
     void SetUp() override {
+        NEO::MockCompilerEnableGuard mock(true);
         DeviceFixture::SetUp();
         createModuleFromBinary();
     }

level_zero/core/test/unit_tests/gen11/test_cmdqueue_thread_arbitration_policy_gen11.cpp

@@ -10,6 +10,7 @@
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
 
 #include "opencl/source/helpers/hardware_commands_helper.h"
+#include "opencl/test/unit_test/mocks/mock_compilers.h"
 #include "test.h"
 
 #include "level_zero/core/source/driver/driver_imp.h"
@@ -22,6 +23,8 @@ namespace ult {
 
 struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
     void SetUp() override {
+        NEO::MockCompilerEnableGuard mock(true);
+        ze_result_t returnValue = ZE_RESULT_SUCCESS;
         auto executionEnvironment = new NEO::ExecutionEnvironment();
         auto mockBuiltIns = new MockBuiltins();
         executionEnvironment->prepareRootDeviceEnvironments(1);
@@ -33,7 +36,7 @@ struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
         std::vector<std::unique_ptr<NEO::Device>> devices;
         devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
 
-        auto driverHandleUlt = whitebox_cast(DriverHandle::create(std::move(devices), L0EnvVariables{}));
+        auto driverHandleUlt = whitebox_cast(DriverHandle::create(std::move(devices), L0EnvVariables{}, &returnValue));
         driverHandle.reset(driverHandleUlt);
 
         ASSERT_NE(nullptr, driverHandle);
@@ -46,7 +49,6 @@ struct CommandQueueThreadArbitrationPolicyTests : public ::testing::Test {
         ASSERT_NE(nullptr, device);
 
         ze_command_queue_desc_t queueDesc = {};
-        ze_result_t returnValue;
         commandQueue = whitebox_cast(CommandQueue::create(productFamily, device,
                                                           neoDevice->getDefaultEngine().commandStreamReceiver,
                                                           &queueDesc,