Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-11-10 05:49:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use global timestamps instead of local

Browse Source 
Change-Id: Ie39b242915a55aef60fcf7164199647299c91a21
This commit is contained in:
Kamil Diedrich
2020-09-03 09:06:11 +02:00
committed by sys_ocldev
parent 0bbd2b2ac4
commit 57269b97a3
24 changed files with 517 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
level_zero/core/source/event/event.cpp
View File

@@ -28,50 +28,6 @@
namespace L0 {
struct EventImp : public Event {
EventImp(EventPool *eventPool, int index, Device *device)
: device(device), eventPool(eventPool) {}
~EventImp() override {}
ze_result_t hostSignal() override;
ze_result_t hostSynchronize(uint64_t timeout) override;
ze_result_t queryStatus() override {
uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
uint32_t queryVal = Event::STATE_CLEARED;
if (metricStreamer != nullptr) {
*hostAddr = metricStreamer->getNotificationState();
}
this->csr->downloadAllocations();
if (isTimestampEvent) {
auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
auto timeStampAddress = baseAddr + offsetof(KernelTimestampEvent, contextEnd);
hostAddr = reinterpret_cast<uint64_t *>(timeStampAddress);
}
memcpy_s(static_cast<void *>(&queryVal), sizeof(uint32_t), static_cast<void *>(hostAddr), sizeof(uint32_t));
return queryVal == Event::STATE_CLEARED ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
}
ze_result_t reset() override;
ze_result_t queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) override;
Device *device;
EventPool *eventPool;
protected:
ze_result_t hostEventSetValue(uint32_t eventValue);
ze_result_t hostEventSetValueTimestamps(uint32_t eventVal);
};
struct EventPoolImp : public EventPool {
EventPoolImp(DriverHandle *driver, uint32_t numDevices, ze_device_handle_t *phDevices, uint32_t numEvents, ze_event_pool_flags_t flags) : numEvents(numEvents) {
if (flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP) {
@@ -165,6 +121,22 @@ ze_result_t Event::destroy() {
return ZE_RESULT_SUCCESS;
}
ze_result_t EventImp::queryStatus() {
uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
uint32_t queryVal = Event::STATE_CLEARED;
if (metricStreamer != nullptr) {
*hostAddr = metricStreamer->getNotificationState();
}
this->csr->downloadAllocations();
if (isTimestampEvent) {
auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
auto timeStampAddress = baseAddr + offsetof(KernelTimestampEvent, contextEnd);
hostAddr = reinterpret_cast<uint64_t *>(timeStampAddress);
}
memcpy_s(static_cast<void *>(&queryVal), sizeof(uint32_t), static_cast<void *>(hostAddr), sizeof(uint32_t));
return queryVal == Event::STATE_CLEARED ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
}
ze_result_t EventImp::hostEventSetValueTimestamps(uint32_t eventVal) {
auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
@@ -256,8 +228,7 @@ ze_result_t EventImp::queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr)
// Ensure timestamps have been written
if (queryStatus() != ZE_RESULT_SUCCESS) {
memcpy_s(dstptr, sizeof(uint64_t), static_cast<void *>(&tsData), sizeof(uint64_t));
return ZE_RESULT_SUCCESS;
return ZE_RESULT_NOT_READY;
}
auto eventTsSetFunc = [&](auto tsAddr, uint64_t &timestampField) {
@@ -267,10 +238,17 @@ ze_result_t EventImp::queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr)
memcpy_s(&(timestampField), sizeof(uint64_t), static_cast<void *>(&tsData), sizeof(uint64_t));
};
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, contextStart), result.context.kernelStart);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalStart), result.global.kernelStart);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, contextEnd), result.context.kernelEnd);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalEnd), result.global.kernelEnd);
if (!NEO::HwHelper::get(device->getHwInfo().platform.eRenderCoreFamily).useOnlyGlobalTimestamps()) {
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, contextStart), result.context.kernelStart);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalStart), result.global.kernelStart);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, contextEnd), result.context.kernelEnd);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalEnd), result.global.kernelEnd);
} else {
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalStart), result.context.kernelStart);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalStart), result.global.kernelStart);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalEnd), result.context.kernelEnd);
eventTsSetFunc(baseAddr + offsetof(KernelTimestampEvent, globalEnd), result.global.kernelEnd);
}
return ZE_RESULT_SUCCESS;
}

25
level_zero/core/source/event/event.h
View File

@@ -63,6 +63,31 @@ struct Event : _ze_event_handle_t {
NEO::GraphicsAllocation *allocation = nullptr;
};
struct EventImp : public Event {
EventImp(EventPool *eventPool, int index, Device *device)
: device(device), eventPool(eventPool) {}
~EventImp() override {}
ze_result_t hostSignal() override;
ze_result_t hostSynchronize(uint64_t timeout) override;
ze_result_t queryStatus() override;
ze_result_t reset() override;
ze_result_t queryKernelTimestamp(ze_kernel_timestamp_result_t *dstptr) override;
Device *device;
EventPool *eventPool;
protected:
ze_result_t hostEventSetValue(uint32_t eventValue);
ze_result_t hostEventSetValueTimestamps(uint32_t eventVal);
void makeAllocationResident();
};
struct KernelTimestampEvent {
uint32_t contextStart = Event::STATE_INITIAL;
uint32_t globalStart = Event::STATE_INITIAL;

1
level_zero/core/test/unit_tests/gen12lp/CMakeLists.txt
View File

@@ -10,6 +10,7 @@ if(TESTS_GEN12LP)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/enable_l0_mocks_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_device_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_events_gen12lp.cpp
)
target_include_directories(${TARGET_NAME} PRIVATE ${COMPUTE_RUNTIME_DIR}/level_zero/core/source/gen12lp/definitions${BRANCH_DIR_SUFFIX}/)

62
level_zero/core/test/unit_tests/gen12lp/test_events_gen12lp.cpp Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "test.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/event/event.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_event.h"
namespace L0 {
namespace ult {
struct TimestampEvent : public Test<DeviceFixture> {
public:
void SetUp() override {
DeviceFixture::SetUp();
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = 0;
eventDesc.wait = 0;
eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
ASSERT_NE(nullptr, eventPool);
event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
ASSERT_NE(nullptr, event);
}
void TearDown() override {
DeviceFixture::TearDown();
}
std::unique_ptr<L0::EventPool> eventPool;
std::unique_ptr<L0::Event> event;
};
GEN12LPTEST_F(TimestampEvent, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet) {
KernelTimestampEvent data = {};
data.contextStart = 1u;
data.contextEnd = 2u;
data.globalStart = 3u;
data.globalEnd = 4u;
event->hostAddress = &data;
ze_kernel_timestamp_result_t result = {};
event->queryKernelTimestamp(&result);
EXPECT_EQ(data.globalStart, result.context.kernelStart);
EXPECT_EQ(data.globalEnd, result.context.kernelEnd);
EXPECT_EQ(data.globalStart, result.global.kernelStart);
EXPECT_EQ(data.globalEnd, result.global.kernelEnd);
}
} // namespace ult
} // namespace L0

26
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@@ -210,7 +210,7 @@ TEST_F(TimestampEventCreate, givenTimestampEventThenAllocationsIsOfPacketTagBuff
EXPECT_EQ(NEO::GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER, allocation->getAllocationType());
}
TEST_F(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet) {
HWCMDTEST_F(IGFX_GEN9_CORE, TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet) {
KernelTimestampEvent data = {};
data.contextStart = 1u;
data.contextEnd = 2u;
@@ -228,5 +228,29 @@ TEST_F(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCor
EXPECT_EQ(data.globalEnd, result.global.kernelEnd);
}
HWCMDTEST_EXCLUDE_ADDITIONAL_FAMILY(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_ADDITIONAL_FAMILY(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet, IGFX_DG1);
TEST_F(TimestampEventCreate, givenEventWhenQueryKernelTimestampThenNotReadyReturned) {
struct MockEventQuery : public EventImp {
MockEventQuery(L0::EventPool *eventPool, int index, L0::Device *device) : EventImp(eventPool, index, device) {}
ze_result_t queryStatus() override {
return ZE_RESULT_NOT_READY;
}
};
auto mockEvent = std::make_unique<MockEventQuery>(eventPool.get(), 1u, device);
ze_kernel_timestamp_result_t resultTimestamp = {};
auto result = mockEvent->queryKernelTimestamp(&resultTimestamp);
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
EXPECT_EQ(0u, resultTimestamp.context.kernelStart);
EXPECT_EQ(0u, resultTimestamp.context.kernelEnd);
EXPECT_EQ(0u, resultTimestamp.global.kernelStart);
EXPECT_EQ(0u, resultTimestamp.global.kernelEnd);
}
} // namespace ult
} // namespace L0

3
opencl/source/command_queue/gpgpu_walker.h
View File

@@ -122,7 +122,8 @@ class GpgpuWalkerHelper {
static void dispatchProfilingCommandsEnd(
TagNode<HwTimeStamps> &hwTimeStamps,
LinearStream *commandStream);
LinearStream *commandStream,
const HardwareInfo &hwInfo);
static void dispatchPerfCountersCommandsStart(
CommandQueue &commandQueue,

5
opencl/source/command_queue/gpgpu_walker_bdw_plus.inl
View File

@@ -228,7 +228,6 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsStart(
TagNode<HwTimeStamps> &hwTimeStamps,
LinearStream *commandStream,
const HardwareInfo &hwInfo) {
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
// PIPE_CONTROL for global timestamp
@@ -257,8 +256,8 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsStart(
template <typename GfxFamily>
void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(
TagNode<HwTimeStamps> &hwTimeStamps,
LinearStream *commandStream) {
LinearStream *commandStream,
const HardwareInfo &hwInfo) {
using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
// PIPE_CONTROL for global timestamp

2
opencl/source/command_queue/hardware_interface_base.inl
View File

@@ -48,7 +48,7 @@ inline void HardwareInterface<GfxFamily>::dispatchProfilingPerfEndCommands(
// If hwTimeStamps is passed (not nullptr), then we know that profiling is enabled
if (hwTimeStamps != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(*hwTimeStamps, commandStream);
GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(*hwTimeStamps, commandStream, commandQueue.getDevice().getHardwareInfo());
}
if (hwPerfCounter != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsEnd(commandQueue, *hwPerfCounter, commandStream);

18
opencl/source/event/event.cpp
View File

@@ -284,11 +284,19 @@ bool Event::calcProfilingData() {
calculateProfilingDataInternal(globalStartTS, globalEndTS, &globalEndTS, globalStartTS);
} else if (timeStampNode) {
calculateProfilingDataInternal(
timeStampNode->tagForCpuAccess->ContextStartTS,
timeStampNode->tagForCpuAccess->ContextEndTS,
&timeStampNode->tagForCpuAccess->ContextCompleteTS,
timeStampNode->tagForCpuAccess->GlobalStartTS);
if (HwHelper::get(this->cmdQueue->getDevice().getHardwareInfo().platform.eRenderCoreFamily).useOnlyGlobalTimestamps()) {
calculateProfilingDataInternal(
timeStampNode->tagForCpuAccess->GlobalStartTS,
timeStampNode->tagForCpuAccess->GlobalEndTS,
&timeStampNode->tagForCpuAccess->GlobalEndTS,
timeStampNode->tagForCpuAccess->GlobalStartTS);
} else {
calculateProfilingDataInternal(
timeStampNode->tagForCpuAccess->ContextStartTS,
timeStampNode->tagForCpuAccess->ContextEndTS,
&timeStampNode->tagForCpuAccess->ContextCompleteTS,
timeStampNode->tagForCpuAccess->GlobalStartTS);
}
}
}
return dataCalculated;

38
opencl/source/gen12lp/gpgpu_walker_gen12lp.cpp
View File

@@ -12,13 +12,47 @@
namespace NEO {
template class HardwareInterface<TGLLPFamily>;
template <>
void GpgpuWalkerHelper<TGLLPFamily>::adjustMiStoreRegMemMode(MI_STORE_REG_MEM<TGLLPFamily> *storeCmd) {
storeCmd->setMmioRemapEnable(true);
}
template <>
void GpgpuWalkerHelper<TGLLPFamily>::dispatchProfilingCommandsStart(
TagNode<HwTimeStamps> &hwTimeStamps,
LinearStream *commandStream,
const HardwareInfo &hwInfo) {
// PIPE_CONTROL for global timestamp
uint64_t timeStampAddress = hwTimeStamps.getGpuAddress() + offsetof(HwTimeStamps, GlobalStartTS);
PipeControlArgs args;
MemorySynchronizationCommands<TGLLPFamily>::addPipeControlAndProgramPostSyncOperation(
*commandStream,
PIPE_CONTROL::POST_SYNC_OPERATION_WRITE_TIMESTAMP,
timeStampAddress,
0llu,
hwInfo,
args);
}
template <>
void GpgpuWalkerHelper<TGLLPFamily>::dispatchProfilingCommandsEnd(
TagNode<HwTimeStamps> &hwTimeStamps,
LinearStream *commandStream,
const HardwareInfo &hwInfo) {
// PIPE_CONTROL for global timestamp
uint64_t timeStampAddress = hwTimeStamps.getGpuAddress() + offsetof(HwTimeStamps, GlobalEndTS);
PipeControlArgs args;
MemorySynchronizationCommands<TGLLPFamily>::addPipeControlAndProgramPostSyncOperation(
*commandStream,
PIPE_CONTROL::POST_SYNC_OPERATION_WRITE_TIMESTAMP,
timeStampAddress,
0llu,
hwInfo,
args);
}
template class HardwareInterface<TGLLPFamily>;
template class GpgpuWalkerHelper<TGLLPFamily>;
template struct EnqueueOperation<TGLLPFamily>;

118
opencl/test/unit_test/command_queue/dispatch_walker_tests.cpp
View File

@@ -1356,10 +1356,9 @@ struct ProfilingCommandsTest : public DispatchWalkerTest, ::testing::WithParamIn
}
};
HWCMDTEST_P(IGFX_GEN8_CORE, ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsTakenThenTimeStampAddressIsProgrammedCorrectly) {
HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsTakenThenTimeStampAddressIsProgrammedCorrectly) {
using MI_STORE_REGISTER_MEM = typename FamilyType::MI_STORE_REGISTER_MEM;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
bool checkForStart = GetParam();
auto &cmdStream = pCmdQ->getCS(0);
TagAllocator<HwTimeStamps> timeStampAllocator(pDevice->getRootDeviceIndex(), this->pDevice->getMemoryManager(), 10,
@@ -1367,19 +1366,13 @@ HWCMDTEST_P(IGFX_GEN8_CORE, ProfilingCommandsTest, givenKernelWhenProfilingComma
auto hwTimeStamp1 = timeStampAllocator.getTag();
ASSERT_NE(nullptr, hwTimeStamp1);
if (checkForStart) {
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsStart(*hwTimeStamp1, &cmdStream, pDevice->getHardwareInfo());
} else {
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsEnd(*hwTimeStamp1, &cmdStream);
}
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsStart(*hwTimeStamp1, &cmdStream, pDevice->getHardwareInfo());
auto hwTimeStamp2 = timeStampAllocator.getTag();
ASSERT_NE(nullptr, hwTimeStamp2);
if (checkForStart) {
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsStart(*hwTimeStamp2, &cmdStream, pDevice->getHardwareInfo());
} else {
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsEnd(*hwTimeStamp2, &cmdStream);
}
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsStart(*hwTimeStamp2, &cmdStream, pDevice->getHardwareInfo());
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
@@ -1390,7 +1383,7 @@ HWCMDTEST_P(IGFX_GEN8_CORE, ProfilingCommandsTest, givenKernelWhenProfilingComma
ASSERT_NE(nullptr, storeReg);
uint64_t gpuAddress = storeReg->getMemoryAddress();
auto contextTimestampFieldOffset = checkForStart ? offsetof(HwTimeStamps, ContextStartTS) : offsetof(HwTimeStamps, ContextEndTS);
auto contextTimestampFieldOffset = offsetof(HwTimeStamps, ContextStartTS);
uint64_t expectedAddress = hwTimeStamp1->getGpuAddress() + contextTimestampFieldOffset;
EXPECT_EQ(expectedAddress, gpuAddress);
@@ -1404,39 +1397,74 @@ HWCMDTEST_P(IGFX_GEN8_CORE, ProfilingCommandsTest, givenKernelWhenProfilingComma
expectedAddress = hwTimeStamp2->getGpuAddress() + contextTimestampFieldOffset;
EXPECT_EQ(expectedAddress, gpuAddress);
if (checkForStart) {
auto itorPipeCtrl = find<typename FamilyType::PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorPipeCtrl);
if (HardwareCommandsHelper<FamilyType>::isPipeControlWArequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
if (UnitTestHelper<FamilyType>::isAdditionalSynchronizationRequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
auto pipeControl = genCmdCast<PIPE_CONTROL *>(*itorPipeCtrl);
ASSERT_NE(nullptr, pipeControl);
gpuAddress = static_cast<uint64_t>(pipeControl->getAddress()) | (static_cast<uint64_t>(pipeControl->getAddressHigh()) << 32);
expectedAddress = hwTimeStamp1->getGpuAddress() + offsetof(HwTimeStamps, GlobalStartTS);
EXPECT_EQ(expectedAddress, gpuAddress);
auto itorPipeCtrl = find<typename FamilyType::PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorPipeCtrl);
if (HardwareCommandsHelper<FamilyType>::isPipeControlWArequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
itorPipeCtrl = find<typename FamilyType::PIPE_CONTROL *>(itorPipeCtrl, cmdList.end());
if (HardwareCommandsHelper<FamilyType>::isPipeControlWArequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
if (UnitTestHelper<FamilyType>::isAdditionalSynchronizationRequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
ASSERT_NE(cmdList.end(), itorPipeCtrl);
pipeControl = genCmdCast<PIPE_CONTROL *>(*itorPipeCtrl);
ASSERT_NE(nullptr, pipeControl);
gpuAddress = static_cast<uint64_t>(pipeControl->getAddress()) | static_cast<uint64_t>(pipeControl->getAddressHigh()) << 32;
expectedAddress = hwTimeStamp2->getGpuAddress() + offsetof(HwTimeStamps, GlobalStartTS);
EXPECT_EQ(expectedAddress, gpuAddress);
}
if (UnitTestHelper<FamilyType>::isAdditionalSynchronizationRequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
auto pipeControl = genCmdCast<PIPE_CONTROL *>(*itorPipeCtrl);
ASSERT_NE(nullptr, pipeControl);
gpuAddress = static_cast<uint64_t>(pipeControl->getAddress()) | (static_cast<uint64_t>(pipeControl->getAddressHigh()) << 32);
expectedAddress = hwTimeStamp1->getGpuAddress() + offsetof(HwTimeStamps, GlobalStartTS);
EXPECT_EQ(expectedAddress, gpuAddress);
itorPipeCtrl++;
itorPipeCtrl = find<typename FamilyType::PIPE_CONTROL *>(itorPipeCtrl, cmdList.end());
if (HardwareCommandsHelper<FamilyType>::isPipeControlWArequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
if (UnitTestHelper<FamilyType>::isAdditionalSynchronizationRequired(pDevice->getHardwareInfo())) {
itorPipeCtrl++;
}
ASSERT_NE(cmdList.end(), itorPipeCtrl);
pipeControl = genCmdCast<PIPE_CONTROL *>(*itorPipeCtrl);
ASSERT_NE(nullptr, pipeControl);
gpuAddress = static_cast<uint64_t>(pipeControl->getAddress()) | static_cast<uint64_t>(pipeControl->getAddressHigh()) << 32;
expectedAddress = hwTimeStamp2->getGpuAddress() + offsetof(HwTimeStamps, GlobalStartTS);
EXPECT_EQ(expectedAddress, gpuAddress);
}
INSTANTIATE_TEST_CASE_P(StartEndFlag,
ProfilingCommandsTest, ::testing::Bool());
HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsNotTakenThenTimeStampAddressIsProgrammedCorrectly) {
using MI_STORE_REGISTER_MEM = typename FamilyType::MI_STORE_REGISTER_MEM;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
auto &cmdStream = pCmdQ->getCS(0);
TagAllocator<HwTimeStamps> timeStampAllocator(pDevice->getRootDeviceIndex(), this->pDevice->getMemoryManager(), 10,
MemoryConstants::cacheLineSize, sizeof(HwTimeStamps), false, pDevice->getDeviceBitfield());
auto hwTimeStamp1 = timeStampAllocator.getTag();
ASSERT_NE(nullptr, hwTimeStamp1);
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsEnd(*hwTimeStamp1, &cmdStream, pDevice->getHardwareInfo());
auto hwTimeStamp2 = timeStampAllocator.getTag();
ASSERT_NE(nullptr, hwTimeStamp2);
GpgpuWalkerHelper<FamilyType>::dispatchProfilingCommandsEnd(*hwTimeStamp2, &cmdStream, pDevice->getHardwareInfo());
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
auto itorStoreReg = find<typename FamilyType::MI_STORE_REGISTER_MEM *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorStoreReg);
auto storeReg = genCmdCast<MI_STORE_REGISTER_MEM *>(*itorStoreReg);
ASSERT_NE(nullptr, storeReg);
uint64_t gpuAddress = storeReg->getMemoryAddress();
auto contextTimestampFieldOffset = offsetof(HwTimeStamps, ContextEndTS);
uint64_t expectedAddress = hwTimeStamp1->getGpuAddress() + contextTimestampFieldOffset;
EXPECT_EQ(expectedAddress, gpuAddress);
itorStoreReg++;
itorStoreReg = find<typename FamilyType::MI_STORE_REGISTER_MEM *>(itorStoreReg, cmdList.end());
ASSERT_NE(cmdList.end(), itorStoreReg);
storeReg = genCmdCast<MI_STORE_REGISTER_MEM *>(*itorStoreReg);
ASSERT_NE(nullptr, storeReg);
gpuAddress = storeReg->getMemoryAddress();
expectedAddress = hwTimeStamp2->getGpuAddress() + contextTimestampFieldOffset;
EXPECT_EQ(expectedAddress, gpuAddress);
}

1
opencl/test/unit_test/gen12lp/CMakeLists.txt
View File

@@ -15,6 +15,7 @@ if(TESTS_GEN12LP)
${CMAKE_CURRENT_SOURCE_DIR}/device_queue_tests_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/enqueue_media_kernel_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/gen12lp_tests_wrapper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gpgpu_walker_tests_gen12lp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/image_tests_gen12lp.inl
${CMAKE_CURRENT_SOURCE_DIR}/kernel_tests_gen12lp.inl

1
opencl/test/unit_test/gen12lp/dg1/CMakeLists.txt
View File

@@ -11,6 +11,7 @@ if(TESTS_DG1)
${CMAKE_CURRENT_SOURCE_DIR}/hw_info_tests_dg1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_dg1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_dg1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/excludes_dg1.cpp
)
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_dg1})
add_subdirectories()

28
opencl/test/unit_test/gen12lp/dg1/excludes_dg1.cpp Normal file
View File

@@ -0,0 +1,28 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "test.h"
namespace NEO {
HWCMDTEST_EXCLUDE_FAMILY(ProfilingTests, GivenCommandQueueBlockedWithProfilingWhenWalkerIsDispatchedThenMiStoreRegisterMemIsPresentInCS, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingTests, GivenCommandQueueWithProflingWhenWalkerIsDispatchedThenMiStoreRegisterMemIsPresentInCS, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTest, givenEventWhenCompleteIsZeroThenCalcProfilingDataSetsEndTimestampInCompleteTimestampAndDoesntCallOsTimeMethods, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTests, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawDataIsReturned, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTest, givenRawTimestampsDebugModeWhenStartTimeStampLTQueueTimeStampThenIncreaseStartTimeStamp, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingWithPerfCountersTests, GivenCommandQueueWithProfilingPerfCountersWhenWalkerIsDispatchedThenRegisterStoresArePresentInCS, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet, IGFX_DG1);
} // namespace NEO
HWCMDTEST_EXCLUDE_FAMILY(ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsTakenThenTimeStampAddressIsProgrammedCorrectly, IGFX_DG1);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsNotTakenThenTimeStampAddressIsProgrammedCorrectly, IGFX_DG1);

32
opencl/test/unit_test/gen12lp/gpgpu_walker_tests_gen12lp.cpp Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/gen12lp/hw_info.h"
#include "opencl/source/command_queue/gpgpu_walker.h"
#include "opencl/source/command_queue/hardware_interface.h"
#include "test.h"
namespace NEO {
struct GpgpuWalkerTests : public ::testing::Test {
void SetUp() override {
}
void TearDown() override {
}
};
GEN12LPTEST_F(GpgpuWalkerTests, givenMiStoreRegMemWhenAdjustMiStoreRegMemModeThenMmioRemapEnableIsSet) {
using MI_STORE_REGISTER_MEM = typename FamilyType::MI_STORE_REGISTER_MEM;
MI_STORE_REGISTER_MEM cmd = FamilyType::cmdInitStoreRegisterMem;
GpgpuWalkerHelper<FamilyType>::adjustMiStoreRegMemMode(&cmd);
EXPECT_EQ(true, cmd.getMmioRemapEnable());
}
} // namespace NEO

132
opencl/test/unit_test/gen12lp/profiling_tests_gen12lp.inl
View File

@@ -27,8 +27,8 @@ struct ProfilingTestsGen12LP : public CommandEnqueueFixture,
std::unique_ptr<MockKernelWithInternals> mockKernelWithInternals;
};
GEN12LPTEST_F(ProfilingTestsGen12LP, GivenCommandQueueWithProflingWhenWalkerIsDispatchedThenTwoMiStoreRegisterMemWithMmioRemapEnableArePresentInCS) {
typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
GEN12LPTEST_F(ProfilingTestsGen12LP, GivenCommandQueueWithProflingWhenWalkerIsDispatchedThenTwoPIPECONTROLSWithOPERATION_WRITE_TIMESTAMPArePresentInCS) {
typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
size_t globalOffsets[3] = {0, 0, 0};
@@ -48,30 +48,118 @@ GEN12LPTEST_F(ProfilingTestsGen12LP, GivenCommandQueueWithProflingWhenWalkerIsDi
parseCommands<FamilyType>(*pCmdQ);
uint32_t writeCounter = 0u;
// Find GPGPU_WALKER
auto itorGPGPUWalkerCmd = find<GPGPU_WALKER *>(cmdList.begin(), cmdList.end());
GenCmdList::reverse_iterator rItorGPGPUWalkerCmd(itorGPGPUWalkerCmd);
ASSERT_NE(cmdList.end(), itorGPGPUWalkerCmd);
auto itorPC = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorPC);
// Check MI_STORE_REGISTER_MEMs
auto itorBeforeMI = reverse_find<MI_STORE_REGISTER_MEM *>(rItorGPGPUWalkerCmd, cmdList.rbegin());
ASSERT_NE(cmdList.rbegin(), itorBeforeMI);
auto pBeforeMI = genCmdCast<MI_STORE_REGISTER_MEM *>(*itorBeforeMI);
pBeforeMI = genCmdCast<MI_STORE_REGISTER_MEM *>(*itorBeforeMI);
ASSERT_NE(nullptr, pBeforeMI);
EXPECT_EQ(GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW, pBeforeMI->getRegisterAddress());
EXPECT_TRUE(pBeforeMI->getMmioRemapEnable());
//auto itorPC = find<PIPE_CONTROL *>(itorGPGPUWalkerCmd, cmdList.end());
auto itorAfterMI = find<MI_STORE_REGISTER_MEM *>(itorGPGPUWalkerCmd, cmdList.end());
ASSERT_NE(cmdList.end(), itorAfterMI);
auto pAfterMI = genCmdCast<MI_STORE_REGISTER_MEM *>(*itorAfterMI);
ASSERT_NE(nullptr, pAfterMI);
EXPECT_EQ(GP_THREAD_TIME_REG_ADDRESS_OFFSET_LOW, pAfterMI->getRegisterAddress());
EXPECT_TRUE(pAfterMI->getMmioRemapEnable());
while (itorPC != cmdList.end()) {
auto pPipeControl = genCmdCast<PIPE_CONTROL *>(*itorPC);
ASSERT_NE(nullptr, pPipeControl);
if (PIPE_CONTROL::POST_SYNC_OPERATION_WRITE_TIMESTAMP == pPipeControl->getPostSyncOperation()) {
++writeCounter;
}
++itorPC;
itorPC = find<PIPE_CONTROL *>(itorPC, cmdList.end());
}
++itorAfterMI;
pAfterMI = genCmdCast<MI_STORE_REGISTER_MEM *>(*itorAfterMI);
EXPECT_EQ(nullptr, pAfterMI);
EXPECT_EQ(writeCounter, 2u);
clReleaseEvent(event);
}
template <typename TagType>
struct MockTagNode : public TagNode<TagType> {
public:
using TagNode<TagType>::tagForCpuAccess;
using TagNode<TagType>::gfxAllocation;
MockTagNode() {
gfxAllocation = nullptr;
tagForCpuAccess = nullptr;
}
};
class MyOSTime : public OSTime {
public:
static int instanceNum;
MyOSTime() {
instanceNum++;
}
double getDynamicDeviceTimerResolution(HardwareInfo const &hwInfo) const override {
EXPECT_FALSE(true);
return 1.0;
}
bool getCpuGpuTime(TimeStampData *pGpuCpuTime) override {
EXPECT_FALSE(true);
return false;
}
bool getCpuTime(uint64_t *timeStamp) override {
EXPECT_FALSE(true);
return false;
};
double getHostTimerResolution() const override {
EXPECT_FALSE(true);
return 0;
}
uint64_t getCpuRawTimestamp() override {
EXPECT_FALSE(true);
return 0;
}
};
int MyOSTime::instanceNum = 0;
GEN12LPTEST_F(ProfilingTestsGen12LP, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawDataIsReturnedGen12Lp) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.ReturnRawGpuTimestamps.set(1);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MyOSTime::instanceNum = 0;
device->setOSTime(new MyOSTime());
EXPECT_EQ(1, MyOSTime::instanceNum);
MockContext context;
cl_command_queue_properties props[5] = {0, 0, 0, 0, 0};
MockCommandQueue cmdQ(&context, device.get(), props);
cmdQ.setProfilingEnabled();
cmdQ.device = device.get();
HwTimeStamps timestamp;
timestamp.GlobalStartTS = 10;
timestamp.ContextStartTS = 20;
timestamp.GlobalEndTS = 80;
timestamp.ContextEndTS = 56;
timestamp.GlobalCompleteTS = 0;
timestamp.ContextCompleteTS = 70;
MockTagNode<HwTimeStamps> timestampNode;
timestampNode.tagForCpuAccess = &timestamp;
MockEvent<Event> event(&cmdQ, CL_COMPLETE, 0, 0);
cl_event clEvent = &event;
event.queueTimeStamp.CPUTimeinNS = 1;
event.queueTimeStamp.GPUTimeStamp = 2;
event.submitTimeStamp.CPUTimeinNS = 3;
event.submitTimeStamp.GPUTimeStamp = 4;
event.setCPUProfilingPath(false);
event.timeStampNode = &timestampNode;
event.calcProfilingData();
cl_ulong queued, submited, start, end, complete;
clGetEventProfilingInfo(clEvent, CL_PROFILING_COMMAND_QUEUED, sizeof(cl_ulong), &queued, nullptr);
clGetEventProfilingInfo(clEvent, CL_PROFILING_COMMAND_SUBMIT, sizeof(cl_ulong), &submited, nullptr);
clGetEventProfilingInfo(clEvent, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &start, nullptr);
clGetEventProfilingInfo(clEvent, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &end, nullptr);
clGetEventProfilingInfo(clEvent, CL_PROFILING_COMMAND_COMPLETE, sizeof(cl_ulong), &complete, nullptr);
EXPECT_EQ(timestamp.GlobalEndTS, complete);
EXPECT_EQ(timestamp.GlobalEndTS, end);
EXPECT_EQ(timestamp.GlobalStartTS, start);
EXPECT_EQ(event.submitTimeStamp.GPUTimeStamp, submited);
EXPECT_EQ(event.queueTimeStamp.GPUTimeStamp, queued);
event.timeStampNode = nullptr;
}

1
opencl/test/unit_test/gen12lp/rkl/CMakeLists.txt
View File

@@ -9,6 +9,7 @@ if(TESTS_RKL)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_helper_rkl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_rkl.cpp
${CMAKE_CURRENT_SOURCE_DIR}/excludes_rkl.cpp
)
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12lp_rkl})
add_subdirectories()

28
opencl/test/unit_test/gen12lp/rkl/excludes_rkl.cpp Normal file
View File

@@ -0,0 +1,28 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "test.h"
namespace NEO {
HWCMDTEST_EXCLUDE_FAMILY(ProfilingTests, GivenCommandQueueBlockedWithProfilingWhenWalkerIsDispatchedThenMiStoreRegisterMemIsPresentInCS, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingTests, GivenCommandQueueWithProflingWhenWalkerIsDispatchedThenMiStoreRegisterMemIsPresentInCS, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTest, givenEventWhenCompleteIsZeroThenCalcProfilingDataSetsEndTimestampInCompleteTimestampAndDoesntCallOsTimeMethods, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTests, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawDataIsReturned, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTest, givenRawTimestampsDebugModeWhenStartTimeStampLTQueueTimeStampThenIncreaseStartTimeStamp, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingWithPerfCountersTests, GivenCommandQueueWithProfilingPerfCountersWhenWalkerIsDispatchedThenRegisterStoresArePresentInCS, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet, IGFX_ROCKETLAKE);
} // namespace NEO
HWCMDTEST_EXCLUDE_FAMILY(ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsTakenThenTimeStampAddressIsProgrammedCorrectly, IGFX_ROCKETLAKE);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsNotTakenThenTimeStampAddressIsProgrammedCorrectly, IGFX_ROCKETLAKE);

1
opencl/test/unit_test/gen12lp/tgllp/CMakeLists.txt
View File

@@ -10,6 +10,7 @@ if(TESTS_TGLLP)
${CMAKE_CURRENT_SOURCE_DIR}/kernel_tests_tgllp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_helper_tgllp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_tgllp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/excludes_tgllp.cpp
)
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen12lp_tgllp})
add_subdirectories()

28
opencl/test/unit_test/gen12lp/tgllp/excludes_tgllp.cpp Normal file
View File

@@ -0,0 +1,28 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "test.h"
namespace NEO {
HWCMDTEST_EXCLUDE_FAMILY(ProfilingTests, GivenCommandQueueBlockedWithProfilingWhenWalkerIsDispatchedThenMiStoreRegisterMemIsPresentInCS, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingTests, GivenCommandQueueWithProflingWhenWalkerIsDispatchedThenMiStoreRegisterMemIsPresentInCS, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTest, givenEventWhenCompleteIsZeroThenCalcProfilingDataSetsEndTimestampInCompleteTimestampAndDoesntCallOsTimeMethods, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTests, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawDataIsReturned, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(EventProfilingTest, givenRawTimestampsDebugModeWhenStartTimeStampLTQueueTimeStampThenIncreaseStartTimeStamp, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingWithPerfCountersTests, GivenCommandQueueWithProfilingPerfCountersWhenWalkerIsDispatchedThenRegisterStoresArePresentInCS, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(TimestampEventCreate, givenEventTimestampsWhenQueryKernelTimestampThenCorrectDataAreSet, IGFX_TIGERLAKE_LP);
} // namespace NEO
HWCMDTEST_EXCLUDE_FAMILY(ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsTakenThenTimeStampAddressIsProgrammedCorrectly, IGFX_TIGERLAKE_LP);
HWCMDTEST_EXCLUDE_FAMILY(ProfilingCommandsTest, givenKernelWhenProfilingCommandStartIsNotTakenThenTimeStampAddressIsProgrammedCorrectly, IGFX_TIGERLAKE_LP);

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

@@ -432,7 +432,9 @@ class MyOSTime : public OSTime {
int MyOSTime::instanceNum = 0;
TEST(EventProfilingTest, givenEventWhenCompleteIsZeroThenCalcProfilingDataSetsEndTimestampInCompleteTimestampAndDoesntCallOsTimeMethods) {
using EventProfilingTest = ProfilingTests;
HWCMDTEST_F(IGFX_GEN8_CORE, EventProfilingTest, givenEventWhenCompleteIsZeroThenCalcProfilingDataSetsEndTimestampInCompleteTimestampAndDoesntCallOsTimeMethods) {
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MyOSTime::instanceNum = 0;
device->setOSTime(new MyOSTime());
@@ -465,7 +467,9 @@ TEST(EventProfilingTest, givenEventWhenCompleteIsZeroThenCalcProfilingDataSetsEn
event.timeStampNode = nullptr;
}
TEST(EventProfilingTest, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawDataIsReturned) {
using EventProfilingTests = ProfilingTests;
HWCMDTEST_F(IGFX_GEN8_CORE, EventProfilingTests, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawDataIsReturned) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.ReturnRawGpuTimestamps.set(1);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
@@ -518,7 +522,7 @@ TEST(EventProfilingTest, givenRawTimestampsDebugModeWhenDataIsQueriedThenRawData
event.timeStampNode = nullptr;
}
TEST(EventProfilingTest, givenRawTimestampsDebugModeWhenStartTimeStampLTQueueTimeStampThenIncreaseStartTimeStamp) {
HWCMDTEST_F(IGFX_GEN8_CORE, EventProfilingTest, givenRawTimestampsDebugModeWhenStartTimeStampLTQueueTimeStampThenIncreaseStartTimeStamp) {
DebugManagerStateRestore stateRestore;
DebugManager.flags.ReturnRawGpuTimestamps.set(1);
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));

5
shared/source/gen12lp/hw_helper_gen12lp.cpp
View File

@@ -228,6 +228,11 @@ void MemorySynchronizationCommands<Family>::setCacheFlushExtraProperties(Family:
pipeControl.setConstantCacheInvalidationEnable(false);
}
template <>
bool HwHelperHw<Family>::useOnlyGlobalTimestamps() const {
return true;
}
template class HwHelperHw<Family>;
template class FlatBatchBufferHelperHw<Family>;
template struct MemorySynchronizationCommands<Family>;

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

@@ -124,6 +124,7 @@ class HwHelper {
virtual uint32_t getDefaultThreadArbitrationPolicy() const = 0;
virtual void adjustPlatformCoreFamilyForIgc(HardwareInfo &hwInfo) = 0;
virtual bool heapInLocalMem(const HardwareInfo &hwInfo) const = 0;
virtual bool useOnlyGlobalTimestamps() const = 0;
static uint32_t getSubDevicesCount(const HardwareInfo *pHwInfo);
static uint32_t getEnginesCount(const HardwareInfo &hwInfo);
@@ -316,6 +317,8 @@ class HwHelperHw : public HwHelper {
void adjustPlatformCoreFamilyForIgc(HardwareInfo &hwInfo) override;
bool useOnlyGlobalTimestamps() const override;
protected:
LocalMemoryAccessMode getDefaultLocalMemoryAccessMode(const HardwareInfo &hwInfo) const override;

4
shared/source/helpers/hw_helper_base.inl
View File

@@ -480,4 +480,8 @@ uint32_t HwHelperHw<GfxFamily>::getDefaultThreadArbitrationPolicy() const {
return 0;
}
template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::useOnlyGlobalTimestamps() const {
return false;
}
} // namespace NEO