Improve GtPin init error status reporting

Related-To: LOCI-1286

Signed-off-by: davidoli <[email protected]>

Author: dmichaelo1

level_zero/tools/source/metrics/metric_oa_source.h

@@ -48,7 +48,6 @@ class OaMetricSourceImp : public MetricSource {
     uint32_t getSubDeviceIndex();
     bool isImplicitScalingCapable() const;
     const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
-    static bool checkDependencies();
     static std::unique_ptr<OaMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
     using OsLibraryLoadPtr = std::add_pointer<NEO::OsLibrary *(const std::string &)>::type;
     static OsLibraryLoadPtr osLibraryLoadFunction;

level_zero/tools/source/pin/pin.cpp

@@ -18,27 +18,28 @@ const std::string gtPinOpenFunctionName = "OpenGTPin";
 
 namespace L0 {
 
+PinContext::OsLibraryLoadPtr PinContext::osLibraryLoadFunction(NEO::OsLibrary::load);
+
 ze_result_t PinContext::init() {
-    std::unique_ptr<NEO::OsLibrary> hGtPinLibrary = nullptr;
+    NEO::OsLibrary *hGtPinLibrary = nullptr;
+
+    hGtPinLibrary = PinContext::osLibraryLoadFunction(gtPinLibraryFilename.c_str());
 
-    hGtPinLibrary.reset(NEO::OsLibrary::load(gtPinLibraryFilename.c_str()));
-    if (hGtPinLibrary.get() == nullptr) {
+    if (hGtPinLibrary == nullptr) {
         PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find gtpin library %s\n", gtPinLibraryFilename.c_str());
-        return ZE_RESULT_ERROR_UNKNOWN;
+        return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
     }
 
     OpenGTPin_fn openGTPin = reinterpret_cast<OpenGTPin_fn>(hGtPinLibrary->getProcAddress(gtPinOpenFunctionName.c_str()));
     if (openGTPin == nullptr) {
-        hGtPinLibrary.reset(nullptr);
         PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find gtpin library open function symbol %s\n", gtPinOpenFunctionName.c_str());
-        return ZE_RESULT_ERROR_UNKNOWN;
+        return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
     }
 
     uint32_t openResult = openGTPin(nullptr);
     if (openResult != 0) {
-        hGtPinLibrary.reset(nullptr);
         PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "gtpin library open %s failed with status %u\n", gtPinOpenFunctionName.c_str(), openResult);
-        return ZE_RESULT_ERROR_UNKNOWN;
+        return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
     }
 
     return ZE_RESULT_SUCCESS;

level_zero/tools/source/pin/pin.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,6 +16,8 @@ namespace L0 {
 class PinContext {
   public:
     static ze_result_t init();
+    using OsLibraryLoadPtr = std::add_pointer<NEO::OsLibrary *(const std::string &)>::type;
+    static OsLibraryLoadPtr osLibraryLoadFunction;
 
   private:
     static const std::string gtPinLibraryFilename;

level_zero/tools/test/unit_tests/sources/pin/CMakeLists.txt

@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2022 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_pin.cpp
+)

level_zero/tools/test/unit_tests/sources/pin/test_pin.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/common/mocks/mock_os_library.h"
+
+#include "level_zero/tools/source/pin/pin.h"
+
+#include "gtest/gtest.h"
+
+namespace ult {
+
+TEST(PinInitializationTest, GivenValidLibraryPinContextInitSucceeds) {
+    uint32_t (*openPinHandler)(void *) = [](void *arg) -> uint32_t { return 0; };
+    auto newPtr = new MockOsLibrary(reinterpret_cast<void *>(openPinHandler), false);
+    MockOsLibrary::loadLibraryNewObject = newPtr;
+    L0::PinContext::osLibraryLoadFunction = MockOsLibrary::load;
+    EXPECT_EQ(L0::PinContext::init(), ZE_RESULT_SUCCESS);
+    L0::PinContext::osLibraryLoadFunction = NEO::OsLibrary::load;
+    MockOsLibrary::loadLibraryNewObject = nullptr;
+    delete newPtr;
+}
+
+TEST(PinInitializationTest, GivenBadLibraryNamePinContextInitFAILS) {
+    MockOsLibrary::loadLibraryNewObject = nullptr;
+    L0::PinContext::osLibraryLoadFunction = MockOsLibrary::load;
+    EXPECT_EQ(L0::PinContext::init(), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
+    L0::PinContext::osLibraryLoadFunction = NEO::OsLibrary::load;
+    MockOsLibrary::loadLibraryNewObject = nullptr;
+}
+
+TEST(PinInitializationTest, GivenBadProcAddressPinContextInitFAILS) {
+    auto newPtr = new MockOsLibrary(nullptr, false);
+    MockOsLibrary::loadLibraryNewObject = newPtr;
+    L0::PinContext::osLibraryLoadFunction = MockOsLibrary::load;
+    EXPECT_EQ(L0::PinContext::init(), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
+    L0::PinContext::osLibraryLoadFunction = NEO::OsLibrary::load;
+    MockOsLibrary::loadLibraryNewObject = nullptr;
+    delete newPtr;
+}
+
+TEST(PinInitializationTest, GivenBadPinHandlerPinContextInitFAILS) {
+    uint32_t (*openPinHandler)(void *) = [](void *arg) -> uint32_t { return 1; };
+    auto newPtr = new MockOsLibrary(reinterpret_cast<void *>(openPinHandler), false);
+    MockOsLibrary::loadLibraryNewObject = newPtr;
+    L0::PinContext::osLibraryLoadFunction = MockOsLibrary::load;
+    EXPECT_EQ(L0::PinContext::init(), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
+    L0::PinContext::osLibraryLoadFunction = NEO::OsLibrary::load;
+    MockOsLibrary::loadLibraryNewObject = nullptr;
+    delete newPtr;
+}
+
+} // namespace ult

shared/test/common/mocks/CMakeLists.txt

@@ -76,6 +76,7 @@ set(NEO_CORE_tests_mocks
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_multi_graphics_allocation.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_os_context.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_os_library.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/mock_os_library.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_ostime.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_physical_address_allocator.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_sip.cpp

shared/test/common/mocks/mock_os_library.cpp

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/common/mocks/mock_os_library.h"
+
+NEO::OsLibrary *MockOsLibrary::loadLibraryNewObject = nullptr;

shared/test/common/mocks/mock_os_library.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,10 +11,27 @@
 
 class MockOsLibrary : public NEO::OsLibrary {
   public:
+    MockOsLibrary(void *procAddress, bool isLoaded) : getProcAddressReturn{procAddress}, isLoadedReturn{isLoaded} {}
+    MockOsLibrary() {}
+
+    std::string lastRequestedProcName;
+    void *getProcAddressReturn = nullptr;
+
     void *getProcAddress(const std::string &procName) override {
-        return nullptr;
+        lastRequestedProcName = procName;
+        return getProcAddressReturn;
     }
+
+    bool isLoadedReturn = false;
+
     bool isLoaded() override {
-        return false;
+        return isLoadedReturn;
+    }
+
+    static OsLibrary *loadLibraryNewObject;
+
+    static OsLibrary *load(const std::string &name) {
+        OsLibrary *ptr = loadLibraryNewObject;
+        return ptr;
     }
 };