Fixed TBX with AUB dump mode without AubStream

Related-To: NEO-3150

Change-Id: I9ee7fc3c44f3021c61db7c27c01522cbe7d7445d
Signed-off-by: Milczarek, Slawomir <slawomir.milczarek@intel.com>

Author: smilczar

runtime/command_queue/cpu_data_transfer_handler.cpp

@@ -125,6 +125,7 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie
             if (!unmapInfo.readOnly) {
                 auto graphicsAllocation = transferProperties.memObj->getGraphicsAllocation();
                 graphicsAllocation->setAubWritable(true);
+                graphicsAllocation->setTbxWritable(true);
             }
             break;
         case CL_COMMAND_READ_BUFFER:

runtime/command_stream/aub_command_stream_receiver_hw_base.inl

@@ -614,6 +614,10 @@ void AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(uint64_t gpuAddress, voi
 
 template <typename GfxFamily>
 bool AUBCommandStreamReceiverHw<GfxFamily>::writeMemory(GraphicsAllocation &gfxAllocation) {
+    if (!gfxAllocation.isAubWritable()) {
+        return false;
+    }
+
     bool ownsLock = !gfxAllocation.isLocked();
 
     uint64_t gpuAddress;

runtime/command_stream/command_stream_receiver_simulated_common_hw.inl

@@ -102,7 +102,7 @@ bool CommandStreamReceiverSimulatedCommonHw<GfxFamily>::getParametersForWriteMem
         size = gmm->gmmResourceInfo->getSizeAllocation();
     }
 
-    if ((size == 0) || !graphicsAllocation.isAubWritable())
+    if (size == 0)
         return false;
 
     if (cpuAddress == nullptr) {

runtime/command_stream/tbx_command_stream_receiver_hw.inl

@@ -365,6 +365,10 @@ void TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(uint64_t gpuAddress, voi
 
 template <typename GfxFamily>
 bool TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(GraphicsAllocation &gfxAllocation) {
+    if (!gfxAllocation.isTbxWritable()) {
+        return false;
+    }
+
     uint64_t gpuAddress;
     void *cpuAddress;
     size_t size;
@@ -379,7 +383,7 @@ bool TbxCommandStreamReceiverHw<GfxFamily>::writeMemory(GraphicsAllocation &gfxA
     }
 
     if (AubHelper::isOneTimeAubWritableAllocationType(gfxAllocation.getAllocationType())) {
-        gfxAllocation.setAubWritable(false);
+        gfxAllocation.setTbxWritable(false);
     }
 
     return true;
@@ -411,7 +415,7 @@ template <typename GfxFamily>
 void TbxCommandStreamReceiverHw<GfxFamily>::processResidency(ResidencyContainer &allocationsForResidency) {
     for (auto &gfxAllocation : allocationsForResidency) {
         if (!writeMemory(*gfxAllocation)) {
-            DEBUG_BREAK_IF(!((gfxAllocation->getUnderlyingBufferSize() == 0) || !gfxAllocation->isAubWritable()));
+            DEBUG_BREAK_IF(!((gfxAllocation->getUnderlyingBufferSize() == 0) || !gfxAllocation->isTbxWritable()));
         }
         gfxAllocation->updateResidencyTaskCount(this->taskCount + 1, this->osContext->getContextId());
     }

runtime/memory_manager/graphics_allocation.h

@@ -133,6 +133,8 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
 
     void setAubWritable(bool writable) { aubInfo.aubWritable = writable; }
     bool isAubWritable() const { return aubInfo.aubWritable; }
+    void setTbxWritable(bool writable) { aubInfo.tbxWritable = writable; }
+    bool isTbxWritable() const { return aubInfo.tbxWritable; }
     void setAllocDumpable(bool dumpable) { aubInfo.allocDumpable = dumpable; }
     bool isAllocDumpable() const { return aubInfo.allocDumpable; }
     bool isMemObjectsAllocationWithWritableFlags() const { return aubInfo.memObjectsAllocationWithWritableFlags; }
@@ -210,6 +212,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
     };
     struct AubInfo {
         bool aubWritable = true;
+        bool tbxWritable = true;
         bool allocDumpable = false;
         bool memObjectsAllocationWithWritableFlags = false;
     };

unit_tests/command_queue/enqueue_unmap_memobject_tests.cpp

@@ -190,10 +190,11 @@ TEST_F(EnqueueUnmapMemObjTest, UnmapMemObjWaitEvent) {
     clReleaseEvent(retEvent);
 }
 
-HWTEST_F(EnqueueUnmapMemObjTest, givenEnqueueUnmapMemObjectWhenNonAubWritableBufferObjectMappedToHostPtrForWritingThenItShouldBeResetToAubWritable) {
+HWTEST_F(EnqueueUnmapMemObjTest, givenEnqueueUnmapMemObjectWhenNonAubWritableBufferObjectMappedToHostPtrForWritingThenItShouldBeResetToAubAndTbxWritable) {
     auto buffer = std::unique_ptr<Buffer>(BufferHelper<>::create());
     ASSERT_NE(nullptr, buffer);
     buffer->getGraphicsAllocation()->setAubWritable(false);
+    buffer->getGraphicsAllocation()->setTbxWritable(false);
 
     auto mappedForWritingPtr = pCmdQ->enqueueMapBuffer(buffer.get(), CL_TRUE, CL_MAP_WRITE, 0, 8, 0, nullptr, nullptr, retVal);
     ASSERT_NE(nullptr, mappedForWritingPtr);
@@ -207,4 +208,5 @@ HWTEST_F(EnqueueUnmapMemObjTest, givenEnqueueUnmapMemObjectWhenNonAubWritableBuf
     ASSERT_EQ(CL_SUCCESS, retVal);
 
     EXPECT_TRUE(buffer->getGraphicsAllocation()->isAubWritable());
+    EXPECT_TRUE(buffer->getGraphicsAllocation()->isTbxWritable());
 }

unit_tests/command_stream/tbx_command_stream_tests.cpp

@@ -217,9 +217,24 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenWriteMemoryIsCa
     auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize, GraphicsAllocation::AllocationType::BUFFER});
     ASSERT_NE(nullptr, graphicsAllocation);
 
-    EXPECT_TRUE(graphicsAllocation->isAubWritable());
+    EXPECT_TRUE(graphicsAllocation->isTbxWritable());
     EXPECT_TRUE(tbxCsr->writeMemory(*graphicsAllocation));
-    EXPECT_FALSE(graphicsAllocation->isAubWritable());
+    EXPECT_FALSE(graphicsAllocation->isTbxWritable());
+
+    memoryManager->freeGraphicsMemory(graphicsAllocation);
+}
+
+HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenWriteMemoryIsCalledWithGraphicsAllocationThatIsOnlyOneTimeWriteableButAlreadyWrittenThenGraphicsAllocationIsNotUpdated) {
+    TbxCommandStreamReceiverHw<FamilyType> *tbxCsr = (TbxCommandStreamReceiverHw<FamilyType> *)pCommandStreamReceiver;
+    TbxMemoryManager *memoryManager = tbxCsr->getMemoryManager();
+    ASSERT_NE(nullptr, memoryManager);
+
+    auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize, GraphicsAllocation::AllocationType::BUFFER});
+    ASSERT_NE(nullptr, graphicsAllocation);
+
+    graphicsAllocation->setTbxWritable(false);
+    EXPECT_FALSE(tbxCsr->writeMemory(*graphicsAllocation));
+    EXPECT_FALSE(graphicsAllocation->isTbxWritable());
 
     memoryManager->freeGraphicsMemory(graphicsAllocation);
 }