Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Metrics: Avoid resetting Implicit Scaling flag when metrics library is released

Browse Source 
This patch fixes issue when metrics library is released, then the implicit
scaling flag is reset. The issue would make further requests to MDAPI not to
perform implicit scaling specific handling.

Releated-To: LOCI-3163

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2022-06-04 08:08:36 +00:00
committed by Compute-Runtime-Automation
parent 461a9c3fdf
commit d36abf7bb0
2 changed files with 144 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/tools/source/metrics/metric_oa_query_imp.cpp
View File

@ -171,7 +171,6 @@ void MetricsLibrary::release() {
api = {};
callbacks = {};
context = {};
isWorkloadPartitionEnabled = false;
initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
}

144
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp
View File

@ -1649,5 +1649,149 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGr
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDevice, 0, nullptr), ZE_RESULT_SUCCESS);
}
TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetricsLibraryIsReleasedThenImplicitScalingStatusIsNotModified) {
zet_device_handle_t metricDevice = devices[0]->toHandle();
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
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;
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;
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;
QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
ContextHandle_1_0 metricsLibraryContextHandle = {&value};
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(*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, MockContextDelete(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
auto &metricSource = deviceImp.subDevices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
auto dummy = ClientOptionsData_1_0{};
auto workloadPartition = ClientOptionsData_1_0{};
// Verify that workload partition is set, before Metrics Library release
metricsLibrary.getSubDeviceClientOptions(dummy, dummy, dummy, workloadPartition);
EXPECT_EQ(workloadPartition.Type, MetricsLibraryApi::ClientOptionsType::WorkloadPartition);
EXPECT_EQ(workloadPartition.WorkloadPartition.Enabled, true);
// Initiate a Metrics Library Release by releaing Metric Query Pool
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), devices[0]->toHandle(), 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroupHandle, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), devices[0]->toHandle(), 0, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
// Verify again that workload partition is not reset
metricsLibrary.getSubDeviceClientOptions(dummy, dummy, dummy, workloadPartition);
EXPECT_EQ(workloadPartition.Type, MetricsLibraryApi::ClientOptionsType::WorkloadPartition);
EXPECT_EQ(workloadPartition.WorkloadPartition.Enabled, true);
}
} // namespace ult
} // namespace L0