Skip to content

Commit 37ec3cb

Browse files
aravindksgCompute-Runtime-Automation
aravindksg
authored and
Compute-Runtime-Automation
committed
Events workaround for L3Flush issue
Related-To: LOCI-2361 Signed-off-by: Aravind Gopalakrishnan <[email protected]> Signed-off-by: Vinod Tipparaju <[email protected]>
1 parent 38915c6 commit 37ec3cb

File tree

5 files changed

+260
-70
lines changed

5 files changed

+260
-70
lines changed

‎level_zero/core/source/cmdlist/cmdlist_hw_xehp_and_later.inl

Lines changed: 42 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -110,6 +110,44 @@ void CommandListCoreFamily<gfxCoreFamily>::applyMemoryRangesBarrier(uint32_t num
110110
}
111111
}
112112

113+
template <GFXCORE_FAMILY gfxCoreFamily>
114+
void programEventL3Flush(ze_event_handle_t hEvent,
115+
Device *device,
116+
uint32_t partitionCount,
117+
NEO::CommandContainer &commandContainer) {
118+
using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
119+
using POST_SYNC_OPERATION = typename GfxFamily::PIPE_CONTROL::POST_SYNC_OPERATION;
120+
auto event = Event::fromHandle(hEvent);
121+
122+
auto eventPartitionOffset = (partitionCount > 1) ? (partitionCount * event->getSinglePacketSize())
123+
: event->getSinglePacketSize();
124+
uint64_t eventAddress = event->getPacketAddress(device) + eventPartitionOffset;
125+
if (event->isEventTimestampFlagSet()) {
126+
eventAddress += event->getContextEndOffset();
127+
}
128+
129+
if (partitionCount > 1) {
130+
event->setPacketsInUse(event->getPacketsInUse() + partitionCount);
131+
} else {
132+
event->setPacketsInUse(event->getPacketsInUse() + 1);
133+
}
134+
135+
NEO::PipeControlArgs args;
136+
args.dcFlushEnable = true;
137+
if (partitionCount > 1) {
138+
args.workloadPartitionOffset = true;
139+
NEO::EncodeSetMMIO<GfxFamily>::encodeIMM(*commandContainer.getCommandStream(),
140+
NEO::PartitionRegisters<GfxFamily>::addressOffsetCCSOffset,
141+
static_cast<uint32_t>(event->getSinglePacketSize()),
142+
true);
143+
}
144+
NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
145+
*commandContainer.getCommandStream(), POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
146+
eventAddress, Event::STATE_SIGNALED,
147+
commandContainer.getDevice()->getHardwareInfo(),
148+
args);
149+
}
150+
113151
template <GFXCORE_FAMILY gfxCoreFamily>
114152
ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(ze_kernel_handle_t hKernel,
115153
const ze_group_count_t *pThreadGroupDimensions,
@@ -228,9 +266,12 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
228266
this->partitionCount = std::max(partitionCount, this->partitionCount);
229267
if (hEvent) {
230268
auto event = Event::fromHandle(hEvent);
231-
if (isTimestampEvent && partitionCount > 1) {
269+
if (partitionCount > 1) {
232270
event->setPacketsInUse(partitionCount);
233271
}
272+
if (L3FlushEnable) {
273+
programEventL3Flush<gfxCoreFamily>(hEvent, this->device, partitionCount, commandContainer);
274+
}
234275
}
235276

236277
if (neoDevice->getDebugger()) {

‎level_zero/core/source/event/event.h

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -95,7 +95,7 @@ struct Event : _ze_event_handle_t {
9595
};
9696

9797
template <typename TagSizeT>
98-
class KernelTimestampsData : public NEO::TimestampPackets<TagSizeT> {
98+
class KernelEventCompletionData : public NEO::TimestampPackets<TagSizeT> {
9999
public:
100100
uint32_t getPacketsUsed() const { return packetsUsed; }
101101
void setPacketsUsed(uint32_t value) { packetsUsed = value; }
@@ -139,7 +139,7 @@ struct EventImp : public Event {
139139
size_t getSinglePacketSize() const override { return NEO::TimestampPackets<TagSizeT>::getSinglePacketSize(); };
140140
ze_result_t hostEventSetValue(uint32_t eventValue) override;
141141

142-
std::unique_ptr<KernelTimestampsData<TagSizeT>[]> kernelTimestampsData;
142+
std::unique_ptr<KernelEventCompletionData<TagSizeT>[]> kernelEventCompletionData;
143143

144144
Device *device;
145145
int index;
@@ -148,8 +148,9 @@ struct EventImp : public Event {
148148
protected:
149149
ze_result_t calculateProfilingData();
150150
ze_result_t queryStatusKernelTimestamp();
151+
ze_result_t queryStatusNonTimestamp();
151152
ze_result_t hostEventSetValueTimestamps(TagSizeT eventVal);
152-
void assignTimestampData(void *address);
153+
void assignKernelEventCompletionData(void *address);
153154
};
154155

155156
struct EventPool : _ze_event_pool_handle_t {

‎level_zero/core/source/event/event_impl.inl

Lines changed: 60 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -15,8 +15,8 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device *
1515

1616
if (eventPool->isEventPoolTimestampFlagSet()) {
1717
event->setEventTimestampFlag(true);
18-
event->kernelTimestampsData = std::make_unique<KernelTimestampsData<TagSizeT>[]>(EventPacketsCount::maxKernelSplit);
1918
}
19+
event->kernelEventCompletionData = std::make_unique<KernelEventCompletionData<TagSizeT>[]>(EventPacketsCount::maxKernelSplit);
2020

2121
auto alloc = eventPool->getAllocation().getGraphicsAllocation(device->getNEODevice()->getRootDeviceIndex());
2222

@@ -49,24 +49,24 @@ NEO::GraphicsAllocation &EventImp<TagSizeT>::getAllocation(Device *device) {
4949

5050
template <typename TagSizeT>
5151
ze_result_t EventImp<TagSizeT>::calculateProfilingData() {
52-
globalStartTS = kernelTimestampsData[0].getGlobalStartValue(0);
53-
globalEndTS = kernelTimestampsData[0].getGlobalEndValue(0);
54-
contextStartTS = kernelTimestampsData[0].getContextStartValue(0);
55-
contextEndTS = kernelTimestampsData[0].getContextEndValue(0);
52+
globalStartTS = kernelEventCompletionData[0].getGlobalStartValue(0);
53+
globalEndTS = kernelEventCompletionData[0].getGlobalEndValue(0);
54+
contextStartTS = kernelEventCompletionData[0].getContextStartValue(0);
55+
contextEndTS = kernelEventCompletionData[0].getContextEndValue(0);
5656

5757
for (uint32_t i = 0; i < kernelCount; i++) {
58-
for (auto packetId = 0u; packetId < kernelTimestampsData[i].getPacketsUsed(); packetId++) {
59-
if (globalStartTS > kernelTimestampsData[i].getGlobalStartValue(packetId)) {
60-
globalStartTS = kernelTimestampsData[i].getGlobalStartValue(packetId);
58+
for (auto packetId = 0u; packetId < kernelEventCompletionData[i].getPacketsUsed(); packetId++) {
59+
if (globalStartTS > kernelEventCompletionData[i].getGlobalStartValue(packetId)) {
60+
globalStartTS = kernelEventCompletionData[i].getGlobalStartValue(packetId);
6161
}
62-
if (contextStartTS > kernelTimestampsData[i].getContextStartValue(packetId)) {
63-
contextStartTS = kernelTimestampsData[i].getContextStartValue(packetId);
62+
if (contextStartTS > kernelEventCompletionData[i].getContextStartValue(packetId)) {
63+
contextStartTS = kernelEventCompletionData[i].getContextStartValue(packetId);
6464
}
65-
if (contextEndTS < kernelTimestampsData[i].getContextEndValue(packetId)) {
66-
contextEndTS = kernelTimestampsData[i].getContextEndValue(packetId);
65+
if (contextEndTS < kernelEventCompletionData[i].getContextEndValue(packetId)) {
66+
contextEndTS = kernelEventCompletionData[i].getContextEndValue(packetId);
6767
}
68-
if (globalEndTS < kernelTimestampsData[i].getGlobalEndValue(packetId)) {
69-
globalEndTS = kernelTimestampsData[i].getGlobalEndValue(packetId);
68+
if (globalEndTS < kernelEventCompletionData[i].getGlobalEndValue(packetId)) {
69+
globalEndTS = kernelEventCompletionData[i].getGlobalEndValue(packetId);
7070
}
7171
}
7272
}
@@ -75,23 +75,40 @@ ze_result_t EventImp<TagSizeT>::calculateProfilingData() {
7575
}
7676

7777
template <typename TagSizeT>
78-
void EventImp<TagSizeT>::assignTimestampData(void *address) {
78+
void EventImp<TagSizeT>::assignKernelEventCompletionData(void *address) {
7979
for (uint32_t i = 0; i < kernelCount; i++) {
80-
uint32_t packetsToCopy = kernelTimestampsData[i].getPacketsUsed();
80+
uint32_t packetsToCopy = 0;
81+
packetsToCopy = kernelEventCompletionData[i].getPacketsUsed();
8182
for (uint32_t packetId = 0; packetId < packetsToCopy; packetId++) {
82-
kernelTimestampsData[i].assignDataToAllTimestamps(packetId, address);
83+
kernelEventCompletionData[i].assignDataToAllTimestamps(packetId, address);
8384
address = ptrOffset(address, NEO::TimestampPackets<TagSizeT>::getSinglePacketSize());
8485
}
8586
}
8687
}
8788

8889
template <typename TagSizeT>
8990
ze_result_t EventImp<TagSizeT>::queryStatusKernelTimestamp() {
90-
assignTimestampData(hostAddress);
91+
assignKernelEventCompletionData(hostAddress);
92+
uint32_t queryVal = Event::STATE_CLEARED;
93+
for (uint32_t i = 0; i < kernelCount; i++) {
94+
uint32_t packetsToCheck = kernelEventCompletionData[i].getPacketsUsed();
95+
for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++) {
96+
if (kernelEventCompletionData[i].getContextEndValue(packetId) == queryVal) {
97+
return ZE_RESULT_NOT_READY;
98+
}
99+
}
100+
}
101+
return ZE_RESULT_SUCCESS;
102+
}
103+
104+
template <typename TagSizeT>
105+
ze_result_t EventImp<TagSizeT>::queryStatusNonTimestamp() {
106+
assignKernelEventCompletionData(hostAddress);
107+
uint32_t queryVal = Event::STATE_CLEARED;
91108
for (uint32_t i = 0; i < kernelCount; i++) {
92-
uint32_t packetsToCheck = kernelTimestampsData[i].getPacketsUsed();
109+
uint32_t packetsToCheck = kernelEventCompletionData[i].getPacketsUsed();
93110
for (uint32_t packetId = 0; packetId < packetsToCheck; packetId++) {
94-
if (kernelTimestampsData[i].getContextEndValue(packetId) == Event::STATE_CLEARED) {
111+
if (kernelEventCompletionData[i].getContextStartValue(packetId) == queryVal) {
95112
return ZE_RESULT_NOT_READY;
96113
}
97114
}
@@ -102,17 +119,16 @@ ze_result_t EventImp<TagSizeT>::queryStatusKernelTimestamp() {
102119
template <typename TagSizeT>
103120
ze_result_t EventImp<TagSizeT>::queryStatus() {
104121
uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
105-
uint32_t queryVal = Event::STATE_CLEARED;
106122

107123
if (metricStreamer != nullptr) {
108124
*hostAddr = metricStreamer->getNotificationState();
109125
}
110126
this->csr->downloadAllocations();
111127
if (isEventTimestampFlagSet()) {
112128
return queryStatusKernelTimestamp();
129+
} else {
130+
return queryStatusNonTimestamp();
113131
}
114-
memcpy_s(static_cast<void *>(&queryVal), sizeof(uint32_t), static_cast<void *>(hostAddr), sizeof(uint32_t));
115-
return (queryVal == Event::STATE_CLEARED) ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
116132
}
117133

118134
template <typename TagSizeT>
@@ -130,7 +146,7 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValueTimestamps(TagSizeT eventVal) {
130146
}
131147
};
132148
for (uint32_t i = 0; i < kernelCount; i++) {
133-
uint32_t packetsToSet = kernelTimestampsData[i].getPacketsUsed();
149+
uint32_t packetsToSet = kernelEventCompletionData[i].getPacketsUsed();
134150
for (uint32_t j = 0; j < packetsToSet; j++) {
135151
eventTsSetFunc(baseAddr + NEO::TimestampPackets<TagSizeT>::getContextStartOffset());
136152
eventTsSetFunc(baseAddr + NEO::TimestampPackets<TagSizeT>::getGlobalStartOffset());
@@ -139,7 +155,7 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValueTimestamps(TagSizeT eventVal) {
139155
baseAddr += NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
140156
}
141157
}
142-
assignTimestampData(hostAddress);
158+
assignKernelEventCompletionData(hostAddress);
143159

144160
return ZE_RESULT_SUCCESS;
145161
}
@@ -208,14 +224,12 @@ ze_result_t EventImp<TagSizeT>::reset() {
208224
if (isEventTimestampFlagSet()) {
209225
kernelCount = EventPacketsCount::maxKernelSplit;
210226
for (uint32_t i = 0; i < kernelCount; i++) {
211-
kernelTimestampsData[i].setPacketsUsed(NEO::TimestampPacketSizeControl::preferredPacketCount);
227+
kernelEventCompletionData[i].setPacketsUsed(NEO::TimestampPacketSizeControl::preferredPacketCount);
212228
}
213-
hostEventSetValue(Event::STATE_INITIAL);
214-
resetPackets();
215-
return ZE_RESULT_SUCCESS;
216-
} else {
217-
return hostEventSetValue(Event::STATE_INITIAL);
218229
}
230+
hostEventSetValue(Event::STATE_INITIAL);
231+
resetPackets();
232+
return ZE_RESULT_SUCCESS;
219233
}
220234

221235
template <typename TagSizeT>
@@ -227,7 +241,7 @@ ze_result_t EventImp<TagSizeT>::queryKernelTimestamp(ze_kernel_timestamp_result_
227241
return ZE_RESULT_NOT_READY;
228242
}
229243

230-
assignTimestampData(hostAddress);
244+
assignKernelEventCompletionData(hostAddress);
231245
calculateProfilingData();
232246

233247
auto eventTsSetFunc = [&](uint64_t &timestampFieldToCopy, uint64_t &timestampFieldForWriting) {
@@ -288,10 +302,10 @@ ze_result_t EventImp<TagSizeT>::queryTimestampsExp(Device *device, uint32_t *pCo
288302
packetId = static_cast<NEO::SubDevice *>(deviceImp->neoDevice)->getSubDeviceIndex();
289303
}
290304

291-
globalStartTs = kernelTimestampsData[timestampPacket].getGlobalStartValue(packetId);
292-
contextStartTs = kernelTimestampsData[timestampPacket].getContextStartValue(packetId);
293-
contextEndTs = kernelTimestampsData[timestampPacket].getContextEndValue(packetId);
294-
globalEndTs = kernelTimestampsData[timestampPacket].getGlobalEndValue(packetId);
305+
globalStartTs = kernelEventCompletionData[timestampPacket].getGlobalStartValue(packetId);
306+
contextStartTs = kernelEventCompletionData[timestampPacket].getContextStartValue(packetId);
307+
contextEndTs = kernelEventCompletionData[timestampPacket].getContextEndValue(packetId);
308+
globalEndTs = kernelEventCompletionData[timestampPacket].getGlobalEndValue(packetId);
295309

296310
queryTsEventAssignFunc(result.global.kernelStart, globalStartTs);
297311
queryTsEventAssignFunc(result.context.kernelStart, contextStartTs);
@@ -305,37 +319,31 @@ ze_result_t EventImp<TagSizeT>::queryTimestampsExp(Device *device, uint32_t *pCo
305319
template <typename TagSizeT>
306320
void EventImp<TagSizeT>::resetPackets() {
307321
for (uint32_t i = 0; i < kernelCount; i++) {
308-
kernelTimestampsData[i].setPacketsUsed(1);
322+
kernelEventCompletionData[i].setPacketsUsed(1);
309323
}
310324
kernelCount = 1;
311325
}
312326

313327
template <typename TagSizeT>
314328
uint32_t EventImp<TagSizeT>::getPacketsInUse() {
315-
if (isEventTimestampFlagSet()) {
316-
uint32_t packetsInUse = 0;
317-
for (uint32_t i = 0; i < kernelCount; i++) {
318-
packetsInUse += kernelTimestampsData[i].getPacketsUsed();
319-
};
320-
return packetsInUse;
321-
} else {
322-
return 1;
329+
uint32_t packetsInUse = 0;
330+
for (uint32_t i = 0; i < kernelCount; i++) {
331+
packetsInUse += kernelEventCompletionData[i].getPacketsUsed();
323332
}
333+
return packetsInUse;
324334
}
325335

326336
template <typename TagSizeT>
327337
void EventImp<TagSizeT>::setPacketsInUse(uint32_t value) {
328-
kernelTimestampsData[getCurrKernelDataIndex()].setPacketsUsed(value);
329-
};
338+
kernelEventCompletionData[getCurrKernelDataIndex()].setPacketsUsed(value);
339+
}
330340

331341
template <typename TagSizeT>
332342
uint64_t EventImp<TagSizeT>::getPacketAddress(Device *device) {
333343
uint64_t address = getGpuAddress(device);
334-
if (isEventTimestampFlagSet() && kernelCount > 1) {
335-
for (uint32_t i = 0; i < kernelCount - 1; i++) {
336-
address += kernelTimestampsData[i].getPacketsUsed() *
337-
NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
338-
}
344+
for (uint32_t i = 0; i < kernelCount - 1; i++) {
345+
address += kernelEventCompletionData[i].getPacketsUsed() *
346+
NEO::TimestampPackets<TagSizeT>::getSinglePacketSize();
339347
}
340348
return address;
341349
}

‎level_zero/core/test/unit_tests/sources/event/test_event.cpp

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -640,15 +640,15 @@ TEST_F(TimestampEventCreate, givenEventCreatedWithTimestampThenIsTimestampEventF
640640
}
641641

642642
TEST_F(TimestampEventCreate, givenEventTimestampsCreatedWhenResetIsInvokeThenCorrectDataAreSet) {
643-
EXPECT_NE(nullptr, event->kernelTimestampsData);
643+
EXPECT_NE(nullptr, event->kernelEventCompletionData);
644644
for (auto j = 0u; j < EventPacketsCount::maxKernelSplit; j++) {
645645
for (auto i = 0u; i < NEO::TimestampPacketSizeControl::preferredPacketCount; i++) {
646-
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelTimestampsData[j].getContextStartValue(i));
647-
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelTimestampsData[j].getGlobalStartValue(i));
648-
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelTimestampsData[j].getContextEndValue(i));
649-
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelTimestampsData[j].getGlobalEndValue(i));
646+
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelEventCompletionData[j].getContextStartValue(i));
647+
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelEventCompletionData[j].getGlobalStartValue(i));
648+
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelEventCompletionData[j].getContextEndValue(i));
649+
EXPECT_EQ(static_cast<uint64_t>(Event::State::STATE_INITIAL), event->kernelEventCompletionData[j].getGlobalEndValue(i));
650650
}
651-
EXPECT_EQ(1u, event->kernelTimestampsData[j].getPacketsUsed());
651+
EXPECT_EQ(1u, event->kernelEventCompletionData[j].getPacketsUsed());
652652
}
653653

654654
EXPECT_EQ(1u, event->kernelCount);
@@ -692,7 +692,7 @@ TEST_F(TimestampEventCreate, givenEventTimestampWhenPacketCountIsSetThenCorrectO
692692
}
693693

694694
TEST_F(TimestampEventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAreSet) {
695-
EXPECT_NE(nullptr, event->kernelTimestampsData);
695+
EXPECT_NE(nullptr, event->kernelEventCompletionData);
696696
event->hostSignal();
697697
ze_result_t result = event->queryStatus();
698698
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -702,12 +702,12 @@ TEST_F(TimestampEventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrec
702702
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
703703
for (auto j = 0u; j < EventPacketsCount::maxKernelSplit; j++) {
704704
for (auto i = 0u; i < NEO::TimestampPacketSizeControl::preferredPacketCount; i++) {
705-
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelTimestampsData[j].getContextStartValue(i));
706-
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelTimestampsData[j].getGlobalStartValue(i));
707-
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelTimestampsData[j].getContextEndValue(i));
708-
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelTimestampsData[j].getGlobalEndValue(i));
705+
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelEventCompletionData[j].getContextStartValue(i));
706+
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelEventCompletionData[j].getGlobalStartValue(i));
707+
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelEventCompletionData[j].getContextEndValue(i));
708+
EXPECT_EQ(Event::State::STATE_INITIAL, event->kernelEventCompletionData[j].getGlobalEndValue(i));
709709
}
710-
EXPECT_EQ(1u, event->kernelTimestampsData[j].getPacketsUsed());
710+
EXPECT_EQ(1u, event->kernelEventCompletionData[j].getPacketsUsed());
711711
}
712712
EXPECT_EQ(1u, event->kernelCount);
713713
}
@@ -799,7 +799,7 @@ TEST_F(EventQueryTimestampExpWithSubDevice, givenEventWhenQuerytimestampExpWithS
799799
uint32_t numPackets = 2;
800800

801801
for (uint32_t packetId = 0; packetId < numPackets; packetId++) {
802-
event->kernelTimestampsData[0].assignDataToAllTimestamps(packetId, event->hostAddress);
802+
event->kernelEventCompletionData[0].assignDataToAllTimestamps(packetId, event->hostAddress);
803803
event->hostAddress = ptrOffset(event->hostAddress, NEO::TimestampPackets<uint32_t>::getSinglePacketSize());
804804
}
805805
uint32_t pCount = 0;
@@ -865,7 +865,7 @@ TEST_F(TimestampEventCreate, givenEventWhenQueryingTimestampExpThenCorrectDataSe
865865
uint32_t pCount = 2;
866866

867867
for (uint32_t packetId = 0; packetId < pCount; packetId++) {
868-
event->kernelTimestampsData[0].assignDataToAllTimestamps(packetId, event->hostAddress);
868+
event->kernelEventCompletionData[0].assignDataToAllTimestamps(packetId, event->hostAddress);
869869
event->hostAddress = ptrOffset(event->hostAddress, NEO::TimestampPackets<uint32_t>::getSinglePacketSize());
870870
}
871871

0 commit comments

Comments
 (0)