Revert commit cc1f4be.

ArturHarasimiuk · ArturHarasimiuk · commit b5f443edc0ae · 2018-12-21T13:25:49.000+01:00
This reverts commit cc1f4be. Revert "Revert "Use GPU instead of CPU address in programming commands for HwTim(...)"" Change-Id: Iff122612bb46ba80bcc70b07b2609bfd5f0b9653 Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
diff --git a/runtime/command_queue/enqueue_common.h b/runtime/command_queue/enqueue_common.h
@@ -146,7 +146,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
     auto devQueue = this->getContext().getDefaultDeviceQueue();
     DeviceQueueHw<GfxFamily> *devQueueHw = castToObject<DeviceQueueHw<GfxFamily>>(devQueue);
 
-    HwTimeStamps *hwTimeStamps = nullptr;
+    TagNode<HwTimeStamps> *hwTimeStamps = nullptr;
 
     auto commandStreamRecieverOwnership = getCommandStreamReceiver().obtainUniqueOwnership();
 
@@ -230,7 +230,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
             }
             if (this->isProfilingEnabled()) {
                 // Get allocation for timestamps
-                hwTimeStamps = eventBuilder.getEvent()->getHwTimeStampNode()->tag;
+                hwTimeStamps = eventBuilder.getEvent()->getHwTimeStampNode();
                 if (this->isPerfCountersEnabled()) {
                     hwPerfCounter = eventBuilder.getEvent()->getHwPerfCounterNode()->tag;
                     // PERF COUNTER: copy current configuration from queue to event
diff --git a/runtime/command_queue/gpgpu_walker.h b/runtime/command_queue/gpgpu_walker.h
@@ -139,11 +139,11 @@ class GpgpuWalkerHelper {
         const iOpenCL::SPatchThreadPayload &threadPayload);
 
     static void dispatchProfilingCommandsStart(
-        HwTimeStamps &hwTimeStamps,
+        TagNode<HwTimeStamps> &hwTimeStamps,
         OCLRT::LinearStream *commandStream);
 
     static void dispatchProfilingCommandsEnd(
-        HwTimeStamps &hwTimeStamps,
+        TagNode<HwTimeStamps> &hwTimeStamps,
         OCLRT::LinearStream *commandStream);
 
     static void dispatchPerfCountersNoopidRegisterCommands(
diff --git a/runtime/command_queue/gpgpu_walker.inl b/runtime/command_queue/gpgpu_walker.inl
@@ -101,17 +101,17 @@ void GpgpuWalkerHelper<GfxFamily>::addAluReadModifyWriteRegister(
 
 template <typename GfxFamily>
 void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsStart(
-    HwTimeStamps &hwTimeStamps,
+    TagNode<HwTimeStamps> &hwTimeStamps,
     OCLRT::LinearStream *commandStream) {
     using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
 
     // PIPE_CONTROL for global timestamp
-    uint64_t TimeStampAddress = reinterpret_cast<uint64_t>(&(hwTimeStamps.GlobalStartTS));
+    uint64_t TimeStampAddress = hwTimeStamps.getGraphicsAllocation()->getGpuAddress() + ptrDiff(&hwTimeStamps.tag->GlobalStartTS, hwTimeStamps.tag);
 
     PipeControlHelper<GfxFamily>::obtainPipeControlAndProgramPostSyncOperation(commandStream, PIPE_CONTROL::POST_SYNC_OPERATION_WRITE_TIMESTAMP, TimeStampAddress, 0llu);
 
     //MI_STORE_REGISTER_MEM for context local timestamp
-    TimeStampAddress = reinterpret_cast<uint64_t>(&(hwTimeStamps.ContextStartTS));
+    TimeStampAddress = hwTimeStamps.getGraphicsAllocation()->getGpuAddress() + ptrDiff(&hwTimeStamps.tag->ContextStartTS, hwTimeStamps.tag);
 
     //low part
     auto pMICmdLow = (MI_STORE_REGISTER_MEM *)commandStream->getSpace(sizeof(MI_STORE_REGISTER_MEM));
@@ -122,7 +122,7 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsStart(
 
 template <typename GfxFamily>
 void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(
-    HwTimeStamps &hwTimeStamps,
+    TagNode<HwTimeStamps> &hwTimeStamps,
     OCLRT::LinearStream *commandStream) {
 
     using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM;
@@ -133,7 +133,7 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(
     pPipeControlCmd->setCommandStreamerStallEnable(true);
 
     //MI_STORE_REGISTER_MEM for context local timestamp
-    uint64_t TimeStampAddress = reinterpret_cast<uint64_t>(&(hwTimeStamps.ContextEndTS));
+    uint64_t TimeStampAddress = hwTimeStamps.getGraphicsAllocation()->getGpuAddress() + ptrDiff(&hwTimeStamps.tag->ContextEndTS, hwTimeStamps.tag);
 
     //low part
     auto pMICmdLow = (MI_STORE_REGISTER_MEM *)commandStream->getSpace(sizeof(MI_STORE_REGISTER_MEM));
diff --git a/runtime/command_queue/hardware_interface.h b/runtime/command_queue/hardware_interface.h
@@ -40,7 +40,7 @@ class HardwareInterface {
         cl_uint numEventsInWaitList,
         const cl_event *eventWaitList,
         KernelOperation **blockedCommandsData,
-        HwTimeStamps *hwTimeStamps,
+        TagNode<HwTimeStamps> *hwTimeStamps,
         HwPerfCounter *hwPerfCounter,
         TimestampPacketContainer *previousTimestampPacketNodes,
         TimestampPacketContainer *currentTimestampPacketNodes,
@@ -69,13 +69,13 @@ class HardwareInterface {
     static void dispatchProfilingPerfStartCommands(
         const DispatchInfo &dispatchInfo,
         const MultiDispatchInfo &multiDispatchInfo,
-        HwTimeStamps *hwTimeStamps,
+        TagNode<HwTimeStamps> *hwTimeStamps,
         HwPerfCounter *hwPerfCounter,
         LinearStream *commandStream,
         CommandQueue &commandQueue);
 
     static void dispatchProfilingPerfEndCommands(
-        HwTimeStamps *hwTimeStamps,
+        TagNode<HwTimeStamps> *hwTimeStamps,
         HwPerfCounter *hwPerfCounter,
         LinearStream *commandStream,
         CommandQueue &commandQueue);
diff --git a/runtime/command_queue/hardware_interface.inl b/runtime/command_queue/hardware_interface.inl
@@ -19,7 +19,7 @@ void HardwareInterface<GfxFamily>::dispatchWalker(
     cl_uint numEventsInWaitList,
     const cl_event *eventWaitList,
     KernelOperation **blockedCommandsData,
-    HwTimeStamps *hwTimeStamps,
+    TagNode<HwTimeStamps> *hwTimeStamps,
     HwPerfCounter *hwPerfCounter,
     TimestampPacketContainer *previousTimestampPacketNodes,
     TimestampPacketContainer *currentTimestampPacketNodes,
diff --git a/runtime/command_queue/hardware_interface_base.inl b/runtime/command_queue/hardware_interface_base.inl
@@ -59,7 +59,7 @@ template <typename GfxFamily>
 inline void HardwareInterface<GfxFamily>::dispatchProfilingPerfStartCommands(
     const DispatchInfo &dispatchInfo,
     const MultiDispatchInfo &multiDispatchInfo,
-    HwTimeStamps *hwTimeStamps,
+    TagNode<HwTimeStamps> *hwTimeStamps,
     HwPerfCounter *hwPerfCounter,
     LinearStream *commandStream,
     CommandQueue &commandQueue) {
@@ -77,7 +77,7 @@ inline void HardwareInterface<GfxFamily>::dispatchProfilingPerfStartCommands(
 
 template <typename GfxFamily>
 inline void HardwareInterface<GfxFamily>::dispatchProfilingPerfEndCommands(
-    HwTimeStamps *hwTimeStamps,
+    TagNode<HwTimeStamps> *hwTimeStamps,
     HwPerfCounter *hwPerfCounter,
     LinearStream *commandStream,
     CommandQueue &commandQueue) {
diff --git a/runtime/device_queue/device_queue.cpp b/runtime/device_queue/device_queue.cpp
@@ -143,7 +143,7 @@ void DeviceQueue::initDeviceQueue() {
     igilEventPool->m_size = caps.maxOnDeviceEvents;
 }
 
-void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp) {
+void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, TagNode<HwTimeStamps> *hwTimeStamp) {
     setupIndirectState(surfaceStateHeap, dynamicStateHeap, parentKernel, parentCount);
     addExecutionModelCleanUpSection(parentKernel, hwTimeStamp, taskCount);
 }
@@ -152,7 +152,7 @@ void DeviceQueue::setupIndirectState(IndirectHeap &surfaceStateHeap, IndirectHea
     return;
 }
 
-void DeviceQueue::addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) {
+void DeviceQueue::addExecutionModelCleanUpSection(Kernel *parentKernel, TagNode<HwTimeStamps> *hwTimeStamp, uint32_t taskCount) {
     return;
 }
 
diff --git a/runtime/device_queue/device_queue.h b/runtime/device_queue/device_queue.h
@@ -22,6 +22,8 @@ class Event;
 struct MultiDispatchInfo;
 class SchedulerKernel;
 struct HwTimeStamps;
+template <class T>
+struct TagNode;
 
 template <>
 struct OpenCLObjectMapper<_device_queue> {
@@ -66,10 +68,10 @@ class DeviceQueue : public BaseObject<_device_queue> {
                                size_t paramValueSize, void *paramValue,
                                size_t *paramValueSizeRet);
 
-    void setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps *hwTimeStamp);
+    void setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel *parentKernel, uint32_t parentCount, uint32_t taskCount, TagNode<HwTimeStamps> *hwTimeStamp);
 
     virtual void setupIndirectState(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel *parentKernel, uint32_t parentIDCount);
-    virtual void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount);
+    virtual void addExecutionModelCleanUpSection(Kernel *parentKernel, TagNode<HwTimeStamps> *hwTimeStamp, uint32_t taskCount);
 
     MOCKABLE_VIRTUAL bool isEMCriticalSectionFree() {
         auto igilCmdQueue = reinterpret_cast<IGIL_CommandQueue *>(queueBuffer->getUnderlyingBuffer());
diff --git a/runtime/device_queue/device_queue_hw.h b/runtime/device_queue/device_queue_hw.h
@@ -55,7 +55,7 @@ class DeviceQueueHw : public DeviceQueue {
 
     void setupIndirectState(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel *parentKernel, uint32_t parentIDCount) override;
 
-    void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) override;
+    void addExecutionModelCleanUpSection(Kernel *parentKernel, TagNode<HwTimeStamps> *hwTimeStamp, uint32_t taskCount) override;
     void resetDeviceQueue() override;
     void dispatchScheduler(CommandQueue &cmdQ, SchedulerKernel &scheduler, PreemptionMode preemptionMode, IndirectHeap *ssh, IndirectHeap *dsh) override;
 
diff --git a/runtime/device_queue/device_queue_hw.inl b/runtime/device_queue/device_queue_hw.inl
@@ -12,6 +12,7 @@
 #include "runtime/helpers/preamble.h"
 #include "runtime/helpers/string.h"
 #include "runtime/memory_manager/memory_manager.h"
+#include "runtime/utilities/tag_allocator.h"
 
 namespace OCLRT {
 template <typename GfxFamily>
@@ -201,7 +202,7 @@ void DeviceQueueHw<GfxFamily>::buildSlbDummyCommands() {
 }
 
 template <typename GfxFamily>
-void DeviceQueueHw<GfxFamily>::addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) {
+void DeviceQueueHw<GfxFamily>::addExecutionModelCleanUpSection(Kernel *parentKernel, TagNode<HwTimeStamps> *hwTimeStamp, uint32_t taskCount) {
     // CleanUp Section
     auto offset = slbCS.getUsed();
     auto alignmentSize = alignUp(offset, MemoryConstants::pageSize) - offset;
@@ -215,7 +216,7 @@ void DeviceQueueHw<GfxFamily>::addExecutionModelCleanUpSection(Kernel *parentKer
     using PIPE_CONTROL = typename GfxFamily::PIPE_CONTROL;
 
     if (hwTimeStamp != nullptr) {
-        uint64_t TimeStampAddress = (uint64_t)((uintptr_t) & (hwTimeStamp->ContextCompleteTS));
+        uint64_t TimeStampAddress = hwTimeStamp->getGraphicsAllocation()->getGpuAddress() + ptrDiff(&hwTimeStamp->tag->ContextCompleteTS, hwTimeStamp->tag);
         igilQueue->m_controls.m_EventTimestampAddress = TimeStampAddress;
 
         addProfilingEndCmds(TimeStampAddress);
diff --git a/runtime/event/event.cpp b/runtime/event/event.cpp
@@ -451,7 +451,7 @@ void Event::submitCommand(bool abortTasks) {
         if ((this->isProfilingEnabled()) && (this->cmdQueue != nullptr)) {
             if (timeStampNode) {
                 this->cmdQueue->getCommandStreamReceiver().makeResident(*timeStampNode->getGraphicsAllocation());
-                cmdToProcess->timestamp = timeStampNode->tag;
+                cmdToProcess->timestamp = timeStampNode;
             }
             if (profilingCpuPath) {
                 setSubmitTimeStamp();
diff --git a/runtime/helpers/task_information.h b/runtime/helpers/task_information.h
@@ -26,6 +26,8 @@ class Surface;
 class PrintfHandler;
 struct HwTimeStamps;
 class TimestampPacketContainer;
+template <class T>
+struct TagNode;
 
 enum MapOperationType {
     MAP,
@@ -42,7 +44,7 @@ class Command : public IFNode<Command> {
     virtual LinearStream *getCommandStream() {
         return nullptr;
     }
-    HwTimeStamps *timestamp = nullptr;
+    TagNode<HwTimeStamps> *timestamp = nullptr;
     CompletionStamp completionStamp = {};
 };
 
diff --git a/unit_tests/device_queue/device_queue_hw_tests.cpp b/unit_tests/device_queue/device_queue_hw_tests.cpp
@@ -7,6 +7,7 @@
 
 #include "hw_cmds.h"
 #include "runtime/helpers/options.h"
+#include "runtime/utilities/tag_allocator.h"
 #include "unit_tests/fixtures/device_host_queue_fixture.h"
 #include "unit_tests/fixtures/execution_model_fixture.h"
 #include "unit_tests/helpers/hw_parse.h"
@@ -352,18 +353,19 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueSlb, AddEMCleanupSectionWithProfiling) {
     MockParentKernel *mockParentKernel = MockParentKernel::create(*pContext);
     uint32_t taskCount = 7;
 
-    HwTimeStamps hwTimeStamp;
+    auto hwTimeStamp = pCommandQueue->getCommandStreamReceiver().getEventTsAllocator()->getTag();
     mockDeviceQueueHw->buildSlbDummyCommands();
-    mockDeviceQueueHw->addExecutionModelCleanUpSection(mockParentKernel, &hwTimeStamp, taskCount);
+    mockDeviceQueueHw->addExecutionModelCleanUpSection(mockParentKernel, hwTimeStamp, taskCount);
 
-    uint32_t eventTimestampLow = (uint32_t)(igilCmdQueue->m_controls.m_EventTimestampAddress & 0xFFFFFFFF);
-    uint32_t eventTimestampHigh = (uint32_t)((igilCmdQueue->m_controls.m_EventTimestampAddress & 0xFFFFFFFF00000000) >> 32);
+    uint32_t eventTimestampAddrLow = static_cast<uint32_t>(igilCmdQueue->m_controls.m_EventTimestampAddress & 0xFFFFFFFF);
+    uint32_t eventTimestampAddrHigh = static_cast<uint32_t>((igilCmdQueue->m_controls.m_EventTimestampAddress & 0xFFFFFFFF00000000) >> 32);
 
-    uint32_t contextCompleteLow = (uint32_t)((uint64_t)((uintptr_t)(&hwTimeStamp.ContextCompleteTS)) & 0xFFFFFFFF);
-    uint32_t contextCompleteHigh = (uint32_t)(((uint64_t)((uintptr_t)(&hwTimeStamp.ContextCompleteTS)) & 0xFFFFFFFF00000000) >> 32);
+    uint64_t contextCompleteAddr = hwTimeStamp->getGraphicsAllocation()->getGpuAddress() + ptrDiff(&hwTimeStamp->tag->ContextCompleteTS, hwTimeStamp->tag);
+    uint32_t contextCompleteAddrLow = static_cast<uint32_t>(contextCompleteAddr & 0xFFFFFFFF);
+    uint32_t contextCompleteAddrHigh = static_cast<uint32_t>((contextCompleteAddr & 0xFFFFFFFF00000000) >> 32);
 
-    EXPECT_EQ(contextCompleteLow, eventTimestampLow);
-    EXPECT_EQ(contextCompleteHigh, eventTimestampHigh);
+    EXPECT_EQ(contextCompleteAddrLow, eventTimestampAddrLow);
+    EXPECT_EQ(contextCompleteAddrHigh, eventTimestampAddrHigh);
 
     HardwareParse hwParser;
     auto *slbCS = mockDeviceQueueHw->getSlbCS();
diff --git a/unit_tests/execution_model/submit_blocked_parent_kernel_tests.cpp b/unit_tests/execution_model/submit_blocked_parent_kernel_tests.cpp
@@ -8,6 +8,7 @@
 #include "runtime/command_queue/gpgpu_walker.h"
 #include "runtime/command_queue/hardware_interface.h"
 #include "runtime/event/hw_timestamps.h"
+#include "runtime/utilities/tag_allocator.h"
 #include "runtime/helpers/kernel_commands.h"
 #include "runtime/helpers/task_information.h"
 #include "unit_tests/mocks/mock_command_queue.h"
@@ -56,9 +57,9 @@ class MockDeviceQueueHwWithCriticalSectionRelease : public DeviceQueueHw<GfxFami
         indirectStateSetup = true;
         return BaseClass::setupIndirectState(surfaceStateHeap, dynamicStateHeap, parentKernel, parentIDCount);
     }
-    void addExecutionModelCleanUpSection(Kernel *parentKernel, HwTimeStamps *hwTimeStamp, uint32_t taskCount) override {
+    void addExecutionModelCleanUpSection(Kernel *parentKernel, TagNode<HwTimeStamps> *hwTimeStamp, uint32_t taskCount) override {
         cleanupSectionAdded = true;
-        timestampAddedInCleanupSection = hwTimeStamp;
+        timestampAddedInCleanupSection = hwTimeStamp ? hwTimeStamp->tag : nullptr;
         return BaseClass::addExecutionModelCleanUpSection(parentKernel, hwTimeStamp, taskCount);
     }
     void dispatchScheduler(CommandQueue &cmdQ, SchedulerKernel &scheduler, PreemptionMode preemptionMode, IndirectHeap *ssh, IndirectHeap *dsh) override {
@@ -249,13 +250,12 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenBlockedParentKernelWithProfilingW
         std::vector<Surface *> surfaces;
         auto *cmdComputeKernel = new CommandComputeKernel(*pCmdQ, std::unique_ptr<KernelOperation>(blockedCommandData), surfaces, false, false, false, nullptr, preemptionMode, parentKernel, 1);
 
-        HwTimeStamps timestamp;
-
-        cmdComputeKernel->timestamp = &timestamp;
+        auto timestamp = pCmdQ->getCommandStreamReceiver().getEventTsAllocator()->getTag();
+        cmdComputeKernel->timestamp = timestamp;
         cmdComputeKernel->submit(0, false);
 
         EXPECT_TRUE(mockDevQueue.cleanupSectionAdded);
-        EXPECT_EQ(mockDevQueue.timestampAddedInCleanupSection, &timestamp);
+        EXPECT_EQ(mockDevQueue.timestampAddedInCleanupSection, timestamp->tag);
 
         delete cmdComputeKernel;
         delete parentKernel;

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ void DeviceQueue::initDeviceQueue() {`
`143`	`143`	`igilEventPool->m_size = caps.maxOnDeviceEvents;`
`144`	`144`	`}`
`145`	`145`
`146`		`-void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel parentKernel, uint32_t parentCount, uint32_t taskCount, HwTimeStamps hwTimeStamp) {`
	`146`	`+void DeviceQueue::setupExecutionModelDispatch(IndirectHeap &surfaceStateHeap, IndirectHeap &dynamicStateHeap, Kernel parentKernel, uint32_t parentCount, uint32_t taskCount, TagNode<HwTimeStamps> hwTimeStamp) {`
`147`	`147`	`setupIndirectState(surfaceStateHeap, dynamicStateHeap, parentKernel, parentCount);`
`148`	`148`	`addExecutionModelCleanUpSection(parentKernel, hwTimeStamp, taskCount);`
`149`	`149`	`}`
`@@ -152,7 +152,7 @@ void DeviceQueue::setupIndirectState(IndirectHeap &surfaceStateHeap, IndirectHea`
`152`	`152`	`return;`
`153`	`153`	`}`
`154`	`154`
`155`		`-void DeviceQueue::addExecutionModelCleanUpSection(Kernel parentKernel, HwTimeStamps hwTimeStamp, uint32_t taskCount) {`
	`155`	`+void DeviceQueue::addExecutionModelCleanUpSection(Kernel parentKernel, TagNode<HwTimeStamps> hwTimeStamp, uint32_t taskCount) {`
`156`	`156`	`return;`
`157`	`157`	`}`
`158`	`158`