intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 23:56:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Metrics Library Performance Counters implementation.

Browse Source 
Signed-off-by: Piotr Maciejewski <piotr.maciejewski@intel.com>
Change-Id: I0f00dca1892f4857baaebc75ba2208a4f33db1bf
This commit is contained in:
Piotr Maciejewski
2019-05-20 11:19:27 +02:00
committed by sys_ocldev
parent 369982995d
commit d1d794c658
67 changed files with 2154 additions and 2617 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
unit_tests/api/cl_create_perf_counters_command_queue_tests.inl
View File

@@ -42,7 +42,7 @@ namespace ULT {
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenCorrectParamatersWhenCreatingPerfCountersCmdQThenCmdQIsCreatedAndPerfCountersAreEnabled) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 1;
cl_uint configuration = 0;
cmdQ = clCreatePerfCountersCommandQueueINTEL(context.get(), clDevice, properties, configuration, &retVal);
ASSERT_NE(nullptr, cmdQ);
@@ -99,7 +99,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenNullContextWhenCreatingP
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenMaximumGtdiConfigurationWhenCreatingPerfCountersCmdQThenOutOfResourcesErrorIsReturned) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = GTDI_CONFIGURATION_SET_MAX;
cl_uint configuration = 4;
cmdQ = clCreatePerfCountersCommandQueueINTEL(context.get(), clDevice, properties, configuration, &retVal);
@@ -110,7 +110,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenMaximumGtdiConfiguration
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenCorrectCmdQWhenEventIsCreatedThenPerfCountersAreEnabled) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 1;
cl_uint configuration = 0;
cmdQ = clCreatePerfCountersCommandQueueINTEL(context.get(), clDevice, properties, configuration, &retVal);
ASSERT_NE(nullptr, cmdQ);
@@ -130,7 +130,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInstrumentationEnabledIs
hwInfo->capabilityTable.instrumentationEnabled = false;
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 1;
cl_uint configuration = 0;
cmdQ = clCreatePerfCountersCommandQueueINTEL(context.get(), clDevice, properties, configuration, &retVal);
ASSERT_EQ(nullptr, cmdQ);
@@ -148,4 +148,26 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInvalidDeviceWhenCreatin
ASSERT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInvalidMetricsLibraryWhenCreatingPerfCountersThenPerfCountersReturnError) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
cmdQ = clCreatePerfCountersCommandQueueINTEL(context.get(), clDevice, properties, configuration, &retVal);
auto commandQueueObject = castToObject<CommandQueue>(cmdQ);
ASSERT_NE(nullptr, cmdQ);
ASSERT_EQ(CL_SUCCESS, retVal);
auto performanceCounters = commandQueueObject->getPerfCounters();
auto metricsLibary = static_cast<MockMetricsLibrary *>(performanceCounters->getMetricsLibraryInterface());
metricsLibary->validOpen = false;
ASSERT_NE(nullptr, metricsLibary);
EXPECT_TRUE(commandQueueObject->isPerfCountersEnabled());
EXPECT_TRUE(commandQueueObject->setPerfCountersEnabled(false, 0));
EXPECT_FALSE(commandQueueObject->setPerfCountersEnabled(true, 0));
EXPECT_FALSE(commandQueueObject->isPerfCountersEnabled());
retVal = clReleaseCommandQueue(cmdQ);
EXPECT_EQ(CL_SUCCESS, retVal);
}
} // namespace ULT

2
unit_tests/api/cl_get_event_profiling_info_tests.inl
View File

@@ -265,7 +265,7 @@ class clEventProfilingWithPerfCountersTests : public DeviceInstrumentationFixtur
commandQueue = std::make_unique<CommandQueue>(context.get(), device.get(), nullptr);
event = std::make_unique<Event>(commandQueue.get(), 0, 0, 0);
event->setStatus(CL_COMPLETE);
commandQueue->getPerfCounters()->processEventReport(0, nullptr, &param_value_size, nullptr, nullptr, true);
commandQueue->getPerfCounters()->getApiReport(0, nullptr, &param_value_size, true);
event->setProfilingEnabled(true);
eventCl = static_cast<cl_event>(event.get());

8
unit_tests/api/cl_set_performance_configuration_tests.inl
View File

@@ -25,13 +25,13 @@ struct clSetPerformanceConfigurationINTELTests : public DeviceInstrumentationFix
};
namespace ULT {
TEST_F(clSetPerformanceConfigurationINTELTests, positiveSetPerfConfig) {
TEST_F(clSetPerformanceConfigurationINTELTests, negativeSetPerfConfig) {
cl_int ret = CL_OUT_OF_RESOURCES;
cl_uint offsets[2];
cl_uint values[2];
ret = clSetPerformanceConfigurationINTEL(device.get(), 2, offsets, values);
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(CL_INVALID_OPERATION, ret);
}
TEST_F(clSetPerformanceConfigurationINTELTests, negativeInvalidDevice) {
@@ -41,7 +41,7 @@ TEST_F(clSetPerformanceConfigurationINTELTests, negativeInvalidDevice) {
cl_device_id clDevice = {0};
ret = clSetPerformanceConfigurationINTEL(clDevice, 2, offsets, values);
EXPECT_EQ(CL_INVALID_DEVICE, ret);
EXPECT_EQ(CL_INVALID_OPERATION, ret);
}
TEST_F(clSetPerformanceConfigurationINTELTests, negativeInstrumentationDisabled) {
@@ -53,7 +53,7 @@ TEST_F(clSetPerformanceConfigurationINTELTests, negativeInstrumentationDisabled)
hwInfo->capabilityTable.instrumentationEnabled = false;
ret = clSetPerformanceConfigurationINTEL(device.get(), 2, offsets, values);
EXPECT_EQ(CL_PROFILING_INFO_NOT_AVAILABLE, ret);
EXPECT_EQ(CL_INVALID_OPERATION, ret);
hwInfo->capabilityTable.instrumentationEnabled = instrumentationEnabled;
}

5
unit_tests/command_stream/command_stream_receiver_tests.cpp
View File

@@ -301,9 +301,10 @@ TEST_F(CommandStreamReceiverTest, whenGetEventTsAllocatorIsCalledItReturnsSameTa
}
TEST_F(CommandStreamReceiverTest, whenGetEventPerfCountAllocatorIsCalledItReturnsSameTagAllocator) {
TagAllocator<HwPerfCounter> *allocator = commandStreamReceiver->getEventPerfCountAllocator();
const uint32_t gpuReportSize = 100;
TagAllocator<HwPerfCounter> *allocator = commandStreamReceiver->getEventPerfCountAllocator(gpuReportSize);
EXPECT_NE(nullptr, allocator);
TagAllocator<HwPerfCounter> *allocator2 = commandStreamReceiver->getEventPerfCountAllocator();
TagAllocator<HwPerfCounter> *allocator2 = commandStreamReceiver->getEventPerfCountAllocator(gpuReportSize);
EXPECT_EQ(allocator2, allocator);
}

73
unit_tests/event/event_tests.cpp
View File

@@ -792,7 +792,6 @@ struct InternalsEventWithPerfCountersTest
PerformanceCountersFixture::SetUp();
InternalsEventTest::SetUp();
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
pDevice->setPerfCounters(performanceCountersBase.get());
}
@@ -806,9 +805,9 @@ HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWh
const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
bool ret = false;
ret = pCmdQ->setPerfCountersEnabled(true, 1);
ret = pCmdQ->setPerfCountersEnabled(true, 0);
EXPECT_TRUE(ret);
ret = pCmdQ->setPerfCountersEnabled(true, 1);
ret = pCmdQ->setPerfCountersEnabled(true, 0);
EXPECT_TRUE(ret);
MockEvent<Event> *event = new MockEvent<Event>(pCmdQ, CL_COMMAND_MARKER, 0, 0);
event->setCPUProfilingPath(true);
@@ -834,7 +833,7 @@ HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWh
HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWhenEnqueuedMarkerThenUseTimeStampNodePerfCounterNode) {
const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
pCmdQ->setPerfCountersEnabled(true, 1);
pCmdQ->setPerfCountersEnabled(true, 0);
MockEvent<Event> *event = new MockEvent<Event>(pCmdQ, CL_COMMAND_MARKER, 0, 0);
event->setCPUProfilingPath(true);
HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
@@ -862,7 +861,7 @@ HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWh
TEST_F(InternalsEventWithPerfCountersTest, IsPerfCounter_Enabled) {
const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
pCmdQ->setPerfCountersEnabled(true, 2);
pCmdQ->setPerfCountersEnabled(true, 0);
Event *ev = new Event(pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
EXPECT_TRUE(ev->isProfilingEnabled());
EXPECT_TRUE(ev->isPerfCountersEnabled());
@@ -1137,57 +1136,6 @@ TEST_F(EventTest, hwTimeStampsMemoryIsPlacedInGraphicsAllocation) {
EXPECT_LE(timeStamps + 1, ptrOffset(memoryStorage, graphicsAllocationSize));
}
TEST_F(EventTest, getHwPerfCounterReturnsValidPointer) {
std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
ASSERT_NE(nullptr, perfCounter);
ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.GlobalStartTS);
ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.ContextStartTS);
ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.GlobalEndTS);
ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.ContextEndTS);
ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.GlobalCompleteTS);
ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.ContextCompleteTS);
EXPECT_TRUE(perfCounter->canBeReleased());
HwPerfCounter *perfCounter2 = event->getHwPerfCounterNode()->tagForCpuAccess;
ASSERT_EQ(perfCounter, perfCounter2);
}
TEST_F(EventTest, getHwPerfCounterAllocationReturnsValidPointer) {
std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
GraphicsAllocation *allocation = event->getHwPerfCounterNode()->getBaseGraphicsAllocation();
ASSERT_NE(nullptr, allocation);
void *memoryStorage = allocation->getUnderlyingBuffer();
size_t memoryStorageSize = allocation->getUnderlyingBufferSize();
EXPECT_NE(nullptr, memoryStorage);
EXPECT_GT(memoryStorageSize, 0u);
}
TEST_F(EventTest, hwPerfCounterMemoryIsPlacedInGraphicsAllocation) {
std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
ASSERT_NE(nullptr, perfCounter);
GraphicsAllocation *allocation = event->getHwPerfCounterNode()->getBaseGraphicsAllocation();
ASSERT_NE(nullptr, allocation);
void *memoryStorage = allocation->getUnderlyingBuffer();
size_t graphicsAllocationSize = allocation->getUnderlyingBufferSize();
EXPECT_GE(perfCounter, memoryStorage);
EXPECT_LE(perfCounter + 1, ptrOffset(memoryStorage, graphicsAllocationSize));
}
TEST_F(EventTest, IsPerfCounter_DisabledByNullQueue) {
Event ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);
EXPECT_FALSE(ev.isProfilingEnabled());
@@ -1212,24 +1160,13 @@ TEST_F(InternalsEventTest, IsPerfCounter_DisabledByNoPerfCounter) {
delete pCmdQ;
}
TEST_F(InternalsEventWithPerfCountersTest, SetPerfCounter_negativeInvalidASInterface) {
const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
performanceCountersBase->setAutoSamplingStartFunc(autoSamplingStartFailing);
bool ret = false;
ret = pCmdQ->setPerfCountersEnabled(true, 1);
EXPECT_FALSE(ret);
delete pCmdQ;
}
TEST_F(InternalsEventWithPerfCountersTest, SetPerfCounter_AvailFalse) {
const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
bool ret = false;
ret = pCmdQ->setPerfCountersEnabled(true, 1);
ret = pCmdQ->setPerfCountersEnabled(true, 0);
EXPECT_TRUE(ret);
performanceCountersBase->setAvailableFlag(false);
ret = pCmdQ->setPerfCountersEnabled(false, 0);
EXPECT_TRUE(ret);
performanceCountersBase->shutdown();

11
unit_tests/instrumentation/CMakeLists.txt
View File

@@ -1,11 +0,0 @@
#
# Copyright (C) 2017-2018 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(IGDRCL_SRCS_tests_instrumentation
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/instrumentation_tests.cpp
)
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_instrumentation})

102
unit_tests/instrumentation/instrumentation_tests.cpp
View File

@@ -1,102 +0,0 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "instrumentation.h"
using namespace NEO;
struct InstrumentationTest : public ::testing::Test {
InstrumentationTest() {}
};
TEST(InstrumentationTest, instrAutoSamplingStart) {
InstrEscCbData cbData = {0};
void **ppOAInterface = nullptr;
instrAutoSamplingStart(cbData, ppOAInterface);
}
TEST(InstrumentationTest, instrAutoSamplingStop) {
void **ppOAInterface = nullptr;
instrAutoSamplingStop(ppOAInterface);
}
TEST(InstrumentationTest, instrCheckPmRegsCfg) {
InstrPmRegsCfg *pQueryPmRegsCfg = nullptr;
uint32_t *pLastPmRegsCfgHandle = nullptr;
const void *pASInterface = nullptr;
instrCheckPmRegsCfg(pQueryPmRegsCfg, pLastPmRegsCfgHandle, pASInterface);
InstrPmRegsCfg cfg;
instrCheckPmRegsCfg(&cfg, pLastPmRegsCfgHandle, pASInterface);
}
TEST(InstrumentationTest, instrGetPerfCountersQueryData) {
InstrEscCbData cbData = {0};
GTDI_QUERY *pData = nullptr;
HwPerfCounters *pLayout = nullptr;
uint64_t cpuRawTimestamp = 0;
void *pASInterface = nullptr;
InstrPmRegsCfg *pPmRegsCfg = nullptr;
bool useMiRPC = false;
bool resetASData = false;
const InstrAllowedContexts *pAllowedContexts = nullptr;
instrGetPerfCountersQueryData(cbData, pData, pLayout, cpuRawTimestamp, pASInterface, pPmRegsCfg, useMiRPC, resetASData, pAllowedContexts);
}
TEST(InstrumentationTest, instrEscGetPmRegsCfg) {
InstrEscCbData cbData = {0};
uint32_t cfgId = 0;
InstrPmRegsCfg *pCfg = nullptr;
InstrAutoSamplingMode *pAutoSampling = nullptr;
instrEscGetPmRegsCfg(cbData, cfgId, pCfg, pAutoSampling);
}
TEST(InstrumentationTest, instrEscHwMetricsEnable) {
InstrEscCbData cbData = {0};
bool enable = false;
instrEscHwMetricsEnable(cbData, enable);
}
TEST(InstrumentationTest, instrEscLoadPmRegsCfg) {
InstrEscCbData cbData = {0};
InstrPmRegsCfg *pCfg = nullptr;
bool hardwareAccess = false;
instrEscLoadPmRegsCfg(cbData, pCfg, hardwareAccess);
}
TEST(InstrumentationTest, instrEscSetPmRegsCfg) {
InstrEscCbData cbData = {0};
uint32_t count = 0;
uint32_t *pOffsets = nullptr;
uint32_t *pValues = nullptr;
instrEscSetPmRegsCfg(cbData, count, pOffsets, pValues);
}
TEST(InstrumentationTest, instrEscSendReadRegsCfg) {
InstrEscCbData cbData = {0};
uint32_t count = 0;
uint32_t *pOffsets = nullptr;
uint32_t *pBitSizes = nullptr;
instrEscSendReadRegsCfg(cbData, count, pOffsets, pBitSizes);
}
TEST(InstrumentationTest, instrSetAvailable) {
bool enabled = false;
instrSetAvailable(enabled);
}
TEST(InstrumentationTest, instrEscVerifyEnable) {
InstrEscCbData cbData = {0};
instrEscVerifyEnable(cbData);
}
TEST(InstrumentationTest, instrSetPlatformInfo) {
uint32_t productId = 0;
void *featureTable = nullptr;
instrSetPlatformInfo(productId, featureTable);
}

1
unit_tests/mocks/CMakeLists.txt
View File

@@ -46,7 +46,6 @@ set(IGDRCL_SRCS_tests_mocks
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_resource_info.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_graphics_allocation.h
${CMAKE_CURRENT_SOURCE_DIR}${IGDRCL__INSTRUMENTATION_DIR_SUFFIX}/mock_instrumentation.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_gmm_client_context.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/mock_gmm_client_context.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_host_ptr_manager.h

6
unit_tests/mocks/mock_device.h
View File

@@ -67,7 +67,11 @@ class MockDevice : public Device {
void injectMemoryManager(MemoryManager *);
void setPerfCounters(PerformanceCounters *perfCounters) {
performanceCounters = std::unique_ptr<PerformanceCounters>(perfCounters);
if (perfCounters) {
performanceCounters = std::unique_ptr<PerformanceCounters>(perfCounters);
} else {
performanceCounters.release();
}
}
template <typename T>

82
unit_tests/mocks/mock_instrumentation.cpp
View File

@@ -1,82 +0,0 @@
/*
* Copyright (C) 2018-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "instrumentation.h"
#include <cstdint>
using namespace NEO;
bool InstrAutoSamplingStart(
InstrEscCbData cbData,
void **ppOAInterface) {
return false;
}
bool InstrAutoSamplingStop(
void **ppOAInterface) {
return false;
}
bool InstrCheckPmRegsCfg(
InstrPmRegsCfg *pQueryPmRegsCfg,
uint32_t *pLastPmRegsCfgHandle,
const void *pASInterface) {
return false;
}
bool InstrEscGetPmRegsCfg(
InstrEscCbData cbData,
uint32_t cfgId,
InstrPmRegsCfg *pCfg,
InstrAutoSamplingMode *pAutoSampling) {
return false;
}
bool InstrEscHwMetricsEnable(
InstrEscCbData cbData,
bool enable) {
return false;
}
bool InstrEscLoadPmRegsCfg(
InstrEscCbData cbData,
InstrPmRegsCfg *pCfg,
bool hardwareAccess) {
return false;
}
bool InstrEscSetPmRegsCfg(
InstrEscCbData cbData,
uint32_t count,
uint32_t *pOffsets,
uint32_t *pValues) {
return false;
}
bool InstrEscSendReadRegsCfg(
InstrEscCbData cbData,
uint32_t count,
uint32_t *pOffsets,
uint32_t *pBitSizes) {
return false;
}
uint32_t InstrSetPlatformInfo(
uint32_t productId,
void *featureTable) {
return -1;
}
bool InstrSetAvailable(bool enabled) {
return false;
}
void InstrEscVerifyEnable(InstrEscCbData cbData) {
}

104
unit_tests/os_interface/linux/mock_performance_counters_linux.cpp
View File

@@ -7,83 +7,53 @@
#include "mock_performance_counters_linux.h"
#include "unit_tests/os_interface/linux/drm_mock.h"
#include "unit_tests/os_interface/linux/mock_os_time_linux.h"
#include "unit_tests/os_interface/mock_performance_counters.h"
namespace NEO {
MockPerformanceCountersLinux::MockPerformanceCountersLinux(OSTime *osTime)
: PerformanceCounters(osTime), PerformanceCountersLinux(osTime), MockPerformanceCounters(osTime) {
dlopenFunc = dlopenMockPassing;
dlsymFunc = dlsymMockPassing;
dlcloseFunc = dlcloseMock;
setPlatformInfoFunc = setPlatformInfo;
PerfCounterFlagsLinux::resetPerfCountersFlags();
}
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(OSTime *osTime) {
return std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersLinux(osTime));
//////////////////////////////////////////////////////
// MockPerformanceCountersLinux::MockPerformanceCountersLinux
//////////////////////////////////////////////////////
MockPerformanceCountersLinux::MockPerformanceCountersLinux(Device *device)
: PerformanceCountersLinux() {
}
int PerfCounterFlagsLinux::dlopenFuncCalled;
int PerfCounterFlagsLinux::dlsymFuncCalled;
int PerfCounterFlagsLinux::dlcloseFuncCalled;
int PerfCounterFlagsLinux::perfmonLoadConfigCalled;
int PerfCounterFlagsLinux::setPlatformInfoFuncCalled;
//////////////////////////////////////////////////////
// MockPerformanceCounters::create
//////////////////////////////////////////////////////
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(Device *device) {
auto performanceCounters = std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersLinux(device));
auto metricsLibrary = std::make_unique<MockMetricsLibrary>();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
void *dlopenMockPassing(const char *filename, int flag) throw() {
PerfCounterFlagsLinux::dlopenFuncCalled++;
return new char[1];
}
void *dlopenMockFailing(const char *filename, int flag) throw() {
PerfCounterFlagsLinux::dlopenFuncCalled++;
return nullptr;
}
void *dlsymMockPassing(void *handle, const char *symbol) throw() {
PerfCounterFlagsLinux::dlsymFuncCalled++;
return (void *)perfmonLoadConfigMock;
}
void *dlsymMockFailing(void *handle, const char *symbol) throw() {
PerfCounterFlagsLinux::dlsymFuncCalled++;
return nullptr;
}
int dlcloseMock(void *handle) throw() {
PerfCounterFlagsLinux::dlcloseFuncCalled++;
if (handle) {
delete[] static_cast<char *>(handle);
}
return 0;
}
uint32_t setPlatformInfo(uint32_t productId, void *featureTable) {
PerfCounterFlagsLinux::setPlatformInfoFuncCalled++;
return 0;
}
int getTimeFuncPassing(clockid_t clkId, struct timespec *tp) throw() {
tp->tv_sec = 0;
tp->tv_nsec = 1;
return 0;
}
int perfmonLoadConfigMock(int fd, drm_intel_context *ctx, uint32_t *oaCfgId, uint32_t *gpCfgId) {
PerfCounterFlagsLinux::perfmonLoadConfigCalled++;
return 0;
metricsLibrary->api = std::make_unique<MockMetricsLibraryValidInterface>();
metricsLibrary->osLibrary = std::move(metricsLibraryDll);
performanceCounters->setMetricsLibraryInterface(std::move(metricsLibrary));
return performanceCounters;
}
void PerfCounterFlagsLinux::resetPerfCountersFlags() {
PerfCounterFlags::resetPerfCountersFlags();
PerfCounterFlagsLinux::dlopenFuncCalled = 0;
PerfCounterFlagsLinux::dlsymFuncCalled = 0;
PerfCounterFlagsLinux::dlcloseFuncCalled = 0;
PerfCounterFlagsLinux::perfmonLoadConfigCalled = 0;
PerfCounterFlagsLinux::setPlatformInfoFuncCalled = 0;
}
//////////////////////////////////////////////////////
// PerformanceCountersFixture::createPerfCounters
//////////////////////////////////////////////////////
void PerformanceCountersFixture::createPerfCounters() {
performanceCountersBase = std::unique_ptr<MockPerformanceCounters>(new MockPerformanceCountersLinux(osTimeBase.get()));
performanceCountersBase = MockPerformanceCounters::create(device.get());
}
void PerformanceCountersFixture::createOsTime() {
osTimeBase = std::unique_ptr<MockOSTimeLinux>(new MockOSTimeLinux(osInterfaceBase.get()));
//////////////////////////////////////////////////////
// PerformanceCountersFixture::SetUp
//////////////////////////////////////////////////////
void PerformanceCountersFixture::SetUp() {
device = std::unique_ptr<MockDevice>(new MockDevice());
context = std::make_unique<MockContext>(device.get());
queue = std::make_unique<MockCommandQueue>(context.get(), device.get(), &queueProperties);
osInterface = std::unique_ptr<OSInterface>(new OSInterface());
device->setOSTime(new MockOSTimeLinux(osInterface.get()));
}
void PerformanceCountersFixture::fillOsInterface() {
osInterfaceBase->get()->setDrm(new DrmMock());
}
void PerformanceCountersFixture::releaseOsInterface() {
delete static_cast<DrmMock *>(osInterfaceBase->get()->getDrm());
//////////////////////////////////////////////////////
// PerformanceCountersFixture::TearDown
//////////////////////////////////////////////////////
void PerformanceCountersFixture::TearDown() {
}
} // namespace NEO

50
unit_tests/os_interface/linux/mock_performance_counters_linux.h
View File

@@ -7,57 +7,11 @@
#pragma once
#include "runtime/os_interface/linux/performance_counters_linux.h"
#include "unit_tests/os_interface/mock_performance_counters.h"
namespace NEO {
void *dlopenMockPassing(const char *filename, int flag) throw();
void *dlopenMockFailing(const char *filename, int flag) throw();
void *dlsymMockPassing(void *handle, const char *symbol) throw();
void *dlsymMockFailing(void *handle, const char *symbol) throw();
int getTimeFuncPassing(clockid_t clk_id, struct timespec *tp) throw();
int dlcloseMock(void *handle) throw();
uint32_t setPlatformInfo(uint32_t productId, void *featureTable);
int perfmonLoadConfigMock(int fd, drm_intel_context *ctx, uint32_t *oa_cfg_id, uint32_t *gp_cfg_id);
class PerfCounterFlagsLinux : public PerfCounterFlags {
class MockPerformanceCountersLinux : public PerformanceCountersLinux {
public:
static int dlopenFuncCalled;
static int dlsymFuncCalled;
static int dlcloseFuncCalled;
static int perfmonLoadConfigCalled;
static int setPlatformInfoFuncCalled;
static void resetPerfCountersFlags();
};
class MockPerformanceCountersLinux : public PerformanceCountersLinux,
public MockPerformanceCounters {
public:
MockPerformanceCountersLinux(OSTime *osTime);
uint32_t getReportId() override {
return MockPerformanceCounters::getReportId();
}
void initialize(const HardwareInfo *hwInfo) override {
MockPerformanceCounters::initialize(hwInfo);
return PerformanceCountersLinux::initialize(hwInfo);
}
void enableImpl() override {
return PerformanceCountersLinux::enableImpl();
}
bool verifyPmRegsCfg(InstrPmRegsCfg *pCfg, uint32_t *pLastPmRegsCfgHandle, bool *pLastPmRegsCfgPending) override {
return PerformanceCountersLinux::verifyPmRegsCfg(pCfg, pLastPmRegsCfgHandle, pLastPmRegsCfgPending);
}
bool getPerfmonConfig(InstrPmRegsCfg *pCfg) override {
return PerformanceCountersLinux::getPerfmonConfig(pCfg);
}
void setDlopenFunc(dlopenFunc_t func) {
dlopenFunc = func;
}
void setDlsymFunc(dlsymFunc_t func) {
dlsymFunc = func;
}
void setPerfmonLoadConfigFunc(perfmonLoadConfig_t func) {
perfmonLoadConfigFunc = func;
}
MockPerformanceCountersLinux(Device *device);
};
} // namespace NEO

1
unit_tests/os_interface/linux/options.cpp
View File

@@ -22,6 +22,7 @@ const char *libvaDllName = nullptr;
const char *testDllName = "libtest_dynamic_lib.so";
const char *gmmDllName = "libmock_gmm.so";
const char *gmmEntryName = "openMockGmm";
const char *metricsLibraryDllName = "";
#endif
const char *sysFsPciPath = "./test_files";
} // namespace Os

435
unit_tests/os_interface/linux/performance_counters_linux_tests.cpp
View File

@@ -6,11 +6,10 @@
*/
#include "runtime/helpers/options.h"
#include "unit_tests/os_interface/linux/drm_mock.h"
#include "unit_tests/os_interface/linux/mock_os_time_linux.h"
#include "unit_tests/os_interface/linux/mock_performance_counters_linux.h"
#include "unit_tests/os_interface/mock_performance_counters.h"
#include "gtest/gtest.h"
#include "mock_performance_counters_linux.h"
using namespace NEO;
@@ -19,438 +18,8 @@ struct PerformanceCountersLinuxTest : public PerformanceCountersFixture,
void SetUp() override {
PerformanceCountersFixture::SetUp();
PerfCounterFlagsLinux::resetPerfCountersFlags();
drm = static_cast<DrmMock *>(osInterfaceBase->get()->getDrm());
osTimeLinux = static_cast<MockOSTimeLinux *>(osTimeBase.get());
}
void TearDown() override {
PerformanceCountersFixture::TearDown();
}
void createPerfCounters() override {
PerformanceCountersFixture::createPerfCounters();
performanceCountersLinux = static_cast<MockPerformanceCountersLinux *>(performanceCountersBase.get());
}
DrmMock *drm;
MockOSTimeLinux *osTimeLinux;
MockPerformanceCountersLinux *performanceCountersLinux;
};
struct PerformanceCountersLinuxSendConfigCommandPointersTest : public PerformanceCountersLinuxTest,
public ::testing::WithParamInterface<bool /*perfmon func is nullptr*/> {
void SetUp() override {
PerformanceCountersLinuxTest::SetUp();
createPerfCounters();
perfmonFuncIsNullptr = GetParam();
}
void TearDown() override {
performanceCountersBase->shutdown();
PerformanceCountersLinuxTest::TearDown();
}
bool perfmonFuncIsNullptr;
InstrPmRegsCfg config;
uint32_t lastConfigHandle;
bool lastConfigPending;
};
struct PerformanceCountersLinuxGetPerfmonConfigTest : public PerformanceCountersLinuxTest,
public ::testing::WithParamInterface<std::tuple<bool /*change handle*/,
bool /*zero value of handle*/>> {
void SetUp() override {
PerformanceCountersLinuxTest::SetUp();
createPerfCounters();
performanceCountersLinux->setPerfmonLoadConfigFunc(perfmonLoadConfigMock);
}
void TearDown() override {
PerformanceCountersLinuxTest::TearDown();
}
};
TEST_F(PerformanceCountersLinuxTest, enableWithCreatedAsInterface) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->setAsIface(new char[1]);
performanceCountersBase->enable();
}
TEST_F(PerformanceCountersLinuxTest, initializePerformanceCountersWithPassingFuncs) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->initialize(platformDevices[0]);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlopenFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlsymFuncCalled);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStarted);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersLinuxTest, initializePerformanceCountersWithFailingDlopenFunc) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockFailing);
performanceCountersBase->initialize(platformDevices[0]);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlopenFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlsymFuncCalled);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
}
TEST_F(PerformanceCountersLinuxTest, initializePerformanceCountersWithPassingDlopenFuncAndFailingDlsymFunc) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockFailing);
performanceCountersBase->initialize(platformDevices[0]);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlopenFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlsymFuncCalled);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithoutInitializing) {
uint32_t refNum = 0;
createPerfCounters();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
performanceCountersBase->enable();
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::hwMetricsEnableStatus);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(1u, refNum);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithPassingEscHwMetricsFuncTwice) {
uint32_t refNum = 0;
createPerfCounters();
EXPECT_FALSE(performanceCountersBase->isAvailable());
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
performanceCountersBase->enable();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStarted);
EXPECT_EQ(1u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->enable();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStarted);
EXPECT_EQ(2u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
EXPECT_EQ(1u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithPassingHwMetricsFuncAfterProperInitializing) {
uint32_t refNum = 0;
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->initialize(platformDevices[0]);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStarted);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(1u, refNum);
EXPECT_TRUE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStopped);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithFailingAutoStartFuncAfterProperInitializing) {
uint32_t refNum = 0;
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->setAutoSamplingStartFunc(autoSamplingStartFailing);
performanceCountersBase->initialize(platformDevices[0]);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStarted);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(1u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithFailingHwMetricsFuncAfterProperInitializing) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncFailing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStarted);
performanceCountersBase->shutdown();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithPassingHwMetricsFuncAfterProperInitializingTwice) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStarted);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStarted);
performanceCountersBase->shutdown();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStopped);
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithFailingHwMetricsFuncAfterStartingAutoSampling) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockPassing);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStarted);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncFailing);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStarted);
performanceCountersBase->shutdown();
EXPECT_EQ(1, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(2, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::autoSamplingStopped);
}
TEST_F(PerformanceCountersLinuxTest, enablePerformanceCountersWithMdLibHandleAndNotLoadedFunc) {
createPerfCounters();
performanceCountersLinux->setDlopenFunc(dlopenMockPassing);
performanceCountersLinux->setDlsymFunc(dlsymMockFailing);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->initialize(platformDevices[0]);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlopenFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::dlsymFuncCalled);
performanceCountersBase->enable();
EXPECT_EQ(0, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStarted);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsLinux::hwMetricsEnableStatus);
EXPECT_EQ(0, PerfCounterFlagsLinux::dlcloseFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::autoSamplingStopped);
}
TEST_F(PerformanceCountersLinuxTest, setCpuTimestamp) {
createPerfCounters();
EXPECT_EQ(0ull, performanceCountersBase->getCpuRawTimestamp());
osTimeLinux->setGetTimeFunc(getTimeFuncPassing);
performanceCountersBase->setCpuTimestamp();
EXPECT_NE(0ull, performanceCountersBase->getCpuRawTimestamp());
EXPECT_EQ(performanceCountersBase->getCpuRawTimestamp(),
osTimeBase->getCpuRawTimestamp());
}
TEST_P(PerformanceCountersLinuxSendConfigCommandPointersTest, givenPerformanceCountersWithPassingFuncsWhenSendPmRegsCfgCommandsIsCalledWithPerfmonFuncNullptrThenReturnsFalseOtherwiseTrue) {
if (!perfmonFuncIsNullptr) {
performanceCountersBase->initialize(platformDevices[0]);
}
lastConfigPending = false;
auto retVal = performanceCountersBase->sendPmRegsCfgCommands(&config, &lastConfigHandle, &lastConfigPending);
if (perfmonFuncIsNullptr) {
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlagsLinux::checkPmRegsCfgCalled);
EXPECT_EQ(0, PerfCounterFlagsLinux::loadPmRegsCfgCalled);
} else {
EXPECT_TRUE(retVal);
EXPECT_TRUE(lastConfigPending);
EXPECT_EQ(1, PerfCounterFlagsLinux::checkPmRegsCfgCalled);
EXPECT_EQ(1, PerfCounterFlagsLinux::loadPmRegsCfgCalled);
}
}
INSTANTIATE_TEST_CASE_P(
PerfCountersTests,
PerformanceCountersLinuxSendConfigCommandPointersTest,
testing::Bool());
int perfmonLoadConfigFailing(int fd, drm_intel_context *ctx, uint32_t *oaCfgId, uint32_t *gpCfgId) {
PerfCounterFlagsLinux::perfmonLoadConfigCalled++;
return -1;
}
TEST_F(PerformanceCountersLinuxTest, givenPerformanceCountersWithFailingPerfmonLoadConfigFuncWhenGetPerfmonConfigIsCalledThenReturnsFalse) {
InstrPmRegsCfg config;
uint32_t lastConfigHandle;
bool lastConfigPending;
createPerfCounters();
performanceCountersLinux->setPerfmonLoadConfigFunc(perfmonLoadConfigFailing);
performanceCountersBase->setCheckPmRegsCfgFunc(checkPmRegsCfgPassing);
performanceCountersBase->setLoadPmRegsCfgFunc(loadPmRegsCfgPassing);
auto retVal = performanceCountersBase->sendPmRegsCfgCommands(&config, &lastConfigHandle, &lastConfigPending);
EXPECT_EQ(1, PerfCounterFlagsLinux::perfmonLoadConfigCalled);
EXPECT_FALSE(retVal);
}
int perfmonLoadConfigChangingOa(int fd, drm_intel_context *ctx, uint32_t *oaCfgId, uint32_t *gpCfgId) {
PerfCounterFlagsLinux::perfmonLoadConfigCalled++;
(*oaCfgId)++;
return 0;
}
int perfmonLoadConfigChangingGp(int fd, drm_intel_context *ctx, uint32_t *oaCfgId, uint32_t *gpCfgId) {
PerfCounterFlagsLinux::perfmonLoadConfigCalled++;
(*gpCfgId)++;
return 0;
}
TEST_P(PerformanceCountersLinuxGetPerfmonConfigTest, givenPassingPerfmonLoadConfigFuncWhenGetPerfmonConfigIsCalledThenReturnsTrueIfDoesntChangeOaHandle) {
bool changingOaHandle;
bool isZeroValue;
InstrPmRegsCfg config;
std::tie(changingOaHandle, isZeroValue) = GetParam();
if (changingOaHandle) {
performanceCountersLinux->setPerfmonLoadConfigFunc(perfmonLoadConfigChangingOa);
}
if (isZeroValue) {
config.OaCounters.Handle = 0;
} else {
config.OaCounters.Handle = 1;
}
auto retVal = performanceCountersLinux->getPerfmonConfig(&config);
EXPECT_EQ(1, PerfCounterFlagsLinux::perfmonLoadConfigCalled);
if (!isZeroValue && changingOaHandle) {
EXPECT_FALSE(retVal);
} else {
EXPECT_TRUE(retVal);
}
}
TEST_P(PerformanceCountersLinuxGetPerfmonConfigTest, givenPassingPerfmonLoadConfigFuncWhenGetPerfmonConfigIsCalledThenReturnsTrueIfDoesntChangeGpHandle) {
bool changingGpHandle;
bool isZeroValue;
InstrPmRegsCfg config;
std::tie(changingGpHandle, isZeroValue) = GetParam();
if (changingGpHandle) {
performanceCountersLinux->setPerfmonLoadConfigFunc(perfmonLoadConfigChangingGp);
}
if (isZeroValue) {
config.GpCounters.Handle = 0;
} else {
config.GpCounters.Handle = 1;
}
auto retVal = performanceCountersLinux->getPerfmonConfig(&config);
EXPECT_EQ(1, PerfCounterFlagsLinux::perfmonLoadConfigCalled);
if (!isZeroValue && changingGpHandle) {
EXPECT_FALSE(retVal);
} else {
EXPECT_TRUE(retVal);
}
}
INSTANTIATE_TEST_CASE_P(
PerfCountersTests,
PerformanceCountersLinuxGetPerfmonConfigTest,
testing::Combine(
testing::Bool(),
testing::Bool()));
TEST_F(PerformanceCountersLinuxTest, givenPerfCountersWithHwContextEqualsZeroWhenGetCurrentReportIdsIsCalledManyTimesThenReturnProperNumber) {
unsigned int retVal;
createPerfCounters();
retVal = performanceCountersBase->getCurrentReportId();
EXPECT_EQ(0x00000u, osInterfaceBase->getHwContextId());
EXPECT_EQ(0x00000001u, retVal);
}

466
unit_tests/os_interface/mock_performance_counters.cpp
View File

@@ -7,141 +7,371 @@
#include "mock_performance_counters.h"
#include "runtime/os_interface/os_interface.h"
using namespace MetricsLibraryApi;
namespace NEO {
MockPerformanceCounters::MockPerformanceCounters(OSTime *osTime)
: PerformanceCounters(osTime) {
autoSamplingStartFunc = autoSamplingStart;
autoSamplingStopFunc = autoSamplingStop;
hwMetricsEnableFunc = hwMetricsEnableFuncPassing;
getPmRegsCfgFunc = getPmRegsCfgPassing;
loadPmRegsCfgFunc = loadPmRegsCfgPassing;
checkPmRegsCfgFunc = checkPmRegsCfgPassing;
setPmRegsCfgFunc = setPmRegsCfgFuncPassing;
sendReadRegsCfgFunc = sendReadRegsCfgFuncPassing;
getPerfCountersQueryDataFunc = getPerfCountersQueryData;
PerfCounterFlags::resetPerfCountersFlags();
}
void MockPerformanceCounters::initialize(const HardwareInfo *hwInfo) {
PerfCounterFlags::initalizeCalled++;
}
int PerfCounterFlags::autoSamplingFuncCalled;
int PerfCounterFlags::autoSamplingStarted;
int PerfCounterFlags::autoSamplingStopped;
int PerfCounterFlags::checkPmRegsCfgCalled;
int PerfCounterFlags::escHwMetricsCalled;
int PerfCounterFlags::getPerfCountersQueryDataCalled;
int PerfCounterFlags::getPmRegsCfgCalled;
int PerfCounterFlags::hwMetricsEnableStatus;
int PerfCounterFlags::initalizeCalled;
int PerfCounterFlags::loadPmRegsCfgCalled;
int PerfCounterFlags::setPmRegsCfgCalled;
int PerfCounterFlags::sendReadRegsCfgCalled;
bool hwMetricsEnableFuncFailing(InstrEscCbData cbData, bool enable) {
PerfCounterFlags::escHwMetricsCalled++;
PerfCounterFlags::hwMetricsEnableStatus = enable;
return false;
}
bool hwMetricsEnableFuncPassing(InstrEscCbData cbData, bool enable) {
PerfCounterFlags::escHwMetricsCalled++;
PerfCounterFlags::hwMetricsEnableStatus = enable;
return true;
}
bool autoSamplingStart(InstrEscCbData cbData, void **ppOAInterface) {
PerfCounterFlags::autoSamplingFuncCalled++;
PerfCounterFlags::autoSamplingStarted++;
ppOAInterface[0] = new char[1];
return true;
}
bool autoSamplingStartFailing(InstrEscCbData cbData, void **ppOAInterface) {
PerfCounterFlags::autoSamplingFuncCalled++;
PerfCounterFlags::autoSamplingStarted++;
ppOAInterface[0] = nullptr;
return false;
}
bool autoSamplingStop(void **ppOAInterface) {
PerfCounterFlags::autoSamplingFuncCalled++;
PerfCounterFlags::autoSamplingStopped++;
if (ppOAInterface[0]) {
delete[] static_cast<char *>(ppOAInterface[0]);
ppOAInterface[0] = nullptr;
//////////////////////////////////////////////////////
// MockMetricsLibrary::open
//////////////////////////////////////////////////////
bool MockMetricsLibrary::open() {
if (validOpen) {
++openCount;
return true;
} else {
return false;
}
return false;
}
bool getPmRegsCfgPassing(InstrEscCbData cbData, uint32_t cfgId, InstrPmRegsCfg *pCfg, InstrAutoSamplingMode *pAutoSampling) {
PerfCounterFlags::getPmRegsCfgCalled++;
if (cfgId == 1) {
pCfg->ReadRegs.RegsCount = 2;
pCfg->ReadRegs.Reg[0].BitSize = 32;
pCfg->ReadRegs.Reg[1].BitSize = 64;
//////////////////////////////////////////////////////
// MockMetricsLibrary::contextCreate
//////////////////////////////////////////////////////
bool MockMetricsLibrary::contextCreate(const ClientType_1_0 &client, ClientData_1_0 &clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle) {
if (client.Api != MetricsLibraryApi::ClientApi::OpenCL) {
return false;
}
handle.data = reinterpret_cast<void *>(this);
++contextCount;
return true;
}
bool getPmRegsCfgFailing(InstrEscCbData cbData, uint32_t cfgId, InstrPmRegsCfg *pCfg, InstrAutoSamplingMode *pAutoSampling) {
PerfCounterFlags::getPmRegsCfgCalled++;
return false;
}
bool checkPmRegsCfgPassing(InstrPmRegsCfg *pQueryPmRegsCfg, uint32_t *pLastPmRegsCfgHandle, const void *pASInterface) {
PerfCounterFlags::checkPmRegsCfgCalled++;
return true;
}
bool checkPmRegsCfgFailing(InstrPmRegsCfg *pQueryPmRegsCfg, uint32_t *pLastPmRegsCfgHandle, const void *pASInterface) {
PerfCounterFlags::checkPmRegsCfgCalled++;
return false;
}
bool loadPmRegsCfgPassing(InstrEscCbData cbData, InstrPmRegsCfg *pCfg, bool hardwareAccess) {
PerfCounterFlags::loadPmRegsCfgCalled++;
return true;
}
bool loadPmRegsCfgFailing(InstrEscCbData cbData, InstrPmRegsCfg *pCfg, bool hardwareAccess) {
PerfCounterFlags::loadPmRegsCfgCalled++;
return false;
}
bool setPmRegsCfgFuncPassing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pValues) {
PerfCounterFlags::setPmRegsCfgCalled++;
//////////////////////////////////////////////////////
// MockMetricsLibrary::contextDelete
//////////////////////////////////////////////////////
bool MockMetricsLibrary::contextDelete(const ContextHandle_1_0 &handle) {
if (!handle.IsValid()) {
return false;
}
--contextCount;
return true;
}
bool setPmRegsCfgFuncFailing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pValues) {
PerfCounterFlags::setPmRegsCfgCalled++;
return false;
}
bool sendReadRegsCfgFuncPassing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pBitSizes) {
PerfCounterFlags::sendReadRegsCfgCalled++;
//////////////////////////////////////////////////////
// MockMetricsLibrary::hwCountersCreate
//////////////////////////////////////////////////////
bool MockMetricsLibrary::hwCountersCreate(const ContextHandle_1_0 &context, const uint32_t slots, const ConfigurationHandle_1_0 mmio, QueryHandle_1_0 &handle) {
++queryCount;
return true;
};
//////////////////////////////////////////////////////
// MockMetricsLibrary::hwCountersDelete
//////////////////////////////////////////////////////
bool MockMetricsLibrary::hwCountersDelete(const QueryHandle_1_0 &handle) {
--queryCount;
return true;
}
bool sendReadRegsCfgFuncFailing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pBitSizes) {
PerfCounterFlags::sendReadRegsCfgCalled++;
return false;
//////////////////////////////////////////////////////
// MockMetricsLibrary::hwCountersGetReport
//////////////////////////////////////////////////////
bool MockMetricsLibrary::hwCountersGetReport(const QueryHandle_1_0 &handle, const uint32_t slot, const uint32_t slotsCount, const uint32_t dataSize, void *data) {
return validGetData;
}
template <typename GTDI_QUERY, typename HwPerfCountersLayout>
void getPerfCountersQueryData(InstrEscCbData cbData, GTDI_QUERY *pData, HwPerfCountersLayout *pLayout, uint64_t cpuRawTimestamp, void *pASInterface, InstrPmRegsCfg *pPmRegsCfg, bool useMiRPC, bool resetASData, const InstrAllowedContexts *pAllowedContexts) {
PerfCounterFlags::getPerfCountersQueryDataCalled++;
//////////////////////////////////////////////////////
// MockMetricsLibrary::hwCountersGetApiReportSize
//////////////////////////////////////////////////////
uint32_t MockMetricsLibrary::hwCountersGetApiReportSize() {
return 1;
}
void PerfCounterFlags::resetPerfCountersFlags() {
PerfCounterFlags::autoSamplingFuncCalled = 0;
PerfCounterFlags::autoSamplingStarted = 0;
PerfCounterFlags::autoSamplingStopped = 0;
PerfCounterFlags::checkPmRegsCfgCalled = 0;
PerfCounterFlags::escHwMetricsCalled = 0;
PerfCounterFlags::getPerfCountersQueryDataCalled = 0;
PerfCounterFlags::getPmRegsCfgCalled = 0;
PerfCounterFlags::hwMetricsEnableStatus = 0;
PerfCounterFlags::initalizeCalled = 0;
PerfCounterFlags::loadPmRegsCfgCalled = 0;
PerfCounterFlags::setPmRegsCfgCalled = 0;
PerfCounterFlags::sendReadRegsCfgCalled = 0;
//////////////////////////////////////////////////////
// MockMetricsLibrary::hwCountersGetGpuReportSize
//////////////////////////////////////////////////////
uint32_t MockMetricsLibrary::hwCountersGetGpuReportSize() {
return sizeof(HwPerfCounter);
}
void PerformanceCountersFixture::SetUp() {
osInterfaceBase = std::unique_ptr<OSInterface>(new OSInterface());
createOsTime();
fillOsInterface();
PerfCounterFlags::resetPerfCountersFlags();
//////////////////////////////////////////////////////
// MockMetricsLibrary::commandBufferGet
//////////////////////////////////////////////////////
bool MockMetricsLibrary::commandBufferGet(CommandBufferData_1_0 &data) {
MI_REPORT_PERF_COUNT mirpc = {};
mirpc.init();
DEBUG_BREAK_IF(data.Data == nullptr);
memcpy(data.Data, &mirpc, sizeof(mirpc));
return true;
}
//////////////////////////////////////////////////////
// MockMetricsLibrary::commandBufferGetSize
//////////////////////////////////////////////////////
bool MockMetricsLibrary::commandBufferGetSize(const CommandBufferData_1_0 &commandBufferData, CommandBufferSize_1_0 &commandBufferSize) {
commandBufferSize.GpuMemorySize = sizeof(MI_REPORT_PERF_COUNT);
return true;
}
//////////////////////////////////////////////////////
// MockMetricsLibrary::getProcAddress
//////////////////////////////////////////////////////
void *MockMetricsLibraryDll::getProcAddress(const std::string &procName) {
if (procName == METRICS_LIBRARY_CONTEXT_CREATE_1_0) {
return validContextCreate
? reinterpret_cast<void *>(&MockMetricsLibraryValidInterface::ContextCreate)
: nullptr;
} else if (procName == METRICS_LIBRARY_CONTEXT_DELETE_1_0) {
return validContextDelete
? reinterpret_cast<void *>(&MockMetricsLibraryValidInterface::ContextDelete)
: nullptr;
} else {
return nullptr;
}
}
//////////////////////////////////////////////////////
// MockMetricsLibrary::isLoaded
//////////////////////////////////////////////////////
bool MockMetricsLibraryDll::isLoaded() {
return validIsLoaded;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::ContextCreate
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::ContextCreate(ClientType_1_0 clientType, ContextCreateData_1_0 *createData, ContextHandle_1_0 *handle) {
// Validate input.
EXPECT_EQ(clientType.Api, ClientApi::OpenCL);
// Library handle.
auto library = new MockMetricsLibraryValidInterface();
handle->data = library;
EXPECT_TRUE(handle->IsValid());
// Context count.
library->contextCount++;
EXPECT_EQ(library->contextCount, 1u);
return handle->IsValid()
? StatusCode::Success
: StatusCode::Failed;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::ContextDelete
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::ContextDelete(const ContextHandle_1_0 handle) {
auto validHandle = handle.IsValid();
auto library = static_cast<MockMetricsLibraryValidInterface *>(handle.data);
// Validate input.
EXPECT_TRUE(validHandle);
EXPECT_TRUE(validHandle);
EXPECT_EQ(--library->contextCount, 0u);
// Delete handle.
delete library;
return validHandle
? StatusCode::Success
: StatusCode::IncorrectObject;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryInterface::QueryCreate
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::QueryCreate(const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle) {
EXPECT_NE(handle, nullptr);
EXPECT_NE(createData, nullptr);
EXPECT_GE(createData->Slots, 1u);
EXPECT_TRUE(createData->HandleContext.IsValid());
EXPECT_EQ(createData->Type, ObjectType::QueryHwCounters);
handle->data = new uint32_t(0);
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::QueryDelete
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::QueryDelete(const QueryHandle_1_0 handle) {
EXPECT_TRUE(handle.IsValid());
delete (uint32_t *)handle.data;
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::CommandBufferGetSize
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::CommandBufferGetSize(const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size) {
auto library = static_cast<MockMetricsLibraryValidInterface *>(data->HandleContext.data);
EXPECT_NE(data, nullptr);
EXPECT_TRUE(data->HandleContext.IsValid());
EXPECT_TRUE(data->QueryHwCounters.Handle.IsValid());
EXPECT_EQ(data->Type, GpuCommandBufferType::Render);
EXPECT_EQ(data->CommandsType, ObjectType::QueryHwCounters);
EXPECT_NE(size, nullptr);
size->GpuMemorySize = library->validGpuReportSize
? 123
: 0;
return library->validGpuReportSize
? StatusCode::Success
: StatusCode::Failed;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::CommandBufferGet
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::CommandBufferGet(const CommandBufferData_1_0 *data) {
EXPECT_NE(data, nullptr);
EXPECT_TRUE(data->HandleContext.IsValid());
EXPECT_TRUE(data->QueryHwCounters.Handle.IsValid());
EXPECT_EQ(data->Type, GpuCommandBufferType::Render);
EXPECT_EQ(data->CommandsType, ObjectType::QueryHwCounters);
EXPECT_NE(data->Data, nullptr);
EXPECT_GT(data->Size, 0u);
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::CommandBufferGet
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::GetParameter(const ParameterType parameter, ValueType *type, TypedValue_1_0 *value) {
EXPECT_NE(type, nullptr);
EXPECT_NE(value, nullptr);
switch (parameter) {
case ParameterType::QueryHwCountersReportApiSize:
*type = ValueType::Uint32;
value->ValueUInt32 = 123;
break;
case ParameterType::QueryHwCountersReportGpuSize:
*type = ValueType::Uint32;
value->ValueUInt32 = 123;
break;
default:
EXPECT_TRUE(false);
break;
}
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::ConfigurationCreate
//////////////////////////////////////////////////////
StatusCode ML_STDCALL MockMetricsLibraryValidInterface::ConfigurationCreate(const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle) {
EXPECT_NE(createData, nullptr);
EXPECT_NE(handle, nullptr);
EXPECT_TRUE(createData->HandleContext.IsValid());
const bool validType = (createData->Type == ObjectType::ConfigurationHwCountersOa) ||
(createData->Type == ObjectType::ConfigurationHwCountersUser);
// Mock overrides
auto api = static_cast<MockMetricsLibraryValidInterface *>(createData->HandleContext.data);
if (!api->validCreateConfigurationOa && (createData->Type == ObjectType::ConfigurationHwCountersOa)) {
return StatusCode::Failed;
}
if (!api->validCreateConfigurationUser && (createData->Type == ObjectType::ConfigurationHwCountersUser)) {
return StatusCode::Failed;
}
EXPECT_TRUE(validType);
handle->data = api;
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::ConfigurationActivate
//////////////////////////////////////////////////////
StatusCode ML_STDCALL MockMetricsLibraryValidInterface::ConfigurationActivate(const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData) {
auto api = static_cast<MockMetricsLibraryValidInterface *>(handle.data);
return api->validActivateConfigurationOa
? StatusCode::Success
: StatusCode::Failed;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::ConfigurationDelete
//////////////////////////////////////////////////////
StatusCode ML_STDCALL MockMetricsLibraryValidInterface::ConfigurationDelete(const ConfigurationHandle_1_0 handle) {
EXPECT_TRUE(handle.IsValid());
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface::GetData
//////////////////////////////////////////////////////
StatusCode MockMetricsLibraryValidInterface::GetData(GetReportData_1_0 *data) {
EXPECT_NE(data, nullptr);
EXPECT_EQ(data->Type, ObjectType::QueryHwCounters);
EXPECT_TRUE(data->Query.Handle.IsValid());
EXPECT_GE(data->Query.Slot, 0u);
EXPECT_GT(data->Query.SlotsCount, 0u);
EXPECT_NE(data->Query.Data, nullptr);
EXPECT_GT(data->Query.DataSize, 0u);
return StatusCode::Success;
}
//////////////////////////////////////////////////////
// PerformanceCountersDeviceFixture::SetUp
//////////////////////////////////////////////////////
void PerformanceCountersDeviceFixture::SetUp() {
createFunc = Device::createPerformanceCountersFunc;
Device::createPerformanceCountersFunc = MockPerformanceCounters::create;
}
//////////////////////////////////////////////////////
// PerformanceCountersDeviceFixture::TearDown
//////////////////////////////////////////////////////
void PerformanceCountersDeviceFixture::TearDown() {
Device::createPerformanceCountersFunc = createFunc;
}
//////////////////////////////////////////////////////
// PerformanceCountersMetricsLibraryFixture::SetUp
//////////////////////////////////////////////////////
void PerformanceCountersMetricsLibraryFixture::SetUp() {
PerformanceCountersFixture::SetUp();
}
//////////////////////////////////////////////////////
// PerformanceCountersMetricsLibraryFixture::TearDown
//////////////////////////////////////////////////////
void PerformanceCountersMetricsLibraryFixture::TearDown() {
device->setPerfCounters(nullptr);
PerformanceCountersFixture::TearDown();
}
//////////////////////////////////////////////////////
// PerformanceCountersMetricsLibraryFixture::createPerformanceCounters
//////////////////////////////////////////////////////
void PerformanceCountersMetricsLibraryFixture::createPerformanceCounters(const bool validMetricsLibraryApi, const bool mockMetricsLibrary) {
performanceCountersBase = MockPerformanceCounters::create(device.get());
auto metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
EXPECT_NE(performanceCountersBase, nullptr);
EXPECT_NE(metricsLibraryInterface, nullptr);
device->setPerfCounters(performanceCountersBase.get());
// Attached mock version of metrics library interface.
if (mockMetricsLibrary) {
performanceCountersBase->setMetricsLibraryInterface(std::make_unique<MockMetricsLibrary>());
metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
} else {
performanceCountersBase->setMetricsLibraryInterface(std::make_unique<MetricsLibrary>());
metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
}
if (validMetricsLibraryApi) {
metricsLibraryInterface->api = std::make_unique<MockMetricsLibraryValidInterface>();
metricsLibraryInterface->osLibrary = std::move(metricsLibraryDll);
} else {
metricsLibraryDll->validContextCreate = false;
metricsLibraryDll->validContextDelete = false;
metricsLibraryDll->validIsLoaded = false;
metricsLibraryInterface->api = std::make_unique<MockMetricsLibraryInvalidInterface>();
metricsLibraryInterface->osLibrary = std::move(metricsLibraryDll);
}
EXPECT_NE(metricsLibraryInterface->api, nullptr);
}
} // namespace NEO

335
unit_tests/os_interface/mock_performance_counters.h
View File

@@ -9,141 +9,238 @@
#include "runtime/device/device.h"
#include "runtime/memory_manager/os_agnostic_memory_manager.h"
#include "unit_tests/libult/create_command_stream.h"
#include "unit_tests/mocks/mock_command_queue.h"
#include "unit_tests/mocks/mock_context.h"
#include "unit_tests/mocks/mock_device.h"
#include "instrumentation.h"
namespace NEO {
class OSInterface;
bool hwMetricsEnableFuncPassing(InstrEscCbData cbData, bool enable);
bool hwMetricsEnableFuncFailing(InstrEscCbData cbData, bool enable);
bool autoSamplingStart(InstrEscCbData cbData, void **ppOAInterface);
bool autoSamplingStartFailing(InstrEscCbData cbData, void **ppOAInterface);
bool autoSamplingStop(void **ppOAInterface);
bool getPmRegsCfgPassing(InstrEscCbData cbData, uint32_t cfgId, InstrPmRegsCfg *pCfg, InstrAutoSamplingMode *pAutoSampling);
bool getPmRegsCfgFailing(InstrEscCbData cbData, uint32_t cfgId, InstrPmRegsCfg *pCfg, InstrAutoSamplingMode *pAutoSampling);
bool checkPmRegsCfgPassing(InstrPmRegsCfg *pQueryPmRegsCfg, uint32_t *pLastPmRegsCfgHandle, const void *pASInterface);
bool checkPmRegsCfgFailing(InstrPmRegsCfg *pQueryPmRegsCfg, uint32_t *pLastPmRegsCfgHandle, const void *pASInterface);
bool loadPmRegsCfgPassing(InstrEscCbData cbData, InstrPmRegsCfg *pCfg, bool hardwareAccess);
bool loadPmRegsCfgFailing(InstrEscCbData cbData, InstrPmRegsCfg *pCfg, bool hardwareAccess);
template <typename GTDI_QUERY, typename HwPerfCountersLayout>
void getPerfCountersQueryData(InstrEscCbData cbData, GTDI_QUERY *pData, HwPerfCountersLayout *pLayout, uint64_t cpuRawTimestamp, void *pASInterface, InstrPmRegsCfg *pPmRegsCfg, bool useMiRPC, bool resetASData = false, const InstrAllowedContexts *pAllowedContexts = NULL);
bool setPmRegsCfgFuncPassing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pValues);
bool setPmRegsCfgFuncFailing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pValues);
bool sendReadRegsCfgFuncPassing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pBitSizes);
bool sendReadRegsCfgFuncFailing(InstrEscCbData cbData, uint32_t count, uint32_t *pOffsets, uint32_t *pBitSizes);
//////////////////////////////////////////////////////
// Metrics Library types
//////////////////////////////////////////////////////
using MetricsLibraryApi::ClientApi;
using MetricsLibraryApi::ClientData_1_0;
using MetricsLibraryApi::ClientGen;
using MetricsLibraryApi::ClientType_1_0;
using MetricsLibraryApi::CommandBufferData_1_0;
using MetricsLibraryApi::CommandBufferSize_1_0;
using MetricsLibraryApi::ConfigurationHandle_1_0;
using MetricsLibraryApi::ContextCreateData_1_0;
using MetricsLibraryApi::ContextHandle_1_0;
using MetricsLibraryApi::GpuMemory_1_0;
using MetricsLibraryApi::QueryHandle_1_0;
class PerfCounterFlags {
public:
static int autoSamplingStarted;
static int autoSamplingStopped;
static int autoSamplingFuncCalled;
static int checkPmRegsCfgCalled;
static int escHwMetricsCalled;
static int getPerfCountersQueryDataCalled;
static int getPmRegsCfgCalled;
static int hwMetricsEnableStatus;
static int initalizeCalled;
static int loadPmRegsCfgCalled;
static int setPmRegsCfgCalled;
static int sendReadRegsCfgCalled;
static void resetPerfCountersFlags();
};
//////////////////////////////////////////////////////
// MI_REPORT_PERF_COUNT definition for all GENs
//////////////////////////////////////////////////////
struct MI_REPORT_PERF_COUNT {
uint32_t DwordLength : BITFIELD_RANGE(0, 5);
uint32_t Reserved_6 : BITFIELD_RANGE(6, 22);
uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28);
uint32_t CommandType : BITFIELD_RANGE(29, 31);
uint64_t UseGlobalGtt : BITFIELD_RANGE(0, 0);
uint64_t Reserved_33 : BITFIELD_RANGE(1, 3);
uint64_t CoreModeEnable : BITFIELD_RANGE(4, 4);
uint64_t Reserved_37 : BITFIELD_RANGE(5, 5);
uint64_t MemoryAddress : BITFIELD_RANGE(6, 63);
uint32_t ReportId;
class MockPerformanceCounters : virtual public PerformanceCounters {
public:
MockPerformanceCounters(OSTime *osTime);
static std::unique_ptr<PerformanceCounters> create(OSTime *osTime);
typedef enum tagDWORD_LENGTH {
DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2,
} DWORD_LENGTH;
void initialize(const HardwareInfo *hwInfo) override;
typedef enum tagMI_COMMAND_OPCODE {
MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT = 0x28,
} MI_COMMAND_OPCODE;
void setEscHwMetricsFunc(decltype(hwMetricsEnableFunc) func) {
hwMetricsEnableFunc = func;
}
void setAutoSamplingStartFunc(decltype(autoSamplingStartFunc) func) {
autoSamplingStartFunc = func;
}
void setGetPmRegsCfgFunc(decltype(getPmRegsCfgFunc) func) {
getPmRegsCfgFunc = func;
}
void setCheckPmRegsCfgFunc(decltype(checkPmRegsCfgFunc) func) {
checkPmRegsCfgFunc = func;
}
void setLoadPmRegsCfgFunc(decltype(loadPmRegsCfgFunc) func) {
loadPmRegsCfgFunc = func;
}
void setSetPmRegsCfgFunc(decltype(setPmRegsCfgFunc) func) {
setPmRegsCfgFunc = func;
}
void setSendReadRegsCfgFunc(decltype(sendReadRegsCfgFunc) func) {
sendReadRegsCfgFunc = func;
}
uint64_t getCpuRawTimestamp() const {
return cpuRawTimestamp;
}
void setAsIface(void *asIface) {
pAutoSamplingInterface = asIface;
}
void setGfxFamily(GFXCORE_FAMILY family) {
gfxFamily = family;
}
uint32_t getReportId() override {
return PerformanceCounters::getReportId();
}
void setAvailableFlag(bool value) {
available = value;
}
GFXCORE_FAMILY getGfxFamily() {
return gfxFamily;
}
InstrEscCbData getCbData() {
return cbData;
}
bool getHwMetricsEnabled() {
return hwMetricsEnabled;
}
bool getUseMIRPC() {
return useMIRPC;
}
void *getPAutoSamplingInterface() {
return pAutoSamplingInterface;
}
uint64_t getCpuRawTimestamp() {
return cpuRawTimestamp;
}
bool getAvailable() {
return available;
typedef enum tagCOMMAND_TYPE {
COMMAND_TYPE_MI_COMMAND = 0x0,
} COMMAND_TYPE;
inline void init(void) {
memset(this, 0, sizeof(MI_REPORT_PERF_COUNT));
DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1;
MiCommandOpcode = MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT;
CommandType = COMMAND_TYPE_MI_COMMAND;
}
};
// clang-format off
//////////////////////////////////////////////////////
// MockMetricsLibrary
//////////////////////////////////////////////////////
class MockMetricsLibrary : public MetricsLibrary {
public:
uint32_t openCount = 0;
uint32_t contextCount = 0;
uint32_t queryCount = 0;
bool validOpen = true;
bool validGetData = true;
// Library open / close functions.
bool open() override;
// Context create / destroy functions.
bool contextCreate (const ClientType_1_0 &client, ClientData_1_0& clientData, ContextCreateData_1_0 &createData, ContextHandle_1_0 &handle) override;
bool contextDelete (const ContextHandle_1_0 &handle) override;
// HwCounters functions.
bool hwCountersCreate (const ContextHandle_1_0 &context, const uint32_t slots, const ConfigurationHandle_1_0 mmio, QueryHandle_1_0 &handle) override;
bool hwCountersDelete (const QueryHandle_1_0 &handle) override;
bool hwCountersGetReport (const QueryHandle_1_0 &handle, const uint32_t slot, const uint32_t slotsCount, const uint32_t dataSize, void *data) override;
uint32_t hwCountersGetApiReportSize() override;
uint32_t hwCountersGetGpuReportSize() override;
// Command buffer functions.
bool commandBufferGet (CommandBufferData_1_0 &data) override;
bool commandBufferGetSize (const CommandBufferData_1_0 &commandBufferData, CommandBufferSize_1_0 &commandBufferSize) override;
// Oa configuration functions.
bool oaConfigurationCreate (const ContextHandle_1_0 &context, ConfigurationHandle_1_0 &handle) override { return true; }
bool oaConfigurationDelete (const ConfigurationHandle_1_0 &handle) override { return true; }
bool oaConfigurationActivate (const ConfigurationHandle_1_0 &handle) override { return true; }
bool oaConfigurationDeactivate (const ConfigurationHandle_1_0 &handle) override { return true; }
// User mmio configuration functions.
bool userConfigurationCreate (const ContextHandle_1_0 &context, ConfigurationHandle_1_0 &handle) override { return true; }
bool userConfigurationDelete (const ConfigurationHandle_1_0 &handle) override { return true; }
};
//////////////////////////////////////////////////////
// MockMetricsLibraryValidInterface
//////////////////////////////////////////////////////
class MockMetricsLibraryValidInterface: public MetricsLibraryInterface {
public:
uint32_t contextCount = 0;
bool validCreateConfigurationOa = true;
bool validCreateConfigurationUser = true;
bool validActivateConfigurationOa = true;
bool validGpuReportSize = true;
static StatusCode ML_STDCALL ContextCreate ( ClientType_1_0 clientType, ContextCreateData_1_0* createData, ContextHandle_1_0* handle );
static StatusCode ML_STDCALL ContextDelete (const ContextHandle_1_0 handle);
static StatusCode ML_STDCALL GetParameter (const ParameterType parameter, ValueType *type, TypedValue_1_0 *value);
static StatusCode ML_STDCALL CommandBufferGet (const CommandBufferData_1_0 *data);
static StatusCode ML_STDCALL CommandBufferGetSize (const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size);
static StatusCode ML_STDCALL QueryCreate (const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle);
static StatusCode ML_STDCALL QueryDelete (const QueryHandle_1_0 handle);
static StatusCode ML_STDCALL ConfigurationCreate (const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle);
static StatusCode ML_STDCALL ConfigurationActivate (const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData);
static StatusCode ML_STDCALL ConfigurationDeactivate (const ConfigurationHandle_1_0 handle) { return StatusCode::Success; }
static StatusCode ML_STDCALL ConfigurationDelete (const ConfigurationHandle_1_0 handle);
static StatusCode ML_STDCALL GetData (GetReportData_1_0 *data);
MockMetricsLibraryValidInterface()
{
contextCreate = &ContextCreate;
contextDelete = &ContextDelete;
functions.GetParameter = &GetParameter;
functions.CommandBufferGet = &CommandBufferGet;
functions.CommandBufferGetSize = &CommandBufferGetSize;
functions.QueryCreate = &QueryCreate;
functions.QueryDelete = &QueryDelete;
functions.ConfigurationCreate = &ConfigurationCreate;
functions.ConfigurationActivate = &ConfigurationActivate;
functions.ConfigurationDeactivate = &ConfigurationDeactivate;
functions.ConfigurationDelete = &ConfigurationDelete;
functions.GetData = &GetData;
}
};
//////////////////////////////////////////////////////
// MockMetricsLibraryInvalidInterface
//////////////////////////////////////////////////////
class MockMetricsLibraryInvalidInterface: public MetricsLibraryInterface {
public:
static StatusCode ML_STDCALL ContextCreate ( ClientType_1_0 clientType, ContextCreateData_1_0* createData, ContextHandle_1_0* handle ){ return StatusCode::Failed;}
static StatusCode ML_STDCALL ContextDelete (const ContextHandle_1_0 handle){ return StatusCode::Failed;}
static StatusCode ML_STDCALL GetParameter (const ParameterType parameter, ValueType *type, TypedValue_1_0 *value){ return StatusCode::Failed;}
static StatusCode ML_STDCALL CommandBufferGet (const CommandBufferData_1_0 *data){ return StatusCode::Failed;}
static StatusCode ML_STDCALL CommandBufferGetSize (const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size){ return StatusCode::Failed;}
static StatusCode ML_STDCALL QueryCreate (const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle){ return StatusCode::Failed;}
static StatusCode ML_STDCALL QueryDelete (const QueryHandle_1_0 handle){ return StatusCode::Failed;}
static StatusCode ML_STDCALL ConfigurationCreate (const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle){ return StatusCode::Failed;}
static StatusCode ML_STDCALL ConfigurationActivate (const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData){ return StatusCode::Failed;}
static StatusCode ML_STDCALL ConfigurationDeactivate (const ConfigurationHandle_1_0 handle){ return StatusCode::Failed;}
static StatusCode ML_STDCALL ConfigurationDelete (const ConfigurationHandle_1_0 handle){ return StatusCode::Failed;}
static StatusCode ML_STDCALL GetData (GetReportData_1_0 *data){ return StatusCode::Failed;}
MockMetricsLibraryInvalidInterface()
{
contextCreate = &ContextCreate;
contextDelete = &ContextDelete;
functions.GetParameter = &GetParameter;
functions.CommandBufferGet = &CommandBufferGet;
functions.CommandBufferGetSize = &CommandBufferGetSize;
functions.QueryCreate = &QueryCreate;
functions.QueryDelete = &QueryDelete;
functions.ConfigurationCreate = &ConfigurationCreate;
functions.ConfigurationActivate = &ConfigurationActivate;
functions.ConfigurationDeactivate = &ConfigurationDeactivate;
functions.ConfigurationDelete = &ConfigurationDelete;
functions.GetData = &GetData;
}
};
// clang-format on
//////////////////////////////////////////////////////
// MockMetricsLibraryDll
//////////////////////////////////////////////////////
class MockMetricsLibraryDll : public OsLibrary {
public:
bool validContextCreate = true;
bool validContextDelete = true;
bool validIsLoaded = true;
void *getProcAddress(const std::string &procName) override;
bool isLoaded() override;
};
//////////////////////////////////////////////////////
// MockPerformanceCounters
//////////////////////////////////////////////////////
class MockPerformanceCounters {
public:
static std::unique_ptr<PerformanceCounters> create(Device *device);
};
//////////////////////////////////////////////////////
// PerformanceCountersDeviceFixture
//////////////////////////////////////////////////////
struct PerformanceCountersDeviceFixture {
virtual void SetUp() {
overrideCSR = overrideCommandStreamReceiverCreation;
createFunc = Device::createPerformanceCountersFunc;
overrideCommandStreamReceiverCreation = true;
Device::createPerformanceCountersFunc = MockPerformanceCounters::create;
}
virtual void TearDown() {
overrideCommandStreamReceiverCreation = overrideCSR;
Device::createPerformanceCountersFunc = createFunc;
}
bool overrideCSR;
virtual void SetUp();
virtual void TearDown();
decltype(&PerformanceCounters::create) createFunc;
};
/////////////////////////////////////////////////////
// PerformanceCountersFixture
//////////////////////////////////////////////////////
struct PerformanceCountersFixture {
virtual void SetUp();
virtual void TearDown() {
releaseOsInterface();
}
virtual void TearDown();
virtual void createPerfCounters();
void createOsTime();
void fillOsInterface();
void releaseOsInterface();
std::unique_ptr<OSInterface> osInterfaceBase;
std::unique_ptr<OSTime> osTimeBase;
std::unique_ptr<MockPerformanceCounters> performanceCountersBase;
cl_queue_properties queueProperties = {};
std::unique_ptr<MockDevice> device;
std::unique_ptr<MockContext> context;
std::unique_ptr<MockCommandQueue> queue;
std::unique_ptr<OSInterface> osInterface;
std::unique_ptr<PerformanceCounters> performanceCountersBase;
};
//////////////////////////////////////////////////////
// PerformanceCountersMetricsLibraryFixture
//////////////////////////////////////////////////////
struct PerformanceCountersMetricsLibraryFixture : PerformanceCountersFixture {
void SetUp() override;
void TearDown() override;
void createPerformanceCounters(const bool validMetricsLibraryApi, const bool mockMatricsLibrary);
std::unique_ptr<PerformanceCounters> performanceCountersBase;
};
} // namespace NEO

58
unit_tests/os_interface/performance_counters_gen_tests.cpp
View File

@@ -5,70 +5,16 @@
*
*/
#include "runtime/helpers/options.h"
#include "runtime/os_interface/performance_counters.h"
#include "test.h"
#include "unit_tests/helpers/variable_backup.h"
#include "unit_tests/mocks/mock_ostime.h"
#include "unit_tests/os_interface/mock_performance_counters.h"
using namespace NEO;
struct PerformanceCountersGenTest : public ::testing::Test {
};
namespace NEO {
extern decltype(&instrGetPerfCountersQueryData) getPerfCountersQueryDataFactory[IGFX_MAX_CORE];
extern size_t perfCountersQuerySize[IGFX_MAX_CORE];
} // namespace NEO
class MockPerformanceCountersGen : public PerformanceCounters {
public:
MockPerformanceCountersGen(OSTime *osTime) : PerformanceCounters(osTime) {
MockPerformanceCountersGen() : PerformanceCounters() {
}
decltype(&instrGetPerfCountersQueryData) getFn() const {
return getPerfCountersQueryDataFunc;
}
};
HWTEST_F(PerformanceCountersGenTest, givenPerfCountersWhenInitializedWithoutGenSpecificThenDefaultFunctionIsUsed) {
auto gfxCore = platformDevices[0]->platform.eRenderCoreFamily;
VariableBackup<decltype(&instrGetPerfCountersQueryData)> bkp(&getPerfCountersQueryDataFactory[gfxCore], nullptr);
MockOSTime osTime;
std::unique_ptr<MockPerformanceCountersGen> counters(new MockPerformanceCountersGen(&osTime));
ASSERT_NE(nullptr, counters.get());
counters->initialize(platformDevices[0]);
EXPECT_EQ(counters->getFn(), &instrGetPerfCountersQueryData);
size_t expected = sizeof(GTDI_QUERY);
EXPECT_EQ(expected, perfCountersQuerySize[gfxCore]);
}
HWTEST_F(PerformanceCountersGenTest, givenPerfCountersWhenInitializedWithGenSpecificThenGenFunctionIsUsed) {
VariableBackup<decltype(&instrGetPerfCountersQueryData)> bkp(&getPerfCountersQueryDataFactory[platformDevices[0]->platform.eRenderCoreFamily]);
auto mockFn = [](
InstrEscCbData cbData,
GTDI_QUERY *pData,
HwPerfCounters *pLayout,
uint64_t cpuRawTimestamp,
void *pASInterface,
InstrPmRegsCfg *pPmRegsCfg,
bool useMiRPC,
bool resetASData = false,
const InstrAllowedContexts *pAllowedContexts = nullptr) -> void {
};
bkp = mockFn;
MockOSTime osTime;
std::unique_ptr<MockPerformanceCountersGen> counters(new MockPerformanceCountersGen(&osTime));
ASSERT_NE(nullptr, counters.get());
counters->initialize(platformDevices[0]);
EXPECT_EQ(counters->getFn(), mockFn);
}
};

745
unit_tests/os_interface/performance_counters_tests.cpp
View File

@@ -8,6 +8,7 @@
#include "runtime/helpers/options.h"
#include "runtime/os_interface/os_interface.h"
#include "runtime/os_interface/os_time.h"
#include "runtime/utilities/tag_allocator.h"
#include "unit_tests/fixtures/device_instrumentation_fixture.h"
#include "unit_tests/mocks/mock_device.h"
#include "unit_tests/os_interface/mock_performance_counters.h"
@@ -21,7 +22,6 @@ struct PerformanceCountersDeviceTest : public PerformanceCountersDeviceFixture,
public ::testing::Test {
void SetUp() override {
PerformanceCountersDeviceFixture::SetUp();
PerfCounterFlags::resetPerfCountersFlags();
}
void TearDown() override {
PerformanceCountersDeviceFixture::TearDown();
@@ -31,13 +31,11 @@ struct PerformanceCountersDeviceTest : public PerformanceCountersDeviceFixture,
TEST_F(PerformanceCountersDeviceTest, createDeviceWithPerformanceCounters) {
DeviceInstrumentationFixture::SetUp(true);
EXPECT_NE(nullptr, device->getPerformanceCounters());
EXPECT_EQ(1, PerfCounterFlags::initalizeCalled);
}
TEST_F(PerformanceCountersDeviceTest, createDeviceWithoutPerformanceCounters) {
DeviceInstrumentationFixture::SetUp(false);
EXPECT_EQ(nullptr, device->getPerformanceCounters());
EXPECT_EQ(0, PerfCounterFlags::initalizeCalled);
}
struct PerformanceCountersTest : public PerformanceCountersFixture,
@@ -53,305 +51,92 @@ struct PerformanceCountersTest : public PerformanceCountersFixture,
};
TEST_F(PerformanceCountersTest, createPerformanceCounters) {
auto performanceCounters = PerformanceCounters::create(osTimeBase.get());
auto performanceCounters = PerformanceCounters::create(device.get());
EXPECT_NE(nullptr, performanceCounters);
EXPECT_NE(nullptr, performanceCounters.get());
EXPECT_FALSE(performanceCounters->isAvailable());
}
TEST_F(PerformanceCountersTest, shutdownPerformanceCountersWithoutEnabling) {
createPerfCounters();
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlags::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlags::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlags::autoSamplingStopped);
}
TEST_F(PerformanceCountersTest, givenPerformanceCountersWhenCreatedThenAllValuesProperlyInitialized) {
createPerfCounters();
EXPECT_EQ(IGFX_UNKNOWN_CORE, performanceCountersBase->getGfxFamily());
EXPECT_EQ(nullptr, performanceCountersBase->getCbData().hDevice);
EXPECT_FALSE(performanceCountersBase->getHwMetricsEnabled());
EXPECT_FALSE(performanceCountersBase->getUseMIRPC());
EXPECT_EQ(nullptr, performanceCountersBase->getPAutoSamplingInterface());
EXPECT_EQ(0u, performanceCountersBase->getCpuRawTimestamp());
EXPECT_EQ(1u, performanceCountersBase->getReportId());
EXPECT_FALSE(performanceCountersBase->getAvailable());
EXPECT_EQ(0u, performanceCountersBase->getPerfCountersReferenceNumber());
EXPECT_NE(nullptr, performanceCountersBase->getMetricsLibraryInterface());
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersTest, givenPerformanceCountersNotEnabledWhenGetPmRegsCfgIsCalledThenReturnsNullptr) {
createPerfCounters();
auto pConfig = performanceCountersBase->getPmRegsCfg(0);
EXPECT_EQ(nullptr, pConfig);
}
TEST_F(PerformanceCountersTest, givenPerformanceCountersEnabledWithPassingGetPmRegsCfgFuncWhenGetPmRegsCfgIsCalledThenReturnsPtr) {
createPerfCounters();
performanceCountersBase->setGetPmRegsCfgFunc(getPmRegsCfgPassing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->enable();
auto pConfig = performanceCountersBase->getPmRegsCfg(0);
EXPECT_EQ(1, PerfCounterFlags::getPmRegsCfgCalled);
EXPECT_NE(nullptr, pConfig);
delete pConfig;
performanceCountersBase->shutdown();
}
TEST_F(PerformanceCountersTest, givenPerformanceCountersEnabledWithFailingGetPmRegsCfgFuncWhenGetPmRegsCfgIsCalledThenReturnsNullptr) {
createPerfCounters();
performanceCountersBase->setGetPmRegsCfgFunc(getPmRegsCfgFailing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->enable();
auto pConfig = performanceCountersBase->getPmRegsCfg(0);
EXPECT_EQ(1, PerfCounterFlags::getPmRegsCfgCalled);
EXPECT_EQ(nullptr, pConfig);
performanceCountersBase->shutdown();
}
TEST_F(PerformanceCountersTest, givenPerfCountersWhenGetReportIdsIsCalledManyTimesThenReturnNextNumbers) {
int retVal;
createPerfCounters();
for (int i = 0; i < 4095; i++) {
retVal = performanceCountersBase->getReportId();
EXPECT_EQ((i + 1), retVal);
}
retVal = performanceCountersBase->getReportId();
EXPECT_EQ(0, retVal);
}
TEST_F(PerformanceCountersTest, sendPerfConfigPositiveReadRegsTag) {
cl_int ret;
cl_uint count = 2;
cl_uint offsets[2];
cl_uint values[2];
offsets[0] = INSTR_READ_REGS_CFG_TAG - 1;
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
ret = performanceCountersBase->sendPerfConfiguration(count, offsets, values);
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(1, PerfCounterFlags::setPmRegsCfgCalled);
EXPECT_EQ(0, PerfCounterFlags::sendReadRegsCfgCalled);
}
TEST_F(PerformanceCountersTest, sendPerfConfigPositiveReadRegs) {
cl_int ret;
cl_uint count = 2;
cl_uint offsets[2];
cl_uint values[2];
offsets[0] = INSTR_READ_REGS_CFG_TAG;
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
ret = performanceCountersBase->sendPerfConfiguration(count, offsets, values);
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(0, PerfCounterFlags::setPmRegsCfgCalled);
EXPECT_EQ(1, PerfCounterFlags::sendReadRegsCfgCalled);
}
TEST_F(PerformanceCountersTest, negativeInvalidVal) {
cl_int ret;
cl_uint count = 2;
cl_uint offsets[2];
cl_uint values[2];
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
ret = performanceCountersBase->sendPerfConfiguration(0, offsets, values);
EXPECT_EQ(CL_INVALID_VALUE, ret);
ret = performanceCountersBase->sendPerfConfiguration(count, nullptr, values);
EXPECT_EQ(CL_INVALID_VALUE, ret);
ret = performanceCountersBase->sendPerfConfiguration(count, offsets, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, ret);
EXPECT_EQ(0, PerfCounterFlags::setPmRegsCfgCalled);
EXPECT_EQ(0, PerfCounterFlags::sendReadRegsCfgCalled);
}
TEST_F(PerformanceCountersTest, negativeNoMatchingData) {
cl_int ret;
cl_uint count = 1;
cl_uint offsets[2];
cl_uint values[2];
offsets[0] = INSTR_READ_REGS_CFG_TAG;
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
ret = performanceCountersBase->sendPerfConfiguration(count, offsets, values);
EXPECT_EQ(CL_PROFILING_INFO_NOT_AVAILABLE, ret);
EXPECT_EQ(0, PerfCounterFlags::setPmRegsCfgCalled);
EXPECT_EQ(0, PerfCounterFlags::sendReadRegsCfgCalled);
}
TEST_F(PerformanceCountersTest, sendPerfConfigNegativeFailingReadRegsTag) {
cl_int ret;
cl_uint count = 1;
cl_uint offsets[1];
cl_uint values[1];
offsets[0] = INSTR_READ_REGS_CFG_TAG - 1;
createPerfCounters();
performanceCountersBase->setSetPmRegsCfgFunc(setPmRegsCfgFuncFailing);
performanceCountersBase->initialize(platformDevices[0]);
ret = performanceCountersBase->sendPerfConfiguration(count, offsets, values);
EXPECT_EQ(CL_PROFILING_INFO_NOT_AVAILABLE, ret);
EXPECT_EQ(1, PerfCounterFlags::setPmRegsCfgCalled);
EXPECT_EQ(0, PerfCounterFlags::sendReadRegsCfgCalled);
}
TEST_F(PerformanceCountersTest, sendPerfConfigNegativeFailingReadRegs) {
cl_int ret;
cl_uint count = 2;
cl_uint offsets[2];
cl_uint values[2];
offsets[0] = INSTR_READ_REGS_CFG_TAG;
createPerfCounters();
performanceCountersBase->setSendReadRegsCfgFunc(sendReadRegsCfgFuncFailing);
performanceCountersBase->initialize(platformDevices[0]);
ret = performanceCountersBase->sendPerfConfiguration(count, offsets, values);
EXPECT_EQ(CL_PROFILING_INFO_NOT_AVAILABLE, ret);
EXPECT_EQ(0, PerfCounterFlags::setPmRegsCfgCalled);
EXPECT_EQ(1, PerfCounterFlags::sendReadRegsCfgCalled);
}
struct PerformanceCountersGetConfigTest : public PerformanceCountersTest,
public ::testing::WithParamInterface<std::tuple<
unsigned int /*given configuration type*/,
bool /*expected value*/>> {
void SetUp() override {
PerformanceCountersTest::SetUp();
}
void TearDown() override {
PerformanceCountersTest::TearDown();
}
unsigned int givenConfigType;
bool expectedValue;
};
TEST_P(PerformanceCountersGetConfigTest, givenPerformanceCountersEnabledWithPassingGetPmRegsCfgFuncWhenGetPmRegsCfgIsCalledWithProperConfigurationTypeThenReturnsPtrOtherwiseNullptr) {
std::tie(givenConfigType, expectedValue) = GetParam();
createPerfCounters();
performanceCountersBase->setGetPmRegsCfgFunc(getPmRegsCfgPassing);
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->enable();
auto pConfig = performanceCountersBase->getPmRegsCfg(givenConfigType);
if (expectedValue) {
EXPECT_EQ(1, PerfCounterFlags::getPmRegsCfgCalled);
EXPECT_NE(nullptr, pConfig);
delete pConfig;
} else {
EXPECT_EQ(0, PerfCounterFlags::getPmRegsCfgCalled);
EXPECT_EQ(nullptr, pConfig);
}
performanceCountersBase->shutdown();
}
std::tuple<unsigned int, bool> configsForGetPmRegsCfgTests[] = {
std::make_tuple(GTDI_CONFIGURATION_SET_DYNAMIC, true),
std::make_tuple(GTDI_CONFIGURATION_SET_1, true),
std::make_tuple(GTDI_CONFIGURATION_SET_2, true),
std::make_tuple(GTDI_CONFIGURATION_SET_3, true),
std::make_tuple(GTDI_CONFIGURATION_SET_4, false),
std::make_tuple(GTDI_CONFIGURATION_SET_COUNT, false),
std::make_tuple(GTDI_CONFIGURATION_SET_MAX, false)};
INSTANTIATE_TEST_CASE_P(
PerfCountersTests,
PerformanceCountersGetConfigTest,
testing::ValuesIn(configsForGetPmRegsCfgTests));
struct PerformanceCountersProcessEventTest : public PerformanceCountersTest,
public ::testing::WithParamInterface<bool> {
void SetUp() override {
PerformanceCountersTest::SetUp();
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
privateData.reset(new HwPerfCounter());
eventComplete = true;
outputParamSize = 0;
inputParam.reset(new GTDI_QUERY());
inputParamSize = sizeof(GTDI_QUERY);
inputParamSize = performanceCountersBase->getApiReportSize();
inputParam.reset(new uint8_t);
}
void TearDown() override {
performanceCountersBase->shutdown();
PerformanceCountersTest::TearDown();
}
std::unique_ptr<GTDI_QUERY> inputParam;
std::unique_ptr<uint8_t> inputParam;
size_t inputParamSize;
size_t outputParamSize;
std::unique_ptr<HwPerfCounter> privateData;
bool eventComplete;
};
TEST_P(PerformanceCountersProcessEventTest, givenNullptrInputParamWhenProcessEventPerfCountersIsCalledThenReturnsFalse) {
eventComplete = GetParam();
auto retVal = performanceCountersBase->processEventReport(inputParamSize, nullptr, &outputParamSize, privateData.get(),
nullptr, eventComplete);
auto retVal = performanceCountersBase->getApiReport(inputParamSize, nullptr, &outputParamSize, eventComplete);
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlags::getPerfCountersQueryDataCalled);
}
TEST_P(PerformanceCountersProcessEventTest, givenCorrectInputParamWhenProcessEventPerfCountersIsCalledAndEventIsCompletedThenReturnsTrue) {
eventComplete = GetParam();
EXPECT_EQ(0ull, outputParamSize);
auto retVal = performanceCountersBase->processEventReport(inputParamSize, inputParam.get(), &outputParamSize, privateData.get(),
nullptr, eventComplete);
auto retVal = performanceCountersBase->getApiReport(inputParamSize, inputParam.get(), &outputParamSize, eventComplete);
if (eventComplete) {
EXPECT_TRUE(retVal);
EXPECT_EQ(1, PerfCounterFlags::getPerfCountersQueryDataCalled);
EXPECT_EQ(outputParamSize, inputParamSize);
} else {
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlags::getPerfCountersQueryDataCalled);
EXPECT_EQ(inputParamSize, outputParamSize);
}
}
TEST_F(PerformanceCountersProcessEventTest, givenInvalidInputParamSizeWhenProcessEventPerfCountersIsCalledThenReturnsFalse) {
EXPECT_EQ(0ull, outputParamSize);
auto retVal = performanceCountersBase->processEventReport(inputParamSize - 1, inputParam.get(), &outputParamSize, privateData.get(),
nullptr, eventComplete);
auto retVal = performanceCountersBase->getApiReport(inputParamSize - 1, inputParam.get(), &outputParamSize, eventComplete);
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlags::getPerfCountersQueryDataCalled);
EXPECT_EQ(outputParamSize, inputParamSize);
}
TEST_F(PerformanceCountersProcessEventTest, givenNullptrOutputParamSizeWhenProcessEventPerfCountersIsCalledThenDoesNotReturnsOutputSize) {
EXPECT_EQ(0ull, outputParamSize);
auto retVal = performanceCountersBase->processEventReport(inputParamSize, inputParam.get(), nullptr, privateData.get(),
nullptr, eventComplete);
auto retVal = performanceCountersBase->getApiReport(inputParamSize, inputParam.get(), nullptr, eventComplete);
EXPECT_TRUE(retVal);
EXPECT_EQ(1, PerfCounterFlags::getPerfCountersQueryDataCalled);
EXPECT_EQ(0ull, outputParamSize);
}
TEST_F(PerformanceCountersProcessEventTest, givenNullptrInputZeroSizeWhenProcessEventPerfCountersIsCalledThenQueryProperSize) {
EXPECT_EQ(0ull, outputParamSize);
auto retVal = performanceCountersBase->processEventReport(0, nullptr, &outputParamSize, privateData.get(),
nullptr, eventComplete);
auto retVal = performanceCountersBase->getApiReport(0, nullptr, &outputParamSize, eventComplete);
EXPECT_TRUE(retVal);
EXPECT_EQ(0, PerfCounterFlags::getPerfCountersQueryDataCalled);
EXPECT_EQ(inputParamSize, outputParamSize);
}
TEST_F(PerformanceCountersProcessEventTest, givenNullptrInputZeroSizeAndNullptrOutputSizeWhenProcessEventPerfCountersIsCalledThenReturnFalse) {
EXPECT_EQ(0ull, outputParamSize);
auto retVal = performanceCountersBase->processEventReport(0, nullptr, nullptr, privateData.get(),
nullptr, eventComplete);
auto retVal = performanceCountersBase->getApiReport(0, nullptr, nullptr, eventComplete);
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlags::getPerfCountersQueryDataCalled);
EXPECT_EQ(0ull, outputParamSize);
}
@@ -360,120 +145,420 @@ INSTANTIATE_TEST_CASE_P(
PerformanceCountersProcessEventTest,
testing::Bool());
struct PerformanceCountersSendConfigCommandPointersTest : public PerformanceCountersTest,
public ::testing::WithParamInterface<std::tuple<bool /*pConfig is nullptr*/,
bool /*pLastConfigHandle is nullptr */,
bool /*pLastConfigPending is nullptr*/>> {
struct PerformanceCountersMetricsLibraryTest : public PerformanceCountersMetricsLibraryFixture,
public ::testing::Test {
public:
void SetUp() override {
PerformanceCountersTest::SetUp();
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
std::tie(pConfigIsNullptr, pLastConfigHandleIsNullptr, pLastConfigPendingIsNullptr) = GetParam();
PerformanceCountersMetricsLibraryFixture::SetUp();
}
void TearDown() override {
performanceCountersBase->shutdown();
PerformanceCountersTest::TearDown();
PerformanceCountersMetricsLibraryFixture::TearDown();
}
bool pConfigIsNullptr;
bool pLastConfigHandleIsNullptr;
bool pLastConfigPendingIsNullptr;
InstrPmRegsCfg config;
uint32_t lastConfigHandle;
bool lastConfigPending;
};
TEST_P(PerformanceCountersSendConfigCommandPointersTest, givenPerformanceCountersWithPassingFuncsWhenSendPmRegsCfgCommandsIsCalledWithAnyNullptrThenReturnsFalseOtherwiseTrue) {
InstrPmRegsCfg *pConfig = nullptr;
uint32_t *pLastConfigHandle = nullptr;
bool *pLastConfigPending = nullptr;
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryIsCreated) {
// Create performance counters.
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->isAvailable());
if (!pConfigIsNullptr) {
pConfig = &config;
}
if (!pLastConfigHandleIsNullptr) {
pLastConfigHandle = &lastConfigHandle;
}
if (!pLastConfigPendingIsNullptr) {
lastConfigPending = false;
pLastConfigPending = &lastConfigPending;
}
// Check metric library context.
auto context = static_cast<MockMetricsLibrary *>(performanceCountersBase->getMetricsLibraryContext().data);
EXPECT_NE(nullptr, context);
EXPECT_EQ(1u, context->contextCount);
auto retVal = performanceCountersBase->sendPmRegsCfgCommands(pConfig, pLastConfigHandle, pLastConfigPending);
if (pConfigIsNullptr || pLastConfigHandleIsNullptr || pLastConfigPendingIsNullptr) {
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlags::checkPmRegsCfgCalled);
EXPECT_EQ(0, PerfCounterFlags::loadPmRegsCfgCalled);
} else {
EXPECT_TRUE(retVal);
EXPECT_TRUE(lastConfigPending);
EXPECT_EQ(1, PerfCounterFlags::checkPmRegsCfgCalled);
EXPECT_EQ(1, PerfCounterFlags::loadPmRegsCfgCalled);
}
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
INSTANTIATE_TEST_CASE_P(
PerfCountersTests,
PerformanceCountersSendConfigCommandPointersTest,
testing::Combine(
testing::Bool(),
testing::Bool(),
testing::Bool()));
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryReturnsValidGpuCommands) {
// Create performance counters.
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->isAvailable());
struct PerformanceCountersSendConfigCommandFuncPointersTest : public PerformanceCountersTest,
public ::testing::WithParamInterface<std::tuple<bool /*check config func returns true*/,
bool /*load config func returns true*/>> {
void SetUp() override {
// Obtain required command buffer size.
uint32_t commandsSize = performanceCountersBase->getGpuCommandsSize(true);
EXPECT_NE(0u, commandsSize);
PerformanceCountersTest::SetUp();
createPerfCounters();
std::tie(checkConfigFuncPassing, loadConfigFuncPassing) = GetParam();
if (checkConfigFuncPassing) {
performanceCountersBase->setCheckPmRegsCfgFunc(checkPmRegsCfgPassing);
} else {
performanceCountersBase->setCheckPmRegsCfgFunc(checkPmRegsCfgFailing);
}
if (loadConfigFuncPassing) {
performanceCountersBase->setLoadPmRegsCfgFunc(loadPmRegsCfgPassing);
} else {
performanceCountersBase->setLoadPmRegsCfgFunc(loadPmRegsCfgFailing);
}
lastConfigPending = false;
performanceCountersBase->initialize(platformDevices[0]);
}
// Fill command buffer.
uint8_t buffer[1000] = {};
HwPerfCounter perfCounter = {};
TagNode<HwPerfCounter> query = {};
query.tagForCpuAccess = &perfCounter;
EXPECT_TRUE(performanceCountersBase->getGpuCommands(query, true, sizeof(buffer), buffer));
void TearDown() override {
performanceCountersBase->shutdown();
PerformanceCountersTest::TearDown();
}
bool checkConfigFuncPassing;
bool loadConfigFuncPassing;
InstrPmRegsCfg config;
uint32_t lastConfigHandle;
bool lastConfigPending;
};
TEST_P(PerformanceCountersSendConfigCommandFuncPointersTest, givenPerformanceCountersSendPmRegsCfgCommandsFuncWhenAllLoadConfigFuncAndCheckConfigFuncAndGetPerfmonConfigReturnTrueThenReturnsTrueOtherwiseFalse) {
auto retVal = performanceCountersBase->sendPmRegsCfgCommands(&config, &lastConfigHandle, &lastConfigPending);
EXPECT_EQ(1, PerfCounterFlags::checkPmRegsCfgCalled);
if (checkConfigFuncPassing) {
EXPECT_EQ(1, PerfCounterFlags::loadPmRegsCfgCalled);
if (loadConfigFuncPassing) {
EXPECT_TRUE(retVal);
EXPECT_TRUE(lastConfigPending);
} else {
EXPECT_FALSE(retVal);
EXPECT_EQ(1, PerfCounterFlags::loadPmRegsCfgCalled);
}
} else {
EXPECT_FALSE(retVal);
EXPECT_EQ(0, PerfCounterFlags::loadPmRegsCfgCalled);
}
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
INSTANTIATE_TEST_CASE_P(
PerfCountersTests,
PerformanceCountersSendConfigCommandFuncPointersTest,
testing::Combine(
testing::Bool(),
testing::Bool()));
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenQueryReturnsInvalidGpuCommands) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
// Obtain required command buffer size.
uint32_t commandsSize = performanceCountersBase->getGpuCommandsSize(true);
EXPECT_EQ(0u, commandsSize);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenApiReportSizeIsValid) {
// Create performance counters.
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->isAvailable());
// Obtain api report size.
uint32_t apiReportSize = performanceCountersBase->getApiReportSize();
EXPECT_GT(apiReportSize, 0u);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenApiReportSizeIsInvalid) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
// Obtain api report size.
uint32_t apiReportSize = performanceCountersBase->getApiReportSize();
EXPECT_EQ(0u, apiReportSize);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenGpuReportSizeIsInvalid) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
// Obtain gpu report size.
uint32_t gpuReportSize = performanceCountersBase->getGpuReportSize();
EXPECT_EQ(0u, gpuReportSize);
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryIsAvailable) {
// Create performance counters.
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->isAvailable());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsInvalidThenQueryIsNotAvailable) {
// Create performance counters.
createPerformanceCounters(false, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_FALSE(performanceCountersBase->isAvailable());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryHasInvalidExportFunctionsDestroyThenQueryIsNotAvailable) {
createPerformanceCounters(true, false);
auto metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
auto metricsLibraryDll = reinterpret_cast<MockMetricsLibraryDll *>(metricsLibraryInterface->osLibrary.get());
metricsLibraryDll->validContextCreate = true;
metricsLibraryDll->validContextDelete = false;
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_FALSE(performanceCountersBase->isAvailable());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryHasInvalidExportFunctionsCreateAndDestroyThenQueryIsNotAvailable) {
createPerformanceCounters(true, false);
auto metricsLibraryInterface = performanceCountersBase->getMetricsLibraryInterface();
auto metricsLibraryDll = reinterpret_cast<MockMetricsLibraryDll *>(metricsLibraryInterface->osLibrary.get());
metricsLibraryDll->validContextCreate = false;
metricsLibraryDll->validContextDelete = false;
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_FALSE(performanceCountersBase->isAvailable());
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryReturnsCorrectApiReport) {
// Create performance counters.
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
EXPECT_TRUE(performanceCountersBase->isAvailable());
// Obtain required command buffer size.
uint32_t commandsSize = performanceCountersBase->getGpuCommandsSize(true);
EXPECT_NE(0u, commandsSize);
// Fill command buffer.
uint8_t buffer[1000] = {};
TagNode<HwPerfCounter> query = {};
HwPerfCounter perfCounter = {};
query.tagForCpuAccess = &perfCounter;
EXPECT_TRUE(performanceCountersBase->getGpuCommands(query, true, sizeof(buffer), buffer));
// Obtain api report size.
uint32_t apiReportSize = performanceCountersBase->getApiReportSize();
EXPECT_GT(apiReportSize, 0u);
// Obtain gpu report size.
uint32_t gpuReportSize = performanceCountersBase->getGpuReportSize();
EXPECT_GT(gpuReportSize, 0u);
// Allocate memory for api report.
uint8_t *apiReport = new uint8_t[apiReportSize];
EXPECT_NE(apiReport, nullptr);
// Obtain api report.
EXPECT_TRUE(performanceCountersBase->getApiReport(apiReportSize, apiReport, nullptr, true));
delete[] apiReport;
apiReport = nullptr;
// Close library.
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenReferenceCounterIsValid) {
createPerformanceCounters(true, true);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->enable();
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());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricLibraryIsValidThenQueryHandleIsValid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
performanceCountersBase->enable();
EXPECT_TRUE(performanceCountersBase->getQueryHandle().IsValid());
EXPECT_TRUE(performanceCountersBase->getQueryHandle().IsValid());
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenOaConfigurationIsInvalidThenGpuReportSizeIsInvalid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
metricLibraryApi->validCreateConfigurationOa = false;
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(true));
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(false), 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenMetricsLibraryIsInvalidGpuReportSizeIsInvalid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
metricLibraryApi->validGpuReportSize = false;
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(true));
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(false));
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenAllConfigurationsAreValidThenGpuReportSizeIsValid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
metricLibraryApi->validCreateConfigurationOa = true;
metricLibraryApi->validCreateConfigurationUser = true;
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(true), 0u);
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(false), 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenOaConfigurationsActivationIsInvalidThenGpuReportSizeIsInvalid) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
auto metricLibraryApi = static_cast<MockMetricsLibraryValidInterface *>(performanceCountersBase->getMetricsLibraryContext().data);
metricLibraryApi->validActivateConfigurationOa = false;
EXPECT_EQ(0u, performanceCountersBase->getGpuCommandsSize(true));
EXPECT_GT(performanceCountersBase->getGpuCommandsSize(false), 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, givenPerformanceCountersWhenCreatingUserConfigurationThenReturnSuccess) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
ConfigurationHandle_1_0 configurationHandle = {};
auto metricsLibrary = performanceCountersBase->getMetricsLibraryInterface();
auto contextHandle = performanceCountersBase->getMetricsLibraryContext();
EXPECT_TRUE(metricsLibrary->userConfigurationCreate(contextHandle, configurationHandle));
EXPECT_TRUE(metricsLibrary->userConfigurationDelete(configurationHandle));
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, getHwPerfCounterReturnsValidPointer) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
ASSERT_NE(nullptr, queue->getPerfCounters());
std::unique_ptr<Event> event(new Event(queue.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
ASSERT_NE(nullptr, perfCounter);
ASSERT_EQ(0ULL, perfCounter->report[0]);
EXPECT_TRUE(perfCounter->canBeReleased());
HwPerfCounter *perfCounter2 = event->getHwPerfCounterNode()->tagForCpuAccess;
ASSERT_EQ(perfCounter, perfCounter2);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, getHwPerfCounterAllocationReturnsValidPointer) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
ASSERT_NE(nullptr, queue->getPerfCounters());
std::unique_ptr<Event> event(new Event(queue.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
GraphicsAllocation *allocation = event->getHwPerfCounterNode()->getBaseGraphicsAllocation();
ASSERT_NE(nullptr, allocation);
void *memoryStorage = allocation->getUnderlyingBuffer();
size_t memoryStorageSize = allocation->getUnderlyingBufferSize();
EXPECT_NE(nullptr, memoryStorage);
EXPECT_GT(memoryStorageSize, 0u);
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, hwPerfCounterMemoryIsPlacedInGraphicsAllocation) {
createPerformanceCounters(true, false);
EXPECT_NE(nullptr, performanceCountersBase);
performanceCountersBase->enable();
EXPECT_EQ(1u, performanceCountersBase->getReferenceNumber());
ASSERT_NE(nullptr, queue->getPerfCounters());
std::unique_ptr<Event> event(new Event(queue.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
ASSERT_NE(nullptr, perfCounter);
GraphicsAllocation *allocation = event->getHwPerfCounterNode()->getBaseGraphicsAllocation();
ASSERT_NE(nullptr, allocation);
void *memoryStorage = allocation->getUnderlyingBuffer();
size_t graphicsAllocationSize = allocation->getUnderlyingBufferSize();
EXPECT_GE(perfCounter, memoryStorage);
EXPECT_LE(perfCounter + 1, ptrOffset(memoryStorage, graphicsAllocationSize));
performanceCountersBase->shutdown();
EXPECT_EQ(0u, performanceCountersBase->getReferenceNumber());
}
TEST_F(PerformanceCountersMetricsLibraryTest, hwPerfCounterNodeWhenPerformanceCountersObjectIsNotPresentThenNodeisNull) {
std::unique_ptr<Event> event(new Event(queue.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
ASSERT_NE(nullptr, event);
auto node = event->getHwPerfCounterNode();
ASSERT_EQ(nullptr, node);
}
TEST_F(PerformanceCountersTest, givenRenderCoreFamilyThenMetricsLibraryGenIdentifierAreValid) {
const auto &hwInfo = device->getHardwareInfo();
const auto gen = hwInfo.platform.eRenderCoreFamily;
EXPECT_NE(ClientGen::Unknown, static_cast<ClientGen>(HwHelper::get(gen).getMetricsLibraryGenId()));
}

2
unit_tests/os_interface/windows/hw_info_config_win_tests.cpp
View File

@@ -11,6 +11,8 @@
#include "runtime/os_interface/windows/wddm/wddm.h"
#include "unit_tests/helpers/debug_manager_state_restore.h"
#include "instrumentation.h"
namespace NEO {
template <>

74
unit_tests/os_interface/windows/mock_performance_counters_win.cpp
View File

@@ -7,47 +7,59 @@
#include "mock_performance_counters_win.h"
#include "runtime/os_interface/os_interface.h"
#include "runtime/os_interface/windows/os_interface.h"
#include "runtime/os_interface/windows/windows_wrapper.h"
#include "unit_tests/mocks/mock_wddm.h"
#include "unit_tests/os_interface/windows/mock_os_time_win.h"
namespace NEO {
MockPerformanceCountersWin::MockPerformanceCountersWin(OSTime *osTime)
: PerformanceCounters(osTime), PerformanceCountersWin(osTime), MockPerformanceCounters(osTime) {
setAvailableFunc = setAvailable;
verifyEnableFunc = verifyEnable;
PerfCounterFlagsWin::resetPerfCountersFlags();
}
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(OSTime *osTime) {
return std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersWin(osTime));
///////////////////////////////////////////////////////
// MockPerformanceCounters::create
///////////////////////////////////////////////////////
std::unique_ptr<PerformanceCounters> MockPerformanceCounters::create(Device *device) {
auto performanceCounters = std::unique_ptr<PerformanceCounters>(new MockPerformanceCountersWin(device));
auto metricsLibrary = std::make_unique<MockMetricsLibrary>();
auto metricsLibraryDll = std::make_unique<MockMetricsLibraryDll>();
metricsLibrary->api = std::make_unique<MockMetricsLibraryValidInterface>();
metricsLibrary->osLibrary = std::move(metricsLibraryDll);
performanceCounters->setMetricsLibraryInterface(std::move(metricsLibrary));
return performanceCounters;
}
int PerfCounterFlagsWin::setAvailableFuncCalled;
int PerfCounterFlagsWin::verifyEnableFuncCalled;
bool setAvailable(bool value) {
PerfCounterFlagsWin::setAvailableFuncCalled++;
return value;
}
void verifyEnable(InstrEscCbData cbData) {
PerfCounterFlagsWin::verifyEnableFuncCalled++;
}
void PerfCounterFlagsWin::resetPerfCountersFlags() {
PerfCounterFlags::resetPerfCountersFlags();
PerfCounterFlagsWin::setAvailableFuncCalled = 0;
PerfCounterFlagsWin::verifyEnableFuncCalled = 0;
///////////////////////////////////////////////////////
// MockPerformanceCountersWin::MockPerformanceCountersWin
///////////////////////////////////////////////////////
MockPerformanceCountersWin::MockPerformanceCountersWin(Device *device)
: PerformanceCountersWin() {
}
//////////////////////////////////////////////////////
// PerformanceCountersFixture::createPerfCounters
//////////////////////////////////////////////////////
void PerformanceCountersFixture::createPerfCounters() {
performanceCountersBase = std::unique_ptr<MockPerformanceCounters>(new MockPerformanceCountersWin(osTimeBase.get()));
performanceCountersBase = MockPerformanceCounters::create(device.get());
}
void PerformanceCountersFixture::createOsTime() {
osTimeBase = std::unique_ptr<MockOSTimeWin>(new MockOSTimeWin(osInterfaceBase.get()));
//////////////////////////////////////////////////////
// PerformanceCountersFixture::SetUp
//////////////////////////////////////////////////////
void PerformanceCountersFixture::SetUp() {
device = std::unique_ptr<MockDevice>(new MockDevice());
context = std::make_unique<MockContext>(device.get());
queue = std::make_unique<MockCommandQueue>(context.get(), device.get(), &queueProperties);
osInterface = std::unique_ptr<OSInterface>(new OSInterface());
osInterface->get()->setWddm(new WddmMock());
device->setOSTime(new MockOSTimeWin(osInterface.get()));
}
void PerformanceCountersFixture::fillOsInterface() {
osInterfaceBase->get()->setWddm(new WddmMock());
}
void PerformanceCountersFixture::releaseOsInterface() {
//////////////////////////////////////////////////////
// PerformanceCountersFixture::TearDown
//////////////////////////////////////////////////////
void PerformanceCountersFixture::TearDown() {
}
} // namespace NEO

23
unit_tests/os_interface/windows/mock_performance_counters_win.h
View File

@@ -8,30 +8,11 @@
#pragma once
#include "runtime/os_interface/windows/performance_counters_win.h"
#include "unit_tests/os_interface/mock_performance_counters.h"
#include "unit_tests/os_interface/windows/mock_os_time_win.h"
namespace NEO {
bool setAvailable(bool value);
void verifyEnable(InstrEscCbData cbData);
class PerfCounterFlagsWin : public PerfCounterFlags {
class MockPerformanceCountersWin : public PerformanceCountersWin {
public:
static int setAvailableFuncCalled;
static int verifyEnableFuncCalled;
static void resetPerfCountersFlags();
};
class MockPerformanceCountersWin : public PerformanceCountersWin,
public MockPerformanceCounters {
public:
MockPerformanceCountersWin(OSTime *osTime);
uint32_t getReportId() override {
return MockPerformanceCounters::getReportId();
}
void initialize(const HardwareInfo *hwInfo) override {
MockPerformanceCounters::initialize(hwInfo);
return PerformanceCountersWin::initialize(hwInfo);
}
MockPerformanceCountersWin(Device *device);
};
} // namespace NEO

1
unit_tests/os_interface/windows/options.cpp
View File

@@ -21,6 +21,7 @@ const char *gdiDllName = "gdi32_mock.dll";
const char *gmmDllName = "mock_gmm.dll";
const char *gmmEntryName = "openMockGmm";
const char *testDllName = "test_dynamic_lib.dll";
const char *metricsLibraryDllName = "";
} // namespace Os
NEO::OsLibrary *setAdapterInfo(const PLATFORM *platform, const GT_SYSTEM_INFO *gtSystemInfo, uint64_t gpuAddressSpace) {

5
unit_tests/os_interface/windows/os_interface_win_tests.cpp
View File

@@ -10,11 +10,6 @@
#include "runtime/os_interface/windows/os_context_win.h"
#include "unit_tests/os_interface/windows/wddm_fixture.h"
TEST_F(OsInterfaceTest, givenOsInterfaceWithoutWddmWhenGetHwContextIdIsCalledThenReturnsZero) {
auto retVal = osInterface->getHwContextId();
EXPECT_EQ(0u, retVal);
}
TEST_F(OsInterfaceTest, GivenWindowsWhenOsSupportFor64KBpagesIsBeingQueriedThenTrueIsReturned) {
EXPECT_TRUE(OSInterface::are64kbPagesEnabled());
}

173
unit_tests/os_interface/windows/performance_counters_win_tests.cpp
View File

@@ -6,8 +6,6 @@
*/
#include "runtime/helpers/options.h"
#include "runtime/os_interface/windows/windows_wrapper.h"
#include "unit_tests/mocks/mock_wddm.h"
#include "unit_tests/os_interface/windows/mock_performance_counters_win.h"
#include "gtest/gtest.h"
@@ -19,180 +17,9 @@ struct PerformanceCountersWinTest : public PerformanceCountersFixture,
public:
void SetUp() override {
PerformanceCountersFixture::SetUp();
PerfCounterFlagsWin::resetPerfCountersFlags();
wddm = static_cast<WddmMock *>(osInterfaceBase->get()->getWddm());
}
void TearDown() override {
PerformanceCountersFixture::TearDown();
}
WddmMock *wddm;
};
TEST_F(PerformanceCountersWinTest, initializePerformanceCounters) {
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
EXPECT_EQ(1, PerfCounterFlagsWin::setAvailableFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::verifyEnableFuncCalled);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersWinTest, enableWithCreatedAsInterface) {
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
performanceCountersBase->setAsIface(new char[1]);
performanceCountersBase->enable();
}
TEST_F(PerformanceCountersWinTest, enablePerformanceCountersWithPassingEscHwMetricsFunc) {
createPerfCounters();
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStarted);
EXPECT_EQ(1, PerfCounterFlagsWin::hwMetricsEnableStatus);
EXPECT_TRUE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
EXPECT_EQ(2, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(2, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStopped);
EXPECT_EQ(0, PerfCounterFlagsWin::hwMetricsEnableStatus);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersWinTest, enablePerformanceCountersWithFailingEscHwMetricsFunc) {
createPerfCounters();
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncFailing);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStarted);
EXPECT_EQ(1, PerfCounterFlagsWin::hwMetricsEnableStatus);
performanceCountersBase->shutdown();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStopped);
}
TEST_F(PerformanceCountersWinTest, enablePerformanceCountersWithPassingEscHwMetricsFuncTwice) {
uint32_t refNum = 0;
createPerfCounters();
EXPECT_FALSE(performanceCountersBase->isAvailable());
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
performanceCountersBase->enable();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStarted);
EXPECT_EQ(1u, refNum);
EXPECT_TRUE(performanceCountersBase->isAvailable());
performanceCountersBase->enable();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStarted);
EXPECT_EQ(2u, refNum);
EXPECT_TRUE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStopped);
EXPECT_EQ(1u, refNum);
EXPECT_TRUE(performanceCountersBase->isAvailable());
performanceCountersBase->shutdown();
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(2, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(2, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStopped);
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersWinTest, enablePerformanceCountersWithFailingEscHwMetricsFuncTwice) {
createPerfCounters();
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncFailing);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStarted);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStarted);
performanceCountersBase->shutdown();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStopped);
}
TEST_F(PerformanceCountersWinTest, enablePerformanceCountersWithFailingAutoStartFuncAfterProperInitializing) {
uint32_t refNum = 0;
createPerfCounters();
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->setAutoSamplingStartFunc(autoSamplingStartFailing);
performanceCountersBase->initialize(platformDevices[0]);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::hwMetricsEnableStatus);
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStarted);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_FALSE(performanceCountersBase->isAvailable());
EXPECT_EQ(1u, refNum);
performanceCountersBase->shutdown();
EXPECT_EQ(0, PerfCounterFlagsWin::hwMetricsEnableStatus);
EXPECT_EQ(2, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStopped);
refNum = performanceCountersBase->getPerfCountersReferenceNumber();
EXPECT_EQ(0u, refNum);
EXPECT_FALSE(performanceCountersBase->isAvailable());
}
TEST_F(PerformanceCountersWinTest, enablePerformanceCountersWithFailingEscHwMetricsFuncAfterStartingAutoSampling) {
createPerfCounters();
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncPassing);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStarted);
performanceCountersBase->setEscHwMetricsFunc(hwMetricsEnableFuncFailing);
performanceCountersBase->enable();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStarted);
performanceCountersBase->shutdown();
EXPECT_EQ(1, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(0, PerfCounterFlagsWin::autoSamplingStopped);
performanceCountersBase->shutdown();
EXPECT_EQ(2, PerfCounterFlagsWin::escHwMetricsCalled);
EXPECT_EQ(2, PerfCounterFlagsWin::autoSamplingFuncCalled);
EXPECT_EQ(1, PerfCounterFlagsWin::autoSamplingStopped);
}
TEST_F(PerformanceCountersWinTest, setCpuTimestamp) {
createPerfCounters();
EXPECT_EQ(0ull, performanceCountersBase->getCpuRawTimestamp());
performanceCountersBase->setCpuTimestamp();
EXPECT_NE(0ull, performanceCountersBase->getCpuRawTimestamp());
}
TEST_F(PerformanceCountersWinTest, givenPerfCountersWithWddmWithSetHwContextIdWhenGetCurrentReportIdsIsCalledManyTimesThenReturnProperNumber) {
unsigned int retVal;
wddm->setHwContextId(0x12345);
createPerfCounters();
retVal = performanceCountersBase->getCurrentReportId();
EXPECT_EQ(0x12345u, osInterfaceBase->getHwContextId());
EXPECT_EQ(0x12345001u, retVal);
}

2
unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -1610,7 +1610,7 @@ TEST(WddmMemoryManagerCleanupTest, givenUsedTagAllocationInWddmMemoryManagerWhen
csr->setupContext(*osContext);
EXPECT_EQ(csr, executionEnvironment.memoryManager->getDefaultCommandStreamReceiver(0));
auto tagAllocator = csr->getEventPerfCountAllocator();
auto tagAllocator = csr->getEventPerfCountAllocator(100);
auto allocation = tagAllocator->getTag()->getBaseGraphicsAllocation();
allocation->updateTaskCount(1, csr->getOsContext().getContextId());
executionEnvironment.commandStreamReceivers.clear();

98
unit_tests/profiling/profiling_tests.cpp
View File

@@ -517,7 +517,6 @@ struct ProfilingWithPerfCountersTests : public ProfilingTests,
PerformanceCountersFixture::SetUp();
ProfilingTests::SetUp();
createPerfCounters();
performanceCountersBase->initialize(platformDevices[0]);
pDevice->setPerfCounters(performanceCountersBase.release());
}
@@ -540,45 +539,13 @@ struct ProfilingWithPerfCountersTests : public ProfilingTests,
}
};
HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCounterAndForWorkloadWithKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
pCmdQ->setPerfCountersEnabled(true, 1);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
uint64_t requiredSize = 2 * sizeof(PIPE_CONTROL) + 4 * sizeof(MI_STORE_REGISTER_MEM) + sizeof(GPGPU_WALKER) + HardwareCommandsHelper<FamilyType>::getSizeRequiredCS(&kernel);
//begin perf cmds
requiredSize += 2 * sizeof(PIPE_CONTROL) + 2 * sizeof(MI_STORE_REGISTER_MEM) + NEO::INSTR_GENERAL_PURPOSE_COUNTERS_COUNT * sizeof(MI_STORE_REGISTER_MEM) + sizeof(MI_REPORT_PERF_COUNT) + pCmdQ->getPerfCountersUserRegistersNumber() * sizeof(MI_STORE_REGISTER_MEM);
//end perf cmds
requiredSize += 2 * sizeof(PIPE_CONTROL) + 3 * sizeof(MI_STORE_REGISTER_MEM) + NEO::INSTR_GENERAL_PURPOSE_COUNTERS_COUNT * sizeof(MI_STORE_REGISTER_MEM) + sizeof(MI_REPORT_PERF_COUNT) + pCmdQ->getPerfCountersUserRegistersNumber() * sizeof(MI_STORE_REGISTER_MEM);
auto &commandStreamNDRangeKernel = getCommandStream<FamilyType, CL_COMMAND_NDRANGE_KERNEL>(*pCmdQ, true, true, &kernel);
auto expectedSizeCS = EnqueueOperation<FamilyType>::getSizeRequiredCS(CL_COMMAND_NDRANGE_KERNEL, true, true, *pCmdQ, &kernel);
EXPECT_GE(expectedSizeCS, requiredSize);
EXPECT_GE(commandStreamNDRangeKernel.getAvailableSpace(), requiredSize);
auto &commandStreamTask = getCommandStream<FamilyType, CL_COMMAND_TASK>(*pCmdQ, true, true, &kernel);
expectedSizeCS = EnqueueOperation<FamilyType>::getSizeRequiredCS(CL_COMMAND_TASK, true, true, *pCmdQ, &kernel);
EXPECT_GE(expectedSizeCS, requiredSize);
EXPECT_GE(commandStreamTask.getAvailableSpace(), requiredSize);
bool retVal = false;
retVal = pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
EXPECT_TRUE(retVal);
retVal = pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
EXPECT_TRUE(retVal);
}
HWTEST_F(ProfilingWithPerfCountersTests,
GIVENCommandQueueWithProfilingPerfCounterAndForWorkloadWithNoKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
typedef typename FamilyType::WALKER_TYPE GPGPU_WALKER;
pCmdQ->setPerfCountersEnabled(true, 1);
pCmdQ->setPerfCountersEnabled(true, 0);
uint64_t requiredSize = 2 * sizeof(PIPE_CONTROL) + 4 * sizeof(MI_STORE_REGISTER_MEM);
@@ -595,43 +562,12 @@ HWTEST_F(ProfilingWithPerfCountersTests,
pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
}
HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersAndForWorkloadWithTwoKernelsInMdiWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
MockKernel kernel(program.get(), kernelInfo, *pDevice);
pCmdQ->setPerfCountersEnabled(true, 1);
uint64_t requiredSize = 2 * sizeof(PIPE_CONTROL) + 4 * sizeof(MI_STORE_REGISTER_MEM) + HardwareCommandsHelper<FamilyType>::getSizeRequiredCS(&kernel);
requiredSize += 2 * sizeof(GPGPU_WALKER);
//begin perf cmds
requiredSize += 2 * sizeof(PIPE_CONTROL) + 2 * sizeof(MI_STORE_REGISTER_MEM) + NEO::INSTR_GENERAL_PURPOSE_COUNTERS_COUNT * sizeof(MI_STORE_REGISTER_MEM) + sizeof(MI_REPORT_PERF_COUNT) + pCmdQ->getPerfCountersUserRegistersNumber() * sizeof(MI_STORE_REGISTER_MEM);
//end perf cmds
requiredSize += 2 * sizeof(PIPE_CONTROL) + 3 * sizeof(MI_STORE_REGISTER_MEM) + NEO::INSTR_GENERAL_PURPOSE_COUNTERS_COUNT * sizeof(MI_STORE_REGISTER_MEM) + sizeof(MI_REPORT_PERF_COUNT) + pCmdQ->getPerfCountersUserRegistersNumber() * sizeof(MI_STORE_REGISTER_MEM);
DispatchInfo dispatchInfo;
dispatchInfo.setKernel(&kernel);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
multiDispatchInfo.push(dispatchInfo);
auto &commandStreamTask = getCommandStream<FamilyType, CL_COMMAND_TASK>(*pCmdQ, true, true, &kernel);
auto expectedSizeCS = EnqueueOperation<FamilyType>::getTotalSizeRequiredCS(CL_COMMAND_TASK, CsrDependencies(), true, true, *pCmdQ, multiDispatchInfo);
EXPECT_GE(expectedSizeCS, requiredSize);
EXPECT_GE(commandStreamTask.getAvailableSpace(), requiredSize);
pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
}
HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
pCmdQ->setPerfCountersEnabled(true, 1);
pCmdQ->setPerfCountersEnabled(true, 0);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -694,7 +630,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWit
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
pCmdQ->setPerfCountersEnabled(true, 2);
pCmdQ->setPerfCountersEnabled(true, 0);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -757,7 +693,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueBlo
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
pCmdQ->setPerfCountersEnabled(true, 1);
pCmdQ->setPerfCountersEnabled(true, 0);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -822,7 +758,7 @@ HWTEST_F(ProfilingWithPerfCountersTests,
typedef typename FamilyType::WALKER_TYPE GPGPU_WALKER;
typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
pCmdQ->setPerfCountersEnabled(true, 1);
pCmdQ->setPerfCountersEnabled(true, 0);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -897,7 +833,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
csr.profilingTimeStampAllocator.reset(new FixedGpuAddressTagAllocator<HwTimeStamps>(csr, timeStampGpuAddress));
csr.perfCounterAllocator.reset(new FixedGpuAddressTagAllocator<HwPerfCounter>(csr, perfCountersGpuAddress));
pCmdQ->setPerfCountersEnabled(true, 1);
pCmdQ->setPerfCountersEnabled(true, 0);
MockKernel kernel(program.get(), kernelInfo, *pDevice);
ASSERT_EQ(CL_SUCCESS, kernel.initialize());
@@ -924,31 +860,9 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
parseCommands<FamilyType>(*pCmdQ);
auto itor = expectStoreRegister<FamilyType>(cmdList.begin(), timeStampGpuAddress + offsetof(HwTimeStamps, ContextStartTS), GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.DMAFenceIdBegin), INSTR_MMIO_NOOPID);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.CoreFreqBegin), INSTR_MMIO_RPSTAT1);
for (auto i = 0u; i < NEO::INSTR_GENERAL_PURPOSE_COUNTERS_COUNT; i++) {
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportBegin.Gp) + i * sizeof(cl_uint),
INSTR_GFX_OFFSETS::INSTR_PERF_CNT_1_DW0 + i * sizeof(cl_uint));
}
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportBegin.User), 0);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportBegin.User) + 8, 0);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportBegin.User) + 12, 4);
// after WALKER:
itor = expectStoreRegister<FamilyType>(itor, timeStampGpuAddress + offsetof(HwTimeStamps, ContextEndTS), GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.OaStatus), INSTR_GFX_OFFSETS::INSTR_OA_STATUS);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.OaHead), INSTR_GFX_OFFSETS::INSTR_OA_HEAD_PTR);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.OaTail), INSTR_GFX_OFFSETS::INSTR_OA_TAIL_PTR);
for (auto i = 0u; i < NEO::INSTR_GENERAL_PURPOSE_COUNTERS_COUNT; i++) {
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportEnd.Gp) + i * sizeof(cl_uint),
INSTR_GFX_OFFSETS::INSTR_PERF_CNT_1_DW0 + i * sizeof(cl_uint));
}
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.DMAFenceIdEnd), INSTR_MMIO_NOOPID);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.CoreFreqEnd), INSTR_MMIO_RPSTAT1);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportEnd.User), 0);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportEnd.User) + 8, 0);
itor = expectStoreRegister<FamilyType>(itor, perfCountersGpuAddress + offsetof(HwPerfCounter, HWPerfCounters.HwPerfReportEnd.User) + 12, 4);
EXPECT_TRUE(pEvent->calcProfilingData());