Metric Api: checking paranoid mode during zeInit

Change-Id: I9e53f5707a959a6a2f598995495c484b72ff1931

level_zero/tools/source/metrics/metric.cpp

@@ -98,9 +98,17 @@ bool MetricContextImp::loadDependencies() {
         result = false;
         DEBUG_BREAK_IF(!result);
     }
+    // Initialize metrics library / discovery here
+    // to check requirements expected from the kernel driver.
     if (result) {
-        setInitializationState(ZE_RESULT_SUCCESS);
+        result = metricsLibrary->isInitialized();
+        DEBUG_BREAK_IF(!result);
     }
+
+    setInitializationState(result
+                               ? ZE_RESULT_SUCCESS
+                               : ZE_RESULT_ERROR_UNKNOWN);
+
     return result;
 }
 

level_zero/tools/source/metrics/metric_enumeration_imp.cpp

@@ -50,11 +50,18 @@ ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count,
     return ZE_RESULT_SUCCESS;
 }
 
-bool MetricEnumeration::isInitialized() { return initializationState == ZE_RESULT_SUCCESS; }
+bool MetricEnumeration::isInitialized() {
+
+    if (initializationState == ZE_RESULT_ERROR_UNINITIALIZED) {
+        initialize();
+    }
+
+    return initializationState == ZE_RESULT_SUCCESS;
+}
 
 ze_result_t MetricEnumeration::initialize() {
     if (initializationState == ZE_RESULT_ERROR_UNINITIALIZED) {
-        if (metricContext.isInitialized() &&
+        if (hMetricsDiscovery &&
             openMetricsDiscovery() == ZE_RESULT_SUCCESS &&
             cacheMetricInformation() == ZE_RESULT_SUCCESS) {
             initializationState = ZE_RESULT_SUCCESS;

level_zero/tools/source/metrics/metric_query_imp.cpp

@@ -155,7 +155,7 @@ void MetricsLibrary::initialize() {
 
     // Metrics Enumeration needs to be initialized before Metrics Library
     const bool validMetricsEnumeration = metricsEnumeration.isInitialized();
-    const bool validMetricsLibrary = validMetricsEnumeration && metricContext.isInitialized() && createContext();
+    const bool validMetricsLibrary = validMetricsEnumeration && handle && createContext();
 
     // Load metrics library and exported functions.
     initializationState = validMetricsLibrary ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;

level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp

@@ -7,6 +7,8 @@
 
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
 
+#include "shared/test/unit_test/mocks/mock_os_library.h"
+
 using namespace MetricsLibraryApi;
 
 namespace L0 {
@@ -24,10 +26,12 @@ void MetricContextFixture::SetUp() {
     // Mock metrics library.
     mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricContext));
     mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi);
+    mockMetricsLibrary->handle = new MockOsLibrary();
 
     //  Mock metric enumeration.
     mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricContext));
     mockMetricEnumeration->setMockedApi(&mockMetricsDiscoveryApi);
+    mockMetricEnumeration->hMetricsDiscovery = std::make_unique<MockOsLibrary>();
 
     // Metrics Discovery device common settings.
     metricsDeviceParams.Version.MajorNumber = MetricEnumeration::requiredMetricsDiscoveryMajorVersion;
@@ -37,6 +41,7 @@ void MetricContextFixture::SetUp() {
 void MetricContextFixture::TearDown() {
 
     // Restore original metrics library
+    delete mockMetricsLibrary->handle;
     mockMetricsLibrary->setMockedApi(nullptr);
     mockMetricsLibrary.reset();
 

level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h

@@ -100,6 +100,9 @@ struct Mock<MetricsLibrary> : public MetricsLibrary {
     Mock(::L0::MetricContext &metricContext);
     ~Mock() override;
 
+    using MetricsLibrary::handle;
+    using MetricsLibrary::initializationState;
+
     // Api mock enable/disable.
     void setMockedApi(MockMetricsLibraryApi *mockedApi);
 

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h

@@ -116,6 +116,9 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
     Mock(::L0::MetricContext &metricContext);
     ~Mock() override;
 
+    using MetricEnumeration::hMetricsDiscovery;
+    using MetricEnumeration::initializationState;
+
     // Api mock enable/disable.
     void setMockedApi(MockMetricsDiscoveryApi *mockedApi);
 
@@ -123,6 +126,9 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
     MOCK_METHOD(bool, isInitialized, (), (override));
     MOCK_METHOD(ze_result_t, loadMetricsDiscovery, (), (override));
 
+    // Not mocked metrics enumeration functions.
+    bool baseIsInitialized() { return MetricEnumeration::isInitialized(); }
+
     // Mock metrics discovery api.
     static MockMetricsDiscoveryApi *g_mockApi;
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp

@@ -2119,5 +2119,121 @@ TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCal
     EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults.data(), &calculatedResultsCount, nullptr), ZE_RESULT_SUCCESS);
     EXPECT_EQ(calculatedResultsCount, metricsSetParams.MetricsCount);
 }
+
+TEST_F(MetricEnumerationTest, givenInitializedMetricEnumerationWhenIsInitializedIsCalledThenMetricEnumerationWillNotBeInitializedAgain) {
+
+    mockMetricEnumeration->initializationState = ZE_RESULT_SUCCESS;
+    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
+}
+
+TEST_F(MetricEnumerationTest, givenNotInitializedMetricEnumerationWhenIsInitializedIsCalledThenMetricEnumerationWillBeInitialized) {
+
+    // Metrics Discovery device.
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    // Metrics Discovery concurrent group.
+    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+
+    // Metrics Discovery: metric set
+    Mock<IMetricSet_1_5> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
+    metricsSetParams.QueryReportSize = 256;
+    metricsSetParams.MetricsCount = 11;
+
+    // Metrics Discovery: metric
+    Mock<IMetric_1_0> metric;
+    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(0);
+
+    EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenMetricsDevice(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockCloseMetricsDevice(_))
+        .Times(1)
+        .WillOnce(Return(TCompletionCode::CC_OK));
+
+    EXPECT_CALL(metricsDevice, GetParams())
+        .WillRepeatedly(Return(&metricsDeviceParams));
+
+    EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
+        .Times(1)
+        .WillOnce(Return(&metricsConcurrentGroup));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetParams())
+        .Times(1)
+        .WillOnce(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, GetMetric(_))
+        .Times(11)
+        .WillRepeatedly(Return(&metric));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    EXPECT_CALL(metric, GetParams())
+        .WillRepeatedly(Return(&metricParams));
+
+    mockMetricEnumeration->initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
+    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
+}
+
+TEST_F(MetricEnumerationTest, givenLoadedMetricsLibraryAndDiscoveryAndMetricsLibraryInitializedWhenLoadDependenciesThenReturnSuccess) {
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(1)
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    EXPECT_CALL(*mockMetricsLibrary, load())
+        .Times(1)
+        .WillOnce(Return(true));
+
+    mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
+
+    auto &metricContext = device->getMetricContext();
+    EXPECT_EQ(metricContext.loadDependencies(), true);
+    EXPECT_EQ(metricContext.isInitialized(), true);
+}
+
+TEST_F(MetricEnumerationTest, givenNotLoadedMetricsLibraryAndDiscoveryWhenLoadDependenciesThenReturnFail) {
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(1)
+        .WillOnce(Return(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE));
+
+    auto &metricContext = device->getMetricContext();
+    EXPECT_EQ(metricContext.loadDependencies(), false);
+    EXPECT_EQ(metricContext.isInitialized(), false);
+}
+
+TEST_F(MetricEnumerationTest, givenLoadedMetricsLibraryAndDiscoveryAndMetricsLibraryNotInitializedWhenLoadDependenciesThenReturnFail) {
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(1)
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    EXPECT_CALL(*mockMetricsLibrary, load())
+        .Times(1)
+        .WillOnce(Return(true));
+
+    mockMetricsLibrary->initializationState = ZE_RESULT_ERROR_NOT_AVAILABLE;
+
+    auto &metricContext = device->getMetricContext();
+    EXPECT_EQ(metricContext.loadDependencies(), false);
+    EXPECT_EQ(metricContext.isInitialized(), false);
+}
+
 } // namespace ult
 } // namespace L0