From 8d2fcad63f7de242bc1e2692356e66fdcf44b9b2 Mon Sep 17 00:00:00 2001 From: Robert Krzemien Date: Wed, 22 Sep 2021 13:30:38 +0000 Subject: [PATCH] Metric Api: Query get data for sub devices Resolves: LOCI-2470 Signed-off-by: Robert Krzemien --- .../tools/source/metrics/metric_query_imp.cpp | 36 +++- .../metrics/test_metric_query_pool_2.cpp | 159 ++++++++++++++++++ 2 files changed, 192 insertions(+), 3 deletions(-) diff --git a/level_zero/tools/source/metrics/metric_query_imp.cpp b/level_zero/tools/source/metrics/metric_query_imp.cpp index 6481262444..ea6173f2bb 100644 --- a/level_zero/tools/source/metrics/metric_query_imp.cpp +++ b/level_zero/tools/source/metrics/metric_query_imp.cpp @@ -653,9 +653,39 @@ ze_result_t MetricQueryImp::appendEnd(CommandList &commandList, ze_event_handle_ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) { const bool calculateSizeOnly = *pRawDataSize == 0; - const bool result = calculateSizeOnly - ? metricsLibrary.getMetricQueryReportSize(*pRawDataSize) - : metricsLibrary.getMetricQueryReport(pool.query, slot, *pRawDataSize, pRawData); + const size_t metricQueriesSize = metricQueries.size(); + bool result = true; + + if (metricQueriesSize > 0) { + + if (calculateSizeOnly) { + + auto pMetricQueryImp = static_cast(MetricQuery::fromHandle(metricQueries[0])); + result = pMetricQueryImp->metricsLibrary.getMetricQueryReportSize(*pRawDataSize); + *pRawDataSize *= metricQueriesSize; + + } else { + + size_t sizePerSubDevice = *pRawDataSize / metricQueriesSize; + DEBUG_BREAK_IF(sizePerSubDevice == 0); + + for (size_t i = 0; i < metricQueriesSize; ++i) { + + auto pMetricQuery = MetricQuery::fromHandle(metricQueries[i]); + ze_result_t tmpResult = pMetricQuery->getData(&sizePerSubDevice, pRawData + (sizePerSubDevice * i)); + + if (tmpResult != ZE_RESULT_SUCCESS) { + result = false; + break; + } + } + } + + } else { + result = calculateSizeOnly + ? metricsLibrary.getMetricQueryReportSize(*pRawDataSize) + : metricsLibrary.getMetricQueryReport(pool.query, slot, *pRawDataSize, pRawData); + } return result ? ZE_RESULT_SUCCESS diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp index c721c076de..a3e20b5ba3 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp @@ -888,5 +888,164 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenExecutionQueryTypeWhenZetMetricQuery EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS); } +TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDataIsCalledThenReturnsFail) { + + zet_device_handle_t metricDevice = devices[0]->toHandle(); + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + + metricsDeviceParams.ConcurrentGroupsCount = 1; + + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + metricsConcurrentGroupParams.Description = "OA description"; + + Mock 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; + + Mock 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; + + zet_metric_group_handle_t metricGroupHandle = {}; + + zet_metric_group_properties_t metricGroupProperties = {}; + metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED; + + zet_metric_query_handle_t queryHandle = {}; + 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; + + size_t reportSize = 256; + + QueryHandle_1_0 metricsLibraryQueryHandle = {&value}; + ContextHandle_1_0 metricsLibraryContextHandle = {&value}; + + CommandBufferSize_1_0 commandBufferSize = {}; + commandBufferSize.GpuMemorySize = 100; + + openMetricsAdapter(); + + EXPECT_CALL(metricsDevice, GetParams()) + .WillRepeatedly(Return(&metricsDeviceParams)); + + EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsConcurrentGroup)); + + EXPECT_CALL(metricsConcurrentGroup, GetParams()) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsConcurrentGroupParams)); + + EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) + .WillRepeatedly(Return(&metricsSet)); + + EXPECT_CALL(metricsSet, GetParams()) + .WillRepeatedly(Return(&metricsSetParams)); + + EXPECT_CALL(metricsSet, GetMetric(_)) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metric)); + + EXPECT_CALL(metric, GetParams()) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricParams)); + + EXPECT_CALL(metricsSet, SetApiFiltering(_)) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + for (uint32_t i = 0; i < subDeviceCount; ++i) { + EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized()) + .Times(1) + .WillOnce(Return(true)); + + EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _)) + .Times(1) + .WillOnce(Return(true)); + } + + EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getMetricQueryReportSize(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgReferee<0>(reportSize), Return(true))); + + EXPECT_CALL(*mockMetricsLibrary, load()) + .Times(0); + + EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _)) + .Times(subDeviceCount) + .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success))); + + EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_)) + .Times(subDeviceCount) + .WillRepeatedly(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(subDeviceCount) + .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success))); + + EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetData(_)) + .Times(subDeviceCount) + .WillOnce(Return(StatusCode::Success)) + .WillOnce(Return(StatusCode::Failed)); + + EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_)) + .Times(subDeviceCount) + .WillRepeatedly(Return(StatusCode::Success)); + + // Metric group count. + uint32_t metricGroupCount = 0; + EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + + // Metric group handle. + EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + // Create metric query pool. + EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroupHandle, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS); + EXPECT_NE(poolHandle, nullptr); + + // Create metric query. + EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS); + EXPECT_NE(queryHandle, nullptr); + + // Get desired raw data size. + size_t rawSize = 0; + EXPECT_EQ(zetMetricQueryGetData(queryHandle, &rawSize, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(rawSize, reportSize * subDeviceCount); + + // Get data. + std::vector rawData; + rawData.resize(rawSize); + EXPECT_EQ(zetMetricQueryGetData(queryHandle, &rawSize, rawData.data()), ZE_RESULT_ERROR_UNKNOWN); + + // Destroy query and its pool. + EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS); +} + } // namespace ult } // namespace L0