Metric Api: zetContextActivateMetricGroups update

RobertKrzemien · Compute-Runtime-Automation · commit 46c7fac0cc09 · 2020-07-28T16:59:53.000+02:00
Change-Id: Ia3f38e8bfc6176063de36685e16e7a4a21f940c7
Signed-off-by: Robert Krzemien &lt;robert.krzemien@intel.com&gt;
diff --git a/level_zero/api/tools/zet_metric.cpp b/level_zero/api/tools/zet_metric.cpp
@@ -62,6 +62,15 @@ zetDeviceActivateMetricGroups(
     return L0::Device::fromHandle(hDevice)->activateMetricGroups(count, phMetricGroups);
 }
 
+__zedllexport ze_result_t __zecall
+zetContextActivateMetricGroups(
+    zet_context_handle_t hContext,
+    zet_device_handle_t hDevice,
+    uint32_t count,
+    zet_metric_group_handle_t *phMetricGroups) {
+    return L0::Context::fromHandle(hContext)->activateMetricGroups(hDevice, count, phMetricGroups);
+}
+
 __zedllexport ze_result_t __zecall
 zetMetricTracerOpen(
     zet_device_handle_t hDevice,
diff --git a/level_zero/core/source/context/context.h b/level_zero/core/source/context/context.h
@@ -11,6 +11,7 @@
 #include <level_zero/ze_api.h>
 
 #include "third_party/level_zero/ze_api_ext.h"
+#include "third_party/level_zero/zet_api_ext.h"
 
 struct _ze_context_handle_t {
     virtual ~_ze_context_handle_t() = default;
@@ -68,6 +69,9 @@ struct Context : _ze_context_handle_t {
     virtual ze_result_t createCommandListImmediate(ze_device_handle_t hDevice,
                                                    const ze_command_queue_desc_t *desc,
                                                    ze_command_list_handle_t *commandList) = 0;
+    virtual ze_result_t activateMetricGroups(zet_device_handle_t hDevice,
+                                             uint32_t count,
+                                             zet_metric_group_handle_t *phMetricGroups) = 0;
 
     static Context *fromHandle(ze_context_handle_t handle) { return static_cast<Context *>(handle); }
     inline ze_context_handle_t toHandle() { return this; }
diff --git a/level_zero/core/source/context/context_imp.cpp b/level_zero/core/source/context/context_imp.cpp
@@ -144,4 +144,10 @@ ze_result_t ContextImp::createCommandListImmediate(ze_device_handle_t hDevice,
     return L0::Device::fromHandle(hDevice)->createCommandListImmediate(desc, commandList);
 }
 
+ze_result_t ContextImp::activateMetricGroups(zet_device_handle_t hDevice,
+                                             uint32_t count,
+                                             zet_metric_group_handle_t *phMetricGroups) {
+    return L0::Device::fromHandle(hDevice)->activateMetricGroups(count, phMetricGroups);
+}
+
 } // namespace L0
diff --git a/level_zero/core/source/context/context_imp.h b/level_zero/core/source/context/context_imp.h
@@ -62,6 +62,9 @@ struct ContextImp : Context {
     ze_result_t createCommandListImmediate(ze_device_handle_t hDevice,
                                            const ze_command_queue_desc_t *desc,
                                            ze_command_list_handle_t *commandList) override;
+    ze_result_t activateMetricGroups(zet_device_handle_t hDevice,
+                                     uint32_t count,
+                                     zet_metric_group_handle_t *phMetricGroups) override;
 
   protected:
     DriverHandle *driverHandle = nullptr;
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_query_pool_linux.cpp b/level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_query_pool_linux.cpp
@@ -22,18 +22,18 @@ using ::testing::Return;
 namespace L0 {
 namespace ult {
 
-class MetricQueryPoolLinuxTest : public MetricDeviceFixture,
+class MetricQueryPoolLinuxTest : public MetricContextFixture,
                                  public ::testing::Test {
   public:
     void SetUp() override {
-        MetricDeviceFixture::SetUp();
+        MetricContextFixture::SetUp();
         neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[device->getRootDeviceIndex()]->osInterface = std::make_unique<NEO::OSInterface>();
         auto osInterface = device->getOsInterface().get();
         osInterface->setDrm(new DrmMock(const_cast<NEO::RootDeviceEnvironment &>(neoDevice->getRootDeviceEnvironment())));
     }
 
     void TearDown() override {
-        MetricDeviceFixture::TearDown();
+        MetricContextFixture::TearDown();
     }
 };
 
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp
@@ -12,10 +12,10 @@ using namespace MetricsLibraryApi;
 namespace L0 {
 namespace ult {
 
-void MetricDeviceFixture::SetUp() {
+void MetricContextFixture::SetUp() {
 
     // Call base class.
-    DeviceFixture::SetUp();
+    ContextFixture::SetUp();
 
     // Initialize metric api.
     auto &metricContext = device->getMetricContext();
@@ -34,7 +34,7 @@ void MetricDeviceFixture::SetUp() {
     metricsDeviceParams.Version.MinorNumber = MetricEnumeration::requiredMetricsDiscoveryMinorVersion;
 }
 
-void MetricDeviceFixture::TearDown() {
+void MetricContextFixture::TearDown() {
 
     // Restore original metrics library
     mockMetricsLibrary->setMockedApi(nullptr);
@@ -45,7 +45,7 @@ void MetricDeviceFixture::TearDown() {
     mockMetricEnumeration.reset();
 
     // Call base class.
-    DeviceFixture::TearDown();
+    ContextFixture::TearDown();
 }
 
 Mock<MetricsLibrary>::Mock(::L0::MetricContext &metricContext) : MetricsLibrary(metricContext) {
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h
@@ -139,7 +139,7 @@ struct Mock<MetricQuery> : public MetricQuery {
     MOCK_METHOD(ze_result_t, destroy, (), (override));
 };
 
-class MetricDeviceFixture : public DeviceFixture {
+class MetricContextFixture : public ContextFixture {
 
   protected:
     void SetUp() override;
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp
@@ -20,7 +20,7 @@ using ::testing::Return;
 namespace L0 {
 namespace ult {
 
-using MetricEnumerationTest = Test<MetricDeviceFixture>;
+using MetricEnumerationTest = Test<MetricContextFixture>;
 
 TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetricGroupIsCalledThenReturnsFail) {
 
@@ -873,6 +873,92 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenZetDeviceActiva
     EXPECT_EQ(zetDeviceActivateMetricGroups(device->toHandle(), 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
 }
 
+TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenZetContextActivateMetricGroupsIsCalledThenReturnsSuccess) {
+
+    // 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";
+    metricsConcurrentGroupParams.Description = "OA description";
+
+    // Metrics Discovery:: metric set.
+    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
+    metricsSetParams.MetricsCount = 0;
+    metricsSetParams.SymbolName = "Metric set name";
+    metricsSetParams.ShortName = "Metric set description";
+    metricsSetParams.MetricsCount = 1;
+
+    // Metrics Discovery:: metric.
+    Mock<IMetric_1_0> metric;
+    TMetricParams_1_0 metricParams = {};
+    metricParams.SymbolName = "Metric symbol name";
+    metricParams.ShortName = "Metric short name";
+    metricParams.LongName = "Metric long name";
+    metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
+    metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
+
+    // One api: metric group handle.
+    zet_metric_group_handle_t metricGroupHandle = {};
+
+    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)
+        .WillRepeatedly(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, GetMetric(_))
+        .Times(1)
+        .WillOnce(Return(&metric));
+
+    EXPECT_CALL(metric, GetParams())
+        .Times(1)
+        .WillOnce(Return(&metricParams));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    // Metric group count.
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+
+    // Metric group handle.
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+    EXPECT_NE(metricGroupHandle, nullptr);
+
+    // Activate metric group.
+    EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
+}
+
 TEST_F(MetricEnumerationTest, givenValidTimeBasedMetricGroupWhenZetDeviceActivateMetricGroupsIsCalledThenReturnsSuccess) {
 
     // Metrics Discovery device.
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool.cpp
@@ -24,17 +24,17 @@ using ::testing::Return;
 namespace L0 {
 namespace ult {
 
-class MetricQueryPoolTest : public MetricDeviceFixture,
+class MetricQueryPoolTest : public MetricContextFixture,
                             public ::testing::Test {
   public:
     void SetUp() override {
-        MetricDeviceFixture::SetUp();
+        MetricContextFixture::SetUp();
         auto executionEnvironment = new NEO::ExecutionEnvironment();
         driverHandle.reset(DriverHandle::create(NEO::DeviceFactory::createDevices(*executionEnvironment), L0EnvVariables{}));
     }
 
     void TearDown() override {
-        MetricDeviceFixture::TearDown();
+        MetricContextFixture::TearDown();
         driverHandle.reset();
         GlobalDriver = nullptr;
     }
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer.cpp
@@ -20,7 +20,7 @@ using ::testing::Return;
 namespace L0 {
 namespace ult {
 
-using MetricStreamerTest = Test<MetricDeviceFixture>;
+using MetricStreamerTest = Test<MetricContextFixture>;
 
 TEST_F(MetricStreamerTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenIsCalledThenReturnsFail) {
 
diff --git a/third_party/level_zero/zet_api_ext.h b/third_party/level_zero/zet_api_ext.h
@@ -13,6 +13,8 @@
 #endif
 
 // standard headers
+#include <level_zero/zet_api.h>
+
 #include "third_party/level_zero/ze_api_ext.h"
 
 #include <stddef.h>
@@ -23,6 +25,10 @@ extern "C" {
 #endif
 
 // Intel 'oneAPI' Level-Zero Tool API common types
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Handle of context object
+typedef ze_context_handle_t zet_context_handle_t;
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Handle of metric streamer's object
 typedef struct _zet_metric_streamer_handle_t *zet_metric_streamer_handle_t;
@@ -166,6 +172,44 @@ zetMetricStreamerReadData(
                                                   ///< reports in raw format
 );
 
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Activates metric groups.
+///
+/// @details
+///     - Immediately reconfigures the device to activate only those metric
+///       groups provided.
+///     - Any metric groups previously activated but not provided will be
+///       deactivated.
+///     - Deactivating metric groups that are still in-use will result in
+///       undefined behavior.
+///     - All metric groups must have different domains, see
+///       ::zet_metric_group_properties_t.
+///     - The application must **not** call this function from simultaneous
+///       threads with the same device handle.
+///
+/// @returns
+///     - ::ZE_RESULT_SUCCESS
+///     - ::ZE_RESULT_ERROR_UNINITIALIZED
+///     - ::ZE_RESULT_ERROR_DEVICE_LOST
+///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
+///         + `nullptr == hContext`
+///         + `nullptr == hDevice`
+///     - ::ZE_RESULT_ERROR_INVALID_SIZE
+///         + `(nullptr == phMetricGroups) && (0 < count)`
+///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
+///         + Multiple metric groups share the same domain
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zetContextActivateMetricGroups(
+    zet_context_handle_t hContext,            ///< [in] handle of the context object
+    zet_device_handle_t hDevice,              ///< [in] handle of the device
+    uint32_t count,                           ///< [in] metric group count to activate; must be 0 if `nullptr ==
+                                              ///< phMetricGroups`
+    zet_metric_group_handle_t *phMetricGroups ///< [in][optional][range(0, count)] handles of the metric groups to activate.
+                                              ///< nullptr deactivates all previously used metric groups.
+                                              ///< all metrics groups must come from a different domains.
+                                              ///< metric query and metric stream must use activated metric groups.
+);
+
 #if defined(__cplusplus)
 } // extern "C"
 #endif
