Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Simplify ownership management of MockPerformanceCounters

Browse Source 
Fixes clang-tidy warning about ignoring result of release()

Signed-off-by: Daniel Chabrowski <daniel.chabrowski@intel.com>
This commit is contained in:
Daniel Chabrowski
2022-07-06 17:44:49 +00:00
committed by Compute-Runtime-Automation
parent e245523730
commit d68dedba3b
13 changed files with 253 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/test/unit_test/event/event_tests.cpp
View File

@ -1049,12 +1049,10 @@ struct InternalsEventWithPerfCountersTest
void SetUp() override {
PerformanceCountersFixture::SetUp();
InternalsEventTest::SetUp();
createPerfCounters();
pDevice->setPerfCounters(performanceCountersBase.get());
pDevice->setPerfCounters(MockPerformanceCounters::create());
}
void TearDown() override {
performanceCountersBase.release();
InternalsEventTest::TearDown();
PerformanceCountersFixture::TearDown();
}

2
opencl/test/unit_test/mocks/mock_cl_device.h
View File

@ -49,7 +49,7 @@ class MockClDevice : public ClDevice {
bool getCpuTime(uint64_t *timeStamp) { return device.getCpuTime(timeStamp); }
void setPreemptionMode(PreemptionMode mode) { device.setPreemptionMode(mode); }
void injectMemoryManager(MemoryManager *pMemoryManager) { device.injectMemoryManager(pMemoryManager); }
void setPerfCounters(PerformanceCounters *perfCounters) { device.setPerfCounters(perfCounters); }
void setPerfCounters(std::unique_ptr<PerformanceCounters> perfCounters) { device.setPerfCounters(std::move(perfCounters)); }
const char *getProductAbbrev() const { return device.getProductAbbrev(); }
template <typename T>
UltCommandStreamReceiver<T> &getUltCommandStreamReceiver() { return device.getUltCommandStreamReceiver<T>(); }

13
opencl/test/unit_test/os_interface/linux/mock_performance_counters_linux.cpp
View File

@ -16,15 +16,15 @@ namespace NEO {
//////////////////////////////////////////////////////
// MockPerformanceCountersLinux::MockPerformanceCountersLinux
//////////////////////////////////////////////////////
MockPerformanceCountersLinux::MockPerformanceCountersLinux(Device *device)
MockPerformanceCountersLinux::MockPerformanceCountersLinux()
: PerformanceCountersLinux() {
}
//////////////////////////////////////////////////////
// MockPerformanceCounters::create
//////////////////////////////////////////////////////
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(Device *device) {
auto performanceCounters = std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersLinux(device));
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create() {
auto performanceCounters = std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersLinux());
auto metricsLibrary = std::make_unique<MockMetricsLibrary>();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
@ -35,13 +35,6 @@ std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(Device *dev
return performanceCounters;
}
//////////////////////////////////////////////////////
// PerformanceCountersFixture::createPerfCounters
//////////////////////////////////////////////////////
void PerformanceCountersFixture::createPerfCounters() {
performanceCountersBase = MockPerformanceCounters::create(&device->getDevice());
}
//////////////////////////////////////////////////////
// PerformanceCountersFixture::SetUp
//////////////////////////////////////////////////////

4
opencl/test/unit_test/os_interface/linux/mock_performance_counters_linux.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -16,6 +16,6 @@ using MetricsLibraryApi::LinuxAdapterType;
class MockPerformanceCountersLinux : public PerformanceCountersLinux {
public:
MockPerformanceCountersLinux(Device *device);
MockPerformanceCountersLinux();
};
} // namespace NEO

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -321,7 +321,7 @@ StatusCode MockMetricsLibraryValidInterface::GetData(GetReportData_1_0 *data) {
//////////////////////////////////////////////////////
void PerformanceCountersDeviceFixture::SetUp() {
createFunc = Device::createPerformanceCountersFunc;
Device::createPerformanceCountersFunc = MockPerformanceCounters::create;
Device::createPerformanceCountersFunc = [](Device *) { return MockPerformanceCounters::create(); };
}
//////////////////////////////////////////////////////
@ -342,7 +342,6 @@ void PerformanceCountersMetricsLibraryFixture::SetUp() {
// PerformanceCountersMetricsLibraryFixture::TearDown
//////////////////////////////////////////////////////
void PerformanceCountersMetricsLibraryFixture::TearDown() {
device->setPerfCounters(nullptr);
PerformanceCountersFixture::TearDown();
}
@ -362,24 +361,23 @@ PerformanceCountersFixture::~PerformanceCountersFixture() {
}
//////////////////////////////////////////////////////
// PerformanceCountersMetricsLibraryFixture::createPerformanceCounters
// PerformanceCountersMetricsLibraryFixture::initDeviceWithPerformanceCounters
//////////////////////////////////////////////////////
void PerformanceCountersMetricsLibraryFixture::createPerformanceCounters(const bool validMetricsLibraryApi, const bool mockMetricsLibrary) {
performanceCountersBase = MockPerformanceCounters::create(&device->getDevice());
auto metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
EXPECT_NE(performanceCountersBase, nullptr);
EXPECT_NE(metricsLibraryInterface, nullptr);
PerformanceCounters *PerformanceCountersMetricsLibraryFixture::initDeviceWithPerformanceCounters(const bool validMetricsLibraryApi, const bool mockMetricsLibrary) {
auto performanceCounters = MockPerformanceCounters::create();
EXPECT_NE(performanceCounters, nullptr);
device->setPerfCounters(performanceCountersBase.get());
auto metricsLibraryInterface = performanceCounters->getMetricsLibraryInterface();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
EXPECT_NE(metricsLibraryInterface, nullptr);
// Attached mock version of metrics library interface.
if (mockMetricsLibrary) {
performanceCountersBase->setMetricsLibraryInterface(std::make_unique<MockMetricsLibrary>());
metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
performanceCounters->setMetricsLibraryInterface(std::make_unique<MockMetricsLibrary>());
metricsLibraryInterface = performanceCounters->getMetricsLibraryInterface();
} else {
performanceCountersBase->setMetricsLibraryInterface(std::make_unique<MetricsLibrary>());
metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
performanceCounters->setMetricsLibraryInterface(std::make_unique<MetricsLibrary>());
metricsLibraryInterface = performanceCounters->getMetricsLibraryInterface();
}
if (validMetricsLibraryApi) {
@ -394,5 +392,9 @@ void PerformanceCountersMetricsLibraryFixture::createPerformanceCounters(const b
}
EXPECT_NE(metricsLibraryInterface->api, nullptr);
auto rawPerformanceCounters = performanceCounters.get();
device->setPerfCounters(std::move(performanceCounters));
return rawPerformanceCounters;
}
} // namespace NEO

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

@ -202,7 +202,7 @@ class MockMetricsLibraryDll : public OsLibrary {
//////////////////////////////////////////////////////
class MockPerformanceCounters {
public:
static std::unique_ptr<PerformanceCounters> create(Device *device);
static std::unique_ptr<PerformanceCounters> create();
};
//////////////////////////////////////////////////////
@ -224,12 +224,10 @@ struct PerformanceCountersFixture {
~PerformanceCountersFixture();
virtual void SetUp(); // NOLINT(readability-identifier-naming)
virtual void TearDown(); // NOLINT(readability-identifier-naming)
virtual void createPerfCounters();
cl_queue_properties queueProperties = {};
std::unique_ptr<MockClDevice> device;
std::unique_ptr<MockContext> context;
std::unique_ptr<MockCommandQueue> queue;
std::unique_ptr<PerformanceCounters> performanceCountersBase;
std::unique_ptr<MockExecutionEnvironment> executionEnvironment;
std::unique_ptr<RootDeviceEnvironment> rootDeviceEnvironment;
std::unique_ptr<OSInterface> osInterface;
@ -243,9 +241,7 @@ struct PerformanceCountersMetricsLibraryFixture : PerformanceCountersFixture {
void SetUp() override;
void TearDown() override;
void createPerformanceCounters(const bool validMetricsLibraryApi, const bool mockMatricsLibrary);
std::unique_ptr<PerformanceCounters> performanceCountersBase;
PerformanceCounters *initDeviceWithPerformanceCounters(const bool validMetricsLibraryApi, const bool mockMatricsLibrary);
};
} // namespace NEO

431
opencl/test/unit_test/os_interface/performance_counters_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -63,10 +63,10 @@ TEST_F(PerformanceCountersTest, WhenCreatingPerformanceCountersThenObjectIsNotNu
}
TEST_F(PerformanceCountersTest, givenPerformanceCountersWhenCreatedThenAllValuesProperlyInitialized) {
createPerfCounters();
auto performanceCounters = MockPerformanceCounters::create();
EXPECT_NE(nullptr, performanceCountersBase->getMetricsLibraryInterface());
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_NE(nullptr, performanceCounters->getMetricsLibraryInterface());
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
struct PerformanceCountersProcessEventTest : public PerformanceCountersTest,
@ -74,18 +74,19 @@ struct PerformanceCountersProcessEventTest : public PerformanceCountersTest,
void SetUp() override {
PerformanceCountersTest::SetUp();
createPerfCounters();
perfCounters = MockPerformanceCounters::create();
eventComplete = true;
outputParamSize = 0;
inputParamSize = performanceCountersBase->getApiReportSize();
inputParamSize = perfCounters->getApiReportSize();
inputParam.reset(new uint8_t);
}
void TearDown() override {
performanceCountersBase->shutdown();
perfCounters->shutdown();
PerformanceCountersTest::TearDown();
}
std::unique_ptr<uint8_t> inputParam;
std::unique_ptr<PerformanceCounters> perfCounters;
size_t inputParamSize;
size_t outputParamSize;
bool eventComplete;
@ -98,9 +99,9 @@ TEST_P(PerformanceCountersProcessEventTest, givenNullptrInputParamWhenProcessEve
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &counters;
performanceCountersBase->getQueryHandleRef(counters.query.handle);
auto retVal = performanceCountersBase->getApiReport(&query, inputParamSize, nullptr, &outputParamSize, eventComplete);
performanceCountersBase->deleteQuery(counters.query.handle);
perfCounters->getQueryHandleRef(counters.query.handle);
auto retVal = perfCounters->getApiReport(&query, inputParamSize, nullptr, &outputParamSize, eventComplete);
perfCounters->deleteQuery(counters.query.handle);
EXPECT_FALSE(retVal);
}
@ -112,9 +113,9 @@ TEST_P(PerformanceCountersProcessEventTest, givenCorrectInputParamWhenProcessEve
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &counters;
performanceCountersBase->getQueryHandleRef(counters.query.handle);
auto retVal = performanceCountersBase->getApiReport(&query, inputParamSize, inputParam.get(), &outputParamSize, eventComplete);
performanceCountersBase->deleteQuery(counters.query.handle);
perfCounters->getQueryHandleRef(counters.query.handle);
auto retVal = perfCounters->getApiReport(&query, inputParamSize, inputParam.get(), &outputParamSize, eventComplete);
perfCounters->deleteQuery(counters.query.handle);
if (eventComplete) {
EXPECT_TRUE(retVal);
@ -132,7 +133,7 @@ TEST_P(PerformanceCountersProcessEventTest, givenCorrectInputParamWhenProcessEve
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &tag;
auto retVal = performanceCountersBase->getApiReport(&query, inputParamSize, inputParam.get(), &outputParamSize, eventComplete);
auto retVal = perfCounters->getApiReport(&query, inputParamSize, inputParam.get(), &outputParamSize, eventComplete);
EXPECT_EQ(eventComplete, retVal);
}
@ -143,9 +144,9 @@ TEST_F(PerformanceCountersProcessEventTest, givenInvalidInputParamSizeWhenProces
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &counters;
performanceCountersBase->getQueryHandleRef(counters.query.handle);
auto retVal = performanceCountersBase->getApiReport(&query, inputParamSize - 1, inputParam.get(), &outputParamSize, eventComplete);
performanceCountersBase->deleteQuery(counters.query.handle);
perfCounters->getQueryHandleRef(counters.query.handle);
auto retVal = perfCounters->getApiReport(&query, inputParamSize - 1, inputParam.get(), &outputParamSize, eventComplete);
perfCounters->deleteQuery(counters.query.handle);
EXPECT_FALSE(retVal);
EXPECT_EQ(outputParamSize, inputParamSize);
@ -158,9 +159,9 @@ TEST_F(PerformanceCountersProcessEventTest, givenNullptrOutputParamSizeWhenProce
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &counters;
performanceCountersBase->getQueryHandleRef(counters.query.handle);
auto retVal = performanceCountersBase->getApiReport(&query, inputParamSize, inputParam.get(), nullptr, eventComplete);
performanceCountersBase->deleteQuery(counters.query.handle);
perfCounters->getQueryHandleRef(counters.query.handle);
auto retVal = perfCounters->getApiReport(&query, inputParamSize, inputParam.get(), nullptr, eventComplete);
perfCounters->deleteQuery(counters.query.handle);
EXPECT_TRUE(retVal);
EXPECT_EQ(0ull, outputParamSize);
@ -173,9 +174,9 @@ TEST_F(PerformanceCountersProcessEventTest, givenNullptrInputZeroSizeWhenProcess
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &counters;
performanceCountersBase->getQueryHandleRef(counters.query.handle);
auto retVal = performanceCountersBase->getApiReport(&query, 0, nullptr, &outputParamSize, eventComplete);
performanceCountersBase->deleteQuery(counters.query.handle);
perfCounters->getQueryHandleRef(counters.query.handle);
auto retVal = perfCounters->getApiReport(&query, 0, nullptr, &outputParamSize, eventComplete);
perfCounters->deleteQuery(counters.query.handle);
EXPECT_TRUE(retVal);
EXPECT_EQ(inputParamSize, outputParamSize);
@ -188,9 +189,9 @@ TEST_F(PerformanceCountersProcessEventTest, givenNullptrInputZeroSizeAndNullptrO
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &counters;
performanceCountersBase->getQueryHandleRef(counters.query.handle);
auto retVal = performanceCountersBase->getApiReport(&query, 0, nullptr, nullptr, eventComplete);
performanceCountersBase->deleteQuery(counters.query.handle);
perfCounters->getQueryHandleRef(counters.query.handle);
auto retVal = perfCounters->getApiReport(&query, 0, nullptr, nullptr, eventComplete);
perfCounters->deleteQuery(counters.query.handle);
EXPECT_FALSE(retVal);
EXPECT_EQ(0ull, outputParamSize);
@ -199,7 +200,7 @@ TEST_F(PerformanceCountersProcessEventTest, givenNullptrInputZeroSizeAndNullptrO
TEST_F(PerformanceCountersProcessEventTest, givenNullptrQueryWhenProcessEventPerfCountersIsCalledThenReturnFalse) {
EXPECT_EQ(0ull, outputParamSize);
auto retVal = performanceCountersBase->getApiReport(nullptr, 0, nullptr, nullptr, eventComplete);
auto retVal = perfCounters->getApiReport(nullptr, 0, nullptr, nullptr, eventComplete);
EXPECT_FALSE(retVal);
}
@ -228,30 +229,30 @@ struct PerformanceCountersMetricsLibraryTest : public PerformanceCountersMetrics
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryIsCreated) {
// Create performance counters.
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Check metric library context.
auto context = static_cast<MockMetricsLibrary *>(performanceCountersBase->getMetricsLibraryContext().data);
auto context = static_cast<MockMetricsLibrary *>(performanceCounters->getMetricsLibraryContext().data);
EXPECT_NE(nullptr, context);
EXPECT_EQ(1u, context->contextCount);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryReturnsValidGpuCommands) {
// Create performance counters.
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Obtain required command buffer size.
uint32_t commandsSize = performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true);
uint32_t commandsSize = performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true);
EXPECT_NE(0u, commandsSize);
// Fill command buffer.
@ -259,178 +260,178 @@ TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetric
HwPerfCounter perfCounter = {};
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &perfCounter;
EXPECT_TRUE(performanceCountersBase->getGpuCommands(MetricsLibraryApi::GpuCommandBufferType::Render, query, true, sizeof(buffer), buffer));
EXPECT_TRUE(performanceCounters->getGpuCommands(MetricsLibraryApi::GpuCommandBufferType::Render, query, true, sizeof(buffer), buffer));
// Close library.
performanceCountersBase->deleteQuery(perfCounter.query.handle);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->deleteQuery(perfCounter.query.handle);
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenInitialNonCcsEngineWhenEnablingThenDontAllowCcsOnNextCalls) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_FALSE(performanceCountersBase->enable(true));
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_FALSE(performanceCounters->enable(true));
performanceCountersBase->shutdown();
performanceCountersBase->shutdown();
performanceCountersBase->shutdown();
performanceCounters->shutdown();
performanceCounters->shutdown();
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->enable(true));
performanceCountersBase->shutdown();
EXPECT_TRUE(performanceCounters->enable(true));
performanceCounters->shutdown();
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenInitialCcsEngineWhenEnablingThenDontAllowNonCcsOnNextCalls) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCountersBase->enable(true));
EXPECT_TRUE(performanceCountersBase->enable(true));
EXPECT_FALSE(performanceCountersBase->enable(false));
EXPECT_TRUE(performanceCounters->enable(true));
EXPECT_TRUE(performanceCounters->enable(true));
EXPECT_FALSE(performanceCounters->enable(false));
performanceCountersBase->shutdown();
performanceCountersBase->shutdown();
performanceCountersBase->shutdown();
performanceCounters->shutdown();
performanceCounters->shutdown();
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->enable(false));
performanceCountersBase->shutdown();
EXPECT_TRUE(performanceCounters->enable(false));
performanceCounters->shutdown();
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenQueryReturnsInvalidGpuCommands) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_FALSE(performanceCountersBase->enable(true));
auto *performanceCounters = initDeviceWithPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_FALSE(performanceCounters->enable(true));
// Obtain required command buffer size.
uint32_t commandsSize = performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true);
uint32_t commandsSize = performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true);
EXPECT_EQ(0u, commandsSize);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenApiReportSizeIsValid) {
// Create performance counters.
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Obtain api report size.
uint32_t apiReportSize = performanceCountersBase->getApiReportSize();
uint32_t apiReportSize = performanceCounters->getApiReportSize();
EXPECT_GT(apiReportSize, 0u);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenApiReportSizeIsInvalid) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_FALSE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_FALSE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Obtain api report size.
uint32_t apiReportSize = performanceCountersBase->getApiReportSize();
uint32_t apiReportSize = performanceCounters->getApiReportSize();
EXPECT_EQ(0u, apiReportSize);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenGpuReportSizeIsInvalid) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_FALSE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_FALSE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Obtain gpu report size.
uint32_t gpuReportSize = performanceCountersBase->getGpuReportSize();
uint32_t gpuReportSize = performanceCounters->getGpuReportSize();
EXPECT_EQ(0u, gpuReportSize);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryIsAvailable) {
// Create performance counters.
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenQueryIsNotAvailable) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_FALSE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_FALSE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryHasInvalidExportFunctionsDestroyThenQueryIsNotAvailable) {
createPerformanceCounters(true, false);
auto metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
auto metricsLibraryInterface = performanceCounters->getMetricsLibraryInterface();
auto metricsLibraryDll = reinterpret_cast<MockMetricsLibraryDll *>(metricsLibraryInterface->osLibrary.get());
metricsLibraryDll->validContextCreate = true;
metricsLibraryDll->validContextDelete = false;
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_FALSE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_NE(nullptr, performanceCounters);
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
EXPECT_FALSE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryHasInvalidExportFunctionsCreateAndDestroyThenQueryIsNotAvailable) {
createPerformanceCounters(true, false);
auto metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
auto metricsLibraryInterface = performanceCounters->getMetricsLibraryInterface();
auto metricsLibraryDll = reinterpret_cast<MockMetricsLibraryDll *>(metricsLibraryInterface->osLibrary.get());
metricsLibraryDll->validContextCreate = false;
metricsLibraryDll->validContextDelete = false;
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_FALSE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_NE(nullptr, performanceCounters);
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
EXPECT_FALSE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryReturnsCorrectApiReport) {
// Create performance counters.
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
// Obtain required command buffer size.
uint32_t commandsSize = performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true);
uint32_t commandsSize = performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true);
EXPECT_NE(0u, commandsSize);
// Fill command buffer.
@ -438,14 +439,14 @@ TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetric
TagNode<HwPerfCounter> query = {};
HwPerfCounter perfCounter = {};
query.tagForCpuAccess = &perfCounter;
EXPECT_TRUE(performanceCountersBase->getGpuCommands(MetricsLibraryApi::GpuCommandBufferType::Render, query, true, sizeof(buffer), buffer));
EXPECT_TRUE(performanceCounters->getGpuCommands(MetricsLibraryApi::GpuCommandBufferType::Render, query, true, sizeof(buffer), buffer));
// Obtain api report size.
uint32_t apiReportSize = performanceCountersBase->getApiReportSize();
uint32_t apiReportSize = performanceCounters->getApiReportSize();
EXPECT_GT(apiReportSize, 0u);
// Obtain gpu report size.
uint32_t gpuReportSize = performanceCountersBase->getGpuReportSize();
uint32_t gpuReportSize = performanceCounters->getGpuReportSize();
EXPECT_GT(gpuReportSize, 0u);
// Allocate memory for api report.
@ -453,136 +454,136 @@ TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetric
EXPECT_NE(apiReport, nullptr);
// Obtain api report.
EXPECT_TRUE(performanceCountersBase->getApiReport(&query, apiReportSize, apiReport, nullptr, true));
EXPECT_TRUE(performanceCounters->getApiReport(&query, apiReportSize, apiReport, nullptr, true));
delete[] apiReport;
apiReport = nullptr;
// Close library.
performanceCountersBase->deleteQuery(perfCounter.query.handle);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->deleteQuery(perfCounter.query.handle);
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenReferenceCounterIsValid) {
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(2u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->shutdown();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(2u, performanceCounters->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryHandleIsValid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
MetricsLibraryApi::QueryHandle_1_0 query = {};
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
EXPECT_TRUE(performanceCounters->enable(false));
performanceCountersBase->getQueryHandleRef(query);
performanceCounters->getQueryHandleRef(query);
EXPECT_TRUE(query.IsValid());
performanceCountersBase->deleteQuery(query);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->deleteQuery(query);
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenOaConfigurationIsInvalidThenGpuReportSizeIsInvalid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCounters->getMetricsLibraryContext().data);
metricLibraryApi->validCreateConfigurationOa = false;
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true));
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false), 0u);
EXPECT_EQ(0u, performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true));
EXPECT_GT(performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false), 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, GivenInvalidMetricsLibraryWhenGettingGpuCommandSizeThenZeroIsReported) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCounters->getMetricsLibraryContext().data);
metricLibraryApi->validGpuReportSize = false;
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true));
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false));
EXPECT_EQ(0u, performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true));
EXPECT_EQ(0u, performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false));
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenAllConfigurationsAreValidThenGpuReportSizeIsValid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCounters->getMetricsLibraryContext().data);
metricLibraryApi->validCreateConfigurationOa = true;
metricLibraryApi->validCreateConfigurationUser = true;
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true), 0u);
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false), 0u);
EXPECT_GT(performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true), 0u);
EXPECT_GT(performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false), 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenOaConfigurationsActivationIsInvalidThenGpuReportSizeIsInvalid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCounters->getMetricsLibraryContext().data);
metricLibraryApi->validActivateConfigurationOa = false;
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true));
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false), 0u);
EXPECT_EQ(0u, performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, true));
EXPECT_GT(performanceCounters->getGpuCommandsSize(MetricsLibraryApi::GpuCommandBufferType::Render, false), 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenCreatingUserConfigurationThenReturnSuccess) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
ConfigurationHandle_1_0 configurationHandle = {};
auto metricsLibrary = performanceCountersBase->getMetricsLibraryInterface();
auto contextHandle = performanceCountersBase->getMetricsLibraryContext();
auto metricsLibrary = performanceCounters->getMetricsLibraryInterface();
auto contextHandle = performanceCounters->getMetricsLibraryContext();
EXPECT_TRUE(metricsLibrary->userConfigurationCreate(contextHandle, configurationHandle));
EXPECT_TRUE(metricsLibrary->userConfigurationDelete(configurationHandle));
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, WhenGettingHwPerfCounterThenValidPointerIsReturned) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
ASSERT_NE(nullptr, queue->getPerfCounters());
@ -597,15 +598,15 @@ TEST_F(PerformanceCountersMetricsLibraryTest, WhenGettingHwPerfCounterThenValidP
auto perfCounter2 = event->getHwPerfCounterNode();
ASSERT_EQ(perfCounter, perfCounter2);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, WhenGettingHwPerfCounterAllocationThenValidPointerIsReturned) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
ASSERT_NE(nullptr, queue->getPerfCounters());
std::unique_ptr<Event> event(new Event(queue.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
@ -620,15 +621,15 @@ TEST_F(PerformanceCountersMetricsLibraryTest, WhenGettingHwPerfCounterAllocation
EXPECT_NE(nullptr, memoryStorage);
EXPECT_GT(memoryStorageSize, 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, WhenCreatingEventThenHwPerfCounterMemoryIsPlacedInGraphicsAllocation) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_TRUE(performanceCountersBase->enable(false));
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto *performanceCounters = initDeviceWithPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCounters);
EXPECT_TRUE(performanceCounters->enable(false));
EXPECT_EQ(1u, performanceCounters->getReferenceNumber());
ASSERT_NE(nullptr, queue->getPerfCounters());
std::unique_ptr<Event> event(new Event(queue.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
@ -646,8 +647,8 @@ TEST_F(PerformanceCountersMetricsLibraryTest, WhenCreatingEventThenHwPerfCounter
EXPECT_GE(perfCounter, memoryStorage);
EXPECT_LE(perfCounter + 1, ptrOffset(memoryStorage, graphicsAllocationSize));
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCounters->shutdown();
EXPECT_EQ(0u, performanceCounters->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, GivenPerformanceCountersObjectIsNotPresentWhenCreatingEventThenNodeisNull) {

15
opencl/test/unit_test/os_interface/windows/mock_performance_counters_win.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -17,15 +17,15 @@ namespace NEO {
///////////////////////////////////////////////////////
// MockPerformanceCountersWin::MockPerformanceCountersWin
///////////////////////////////////////////////////////
MockPerformanceCountersWin::MockPerformanceCountersWin(Device *device)
MockPerformanceCountersWin::MockPerformanceCountersWin()
: PerformanceCountersWin() {
}
///////////////////////////////////////////////////////
// MockPerformanceCounters::create
///////////////////////////////////////////////////////
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(Device *device) {
auto performanceCounters = std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersWin(device));
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create() {
auto performanceCounters = std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersWin());
auto metricsLibrary = std::make_unique<MockMetricsLibrary>();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
@ -36,13 +36,6 @@ std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(Device *dev
return performanceCounters;
}
//////////////////////////////////////////////////////
// PerformanceCountersFixture::createPerfCounters
//////////////////////////////////////////////////////
void PerformanceCountersFixture::createPerfCounters() {
performanceCountersBase = MockPerformanceCounters::create(&device->getDevice());
}
//////////////////////////////////////////////////////
// PerformanceCountersFixture::SetUp
//////////////////////////////////////////////////////

4
opencl/test/unit_test/os_interface/windows/mock_performance_counters_win.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,6 +14,6 @@ namespace NEO {
class MockPerformanceCountersWin : public PerformanceCountersWin {
public:
MockPerformanceCountersWin(Device *device);
MockPerformanceCountersWin();
};
} // namespace NEO

3
opencl/test/unit_test/profiling/profiling_tests.cpp
View File

@ -673,7 +673,6 @@ struct ProfilingWithPerfCountersTests : public PerformanceCountersFixture, ::tes
void SetUp(const NEO::HardwareInfo *hardwareInfo) {
PerformanceCountersFixture::SetUp();
createPerfCounters();
HardwareInfo hwInfo = *hardwareInfo;
if (hwInfo.capabilityTable.defaultEngineType == aub_stream::EngineType::ENGINE_CCS) {
@ -683,7 +682,7 @@ struct ProfilingWithPerfCountersTests : public PerformanceCountersFixture, ::tes
pDevice = MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo, 0);
pClDevice = std::make_unique<ClDevice>(*pDevice, nullptr);
pDevice->setPerfCounters(performanceCountersBase.release());
pDevice->setPerfCounters(MockPerformanceCounters::create());
context = std::make_unique<MockContext>(pClDevice.get());

3
shared/source/helpers/hardware_context_controller.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -13,7 +13,6 @@
#include <vector>
namespace NEO {
struct AllocationParams;
class OsContext;
class HardwareContextController {

4
shared/source/program/sync_buffer_handler.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,10 +14,8 @@
namespace NEO {
class CommandStreamReceiver;
class Context;
class Device;
class GraphicsAllocation;
class Kernel;
class MemoryManager;
class SyncBufferHandler {

8
shared/test/common/mocks/mock_device.h
View File

@ -87,12 +87,8 @@ class MockDevice : public RootDevice {
void injectMemoryManager(MemoryManager *);
void setPerfCounters(PerformanceCounters *perfCounters) {
if (perfCounters) {
performanceCounters = std::unique_ptr<PerformanceCounters>(perfCounters);
} else {
performanceCounters.release();
}
void setPerfCounters(std::unique_ptr<PerformanceCounters> perfCounters) {
performanceCounters = std::move(perfCounters);
}
size_t getMaxParameterSizeFromIGC() const override {