Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

L0 and Ocl Metric Api sub device support 

Signed-off-by: Piotr Maciejewski <piotr.maciejewski@intel.com>
This commit is contained in:
Piotr Maciejewski 2020-12-17 13:17:28 +00:00 committed by Compute-Runtime-Automation
parent 6a81edfbe1
commit aa05b5adb4
25 changed files with 491 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/tools/source/metrics/linux/os_metric_enumeration_imp_linux.cpp
View File

@ -33,7 +33,7 @@ bool MetricEnumeration::getAdapterId(uint32_t &adapterMajor, uint32_t &adapterMi
return result == 0;
}
MetricsDiscovery::IAdapter_1_8 *MetricEnumeration::getMetricsAdapter() {
MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() {
UNRECOVERABLE_IF(pAdapterGroup == nullptr);

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -65,6 +65,8 @@ struct MetricContextImp : public MetricContext {
void setUseCompute(const bool useCompute) override;
bool isComputeUsed() override;
uint32_t getSubDeviceIndex() override;
void setSubDeviceIndex(const uint32_t index) override;
protected:
ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
@ -73,6 +75,7 @@ struct MetricContextImp : public MetricContext {
std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
MetricGroupDomains metricGroupDomains;
MetricStreamer *pMetricStreamer = nullptr;
uint32_t subDeviceIndex = 0;
bool useCompute = false;
};
@ -81,6 +84,13 @@ MetricContextImp::MetricContextImp(Device &deviceInput)
metricEnumeration(std::unique_ptr<MetricEnumeration>(new (std::nothrow) MetricEnumeration(*this))),
metricsLibrary(std::unique_ptr<MetricsLibrary>(new (std::nothrow) MetricsLibrary(*this))),
metricGroupDomains(*this) {
auto deviceNeo = deviceInput.getNEODevice();
bool isSubDevice = deviceNeo->getParentDevice() != nullptr;
subDeviceIndex = isSubDevice
? static_cast<NEO::SubDevice *>(deviceNeo)->getSubDeviceIndex()
: 0;
}
MetricContextImp::~MetricContextImp() {
@ -98,15 +108,6 @@ bool MetricContextImp::loadDependencies() {
result = false;
DEBUG_BREAK_IF(!result);
}
// Initialize metrics library temporarily
// to check requirements expected from the kernel driver.
if (result) {
result = metricsLibrary->isInitialized();
DEBUG_BREAK_IF(!result);
}
// Disable temporary metrics library instance.
metricsLibrary->release();
// Set metric context initialization state.
setInitializationState(result
@ -154,6 +155,14 @@ bool MetricContextImp::isComputeUsed() {
return useCompute;
}
uint32_t MetricContextImp::getSubDeviceIndex() {
return subDeviceIndex;
}
void MetricContextImp::setSubDeviceIndex(const uint32_t index) {
subDeviceIndex = index;
}
ze_result_t
MetricContextImp::activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
@ -171,30 +180,51 @@ bool MetricContextImp::isMetricGroupActivated(const zet_metric_group_handle_t hM
ze_result_t MetricContextImp::activateMetricGroups() { return metricGroupDomains.activate(); }
ze_result_t MetricContext::enableMetricApi() {
if (!isMetricApiAvailable()) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
DriverHandle *driverHandle = L0::DriverHandle::fromHandle(GlobalDriverHandle);
bool failed = false;
uint32_t count = 0;
if (driverHandle->getDevice(&count, nullptr) != ZE_RESULT_SUCCESS) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
uint32_t rootDeviceCount = 0;
uint32_t subDeviceCount = 0;
std::vector<ze_device_handle_t> devices(count);
if (driverHandle->getDevice(&count, devices.data()) != ZE_RESULT_SUCCESS) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
auto driverHandle = L0::DriverHandle::fromHandle(GlobalDriverHandle);
auto rootDevices = std::vector<ze_device_handle_t>();
auto subDevices = std::vector<ze_device_handle_t>();
for (auto deviceHandle : devices) {
Device *device = L0::Device::fromHandle(deviceHandle);
if (!device->getMetricContext().loadDependencies()) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
// Obtain root devices.
driverHandle->getDevice(&rootDeviceCount, nullptr);
rootDevices.resize(rootDeviceCount);
driverHandle->getDevice(&rootDeviceCount, rootDevices.data());
for (auto rootDeviceHandle : rootDevices) {
// Initialize root device.
auto rootDevice = L0::Device::fromHandle(rootDeviceHandle);
failed |= !rootDevice->getMetricContext().loadDependencies();
// Sub devices count.
subDeviceCount = 0;
rootDevice->getSubDevices(&subDeviceCount, nullptr);
// Sub device instances.
subDevices.clear();
subDevices.resize(subDeviceCount);
rootDevice->getSubDevices(&subDeviceCount, subDevices.data());
// Initialize sub devices.
for (uint32_t i = 0; i < subDevices.size(); ++i) {
auto subDevice = L0::Device::fromHandle(subDevices[i]);
failed |= !subDevice->getMetricContext().loadDependencies();
}
}
return ZE_RESULT_SUCCESS;
return failed
? ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
: ZE_RESULT_SUCCESS;
}
std::unique_ptr<MetricContext> MetricContext::create(Device &device) {

4
level_zero/tools/source/metrics/metric.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -54,6 +54,8 @@ struct MetricContext {
virtual void setUseCompute(const bool useCompute) = 0;
virtual bool isComputeUsed() = 0;
virtual uint32_t getSubDeviceIndex() = 0;
virtual void setSubDeviceIndex(const uint32_t index) = 0;
};
struct Metric : _zet_metric_handle_t {

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

@ -97,6 +97,8 @@ ze_result_t MetricEnumeration::loadMetricsDiscovery() {
ze_result_t MetricEnumeration::openMetricsDiscovery() {
UNRECOVERABLE_IF(openAdapterGroup == nullptr);
const uint32_t subDeviceIndex = metricContext.getSubDeviceIndex();
// Clean up members.
pAdapterGroup = nullptr;
pAdapter = nullptr;
@ -118,9 +120,14 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
pAdapter->OpenMetricsDevice(&pMetricsDevice);
if (subDeviceIndex == 0) {
pAdapter->OpenMetricsDevice(&pMetricsDevice);
} else {
pAdapter->OpenMetricsSubDevice(subDeviceIndex, &pMetricsDevice);
}
if (pMetricsDevice == nullptr) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %s\n", " ");
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %u\n", subDeviceIndex);
cleanupMetricsDiscovery();
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}

6
level_zero/tools/source/metrics/metric_enumeration_imp.h
View File

@ -33,7 +33,7 @@ struct MetricEnumeration {
virtual ze_result_t openMetricsDiscovery();
virtual bool getAdapterId(uint32_t &major, uint32_t &minor);
virtual MetricsDiscovery::IAdapter_1_8 *getMetricsAdapter();
virtual MetricsDiscovery::IAdapter_1_9 *getMetricsAdapter();
ze_result_t cleanupMetricsDiscovery();
ze_result_t cacheMetricInformation();
@ -60,8 +60,8 @@ struct MetricEnumeration {
// Metrics Discovery API.
std::unique_ptr<NEO::OsLibrary> hMetricsDiscovery = nullptr;
MetricsDiscovery::OpenAdapterGroup_fn openAdapterGroup = nullptr;
MetricsDiscovery::IAdapterGroup_1_8 *pAdapterGroup = nullptr;
MetricsDiscovery::IAdapter_1_8 *pAdapter = nullptr;
MetricsDiscovery::IAdapterGroup_1_9 *pAdapterGroup = nullptr;
MetricsDiscovery::IAdapter_1_9 *pAdapter = nullptr;
MetricsDiscovery::IMetricsDevice_1_5 *pMetricsDevice = nullptr;
public:

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

@ -197,12 +197,44 @@ bool MetricsLibrary::load() {
return true;
}
void MetricsLibrary::getSubDeviceClientOptions(
NEO::Device &neoDevice,
ClientOptionsData_1_0 &subDevice,
ClientOptionsData_1_0 &subDeviceIndex,
ClientOptionsData_1_0 &subDeviceCount) {
if (neoDevice.getParentDevice() == nullptr) {
// Root device.
subDevice.Type = ClientOptionsType::SubDevice;
subDevice.SubDevice.Enabled = false;
subDeviceIndex.Type = ClientOptionsType::SubDeviceIndex;
subDeviceIndex.SubDeviceIndex.Index = 0;
subDeviceCount.Type = ClientOptionsType::SubDeviceCount;
subDeviceCount.SubDeviceCount.Count = neoDevice.getNumAvailableDevices();
} else {
// Sub device.
subDevice.Type = ClientOptionsType::SubDevice;
subDevice.SubDevice.Enabled = true;
subDeviceIndex.Type = ClientOptionsType::SubDeviceIndex;
subDeviceIndex.SubDeviceIndex.Index = static_cast<NEO::SubDevice *>(&neoDevice)->getSubDeviceIndex();
subDeviceCount.Type = ClientOptionsType::SubDeviceCount;
subDeviceCount.SubDeviceCount.Count = neoDevice.getParentDevice()->getNumAvailableDevices();
}
}
bool MetricsLibrary::createContext() {
auto &device = metricContext.getDevice();
const auto &hwHelper = device.getHwHelper();
const auto &asyncComputeEngines = hwHelper.getGpgpuEngineInstances(device.getHwInfo());
ContextCreateData_1_0 createData = {};
ClientOptionsData_1_0 clientOptions[2] = {};
ClientOptionsData_1_0 clientOptions[5] = {};
ClientData_1_0 clientData = {};
ClientType_1_0 clientType = {};
ClientDataLinuxAdapter_1_0 adapter = {};
@ -230,6 +262,9 @@ bool MetricsLibrary::createContext() {
clientOptions[1].Type = ClientOptionsType::Tbs;
clientOptions[1].Tbs.Enabled = metricContext.getMetricStreamer() != nullptr;
// Sub device client options #2
getSubDeviceClientOptions(*device.getNEODevice(), clientOptions[2], clientOptions[3], clientOptions[4]);
clientData.Linux.Adapter = &adapter;
clientData.ClientOptions = clientOptions;
clientData.ClientOptionsCount = sizeof(clientOptions) / sizeof(ClientOptionsData_1_0);

5
level_zero/tools/source/metrics/metric_query_imp.h
View File

@ -13,6 +13,7 @@
using MetricsLibraryApi::ClientCallbacks_1_0;
using MetricsLibraryApi::ClientGen;
using MetricsLibraryApi::ClientOptionsData_1_0;
using MetricsLibraryApi::CommandBufferData_1_0;
using MetricsLibraryApi::ConfigurationHandle_1_0;
using MetricsLibraryApi::ContextCreateData_1_0;
@ -44,6 +45,10 @@ struct MetricsLibrary {
virtual bool load();
bool isInitialized();
ze_result_t getInitializationState();
void getSubDeviceClientOptions(NEO::Device &neoDevice,
ClientOptionsData_1_0 &subDevice,
ClientOptionsData_1_0 &subDeviceIndex,
ClientOptionsData_1_0 &subDeviceCount);
static const char *getFilename();
// Deinitialization.

2
level_zero/tools/source/metrics/windows/os_metric_enumeration_imp_windows.cpp
View File

@ -33,7 +33,7 @@ bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) {
return true;
}
MetricsDiscovery::IAdapter_1_8 *MetricEnumeration::getMetricsAdapter() {
MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() {
uint32_t major = 0;
uint32_t minor = 0;

14
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_query_pool_linux.cpp
View File

@ -76,7 +76,7 @@ class MetricEnumerationTestLinux : public MetricContextFixture,
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
@ -112,7 +112,7 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorPrimaryNodeDrmAdapterWh
const int32_t drmMaxDevices = 64; // From drm_drv.c#110
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
@ -150,7 +150,7 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorRenderNodeDrmAdapterWhe
const int32_t drmMaxDevices = 64; // From drm_drv.c#110
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
@ -185,7 +185,7 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorRenderNodeDrmAdapterWhe
TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterTypeWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_LUID;
@ -220,7 +220,7 @@ TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterTypeWhenGe
TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMajorWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
@ -256,7 +256,7 @@ TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMajorWhenG
TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMinorWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
@ -292,7 +292,7 @@ TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMinorWhenG
TEST_F(MetricEnumerationTestLinux, givenIcorrectOpenMetricDeviceOnAdapterWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;

4
level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h
View File

@ -160,8 +160,8 @@ class MetricContextFixture : public ContextFixture {
MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {};
// Metrics discovery device
Mock<IAdapterGroup_1_8> adapterGroup;
Mock<IAdapter_1_8> adapter;
Mock<IAdapterGroup_1_9> adapterGroup;
Mock<IAdapter_1_9> adapter;
Mock<IMetricsDevice_1_5> metricsDevice;
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
};

34
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.cpp
View File

@ -18,7 +18,7 @@ Mock<MetricEnumeration>::~Mock() {
MockMetricsDiscoveryApi *Mock<MetricEnumeration>::g_mockApi = nullptr;
TCompletionCode MockMetricsDiscoveryApi::OpenAdapterGroup(IAdapterGroup_1_8 **group) {
TCompletionCode MockMetricsDiscoveryApi::OpenAdapterGroup(IAdapterGroup_1_9 **group) {
return Mock<MetricEnumeration>::g_mockApi->MockOpenAdapterGroup(group);
}
@ -264,6 +264,11 @@ IAdapter_1_8 *IAdapterGroup_1_8::GetAdapter(uint32_t index) {
return nullptr;
}
IAdapter_1_6 *IAdapterGroup_1_6::GetAdapter(uint32_t index) {
UNRECOVERABLE_IF(true);
return nullptr;
}
IAdapterGroup_1_6 ::~IAdapterGroup_1_6() {
}
@ -272,7 +277,7 @@ const TAdapterGroupParams_1_6 *IAdapterGroup_1_6::GetParams(void) const {
return nullptr;
}
IAdapter_1_6 *IAdapterGroup_1_6::GetAdapter(uint32_t index) {
IAdapter_1_9 *IAdapterGroup_1_9::GetAdapter(uint32_t index) {
UNRECOVERABLE_IF(true);
return nullptr;
}
@ -294,6 +299,11 @@ const TAdapterParams_1_8 *IAdapter_1_8::GetParams(void) const {
return nullptr;
}
const TAdapterParams_1_9 *IAdapter_1_9::GetParams(void) const {
UNRECOVERABLE_IF(true);
return nullptr;
}
TCompletionCode IAdapter_1_6 ::Reset() {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
@ -319,4 +329,24 @@ TCompletionCode IAdapter_1_6 ::SaveMetricsDeviceToFile(const char *fileName, voi
return CC_ERROR_NOT_SUPPORTED;
}
const TSubDeviceParams_1_9 *IAdapter_1_9::GetSubDeviceParams(const uint32_t subDeviceIndex) {
UNRECOVERABLE_IF(true);
return nullptr;
}
const TEngineParams_1_9 *IAdapter_1_9::GetEngineParams(const uint32_t subDeviceIndex, const uint32_t engineIndex) {
UNRECOVERABLE_IF(true);
return nullptr;
}
TCompletionCode IAdapter_1_9::OpenMetricsSubDevice(const uint32_t subDeviceIndex, IMetricsDevice_1_5 **metricsDevice) {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
TCompletionCode IAdapter_1_9::OpenMetricsSubDeviceFromFile(const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_5 **metricsDevice) {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
} // namespace MetricsDiscovery

28
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h
View File

@ -26,8 +26,10 @@ using MetricGroup = WhiteBox<::L0::MetricGroup>;
using MetricsDiscovery::IAdapter_1_6;
using MetricsDiscovery::IAdapter_1_8;
using MetricsDiscovery::IAdapter_1_9;
using MetricsDiscovery::IAdapterGroup_1_6;
using MetricsDiscovery::IAdapterGroup_1_8;
using MetricsDiscovery::IAdapterGroup_1_9;
using MetricsDiscovery::IConcurrentGroup_1_5;
using MetricsDiscovery::IInformation_1_0;
using MetricsDiscovery::IMetric_1_0;
@ -38,13 +40,16 @@ using MetricsDiscovery::IOverride_1_2;
using MetricsDiscovery::TAdapterGroupParams_1_6;
using MetricsDiscovery::TAdapterParams_1_6;
using MetricsDiscovery::TAdapterParams_1_8;
using MetricsDiscovery::TAdapterParams_1_9;
using MetricsDiscovery::TCompletionCode;
using MetricsDiscovery::TConcurrentGroupParams_1_0;
using MetricsDiscovery::TEngineParams_1_9;
using MetricsDiscovery::TGlobalSymbol_1_0;
using MetricsDiscovery::TMetricParams_1_0;
using MetricsDiscovery::TMetricsDeviceParams_1_2;
using MetricsDiscovery::TMetricSetParams_1_4;
using MetricsDiscovery::TSamplingType;
using MetricsDiscovery::TSubDeviceParams_1_9;
using MetricsDiscovery::TTypedValue_1_0;
struct MockMetricsDiscoveryApi {
@ -53,31 +58,37 @@ struct MockMetricsDiscoveryApi {
static TCompletionCode MD_STDCALL OpenMetricsDeviceFromFile(const char *fileName, void *openParams, IMetricsDevice_1_5 **device);
static TCompletionCode MD_STDCALL CloseMetricsDevice(IMetricsDevice_1_5 *device);
static TCompletionCode MD_STDCALL SaveMetricsDeviceToFile(const char *fileName, void *saveParams, IMetricsDevice_1_5 *device);
static TCompletionCode MD_STDCALL OpenAdapterGroup(IAdapterGroup_1_8 **adapterGroup);
static TCompletionCode MD_STDCALL OpenAdapterGroup(IAdapterGroup_1_9 **adapterGroup);
// Mocked api functions.
MOCK_METHOD(TCompletionCode, MockOpenMetricsDeviceFromFile, (const char *, void *, IMetricsDevice_1_5 **));
MOCK_METHOD(TCompletionCode, MockCloseMetricsDevice, (IMetricsDevice_1_5 *));
MOCK_METHOD(TCompletionCode, MockSaveMetricsDeviceToFile, (const char *, void *, IMetricsDevice_1_5 *));
MOCK_METHOD(TCompletionCode, MockOpenAdapterGroup, (IAdapterGroup_1_8 * *adapterGroup));
MOCK_METHOD(TCompletionCode, MockOpenAdapterGroup, (IAdapterGroup_1_9 * *adapterGroup));
};
template <>
class Mock<IAdapterGroup_1_8> : public IAdapterGroup_1_8 {
class Mock<IAdapterGroup_1_9> : public IAdapterGroup_1_9 {
public:
Mock(){};
MOCK_METHOD(IAdapter_1_8 *, GetAdapter, (uint32_t), (override));
MOCK_METHOD(IAdapter_1_9 *, GetAdapter, (uint32_t), (override));
MOCK_METHOD(const TAdapterGroupParams_1_6 *, GetParams, (), (const, override));
MOCK_METHOD(TCompletionCode, Close, (), (override));
};
template <>
class Mock<IAdapter_1_8> : public IAdapter_1_8 {
class Mock<IAdapter_1_9> : public IAdapter_1_9 {
public:
Mock(){};
MOCK_METHOD(const TAdapterParams_1_8 *, GetParams, (), (const, override));
// 1.9
MOCK_METHOD(const TSubDeviceParams_1_9 *, GetSubDeviceParams, (const uint32_t subDeviceIndex), (override));
MOCK_METHOD(const TEngineParams_1_9 *, GetEngineParams, (const uint32_t subDeviceIndex, const uint32_t engineIndex), (override));
MOCK_METHOD(TCompletionCode, OpenMetricsSubDevice, (const uint32_t subDeviceIndex, IMetricsDevice_1_5 **metricsDevice), (override));
MOCK_METHOD(TCompletionCode, OpenMetricsSubDeviceFromFile, (const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_5 **metricsDevice), (override));
MOCK_METHOD(const TAdapterParams_1_9 *, GetParams, (), (const, override));
MOCK_METHOD(TCompletionCode, Reset, (), (override));
MOCK_METHOD(TCompletionCode, OpenMetricsDevice, (IMetricsDevice_1_5 **), (override));
MOCK_METHOD(TCompletionCode, OpenMetricsDeviceFromFile, (const char *, void *, IMetricsDevice_1_5 **), (override));
@ -146,6 +157,7 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
Mock(::L0::MetricContext &metricContext);
~Mock() override;
using MetricEnumeration::cleanupMetricsDiscovery;
using MetricEnumeration::hMetricsDiscovery;
using MetricEnumeration::initializationState;
using MetricEnumeration::openAdapterGroup;
@ -157,12 +169,12 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
// Mock metric enumeration functions.
MOCK_METHOD(bool, isInitialized, (), (override));
MOCK_METHOD(ze_result_t, loadMetricsDiscovery, (), (override));
MOCK_METHOD(MetricsDiscovery::IAdapter_1_8 *, getMetricsAdapter, (), (override));
MOCK_METHOD(MetricsDiscovery::IAdapter_1_9 *, getMetricsAdapter, (), (override));
MOCK_METHOD(bool, getAdapterId, (uint32_t & drmMajor, uint32_t &drmMinor), (override));
// Not mocked metrics enumeration functions.
bool baseIsInitialized() { return MetricEnumeration::isInitialized(); }
IAdapter_1_8 *baseGetMetricsAdapter() { return MetricEnumeration::getMetricsAdapter(); }
IAdapter_1_9 *baseGetMetricsAdapter() { return MetricEnumeration::getMetricsAdapter(); }
bool baseGetAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor) { return MetricEnumeration::getAdapterId(adapterMajor, adapterMinor); }
ze_result_t baseLoadMetricsDiscovery() { return MetricEnumeration::loadMetricsDiscovery(); }

88
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp
View File

@ -1966,22 +1966,94 @@ TEST_F(MetricEnumerationTest, givenNotLoadedMetricsLibraryAndDiscoveryWhenLoadDe
EXPECT_EQ(metricContext.isInitialized(), false);
}
TEST_F(MetricEnumerationTest, givenLoadedMetricsLibraryAndDiscoveryAndMetricsLibraryNotInitializedWhenLoadDependenciesThenReturnFail) {
TEST_F(MetricEnumerationTest, givenRootDeviceWhenLoadDependenciesIsCalledThenLegacyOpenMetricsDeviceWillBeCalled) {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
auto &metricContext = device->getMetricContext();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
mockMetricsLibrary->initializationState = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
auto &metricContext = device->getMetricContext();
EXPECT_EQ(metricContext.loadDependencies(), false);
EXPECT_EQ(metricContext.isInitialized(), false);
EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&mockAdapter));
EXPECT_CALL(mockAdapter, OpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(mockDevice, GetParams())
.Times(1)
.WillOnce(Return(&metricsDeviceParams));
// Use first sub device.
metricContext.setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTest, givenSubDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalled) {
auto &metricContext = device->getMetricContext();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&mockAdapter));
EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(mockDevice, GetParams())
.Times(1)
.WillOnce(Return(&metricsDeviceParams));
// Use first sub device.
metricContext.setSubDeviceIndex(1);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

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

@ -6,6 +6,7 @@
*/
#include "shared/source/os_interface/device_factory.h"
#include "shared/test/common/mocks/ult_device_factory.h"
#include "test.h"
@ -879,5 +880,52 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeAndMetricsLibraryWillFailWhen
EXPECT_EQ(zeEventPoolDestroy(eventPoolHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricQueryPoolTest, givenRootDeviceWhenGetSubDeviceClientOptionsIsCalledThenReturnRootDeviceProperties) {
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto subDevice = ClientOptionsData_1_0{};
auto subDeviceIndex = ClientOptionsData_1_0{};
auto subDeviceCount = ClientOptionsData_1_0{};
metricsLibrary.getSubDeviceClientOptions(*device->getNEODevice(), subDevice, subDeviceIndex, subDeviceCount);
// Root device
EXPECT_EQ(subDevice.Type, MetricsLibraryApi::ClientOptionsType::SubDevice);
EXPECT_EQ(subDevice.SubDevice.Enabled, false);
EXPECT_EQ(subDeviceIndex.Type, MetricsLibraryApi::ClientOptionsType::SubDeviceIndex);
EXPECT_EQ(subDeviceIndex.SubDeviceIndex.Index, 0u);
EXPECT_EQ(subDeviceCount.Type, MetricsLibraryApi::ClientOptionsType::SubDeviceCount);
EXPECT_EQ(subDeviceCount.SubDeviceCount.Count, device->getNEODevice()->getNumAvailableDevices());
}
TEST_F(MetricQueryPoolTest, givenSubDeviceWhenGetSubDeviceClientOptionsIsCalledThenReturnSubDeviceProperties) {
auto deviceFactory = std::make_unique<UltDeviceFactory>(1, 4);
auto rootDevice = deviceFactory->rootDevices[0];
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto subDevice = ClientOptionsData_1_0{};
auto subDeviceIndex = ClientOptionsData_1_0{};
auto subDeviceCount = ClientOptionsData_1_0{};
// Sub devices
for (uint32_t i = 0, count = rootDevice->getNumAvailableDevices(); i < count; ++i) {
metricsLibrary.getSubDeviceClientOptions(*rootDevice->subdevices[i], subDevice, subDeviceIndex, subDeviceCount);
EXPECT_EQ(subDevice.Type, MetricsLibraryApi::ClientOptionsType::SubDevice);
EXPECT_EQ(subDevice.SubDevice.Enabled, true);
EXPECT_EQ(subDeviceIndex.Type, MetricsLibraryApi::ClientOptionsType::SubDeviceIndex);
EXPECT_EQ(subDeviceIndex.SubDeviceIndex.Index, i);
EXPECT_EQ(subDeviceCount.Type, MetricsLibraryApi::ClientOptionsType::SubDeviceCount);
EXPECT_EQ(subDeviceCount.SubDeviceCount.Count, rootDevice->getNumAvailableDevices());
}
}
} // namespace ult
} // namespace L0

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

@ -29,7 +29,7 @@ TEST_F(MetricEnumerationTestWindows, givenCorrectWindowsAdapterWhenGetMetricsAda
auto &osInterface = rootDevice->osInterface;
auto wddm = new WddmMock(*rootDevice);
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
auto adapterParams = TAdapterParams_1_9{};
osInterface = std::make_unique<NEO::OSInterface>();
osInterface->get()->setWddm(wddm);

21
opencl/source/os_interface/linux/performance_counters_linux.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -8,6 +8,7 @@
#include "performance_counters_linux.h"
#include "shared/source/device/device.h"
#include "shared/source/device/sub_device.h"
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/os_interface/linux/os_interface.h"
#include "shared/source/os_interface/linux/os_time_linux.h"
@ -24,10 +25,28 @@ std::unique_ptr<PerformanceCounters> PerformanceCounters::create(Device *device)
auto &hwHelper = HwHelper::get(gen);
UNRECOVERABLE_IF(counter == nullptr);
if (device->getParentDevice() == nullptr) {
// Root device.
counter->subDevice.Enabled = false;
counter->subDeviceIndex.Index = 0;
counter->subDeviceCount.Count = device->getNumAvailableDevices();
} else {
// Sub device.
counter->subDevice.Enabled = true;
counter->subDeviceIndex.Index = static_cast<NEO::SubDevice *>(device)->getSubDeviceIndex();
counter->subDeviceCount.Count = device->getParentDevice()->getNumAvailableDevices();
}
// Adapter data.
counter->adapter.Type = LinuxAdapterType::DrmFileDescriptor;
counter->adapter.DrmFileDescriptor = drm->getFileDescriptor();
counter->clientData.Linux.Adapter = &(counter->adapter);
// Gen data.
counter->clientType.Gen = static_cast<MetricsLibraryApi::ClientGen>(hwHelper.getMetricsLibraryGenId());
return counter;
}

15
opencl/source/os_interface/metrics_library.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -51,14 +51,23 @@ bool MetricsLibrary::open() {
//////////////////////////////////////////////////////
bool MetricsLibrary::contextCreate(
const ClientType_1_0 &clientType,
ClientOptionsSubDeviceData_1_0 &subDevice,
ClientOptionsSubDeviceIndexData_1_0 &subDeviceIndex,
ClientOptionsSubDeviceCountData_1_0 &subDeviceCount,
ClientData_1_0 &clientData,
ContextCreateData_1_0 &createData,
ContextHandle_1_0 &handle) {
MetricsLibraryApi::ClientOptionsData_1_0 clientOptions[1] = {};
MetricsLibraryApi::ClientOptionsData_1_0 clientOptions[4] = {};
clientOptions[0].Type = MetricsLibraryApi::ClientOptionsType::Compute;
clientOptions[0].Compute.Asynchronous = true;
clientData.ClientOptionsCount = 1;
clientOptions[1].Type = MetricsLibraryApi::ClientOptionsType::SubDevice;
clientOptions[1].SubDevice = subDevice;
clientOptions[2].Type = MetricsLibraryApi::ClientOptionsType::SubDeviceIndex;
clientOptions[2].SubDeviceIndex = subDeviceIndex;
clientOptions[3].Type = MetricsLibraryApi::ClientOptionsType::SubDeviceCount;
clientOptions[3].SubDeviceCount = subDeviceCount;
clientData.ClientOptionsCount = 4;
clientData.ClientOptions = clientOptions;
createData.Api = &api->functions;

7
opencl/source/os_interface/metrics_library.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,6 +19,9 @@ using MetricsLibraryApi::ClientApi;
using MetricsLibraryApi::ClientCallbacks_1_0;
using MetricsLibraryApi::ClientData_1_0;
using MetricsLibraryApi::ClientGen;
using MetricsLibraryApi::ClientOptionsSubDeviceCountData_1_0;
using MetricsLibraryApi::ClientOptionsSubDeviceData_1_0;
using MetricsLibraryApi::ClientOptionsSubDeviceIndexData_1_0;
using MetricsLibraryApi::ClientType_1_0;
using MetricsLibraryApi::CommandBufferData_1_0;
using MetricsLibraryApi::CommandBufferSize_1_0;
@ -58,7 +61,7 @@ class MetricsLibrary {
MOCKABLE_VIRTUAL bool open();
// Context create / destroy functions.
MOCKABLE_VIRTUAL bool contextCreate(const ClientType_1_0 &client, ClientData_1_0 &clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle);
MOCKABLE_VIRTUAL bool contextCreate(const ClientType_1_0 &client, ClientOptionsSubDeviceData_1_0 &subDevice, ClientOptionsSubDeviceIndexData_1_0 &subDeviceIndex, ClientOptionsSubDeviceCountData_1_0 &subDeviceCount, ClientData_1_0 &clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle);
MOCKABLE_VIRTUAL bool contextDelete(const ContextHandle_1_0 &handle);
// HwCounters functions.

5
opencl/source/os_interface/performance_counters.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -98,6 +98,9 @@ bool PerformanceCounters::openMetricsLibrary() {
if (result) {
result = metricsLibrary->contextCreate(
clientType,
subDevice,
subDeviceIndex,
subDeviceCount,
clientData,
contextData,
context);

5
opencl/source/os_interface/performance_counters.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -93,6 +93,9 @@ class PerformanceCounters {
/////////////////////////////////////////////////////
ClientData_1_0 clientData = {};
ClientType_1_0 clientType = {ClientApi::OpenCL, ClientGen::Unknown};
ClientOptionsSubDeviceData_1_0 subDevice = {};
ClientOptionsSubDeviceIndexData_1_0 subDeviceIndex = {};
ClientOptionsSubDeviceCountData_1_0 subDeviceCount = {};
/////////////////////////////////////////////////////
// Metrics Library context.

4
opencl/test/unit_test/os_interface/mock_performance_counters.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -29,7 +29,7 @@ bool MockMetricsLibrary::open() {
//////////////////////////////////////////////////////
// MockMetricsLibrary::contextCreate
//////////////////////////////////////////////////////
bool MockMetricsLibrary::contextCreate(const ClientType_1_0 &client, ClientData_1_0 &clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle) {
bool MockMetricsLibrary::contextCreate(const ClientType_1_0 &client, ClientOptionsSubDeviceData_1_0 &subDevice, ClientOptionsSubDeviceIndexData_1_0 &subDeviceIndex, ClientOptionsSubDeviceCountData_1_0 &subDeviceCount, ClientData_1_0 &clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle) {
if (client.Api != MetricsLibraryApi::ClientApi::OpenCL) {
return false;
}

2
opencl/test/unit_test/os_interface/mock_performance_counters.h
View File

@ -82,7 +82,7 @@ class MockMetricsLibrary : public MetricsLibrary {
bool open() override;
// Context create / destroy functions.
bool contextCreate (const ClientType_1_0 &client, ClientData_1_0& clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle) override;
bool contextCreate (const ClientType_1_0 &client, ClientOptionsSubDeviceData_1_0 &subDevice, ClientOptionsSubDeviceIndexData_1_0 &subDeviceIndex, ClientOptionsSubDeviceCountData_1_0 &subDeviceCount, ClientData_1_0& clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle) override;
bool contextDelete (const ContextHandle_1_0 &handle) override;
// HwCounters functions.

2
third_party/metrics_discovery/.revision vendored
View File

@ -1 +1 @@
17f4240027df2dd8981200f6d8cf5e20f8015fd3
a2a6507c3d035bb002012238dde3223b3fb77e41

109
third_party/metrics_discovery/metrics_discovery_api.h vendored
View File

@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
// Copyright © 2019-2021, Intel Corporation
// Copyright © 2019-2020, Intel Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
@ -54,7 +54,7 @@
//////////////////////////////////////////////////////////////////////////////////
// API build number:
//////////////////////////////////////////////////////////////////////////////////
#define MD_API_BUILD_NUMBER_CURRENT 131
#define MD_API_BUILD_NUMBER_CURRENT 133
namespace MetricsDiscovery
{
@ -82,7 +82,8 @@ namespace MetricsDiscovery
MD_API_MINOR_NUMBER_6 = 6, // Multi adapter support
MD_API_MINOR_NUMBER_7 = 7,
MD_API_MINOR_NUMBER_8 = 8, // TAdapterParams update
MD_API_MINOR_NUMBER_CURRENT = MD_API_MINOR_NUMBER_8,
MD_API_MINOR_NUMBER_9 = 9, // Sub device support.
MD_API_MINOR_NUMBER_CURRENT = MD_API_MINOR_NUMBER_9,
MD_API_MINOR_NUMBER_CEIL = 0xFFFFFFFF
} MD_API_MINOR_VERSION;
@ -421,9 +422,63 @@ namespace MetricsDiscovery
//////////////////////////////////////////////////////////////////////////////////
typedef struct SAdapterParams_1_8 : public SAdapterParams_1_6
{
uint32_t DomainNumber;
uint32_t DomainNumber;
} TAdapterParams_1_8;
//////////////////////////////////////////////////////////////////////////////////
// Global parameters of GPU adapter:
//////////////////////////////////////////////////////////////////////////////////
typedef struct SAdapterParams_1_9 : public SAdapterParams_1_8
{
uint32_t SubDevicesCount;
} TAdapterParams_1_9;
//////////////////////////////////////////////////////////////////////////////////
// Global parameters of GPU sub device:
//////////////////////////////////////////////////////////////////////////////////
typedef struct SSubDeviceParams_1_9
{
uint32_t EnginesCount;
} TSubDeviceParams_1_9;
//////////////////////////////////////////////////////////////////////////////////
// Engine ID types:
//////////////////////////////////////////////////////////////////////////////////
typedef enum EEngineIdType
{
ENGINE_ID_TYPE_CLASS_INSTANCE = 0
} TEngineIdType;
//////////////////////////////////////////////////////////////////////////////////
// Class / instance engine ID:
//////////////////////////////////////////////////////////////////////////////////
typedef struct SEngineIdClassInstance_1_9
{
uint32_t Class;
uint32_t Instance;
} TEngineIdClassInstance_1_9;
//////////////////////////////////////////////////////////////////////////////////
// Engine identification:
//////////////////////////////////////////////////////////////////////////////////
typedef struct SEngineId_1_9
{
TEngineIdType Type;
union
{
TEngineIdClassInstance_1_9 ClassInstance;
};
} TEngineId_1_9;
//////////////////////////////////////////////////////////////////////////////////
// Global parameters of GPU engine:
//////////////////////////////////////////////////////////////////////////////////
typedef struct SEngineParams_1_9
{
TEngineId_1_9 EngineId;
} TEngineParams_1_9;
//////////////////////////////////////////////////////////////////////////////////
// Global parameters of Adapter Group:
//////////////////////////////////////////////////////////////////////////////////
@ -1217,6 +1272,32 @@ namespace MetricsDiscovery
virtual const TAdapterParams_1_8* GetParams( void ) const;
};
///////////////////////////////////////////////////////////////////////////////
//
// Class:
// IAdapter_1_9
//
// Description:
// Abstract interface for GPU adapter.
//
// New:
// - GetParams: To get this adapter parameters
// - GetSubDeviceParams To get sub device parameters
// - GetEngineParams To get engine parameters
// - OpenMetricsSubDevice To open metrics device on given sub device
// - OpenMetricsSubDeviceFromFile To open metrics device from file on given sub device
//
///////////////////////////////////////////////////////////////////////////////
class IAdapter_1_9 : public IAdapter_1_8
{
public:
virtual const TAdapterParams_1_9* GetParams( void ) const;
virtual const TSubDeviceParams_1_9* GetSubDeviceParams( const uint32_t subDeviceIndex );
virtual const TEngineParams_1_9* GetEngineParams( const uint32_t subDeviceIndex, const uint32_t engineIndex );
virtual TCompletionCode OpenMetricsSubDevice( const uint32_t subDeviceIndex, IMetricsDevice_1_5** metricsDevice );
virtual TCompletionCode OpenMetricsSubDeviceFromFile( const uint32_t subDeviceIndex, const char* fileName, void* openParams, IMetricsDevice_1_5** metricsDevice );
};
///////////////////////////////////////////////////////////////////////////////
//
// Class:
@ -1258,13 +1339,31 @@ namespace MetricsDiscovery
virtual IAdapter_1_8* GetAdapter( uint32_t index );
};
///////////////////////////////////////////////////////////////////////////////
//
// Class:
// IAdapterGroup_1_9
//
// Description:
// Abstract interface for the GPU adapters root object.
//
// New:
// - GetAdapter: To enumerate available GPU adapters
//
///////////////////////////////////////////////////////////////////////////////
class IAdapterGroup_1_9 : public IAdapterGroup_1_8
{
public:
virtual IAdapter_1_9* GetAdapter( uint32_t index );
};
#ifdef __cplusplus
extern "C"
{
#endif
// [Current] Factory functions
typedef TCompletionCode( MD_STDCALL* OpenAdapterGroup_fn )( IAdapterGroup_1_8** adapterGroup );
typedef TCompletionCode( MD_STDCALL* OpenAdapterGroup_fn )( IAdapterGroup_1_9** adapterGroup );
// [Legacy] Factory functions
typedef TCompletionCode( MD_STDCALL* OpenMetricsDevice_fn )( IMetricsDevice_1_5** metricsDevice );

41
third_party/metrics_library/metrics_library_api_1_0.h vendored
View File

@ -131,6 +131,9 @@ enum class ClientOptionsType : uint32_t
Ptbr,
Compute,
Tbs,
SubDevice,
SubDeviceIndex,
SubDeviceCount,
// ...
Last
};
@ -159,6 +162,7 @@ enum class StatusCode : uint32_t
ReportLost,
ReportInconsistent,
CannotOpenFile,
ReportContextSwitchLost,
// ...
Last
};
@ -648,6 +652,30 @@ struct ClientOptionsTbsData_1_0
bool Enabled;
};
//////////////////////////////////////////////////////////////////////////
/// @brief Client options sub device data.
//////////////////////////////////////////////////////////////////////////
struct ClientOptionsSubDeviceData_1_0
{
bool Enabled;
};
//////////////////////////////////////////////////////////////////////////
/// @brief Client options sub device index data.
//////////////////////////////////////////////////////////////////////////
struct ClientOptionsSubDeviceIndexData_1_0
{
uint8_t Index;
};
//////////////////////////////////////////////////////////////////////////
/// @brief Client options sub device count data.
//////////////////////////////////////////////////////////////////////////
struct ClientOptionsSubDeviceCountData_1_0
{
uint8_t Count;
};
//////////////////////////////////////////////////////////////////////////
/// @brief Client options data.
//////////////////////////////////////////////////////////////////////////
@ -657,10 +685,13 @@ struct ClientOptionsData_1_0
union
{
ClientOptionsPoshData_1_0 Posh;
ClientOptionsPtbrData_1_0 Ptbr;
ClientOptionsComputeData_1_0 Compute;
ClientOptionsTbsData_1_0 Tbs;
ClientOptionsPoshData_1_0 Posh;
ClientOptionsPtbrData_1_0 Ptbr;
ClientOptionsComputeData_1_0 Compute;
ClientOptionsTbsData_1_0 Tbs;
ClientOptionsSubDeviceData_1_0 SubDevice;
ClientOptionsSubDeviceIndexData_1_0 SubDeviceIndex;
ClientOptionsSubDeviceCountData_1_0 SubDeviceCount;
};
};
@ -705,6 +736,6 @@ using ContextDeleteFunction_1_0 = StatusCode ( ML_STDCALL* ) ( const ContextHand
//////////////////////////////////////////////////////////////////////////
#define METRICS_LIBRARY_MAJOR_NUMBER 1
#define METRICS_LIBRARY_MINOR_NUMBER 0
#define METRICS_LIBRARY_BUILD_NUMBER 6
#define METRICS_LIBRARY_BUILD_NUMBER 44
} // namespace MetricsLibraryApi