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

L0 Metrics Api: multi adapter support

Browse Source 
Switching to Metrics Discovery adapter interface.
This commit is contained in:
Piotr Maciejewski
2020-12-11 13:11:00 +00:00
committed by Compute-Runtime-Automation
parent 09f9b2896e
commit 4a5599b1ee
16 changed files with 1488 additions and 1153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,14 +1,78 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/drm_neo.h"
#include "shared/source/os_interface/linux/os_interface.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include <sys/stat.h>
#include <sys/sysmacros.h>
namespace L0 {
const char *MetricEnumeration::getMetricsDiscoveryFilename() { return "libmd.so"; }
bool MetricEnumeration::getAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor) {
auto &device = metricContext.getDevice();
auto osInterface = device.getOsInterface().get();
auto drm = osInterface->getDrm();
auto drmFile = drm->getFileDescriptor();
struct stat drmStat = {};
int32_t result = fstat(drmFile, &drmStat);
adapterMajor = major(drmStat.st_rdev);
adapterMinor = minor(drmStat.st_rdev);
return result == 0;
}
MetricsDiscovery::IAdapter_1_8 *MetricEnumeration::getMetricsAdapter() {
UNRECOVERABLE_IF(pAdapterGroup == nullptr);
// Obtain drm minor / major version.
uint32_t drmMajor = 0;
uint32_t drmMinor = 0;
UNRECOVERABLE_IF(getAdapterId(drmMajor, drmMinor) == false);
// Driver drm major/minor version.
const int32_t drmNodePrimary = 0; // From xf86drm.h
const int32_t drmNodeRender = 2; // From xf86drm.h
const int32_t drmMaxDevices = 64; // From drm_drv.c#110
const int32_t drmMinorRender = drmMinor - (drmNodeRender * drmMaxDevices);
const int32_t drmMinorPrimary = drmMinor - (drmNodePrimary * drmMaxDevices);
// Enumerate metrics discovery adapters.
for (uint32_t index = 0, count = pAdapterGroup->GetParams()->AdapterCount;
index < count;
++index) {
UNRECOVERABLE_IF(pAdapterGroup->GetAdapter(index) == nullptr);
UNRECOVERABLE_IF(pAdapterGroup->GetAdapter(index)->GetParams() == nullptr);
auto adapter = pAdapterGroup->GetAdapter(index);
auto adapterParams = adapter->GetParams();
const bool validAdapterType = adapterParams->SystemId.Type == MetricsDiscovery::ADAPTER_ID_TYPE_MAJOR_MINOR;
const bool validAdapterMajor = adapterParams->SystemId.MajorMinor.Major == static_cast<int32_t>(drmMajor);
const bool validAdapterMinor = (adapterParams->SystemId.MajorMinor.Minor == drmMinorRender) ||
(adapterParams->SystemId.MajorMinor.Minor == drmMinorPrimary);
if (validAdapterType && validAdapterMajor && validAdapterMinor) {
return adapter;
}
}
return nullptr;
}
} // namespace L0

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -80,20 +80,14 @@ ze_result_t MetricEnumeration::loadMetricsDiscovery() {
// Load exported functions.
if (hMetricsDiscovery) {
openMetricsDevice = reinterpret_cast<MetricsDiscovery::OpenMetricsDevice_fn>(
hMetricsDiscovery->getProcAddress("OpenMetricsDevice"));
closeMetricsDevice = reinterpret_cast<MetricsDiscovery::CloseMetricsDevice_fn>(
hMetricsDiscovery->getProcAddress("CloseMetricsDevice"));
openMetricsDeviceFromFile =
reinterpret_cast<MetricsDiscovery::OpenMetricsDeviceFromFile_fn>(
hMetricsDiscovery->getProcAddress("OpenMetricsDeviceFromFile"));
openAdapterGroup = reinterpret_cast<MetricsDiscovery::OpenAdapterGroup_fn>(
hMetricsDiscovery->getProcAddress("OpenAdapterGroup"));
}
if (openMetricsDevice == nullptr || closeMetricsDevice == nullptr ||
openMetricsDeviceFromFile == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "cannot load %s exported functions\n", MetricEnumeration::getMetricsDiscoveryFilename());
if (openAdapterGroup == nullptr) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "cannot load %s exported functions\n", MetricEnumeration::getMetricsDiscoveryFilename());
cleanupMetricsDiscovery();
return ZE_RESULT_ERROR_UNKNOWN;
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
// Return success if exported functions have been loaded.
@ -101,14 +95,36 @@ ze_result_t MetricEnumeration::loadMetricsDiscovery() {
}
ze_result_t MetricEnumeration::openMetricsDiscovery() {
UNRECOVERABLE_IF(openMetricsDevice == nullptr);
UNRECOVERABLE_IF(closeMetricsDevice == nullptr);
UNRECOVERABLE_IF(openAdapterGroup == nullptr);
auto openResult = openMetricsDevice(&pMetricsDevice);
if (openResult != MetricsDiscovery::CC_OK) {
// Clean up members.
pAdapterGroup = nullptr;
pAdapter = nullptr;
pMetricsDevice = nullptr;
// Open adapter group.
openAdapterGroup(&pAdapterGroup);
if (pAdapterGroup == nullptr) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics adapter groups %s\n", " ");
cleanupMetricsDiscovery();
return ZE_RESULT_ERROR_UNKNOWN;
}
// Obtain metrics adapter that matches adapter used by l0.
pAdapter = getMetricsAdapter();
if (pAdapter == nullptr) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics adapter %s\n", " ");
cleanupMetricsDiscovery();
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
pAdapter->OpenMetricsDevice(&pMetricsDevice);
if (pMetricsDevice == nullptr) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %s\n", " ");
cleanupMetricsDiscovery();
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
@ -119,16 +135,13 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
metricGroups.clear();
if (pMetricsDevice) {
closeMetricsDevice(pMetricsDevice);
if (pAdapter && pMetricsDevice) {
pAdapter->CloseMetricsDevice(pMetricsDevice);
pMetricsDevice = nullptr;
}
if (hMetricsDiscovery != nullptr) {
openMetricsDevice = nullptr;
closeMetricsDevice = nullptr;
openMetricsDeviceFromFile = nullptr;
openAdapterGroup = nullptr;
hMetricsDiscovery.reset();
}

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -32,6 +32,8 @@ struct MetricEnumeration {
ze_result_t initialize();
virtual ze_result_t openMetricsDiscovery();
virtual bool getAdapterId(uint32_t &major, uint32_t &minor);
virtual MetricsDiscovery::IAdapter_1_8 *getMetricsAdapter();
ze_result_t cleanupMetricsDiscovery();
ze_result_t cacheMetricInformation();
@ -57,9 +59,9 @@ struct MetricEnumeration {
// Metrics Discovery API.
std::unique_ptr<NEO::OsLibrary> hMetricsDiscovery = nullptr;
MetricsDiscovery::OpenMetricsDevice_fn openMetricsDevice = nullptr;
MetricsDiscovery::CloseMetricsDevice_fn closeMetricsDevice = nullptr;
MetricsDiscovery::OpenMetricsDeviceFromFile_fn openMetricsDeviceFromFile = nullptr;
MetricsDiscovery::OpenAdapterGroup_fn openAdapterGroup = nullptr;
MetricsDiscovery::IAdapterGroup_1_8 *pAdapterGroup = nullptr;
MetricsDiscovery::IAdapter_1_8 *pAdapter = nullptr;
MetricsDiscovery::IMetricsDevice_1_5 *pMetricsDevice = nullptr;
public:

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

@ -1,10 +1,12 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/windows/os_interface.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#if defined(_WIN64)
@ -19,4 +21,47 @@ namespace L0 {
const char *MetricEnumeration::getMetricsDiscoveryFilename() { return METRICS_DISCOVERY_NAME; }
bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) {
auto &device = metricContext.getDevice();
auto osInterface = device.getOsInterface().get();
auto luid = osInterface->getWddm()->getAdapterLuid();
major = luid.HighPart;
minor = luid.LowPart;
return true;
}
MetricsDiscovery::IAdapter_1_8 *MetricEnumeration::getMetricsAdapter() {
uint32_t major = 0;
uint32_t minor = 0;
UNRECOVERABLE_IF(pAdapterGroup == nullptr);
UNRECOVERABLE_IF(getAdapterId(major, minor) == false);
// Enumerate metrics discovery adapters.
for (uint32_t index = 0, count = pAdapterGroup->GetParams()->AdapterCount;
index < count;
++index) {
UNRECOVERABLE_IF(pAdapterGroup->GetAdapter(index) == nullptr);
UNRECOVERABLE_IF(pAdapterGroup->GetAdapter(index)->GetParams() == nullptr);
auto adapter = pAdapterGroup->GetAdapter(index);
auto adapterParams = adapter->GetParams();
const bool validAdapterInfo = adapterParams->SystemId.Type == MetricsDiscovery::ADAPTER_ID_TYPE_LUID;
const bool validAdapterMatch = (adapterParams->SystemId.Luid.HighPart == major) &&
(adapterParams->SystemId.Luid.LowPart == minor);
if (validAdapterInfo && validAdapterMatch) {
return adapter;
}
}
return nullptr;
}
} // namespace L0

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -58,5 +58,283 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenGetContextDataIsCalled
EXPECT_EQ(contextData.ClientData->Linux.Adapter->Type, LinuxAdapterType::DrmFileDescriptor);
}
class MetricEnumerationTestLinux : public MetricContextFixture,
public ::testing::Test {
public:
void SetUp() override {
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 {
MetricContextFixture::TearDown();
}
};
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 0;
openMetricsAdapterGroup();
EXPECT_CALL(adapterGroup, GetParams())
.Times(1)
.WillOnce(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorPrimaryNodeDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
const int32_t drmNodePrimary = 0; // From xf86drm.h
const int32_t drmMaxDevices = 64; // From drm_drv.c#110
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 1000 - (drmNodePrimary * drmMaxDevices);
uint32_t drmMajor = 0;
uint32_t drmMinor = 1000;
openMetricsAdapterGroup();
EXPECT_CALL(adapterGroup, GetParams())
.WillRepeatedly(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(drmMajor), ::testing::SetArgReferee<1>(drmMinor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorRenderNodeDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
const int32_t drmNodeRender = 2; // From xf86drm.h
const int32_t drmMaxDevices = 64; // From drm_drv.c#110
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 1000 - (drmNodeRender * drmMaxDevices);
uint32_t drmMajor = 0;
uint32_t drmMinor = 1000;
openMetricsAdapterGroup();
EXPECT_CALL(adapterGroup, GetParams())
.WillRepeatedly(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(drmMajor), ::testing::SetArgReferee<1>(drmMinor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterTypeWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_LUID;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 0;
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapterGroup, GetParams())
.Times(1)
.WillOnce(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_NE(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMajorWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 0;
uint32_t incorrectMajor = 1;
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapterGroup, GetParams())
.Times(1)
.WillOnce(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(incorrectMajor), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_NE(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMinorWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 0;
uint32_t incorrectMinor = 1;
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapterGroup, GetParams())
.Times(1)
.WillOnce(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(incorrectMinor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_NE(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenIcorrectOpenMetricDeviceOnAdapterWhenGetMetricsAdapterThenReturnFail) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};
auto adapterParams = TAdapterParams_1_8{};
adapterGroupParams.AdapterCount = 1;
adapterParams.SystemId.Type = MetricsDiscovery::TAdapterIdType::ADAPTER_ID_TYPE_MAJOR_MINOR;
adapterParams.SystemId.MajorMinor.Major = 0;
adapterParams.SystemId.MajorMinor.Minor = 0;
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapterGroup, GetParams())
.Times(1)
.WillOnce(Return(&adapterGroupParams));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.WillRepeatedly(Return(&adapter));
EXPECT_CALL(adapter, GetParams())
.WillRepeatedly(Return(&adapterParams));
EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_CALL(adapter, OpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(nullptr), Return(TCompletionCode::CC_ERROR_GENERAL)));
EXPECT_NE(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTestLinux, givenIcorrectDrmFileForFstaWhenGetMetricsAdapterThenReturnFail) {
uint32_t drmMajor = 0;
uint32_t drmMinor = 0;
EXPECT_EQ(mockMetricEnumeration->baseGetAdapterId(drmMajor, drmMinor), false);
}
} // namespace ult
} // namespace L0

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -11,6 +11,9 @@
using namespace MetricsLibraryApi;
using ::testing::_;
using ::testing::Return;
namespace L0 {
namespace ult {
@ -53,6 +56,49 @@ void MetricContextFixture::TearDown() {
ContextFixture::TearDown();
}
void MetricContextFixture::openMetricsAdapter() {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, OpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, CloseMetricsDevice(_))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.Times(0);
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&adapter));
}
void MetricContextFixture::openMetricsAdapterGroup() {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, OpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, CloseMetricsDevice(_))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
}
Mock<MetricsLibrary>::Mock(::L0::MetricContext &metricContext) : MetricsLibrary(metricContext) {
}

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -147,6 +147,8 @@ class MetricContextFixture : public ContextFixture {
protected:
void SetUp() override;
void TearDown() override;
void openMetricsAdapter();
void openMetricsAdapterGroup();
public:
// Mocked objects.
@ -158,6 +160,8 @@ class MetricContextFixture : public ContextFixture {
MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {};
// Metrics discovery device
Mock<IAdapterGroup_1_8> adapterGroup;
Mock<IAdapter_1_8> adapter;
Mock<IMetricsDevice_1_5> metricsDevice;
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
};

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -18,8 +18,8 @@ Mock<MetricEnumeration>::~Mock() {
MockMetricsDiscoveryApi *Mock<MetricEnumeration>::g_mockApi = nullptr;
TCompletionCode MockMetricsDiscoveryApi::OpenMetricsDevice(IMetricsDevice_1_5 **device) {
return Mock<MetricEnumeration>::g_mockApi->MockOpenMetricsDevice(device);
TCompletionCode MockMetricsDiscoveryApi::OpenAdapterGroup(IAdapterGroup_1_8 **group) {
return Mock<MetricEnumeration>::g_mockApi->MockOpenAdapterGroup(group);
}
TCompletionCode MockMetricsDiscoveryApi::OpenMetricsDeviceFromFile(const char *fileName, void *openParams, IMetricsDevice_1_5 **device) {
@ -43,9 +43,7 @@ void Mock<MetricEnumeration>::setMockedApi(MockMetricsDiscoveryApi *mockedApi) {
metricContext.setMetricEnumeration(*this);
// Mock metrics library api functions.
openMetricsDevice = mockedApi->OpenMetricsDevice;
closeMetricsDevice = mockedApi->CloseMetricsDevice;
openMetricsDeviceFromFile = mockedApi->OpenMetricsDeviceFromFile;
openAdapterGroup = mockedApi->OpenAdapterGroup;
// Mock metrics library api.
Mock<MetricEnumeration>::g_mockApi = mockedApi;
@ -261,4 +259,64 @@ TMetricParams_1_0 *IMetric_1_0::GetParams() {
return nullptr;
}
IAdapter_1_8 *IAdapterGroup_1_8::GetAdapter(uint32_t index) {
UNRECOVERABLE_IF(true);
return nullptr;
}
IAdapterGroup_1_6 ::~IAdapterGroup_1_6() {
}
const TAdapterGroupParams_1_6 *IAdapterGroup_1_6::GetParams(void) const {
UNRECOVERABLE_IF(true);
return nullptr;
}
IAdapter_1_6 *IAdapterGroup_1_6::GetAdapter(uint32_t index) {
UNRECOVERABLE_IF(true);
return nullptr;
}
TCompletionCode IAdapterGroup_1_6::Close() {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
IAdapter_1_6 ::~IAdapter_1_6() {}
const TAdapterParams_1_6 *IAdapter_1_6 ::GetParams(void) const {
UNRECOVERABLE_IF(true);
return nullptr;
}
const TAdapterParams_1_8 *IAdapter_1_8::GetParams(void) const {
UNRECOVERABLE_IF(true);
return nullptr;
}
TCompletionCode IAdapter_1_6 ::Reset() {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
TCompletionCode IAdapter_1_6 ::OpenMetricsDevice(IMetricsDevice_1_5 **metricsDevice) {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
TCompletionCode IAdapter_1_6 ::OpenMetricsDeviceFromFile(const char *fileName, void *openParams, IMetricsDevice_1_5 **metricsDevice) {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
TCompletionCode IAdapter_1_6 ::CloseMetricsDevice(IMetricsDevice_1_5 *metricsDevice) {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
TCompletionCode IAdapter_1_6 ::SaveMetricsDeviceToFile(const char *fileName, void *saveParams, IMetricsDevice_1_5 *metricsDevice) {
UNRECOVERABLE_IF(true);
return CC_ERROR_NOT_SUPPORTED;
}
} // namespace MetricsDiscovery

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -24,6 +24,10 @@ struct WhiteBox<::L0::MetricGroup> : public ::L0::MetricGroup {
using MetricGroup = WhiteBox<::L0::MetricGroup>;
using MetricsDiscovery::IAdapter_1_6;
using MetricsDiscovery::IAdapter_1_8;
using MetricsDiscovery::IAdapterGroup_1_6;
using MetricsDiscovery::IAdapterGroup_1_8;
using MetricsDiscovery::IConcurrentGroup_1_5;
using MetricsDiscovery::IInformation_1_0;
using MetricsDiscovery::IMetric_1_0;
@ -31,6 +35,9 @@ using MetricsDiscovery::IMetricsDevice_1_5;
using MetricsDiscovery::IMetricSet_1_0;
using MetricsDiscovery::IMetricSet_1_5;
using MetricsDiscovery::IOverride_1_2;
using MetricsDiscovery::TAdapterGroupParams_1_6;
using MetricsDiscovery::TAdapterParams_1_6;
using MetricsDiscovery::TAdapterParams_1_8;
using MetricsDiscovery::TCompletionCode;
using MetricsDiscovery::TConcurrentGroupParams_1_0;
using MetricsDiscovery::TGlobalSymbol_1_0;
@ -43,16 +50,39 @@ using MetricsDiscovery::TTypedValue_1_0;
struct MockMetricsDiscoveryApi {
// Original api functions.
static TCompletionCode MD_STDCALL OpenMetricsDevice(IMetricsDevice_1_5 **device);
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);
// Mocked api functions.
MOCK_METHOD(TCompletionCode, MockOpenMetricsDevice, (IMetricsDevice_1_5 **));
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));
};
template <>
class Mock<IAdapterGroup_1_8> : public IAdapterGroup_1_8 {
public:
Mock(){};
MOCK_METHOD(IAdapter_1_8 *, 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 {
public:
Mock(){};
MOCK_METHOD(const TAdapterParams_1_8 *, 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));
MOCK_METHOD(TCompletionCode, CloseMetricsDevice, (IMetricsDevice_1_5 *), (override));
MOCK_METHOD(TCompletionCode, SaveMetricsDeviceToFile, (const char *, void *, IMetricsDevice_1_5 *), (override));
};
template <>
@ -118,6 +148,8 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
using MetricEnumeration::hMetricsDiscovery;
using MetricEnumeration::initializationState;
using MetricEnumeration::openAdapterGroup;
using MetricEnumeration::openMetricsDiscovery;
// Api mock enable/disable.
void setMockedApi(MockMetricsDiscoveryApi *mockedApi);
@ -125,9 +157,14 @@ 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(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(); }
bool baseGetAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor) { return MetricEnumeration::getAdapterId(adapterMajor, adapterMinor); }
ze_result_t baseLoadMetricsDiscovery() { return MetricEnumeration::loadMetricsDiscovery(); }
// Mock metrics discovery api.
static MockMetricsDiscoveryApi *g_mockApi;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -27,7 +27,7 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetr
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenMetricsDevice(_))
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(nullptr), Return(TCompletionCode::CC_ERROR_GENERAL)));
@ -41,16 +41,7 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhen
metricsDeviceParams.Version.MajorNumber = 0;
metricsDeviceParams.Version.MinorNumber = 1;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.Times(1)
@ -63,16 +54,7 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhen
TEST_F(MetricEnumerationTest, givenNoConcurrentMetricGroupsWhenZetGetMetricGroupIsCalledThenReturnsZeroMetricsGroups) {
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.Times(1)
@ -101,16 +83,7 @@ TEST_F(MetricEnumerationTest, givenTwoConcurrentMetricGroupsWhenZetGetMetricGrou
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -169,16 +142,7 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetGetMetricGroupProperti
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -235,16 +199,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -308,16 +263,7 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetIsCalledThenR
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -378,16 +324,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -461,16 +398,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -547,16 +475,7 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetPropertiestIs
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -639,16 +558,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -738,16 +648,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -836,16 +737,7 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenzetContextActivateMetricG
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -919,16 +811,7 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenzetContextActiv
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1005,16 +888,7 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenZetContextActiv
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1091,16 +965,7 @@ TEST_F(MetricEnumerationTest, givenValidTimeBasedMetricGroupWhenzetContextActiva
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1177,16 +1042,7 @@ TEST_F(MetricEnumerationTest, givenActivateTheSameMetricGroupTwiceWhenzetContext
// 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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1255,16 +1111,7 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsWh
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1334,16 +1181,7 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsAt
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1411,16 +1249,7 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithTheSameDomainsWhen
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1490,16 +1319,7 @@ TEST_F(MetricEnumerationTest, givenDeactivateTestsWhenzetContextActivateMetricGr
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1580,16 +1400,7 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGroupCalculateMe
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1639,16 +1450,7 @@ TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalcu
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1717,16 +1519,7 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalcula
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1807,16 +1600,7 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndLowerProvidedCalculate
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1895,16 +1679,7 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -1981,16 +1756,7 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -2067,16 +1833,7 @@ TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCal
// One api: metric group.
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -2148,16 +1905,7 @@ TEST_F(MetricEnumerationTest, givenNotInitializedMetricEnumerationWhenIsInitiali
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -152,16 +152,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPool
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(0);
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));

80
level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -90,16 +90,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -200,16 +191,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -395,17 +377,7 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetMetricStreamerReadDataIsC
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -503,16 +475,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -625,16 +588,7 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetCommandListAppendMetricSt
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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));
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
@ -757,8 +711,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre
uint32_t markerValue = 0x12345678;
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
openMetricsAdapter();
EXPECT_CALL(*mockMetricEnumeration, isInitialized())
.Times(1)
@ -768,14 +721,6 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre
.Times(1)
.WillOnce(Return(true));
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(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
@ -905,8 +850,7 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
CommandBufferSize_1_0 commandBufferSize = {};
commandBufferSize.GpuMemorySize = 100;
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
openMetricsAdapter();
EXPECT_CALL(*mockMetricEnumeration, isInitialized())
.Times(1)
@ -916,14 +860,6 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
.Times(1)
.WillOnce(Return(true));
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(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));

4
shared/source/os_interface/windows/wddm/wddm.cpp
View File

@ -937,6 +937,10 @@ bool Wddm::verifyAdapterLuid(LUID adapterLuid) const {
return adapterLuid.HighPart == hwDeviceId->getAdapterLuid().HighPart && adapterLuid.LowPart == hwDeviceId->getAdapterLuid().LowPart;
}
LUID Wddm::getAdapterLuid() const {
return hwDeviceId->getAdapterLuid();
}
VOID *Wddm::registerTrimCallback(PFND3DKMT_TRIMNOTIFICATIONCALLBACK callback, WddmResidencyController &residencyController) {
if (DebugManager.flags.DoNotRegisterTrimCallback.get()) {
return nullptr;

3
shared/source/os_interface/windows/wddm/wddm.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
* Copyright (C) 2017-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -118,6 +118,7 @@ class Wddm {
D3DKMT_HANDLE getPagingQueueSyncObject() const { return pagingQueueSyncObject; }
inline Gdi *getGdi() const { return hwDeviceId->getGdi(); }
MOCKABLE_VIRTUAL bool verifyAdapterLuid(LUID adapterLuid) const;
LUID getAdapterLuid() const;
PFND3DKMT_ESCAPE getEscapeHandle() const;

2
third_party/metrics_discovery/.revision vendored
View File

@ -1 +1 @@
0928b82f6242217637c3a89d01eb630c55a52ce7
17f4240027df2dd8981200f6d8cf5e20f8015fd3

1600
third_party/metrics_discovery/metrics_discovery_api.h vendored
View File

File diff suppressed because it is too large Load Diff