Add notify functions to enqueue read buffer and image calls

This commit adds notifications to enqueue read buffer and image calls
and setters/getters to mark/check if an allocation is dumpable.

Change-Id: I123f24752d2a86abcf934e0d404f4e0ecf1729cc

Author: smilczar

runtime/command_queue/command_queue_hw.h

@@ -76,6 +76,9 @@ class CommandQueueHw : public CommandQueue {
         return new CommandQueueHw<GfxFamily>(context, device, properties);
     }
 
+    MOCKABLE_VIRTUAL void notifyEnqueueReadBuffer(Buffer *buffer, bool blockingRead);
+    MOCKABLE_VIRTUAL void notifyEnqueueReadImage(Image *image, bool blockingRead);
+
     cl_int enqueueBarrierWithWaitList(cl_uint numEventsInWaitList,
                                       const cl_event *eventWaitList,
                                       cl_event *event) override;

runtime/command_queue/command_queue_hw.inl

@@ -41,3 +41,12 @@
 #include "runtime/command_queue/enqueue_write_image.h"
 #include "runtime/command_queue/finish.h"
 #include "runtime/command_queue/flush.h"
+
+namespace OCLRT {
+template <typename Family>
+void CommandQueueHw<Family>::notifyEnqueueReadBuffer(Buffer *buffer, bool blockingRead) {
+}
+template <typename Family>
+void CommandQueueHw<Family>::notifyEnqueueReadImage(Image *image, bool blockingRead) {
+}
+} // namespace OCLRT

runtime/command_queue/enqueue_read_buffer.h

@@ -45,6 +45,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBuffer(
     const cl_event *eventWaitList,
     cl_event *event) {
 
+    notifyEnqueueReadBuffer(buffer, !!blockingRead);
+
     cl_int retVal = CL_SUCCESS;
     bool isMemTransferNeeded = buffer->isMemObjZeroCopy() ? buffer->checkIfMemoryTransferIsRequired(offset, 0, ptr, CL_COMMAND_READ_BUFFER) : true;
     if ((DebugManager.flags.DoCpuCopyOnReadBuffer.get() ||

runtime/command_queue/enqueue_read_image.h

@@ -50,6 +50,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadImage(
     const cl_event *eventWaitList,
     cl_event *event) {
 
+    notifyEnqueueReadImage(srcImage, !!blockingRead);
+
     MultiDispatchInfo di;
     auto isMemTransferNeeded = true;
     if (srcImage->isMemObjZeroCopy()) {

runtime/memory_manager/graphics_allocation.h

@@ -136,6 +136,8 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
 
     void setAubWritable(bool writable) { aubWritable = writable; }
     bool isAubWritable() const { return aubWritable; }
+    void setAllocDumpable(bool dumpable) { allocDumpable = dumpable; }
+    bool isAllocDumpable() const { return allocDumpable; }
     bool isMemObjectsAllocationWithWritableFlags() const { return memObjectsAllocationWithWritableFlags; }
     void setMemObjectsAllocationWithWritableFlags(bool newValue) { memObjectsAllocationWithWritableFlags = newValue; }
 
@@ -160,6 +162,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
     uint32_t inspectionId = 0;
     AllocationType allocationType = AllocationType::UNKNOWN;
     bool aubWritable = true;
+    bool allocDumpable = false;
     bool memObjectsAllocationWithWritableFlags = false;
 };
 } // namespace OCLRT

unit_tests/command_queue/enqueue_read_buffer_tests.cpp

@@ -30,6 +30,7 @@
 #include "unit_tests/command_queue/enqueue_read_buffer_fixture.h"
 #include "unit_tests/helpers/debug_manager_state_restore.h"
 #include "unit_tests/helpers/unit_test_helper.h"
+#include "unit_tests/mocks/mock_command_queue.h"
 #include "test.h"
 
 using namespace OCLRT;
@@ -451,6 +452,22 @@ HWTEST_F(EnqueueReadBufferTypeTest, givenInOrderQueueAndEnabledSupportCpuCopiesA
     EXPECT_EQ(pCmdQ->taskLevel, 1u);
 }
 
+HWTEST_F(EnqueueReadBufferTypeTest, givenCommandQueueWhenEnqueueReadBufferIsCalledThenItCallsNotifyFunction) {
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pDevice, nullptr);
+    void *ptr = nonZeroCopyBuffer->getCpuAddressForMemoryTransfer();
+    auto retVal = mockCmdQ->enqueueReadBuffer(srcBuffer.get(),
+                                              CL_TRUE,
+                                              0,
+                                              MemoryConstants::cacheLineSize,
+                                              ptr,
+                                              0,
+                                              nullptr,
+                                              nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_TRUE(mockCmdQ->notifyEnqueueReadBufferCalled);
+}
+
 using NegativeFailAllocationTest = Test<NegativeFailAllocationCommandEnqueueBaseFixture>;
 
 HWTEST_F(NegativeFailAllocationTest, givenEnqueueReadBufferWhenHostPtrAllocationCreationFailsThenReturnOutOfResource) {

unit_tests/command_queue/enqueue_read_image_tests.cpp

@@ -25,7 +25,9 @@
 #include "unit_tests/command_queue/enqueue_read_image_fixture.h"
 #include "unit_tests/gen_common/gen_commands_common_validation.h"
 #include "unit_tests/helpers/unit_test_helper.h"
+#include "unit_tests/helpers/debug_manager_state_restore.h"
 #include "unit_tests/mocks/mock_builtin_dispatch_info_builder.h"
+#include "unit_tests/mocks/mock_command_queue.h"
 #include "test.h"
 
 using namespace OCLRT;
@@ -533,6 +535,18 @@ HWTEST_F(EnqueueReadImageTest, GivenNonZeroCopyImage2DAndImageShareTheSameStorag
     EXPECT_EQ(pCmdQ->taskLevel, 2u);
 }
 
+HWTEST_F(EnqueueReadImageTest, givenCommandQueueWhenEnqueueReadImageIsCalledThenItCallsNotifyFunction) {
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pDevice, nullptr);
+    std::unique_ptr<Image> srcImage(Image2dArrayHelper<>::create(context));
+    auto imageDesc = srcImage->getImageDesc();
+    size_t origin[] = {0, 0, 0};
+    size_t region[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
+
+    EnqueueReadImageHelper<>::enqueueReadImage(mockCmdQ.get(), srcImage.get(), CL_TRUE, origin, region);
+
+    EXPECT_TRUE(mockCmdQ->notifyEnqueueReadImageCalled);
+}
+
 typedef EnqueueReadImageMipMapTest MipMapReadImageTest;
 
 HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalledThenProperMipLevelIsSet) {

unit_tests/mem_obj/mem_obj_tests.cpp

@@ -481,3 +481,10 @@ TEST(MemObj, givenNotSharedMemObjectWhenChangingGfxAllocationThenOldAllocationIs
 
     EXPECT_EQ(newGfxAllocation, memObj.getGraphicsAllocation());
 }
+
+TEST(MemObj, givenGraphicsAllocationWhenCallingIsAllocDumpableThenItReturnsTheCorrectValue) {
+    GraphicsAllocation gfxAllocation(nullptr, 0);
+    EXPECT_FALSE(gfxAllocation.isAllocDumpable());
+    gfxAllocation.setAllocDumpable(true);
+    EXPECT_TRUE(gfxAllocation.isAllocDumpable());
+}

unit_tests/mocks/mock_command_queue.h

@@ -114,11 +114,20 @@ class MockCommandQueueHw : public CommandQueueHw<GfxFamily> {
         }
     }
 
+    void notifyEnqueueReadBuffer(Buffer *buffer, bool blockingRead) override {
+        notifyEnqueueReadBufferCalled = true;
+    }
+    void notifyEnqueueReadImage(Image *image, bool blockingRead) override {
+        notifyEnqueueReadImageCalled = true;
+    }
+
     unsigned int lastCommandType;
     std::vector<Kernel *> lastEnqueuedKernels;
     size_t EnqueueWriteImageCounter = 0;
     size_t EnqueueWriteBufferCounter = 0;
     bool blockingWriteBuffer = false;
+    bool notifyEnqueueReadBufferCalled = false;
+    bool notifyEnqueueReadImageCalled = false;
 
     LinearStream *peekCommandStream() {
         return this->commandStream;