intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Metric Api: Fix activation for sub devices

Browse Source 
Resolves: LOCI-2611
Signed-off-by: Robert Krzemien <robert.krzemien@intel.com>
This commit is contained in:
Robert Krzemien
2021-10-01 14:20:27 +00:00
committed by Compute-Runtime-Automation
parent 0b1c3d24f1
commit b5e0d32fe1
8 changed files with 301 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/core/source/device/device_imp.cpp
View File

@@ -679,7 +679,13 @@ MetricContext &DeviceImp::getMetricContext() { return *metricContext; }
void DeviceImp::activateMetricGroups() {
if (metricContext != nullptr) {
metricContext->activateMetricGroups();
if (metricContext->isMultiDeviceCapable()) {
for (uint32_t i = 0; i < numSubDevices; i++) {
subDevices[i]->getMetricContext().activateMetricGroups();
}
} else {
metricContext->activateMetricGroups();
}
}
}
uint32_t DeviceImp::getMaxNumHwThreads() const { return maxNumHwThreads; }

12
level_zero/tools/source/metrics/metric.cpp
View File

@@ -35,7 +35,7 @@ struct MetricGroupDomains {
bool activateEventMetricGroup(const zet_metric_group_handle_t hMetricGroup);
protected:
MetricsLibrary &metricsLibrary;
MetricContext &metricContext;
// Map holds activated domains and associated metric groups.
// Content: <domain number, pair<metric group, is activated on gpu flag>
@@ -250,7 +250,7 @@ bool MetricContext::isMetricApiAvailable() {
}
MetricGroupDomains::MetricGroupDomains(MetricContext &metricContext)
: metricsLibrary(metricContext.getMetricsLibrary()) {}
: metricContext(metricContext) {}
ze_result_t MetricGroupDomains::activateDeferred(const uint32_t subDeviceIndex,
const uint32_t count,
@@ -329,7 +329,7 @@ ze_result_t MetricGroupDomains::activate() {
bool MetricGroupDomains::activateEventMetricGroup(const zet_metric_group_handle_t hMetricGroup) {
// Obtain metric group configuration handle from metrics library.
auto hConfiguration = metricsLibrary.getConfiguration(hMetricGroup);
auto hConfiguration = metricContext.getMetricsLibrary().getConfiguration(hMetricGroup);
// Validate metrics library handle.
if (!hConfiguration.IsValid()) {
@@ -338,7 +338,7 @@ bool MetricGroupDomains::activateEventMetricGroup(const zet_metric_group_handle_
}
// Write metric group configuration to gpu.
const bool result = metricsLibrary.activateConfiguration(hConfiguration);
const bool result = metricContext.getMetricsLibrary().activateConfiguration(hConfiguration);
DEBUG_BREAK_IF(!result);
return result;
@@ -356,12 +356,12 @@ ze_result_t MetricGroupDomains::deactivate() {
: false;
auto hConfigurationEmpty = ConfigurationHandle_1_0{};
auto hConfiguration = metricGroupEventBased
? metricsLibrary.getConfiguration(hMetricGroup)
? metricContext.getMetricsLibrary().getConfiguration(hMetricGroup)
: hConfigurationEmpty;
// Deactivate metric group configuration using metrics library.
if (hConfiguration.IsValid() && metricGroupActivated) {
metricsLibrary.deactivateConfiguration(hConfiguration);
metricContext.getMetricsLibrary().deactivateConfiguration(hConfiguration);
}
// Mark domain as free.

10
level_zero/tools/source/metrics/metric_enumeration_imp.cpp
View File

@@ -666,11 +666,14 @@ ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calc
pMetricCounts[0] = *pTotalMetricValueCount;
} else {
for (size_t i = 0; i < metricGroupCount; i++) {
UNRECOVERABLE_IF(*pSetCount > metricGroupCount);
const uint32_t maxTotalMetricValueCount = *pTotalMetricValueCount;
*pTotalMetricValueCount = 0;
for (size_t i = 0; i < *pSetCount; i++) {
auto &metricGroup = *static_cast<MetricGroupImp *>(metricGroups[i]);
const uint32_t dataSize = pRawDataSizesUnpacked[i];
const uint8_t *pRawDataOffset = pRawDataOffsetUnpacked + pRawDataOffsetsUnpacked[i];
pMetricCounts[i] = *pTotalMetricValueCount;
pMetricCounts[i] = maxTotalMetricValueCount;
result = metricGroup.getCalculatedMetricValues(type, dataSize, pRawDataOffset, pMetricCounts[i], pMetricValues);
if (!result) {
@@ -679,6 +682,9 @@ ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calc
}
break;
}
*pTotalMetricValueCount += pMetricCounts[i];
pMetricValues += pMetricCounts[i];
}
}
}

17
level_zero/tools/source/metrics/metric_query_imp.cpp
View File

@@ -702,7 +702,7 @@ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
pRawDataHeader->rawDataSizes = static_cast<uint32_t>(pRawDataHeader->rawDataOffsets + (sizeof(uint32_t) * metricQueriesSize));
pRawDataHeader->rawDataOffset = static_cast<uint32_t>(pRawDataHeader->rawDataSizes + (sizeof(uint32_t) * metricQueriesSize));
size_t sizePerSubDevice = (*pRawDataSize - pRawDataHeader->rawDataOffset) / metricQueriesSize;
const size_t sizePerSubDevice = (*pRawDataSize - pRawDataHeader->rawDataOffset) / metricQueriesSize;
DEBUG_BREAK_IF(sizePerSubDevice == 0);
*pRawDataSize = pRawDataHeader->rawDataOffset;
@@ -712,18 +712,17 @@ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
for (size_t i = 0; i < metricQueriesSize; ++i) {
const uint32_t rawDataOffset = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] : 0;
size_t getDataSize = sizePerSubDevice;
const uint32_t rawDataOffset = (i != 0) ? (pRawDataSizesUnpacked[i - 1] + pRawDataOffsetsUnpacked[i - 1]) : 0;
auto pMetricQuery = MetricQuery::fromHandle(metricQueries[i]);
ze_result_t tmpResult = pMetricQuery->getData(&sizePerSubDevice, pRawDataUnpacked + rawDataOffset);
ze_result_t tmpResult = pMetricQuery->getData(&getDataSize, pRawDataUnpacked + rawDataOffset);
// Return at first error.
if (tmpResult != ZE_RESULT_SUCCESS) {
result = false;
break;
return tmpResult;
}
pRawDataSizesUnpacked[i] = static_cast<uint32_t>(sizePerSubDevice);
pRawDataSizesUnpacked[i] = static_cast<uint32_t>(getDataSize);
pRawDataOffsetsUnpacked[i] = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] + pRawDataSizesUnpacked[i] : 0;
*pRawDataSize += sizePerSubDevice;
*pRawDataSize += getDataSize;
}
}

5
level_zero/tools/source/metrics/metric_streamer_imp.cpp
View File

@@ -52,9 +52,8 @@ ze_result_t MetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDat
for (size_t i = 0; i < metricStreamerSize; ++i) {
size_t readSize = sizePerSubDevice;
auto metricStreamerHandle = metricStreamers[i];
const uint32_t rawDataOffset = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] : 0;
pMetricStreamer = MetricStreamer::fromHandle(metricStreamerHandle);
const uint32_t rawDataOffset = (i != 0) ? (pRawDataSizesUnpacked[i - 1] + pRawDataOffsetsUnpacked[i - 1]) : 0;
pMetricStreamer = MetricStreamer::fromHandle(metricStreamers[i]);
result = pMetricStreamer->readData(maxReportCount, &readSize, pRawDataUnpacked + rawDataOffset);
// Return at first error.
if (result != ZE_RESULT_SUCCESS) {

2
level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp
View File

@@ -395,7 +395,7 @@ StatusCode MockMetricsLibraryApi::ConfigurationDeactivate(const ConfigurationHan
}
StatusCode MockMetricsLibraryApi::ConfigurationDelete(const ConfigurationHandle_1_0 handle) {
return Mock<MetricsLibrary>::g_mockApi->MockConfigurationDeactivate(handle);
return Mock<MetricsLibrary>::g_mockApi->MockConfigurationDelete(handle);
}
StatusCode MockMetricsLibraryApi::GetData(GetReportData_1_0 *data) {

132
level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp
View File

@@ -433,5 +433,137 @@ TEST_F(MetricQueryPoolTest, givenUninitializedMetricEnumerationWhenGetQueryRepor
EXPECT_EQ(invalidSize, 0u);
}
TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalledThenReturnsSuccess) {
zet_device_handle_t metricDevice = device->toHandle();
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;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
value.ValueUInt32 = 64;
ConfigurationHandle_1_0 metricsLibraryConfigurationHandle = {&value};
ContextHandle_1_0 metricsLibraryContextHandle = {&value};
openMetricsAdapter();
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(1)
.WillOnce(Return(&metric));
EXPECT_CALL(metricsSet, Activate())
.Times(1)
.WillOnce(Return(MetricsDiscovery::CC_OK));
EXPECT_CALL(metricsSet, Deactivate())
.Times(1)
.WillOnce(Return(MetricsDiscovery::CC_OK));
EXPECT_CALL(metric, GetParams())
.Times(1)
.WillOnce(Return(&metricParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(*mockMetricEnumeration, isInitialized())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(0);
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
.Times(1)
.WillOnce(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationCreate(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryConfigurationHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
.Times(1)
.WillOnce(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
.Times(1)
.WillOnce(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDelete(_))
.Times(1)
.WillOnce(Return(StatusCode::Success));
// 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);
// Activate metric groups.
device->activateMetricGroups();
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDevice, 0, nullptr), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

137
level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_3.cpp
View File

@@ -1412,5 +1412,142 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc
EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalledThenReturnsSuccess) {
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;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
value.ValueUInt32 = 64;
ConfigurationHandle_1_0 metricsLibraryConfigurationHandle = {&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(metricsSet, Activate())
.Times(subDeviceCount)
.WillRepeatedly(Return(MetricsDiscovery::CC_OK));
EXPECT_CALL(metricsSet, Deactivate())
.Times(subDeviceCount)
.WillRepeatedly(Return(MetricsDiscovery::CC_OK));
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, MockContextCreate(_, _, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationCreate(_, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryConfigurationHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDelete(_))
.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);
// Activate metric group (deferred).
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), devices[0]->toHandle(), 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
// Activate metric groups.
devices[0]->activateMetricGroups();
// Deactivate metric groups.
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDevice, 0, nullptr), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0