Modify metric query pool create for sub devices

Signed-off-by: davidoli <david.olien@intel.com>

level_zero/tools/source/metrics/metric_query_imp.cpp

@@ -230,7 +230,22 @@ void MetricsLibrary::getSubDeviceClientOptions(
 }
 
 bool MetricsLibrary::createContext() {
+
     auto &device = metricContext.getDevice();
+    bool status = true;
+
+    if (device.isMultiDeviceCapable()) {
+        const auto &deviceImp = *static_cast<DeviceImp *>(&device);
+        for (auto subDevice : deviceImp.subDevices) {
+            status &= createContextForDevice(*subDevice);
+        }
+    } else {
+        status = createContextForDevice(device);
+    }
+    return status;
+}
+
+bool MetricsLibrary::createContextForDevice(Device &device) {
     const auto &hwHelper = device.getHwHelper();
     const auto &asyncComputeEngines = hwHelper.getGpgpuEngineInstances(device.getHwInfo());
     ContextCreateData_1_0 createData = {};

level_zero/tools/source/metrics/metric_query_imp.h

@@ -77,6 +77,7 @@ struct MetricsLibrary {
     void initialize();
 
     bool createContext();
+    bool createContextForDevice(Device &device);
     virtual bool getContextData(Device &device, ContextCreateData_1_0 &contextData);
 
     ConfigurationHandle_1_0 createConfiguration(const zet_metric_group_handle_t metricGroup,

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

@@ -187,6 +187,95 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
         .WillOnce(Return(TCompletionCode::CC_OK));
 }
 
+void MetricMultiDeviceContextFixture::SetUp() {
+
+    NEO::ImplicitScaling::apiSupport = true;
+
+    MultiDeviceFixture::SetUp();
+
+    devices.resize(driverHandle->devices.size());
+
+    for (uint32_t i = 0; i < driverHandle->devices.size(); i++) {
+        devices[i] = driverHandle->devices[i];
+    }
+
+    // Initialize metric api.
+    auto &metricContext = devices[0]->getMetricContext();
+
+    // 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;
+    metricsDeviceParams.Version.MinorNumber = MetricEnumeration::requiredMetricsDiscoveryMinorVersion;
+}
+
+void MetricMultiDeviceContextFixture::TearDown() {
+
+    // Restore original metrics library
+    delete mockMetricsLibrary->handle;
+    mockMetricsLibrary->setMockedApi(nullptr);
+    mockMetricsLibrary.reset();
+
+    // Restore original metric enumeration.
+    mockMetricEnumeration->setMockedApi(nullptr);
+    mockMetricEnumeration.reset();
+
+    MultiDeviceFixture::TearDown();
+
+    NEO::ImplicitScaling::apiSupport = false;
+}
+
+void MetricMultiDeviceContextFixture::openMetricsAdapter() {
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(0);
+
+    EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(adapter, OpenMetricsDevice(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(adapter, CloseMetricsDevice(_))
+        .Times(1)
+        .WillOnce(Return(TCompletionCode::CC_OK));
+
+    EXPECT_CALL(adapterGroup, GetAdapter(_))
+        .Times(0);
+
+    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
+        .Times(1)
+        .WillOnce(Return(&adapter));
+}
+
+void MetricMultiDeviceContextFixture::openMetricsAdapterGroup() {
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(0);
+
+    EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(adapter, OpenMetricsDevice(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(adapter, CloseMetricsDevice(_))
+        .Times(1)
+        .WillOnce(Return(TCompletionCode::CC_OK));
+}
+
 Mock<MetricsLibrary>::Mock(::L0::MetricContext &metricContext) : MetricsLibrary(metricContext) {
 }
 

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

@@ -6,6 +6,8 @@
  */
 
 #pragma once
+#include "test.h"
+
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
 #include "level_zero/core/test/unit_tests/mock.h"
@@ -192,5 +194,31 @@ class MetricMultiDeviceFixture : public MultiDeviceFixture {
     MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
 };
 
+class MetricMultiDeviceContextFixture : public MultiDeviceFixture {
+
+  protected:
+    void SetUp() override;
+    void TearDown() override;
+    void openMetricsAdapter();
+    void openMetricsAdapterGroup();
+
+  public:
+    std::vector<L0::Device *> devices;
+
+    // Mocked objects.
+    std::unique_ptr<Mock<MetricEnumeration>> mockMetricEnumeration = nullptr;
+    std::unique_ptr<Mock<MetricsLibrary>> mockMetricsLibrary = nullptr;
+
+    // Mocked metrics library/discovery APIs.
+    MockMetricsLibraryApi mockMetricsLibraryApi = {};
+    MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {};
+
+    // Metrics discovery device
+    Mock<IAdapterGroup_1_9> adapterGroup;
+    Mock<IAdapter_1_9> adapter;
+    Mock<IMetricsDevice_1_5> metricsDevice;
+    MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
+};
+
 } // namespace ult
 } // namespace L0

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

@@ -1229,5 +1229,84 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
     EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
 }
 
+class MultiDeviceMetricQueryPoolTest : public MetricMultiDeviceContextFixture,
+                                       public ::testing::Test {
+  public:
+    void SetUp() override {
+        ze_result_t returnValue = ZE_RESULT_SUCCESS;
+        MetricMultiDeviceContextFixture::SetUp();
+        auto executionEnvironment = new NEO::ExecutionEnvironment();
+        driverHandle.reset(DriverHandle::create(NEO::DeviceFactory::createDevices(*executionEnvironment), L0EnvVariables{}, &returnValue));
+    }
+
+    void TearDown() override {
+        MetricMultiDeviceContextFixture::TearDown();
+        driverHandle.reset();
+        GlobalDriver = nullptr;
+    }
+    std::unique_ptr<L0::DriverHandle> driverHandle;
+};
+
+TEST_F(MultiDeviceMetricQueryPoolTest, multiDeviceGivenCorrectArgumentsWhenZetMetricQueryPoolCreateIsCalledThenQueryPoolIsObtained) {
+
+    zet_device_handle_t metricDevice = devices[0]->toHandle();
+
+    Mock<MetricGroup> metricGroup;
+    zet_metric_group_properties_t metricGroupProperties = {};
+    metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
+
+    zet_metric_query_pool_handle_t poolHandle = {};
+    zet_metric_query_pool_desc_t poolDesc = {};
+    poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
+    poolDesc.count = 1;
+    poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
+
+    TypedValue_1_0 value = {};
+    value.Type = ValueType::Uint32;
+    value.ValueUInt32 = 64;
+
+    QueryHandle_1_0 queryHandle = {&value};
+    ContextHandle_1_0 contextHandle = {&value};
+
+    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+        .Times(1)
+        .WillOnce(Return(true));
+
+    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+        .Times(2)
+        .WillRepeatedly(Return(true));
+
+    EXPECT_CALL(*mockMetricsLibrary, load())
+        .Times(0);
+
+    EXPECT_CALL(metricGroup, getProperties(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
+
+    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<1>(queryHandle), Return(StatusCode::Success)));
+
+    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
+        .Times(1)
+        .WillOnce(Return(StatusCode::Success));
+
+    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
+
+    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
+        .Times(2)
+        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
+
+    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
+        .Times(1)
+        .WillOnce(Return(StatusCode::Success));
+
+    EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
+    EXPECT_NE(poolHandle, nullptr);
+    EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
+}
+
 } // namespace ult
 } // namespace L0