[33/n] Internal 4GB allocator.

MichalMrozek · Compute-Runtime-Automation · commit d900bdffc64c · 2018-04-19T08:13:48.000+02:00
- Move indirect heap to internal allocator domain.
- Add logic in getIndirectHeap to allocate with proper API depending on
heap type
- Add State base Address programming, reflecting that now Indirect Object
Heap is placed in 4GB domain.
- For AddPatchInfoCommentsForAUBDump mode , keep all heaps in non 4GB mode.

Change-Id: I6862f6a249e444d0d6cfe7e499a10d43f284553e
diff --git a/runtime/command_queue/command_queue.cpp b/runtime/command_queue/command_queue.cpp
@@ -635,15 +635,24 @@ void CommandQueue::allocateHeapMemory(IndirectHeap::Type heapType,
     auto memoryManager = device->getMemoryManager();
     size_t reservedSize = 0;
     auto finalHeapSize = defaultHeapSize;
+    bool requireInternalHeap = IndirectHeap::INDIRECT_OBJECT == heapType ? true : false;
+
+    if (DebugManager.flags.AddPatchInfoCommentsForAUBDump.get()) {
+        requireInternalHeap = false;
+    }
 
     minRequiredSize += reservedSize;
 
     finalHeapSize = alignUp(std::max(finalHeapSize, minRequiredSize), MemoryConstants::pageSize);
 
-    auto heapMemory = memoryManager->obtainReusableAllocation(finalHeapSize, false).release();
+    auto heapMemory = memoryManager->obtainReusableAllocation(finalHeapSize, requireInternalHeap).release();
 
     if (!heapMemory) {
-        heapMemory = memoryManager->allocateGraphicsMemory(finalHeapSize, MemoryConstants::pageSize);
+        if (requireInternalHeap) {
+            heapMemory = memoryManager->createInternalGraphicsAllocation(nullptr, finalHeapSize);
+        } else {
+            heapMemory = memoryManager->allocateGraphicsMemory(finalHeapSize, MemoryConstants::pageSize);
+        }
     } else {
         finalHeapSize = std::max(heapMemory->getUnderlyingBufferSize(), finalHeapSize);
     }
@@ -659,7 +668,7 @@ void CommandQueue::allocateHeapMemory(IndirectHeap::Type heapType,
         indirectHeap->replaceBuffer(heapMemory->getUnderlyingBuffer(), finalHeapSize);
         indirectHeap->replaceGraphicsAllocation(heapMemory);
     } else {
-        indirectHeap = new IndirectHeap(heapMemory);
+        indirectHeap = new IndirectHeap(heapMemory, requireInternalHeap);
         indirectHeap->overrideMaxSize(finalHeapSize);
     }
 }
diff --git a/runtime/helpers/state_base_address.h b/runtime/helpers/state_base_address.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -25,15 +25,16 @@
 
 namespace OCLRT {
 
+class IndirectHeap;
 class LinearStream;
 
 template <typename GfxFamily>
 struct StateBaseAddressHelper {
     static void programStateBaseAddress(
         LinearStream &commandStream,
-        const LinearStream &dsh,
-        const LinearStream &ioh,
-        const LinearStream &ssh,
+        const IndirectHeap &dsh,
+        const IndirectHeap &ioh,
+        const IndirectHeap &ssh,
         uint64_t generalStateBase,
         uint32_t statelessMocsIndex,
         uint64_t internalHeapBase);
diff --git a/runtime/helpers/state_base_address.inl b/runtime/helpers/state_base_address.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -21,7 +21,7 @@
  */
 
 #include "hw_cmds.h"
-#include "runtime/command_stream/linear_stream.h"
+#include "runtime/indirect_heap/indirect_heap.h"
 #include "runtime/helpers/cache_policy.h"
 #include "runtime/gmm_helper/gmm_helper.h"
 #include "runtime/memory_manager/memory_constants.h"
@@ -30,9 +30,9 @@ namespace OCLRT {
 template <typename GfxFamily>
 void StateBaseAddressHelper<GfxFamily>::programStateBaseAddress(
     LinearStream &commandStream,
-    const LinearStream &dsh,
-    const LinearStream &ioh,
-    const LinearStream &ssh,
+    const IndirectHeap &dsh,
+    const IndirectHeap &ioh,
+    const IndirectHeap &ssh,
     uint64_t generalStateBase,
     uint32_t statelessMocsIndex,
     uint64_t internalHeapBase) {
@@ -51,7 +51,6 @@ void StateBaseAddressHelper<GfxFamily>::programStateBaseAddress(
     // GSH must be set to 0 for stateless
     pCmd->setGeneralStateBaseAddress(generalStateBase);
     pCmd->setSurfaceStateBaseAddress(reinterpret_cast<uintptr_t>(ssh.getCpuBase()));
-    pCmd->setIndirectObjectBaseAddress(reinterpret_cast<uintptr_t>(ioh.getCpuBase()));
     pCmd->setInstructionBaseAddress(internalHeapBase);
 
     pCmd->setDynamicStateBufferSizeModifyEnable(true);
@@ -61,7 +60,9 @@ void StateBaseAddressHelper<GfxFamily>::programStateBaseAddress(
 
     pCmd->setDynamicStateBufferSize(static_cast<uint32_t>((dsh.getMaxAvailableSpace() + MemoryConstants::pageMask) / MemoryConstants::pageSize));
     pCmd->setGeneralStateBufferSize(static_cast<uint32_t>(-1));
-    pCmd->setIndirectObjectBufferSize(static_cast<uint32_t>((ioh.getMaxAvailableSpace() + MemoryConstants::pageMask) / MemoryConstants::pageSize));
+
+    pCmd->setIndirectObjectBaseAddress(ioh.getHeapGpuBase());
+    pCmd->setIndirectObjectBufferSize(ioh.getHeapSizeInPages());
 
     pCmd->setInstructionBufferSize(MemoryConstants::sizeOf4GBinPageEntities);
 
diff --git a/runtime/indirect_heap/indirect_heap.h b/runtime/indirect_heap/indirect_heap.h
@@ -25,6 +25,7 @@
 #include "runtime/helpers/aligned_memory.h"
 #include "runtime/helpers/ptr_math.h"
 #include "runtime/helpers/basic_math.h"
+#include "runtime/memory_manager/memory_constants.h"
 
 namespace OCLRT {
 class GraphicsAllocation;
@@ -53,8 +54,9 @@ class IndirectHeap : public LinearStream {
     IndirectHeap &operator=(const IndirectHeap &) = delete;
 
     void align(size_t alignment);
-    uint64_t getHeapGpuStartOffset();
-    uint64_t getHeapGpuBase();
+    uint64_t getHeapGpuStartOffset() const;
+    uint64_t getHeapGpuBase() const;
+    uint32_t getHeapSizeInPages() const;
 
   protected:
     bool canBeUtilizedAs4GbHeap = false;
@@ -64,18 +66,25 @@ inline void IndirectHeap::align(size_t alignment) {
     auto address = alignUp(ptrOffset(buffer, sizeUsed), alignment);
     sizeUsed = ptrDiff(address, buffer);
 }
-inline uint64_t IndirectHeap::getHeapGpuStartOffset() {
+inline uint64_t IndirectHeap::getHeapGpuStartOffset() const {
     if (this->canBeUtilizedAs4GbHeap) {
         return this->graphicsAllocation->getGpuAddressToPatch();
     } else {
         return 0llu;
     }
 }
-inline uint64_t IndirectHeap::getHeapGpuBase() {
+inline uint64_t IndirectHeap::getHeapGpuBase() const {
     if (this->canBeUtilizedAs4GbHeap) {
         return this->graphicsAllocation->gpuBaseAddress;
     } else {
         return this->graphicsAllocation->getGpuAddress();
     }
 }
+inline uint32_t IndirectHeap::getHeapSizeInPages() const {
+    if (this->canBeUtilizedAs4GbHeap) {
+        return MemoryConstants::sizeOf4GBinPageEntities;
+    } else {
+        return (static_cast<uint32_t>(getMaxAvailableSpace()) + MemoryConstants::pageMask) / MemoryConstants::pageSize;
+    }
+}
 }
diff --git a/unit_tests/aub_tests/command_queue/enqueue_copy_buffer_rect_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_copy_buffer_rect_aub_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -60,7 +60,7 @@ HWTEST_P(AUBCopyBufferRect, simple) {
     static const size_t rowPitch = 20;
     static const size_t slicePitch = rowPitch * rowPitch;
     static const size_t elementCount = slicePitch * rowPitch;
-    MockContext context;
+    MockContext context(this->pDevice);
 
     cl_uchar *srcMemory = new uint8_t[elementCount + 8];
     cl_uchar *dstMemory = new uint8_t[elementCount + 8];
diff --git a/unit_tests/aub_tests/command_queue/enqueue_read_buffer_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_read_buffer_aub_tests.cpp
@@ -48,7 +48,7 @@ struct ReadBufferHw
 typedef ReadBufferHw AUBReadBuffer;
 
 HWTEST_P(AUBReadBuffer, simple) {
-    MockContext context;
+    MockContext context(this->pDevice);
 
     cl_float srcMemory[] = {1.0f, 2.0f, 3.0f, 4.0f};
     cl_float destMemory[] = {0.0f, 0.0f, 0.0f, 0.0f};
@@ -118,7 +118,7 @@ HWTEST_F(AUBReadBuffer, reserveCanonicalGpuAddress) {
         return;
     }
 
-    MockContext context;
+    MockContext context(this->pDevice);
 
     cl_float srcMemory[] = {1.0f, 2.0f, 3.0f, 4.0f};
     cl_float dstMemory[] = {0.0f, 0.0f, 0.0f, 0.0f};
diff --git a/unit_tests/aub_tests/command_queue/enqueue_read_buffer_rect_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_read_buffer_rect_aub_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -49,7 +49,7 @@ typedef ReadBufferRectHw AUBReadBufferRect;
 static const size_t width = 10;
 
 HWTEST_P(AUBReadBufferRect, simple3D) {
-    MockContext context;
+    MockContext context(this->pDevice);
     size_t rowPitch = width;
     size_t slicePitch = rowPitch * rowPitch;
 
diff --git a/unit_tests/aub_tests/command_queue/enqueue_write_buffer_rect_aub_tests.cpp b/unit_tests/aub_tests/command_queue/enqueue_write_buffer_rect_aub_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -50,7 +50,7 @@ typedef WriteBufferRectHw AUBWriteBufferRect;
 static const size_t width = 10;
 
 HWTEST_P(AUBWriteBufferRect, simple3D) {
-    MockContext context;
+    MockContext context(this->pDevice);
     size_t rowPitch = width;
     size_t slicePitch = rowPitch * rowPitch;
 
diff --git a/unit_tests/command_queue/command_queue_tests.cpp b/unit_tests/command_queue/command_queue_tests.cpp
@@ -419,6 +419,18 @@ TEST_P(CommandQueueIndirectHeapTest, IndirectHeapIsProvidedByDevice) {
     EXPECT_NE(nullptr, &indirectHeap);
 }
 
+TEST_P(CommandQueueIndirectHeapTest, givenIndirectObjectHeapWhenItIsQueriedForInternalAllocationThenTrueIsReturned) {
+    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
+    CommandQueue cmdQ(context.get(), pDevice, props);
+
+    auto &indirectHeap = cmdQ.getIndirectHeap(this->GetParam(), 8192);
+    if (this->GetParam() == IndirectHeap::INDIRECT_OBJECT) {
+        EXPECT_TRUE(indirectHeap.getGraphicsAllocation()->is32BitAllocation);
+    } else {
+        EXPECT_FALSE(indirectHeap.getGraphicsAllocation()->is32BitAllocation);
+    }
+}
+
 TEST_P(CommandQueueIndirectHeapTest, IndirectHeapContainsAtLeast64KB) {
     const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
     CommandQueue cmdQ(context.get(), pDevice, props);
@@ -482,7 +494,14 @@ TEST_P(CommandQueueIndirectHeapTest, MemoryManagerWithReusableAllocationsWhenAsk
     auto memoryManager = pDevice->getMemoryManager();
     auto allocationSize = defaultHeapSize * 2;
 
-    auto allocation = memoryManager->allocateGraphicsMemory(allocationSize);
+    GraphicsAllocation *allocation = nullptr;
+
+    if (this->GetParam() == IndirectHeap::INDIRECT_OBJECT) {
+        allocation = memoryManager->createInternalGraphicsAllocation(nullptr, allocationSize);
+    } else {
+        allocation = memoryManager->allocateGraphicsMemory(allocationSize);
+    }
+
     memoryManager->storeAllocation(std::unique_ptr<GraphicsAllocation>(allocation), REUSABLE_ALLOCATION);
 
     EXPECT_FALSE(memoryManager->allocationsForReuse.peekIsEmpty());
diff --git a/unit_tests/command_queue/enqueue_copy_buffer_tests.cpp b/unit_tests/command_queue/enqueue_copy_buffer_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -281,7 +281,7 @@ HWTEST_F(EnqueueCopyBufferTest, argumentZeroShouldMatchSourceAddress) {
     ASSERT_NE(nullptr, kernel);
 
     // Determine where the argument is
-    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 0u);
+    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 0u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));
 
     EXPECT_EQ((void *)((uintptr_t)srcBuffer->getGraphicsAllocation()->getGpuAddress()), *pArgument);
 }
@@ -308,7 +308,7 @@ HWTEST_F(EnqueueCopyBufferTest, argumentOneShouldMatchDestAddress) {
     ASSERT_NE(nullptr, kernel);
 
     // Determine where the argument is
-    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 1);
+    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 1u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));
 
     EXPECT_EQ((void *)((uintptr_t)dstBuffer->getGraphicsAllocation()->getGpuAddress()), *pArgument);
 }
diff --git a/unit_tests/command_queue/enqueue_fill_buffer_tests.cpp b/unit_tests/command_queue/enqueue_fill_buffer_tests.cpp
@@ -334,7 +334,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, argumentZeroShouldMatchDestAddress) {
     ASSERT_NE(nullptr, kernel);
 
     // Determine where the argument is
-    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 0);
+    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 0u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));
 
     EXPECT_EQ((void *)((uintptr_t)buffer->getGraphicsAllocation()->getGpuAddress()), *pArgument);
 
@@ -369,7 +369,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, DISABLED_argumentOneShouldMatchOffset) {
     ASSERT_NE(nullptr, kernel);
 
     // Determine where the argument is
-    auto pArgument = (uint32_t *)getStatelessArgumentPointer<FamilyType>(*kernel, 1);
+    auto pArgument = (uint32_t *)getStatelessArgumentPointer<FamilyType>(*kernel, 1u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));
     ASSERT_NE(nullptr, pArgument);
     EXPECT_EQ(0u, *pArgument);
 
@@ -401,7 +401,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, argumentTwoShouldMatchPatternPtr) {
     ASSERT_NE(nullptr, kernel);
 
     // Determine where the argument is
-    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 2);
+    auto pArgument = (void **)getStatelessArgumentPointer<FamilyType>(*kernel, 2u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));
     EXPECT_NE(nullptr, *pArgument);
 
     context.getMemoryManager()->freeGraphicsMemory(patternAllocation);
diff --git a/unit_tests/gen_common/gen_commands_common_validation.h b/unit_tests/gen_common/gen_commands_common_validation.h
@@ -56,7 +56,7 @@ void validateStateBaseAddress(uint64_t internalHeapBase, IndirectHeap *pDSH,
     // Stateless accesses require GSH.base to be 0.
     EXPECT_EQ(expectedGeneralStateHeapBaseAddress, cmd->getGeneralStateBaseAddress());
     EXPECT_EQ(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pSSH->getCpuBase())), cmd->getSurfaceStateBaseAddress());
-    EXPECT_EQ(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pIOH->getCpuBase())), cmd->getIndirectObjectBaseAddress());
+    EXPECT_EQ(pIOH->getGpuBase(), cmd->getIndirectObjectBaseAddress());
     EXPECT_EQ(internalHeapBase, cmd->getInstructionBaseAddress());
 
     // Verify all sizes are getting programmed
@@ -67,7 +67,7 @@ void validateStateBaseAddress(uint64_t internalHeapBase, IndirectHeap *pDSH,
 
     EXPECT_EQ(pDSH->getMaxAvailableSpace(), cmd->getDynamicStateBufferSize() * MemoryConstants::pageSize);
     EXPECT_NE(0u, cmd->getGeneralStateBufferSize());
-    EXPECT_EQ(pIOH->getMaxAvailableSpace(), cmd->getIndirectObjectBufferSize() * MemoryConstants::pageSize);
+    EXPECT_EQ(MemoryConstants::sizeOf4GBinPageEntities, cmd->getIndirectObjectBufferSize());
     EXPECT_EQ(MemoryConstants::sizeOf4GBinPageEntities, cmd->getInstructionBufferSize());
 
     // Generically validate this command
diff --git a/unit_tests/helpers/hw_parse.h b/unit_tests/helpers/hw_parse.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -211,24 +211,24 @@ struct HardwareParse {
     }
 
     template <typename FamilyType>
-    const void *getStatelessArgumentPointer(const Kernel &kernel, uint32_t indexArg) {
-        typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
-        typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
+    const void *getStatelessArgumentPointer(const Kernel &kernel, uint32_t indexArg, IndirectHeap &ioh) {
         typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
-        auto cmdIDD = (INTERFACE_DESCRIPTOR_DATA *)cmdInterfaceDescriptorData;
-        EXPECT_NE(nullptr, cmdIDD);
-        auto cmdSBA = (STATE_BASE_ADDRESS *)cmdStateBaseAddress;
-        EXPECT_NE(nullptr, cmdSBA);
+        typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
 
         auto cmdWalker = (GPGPU_WALKER *)this->cmdWalker;
         EXPECT_NE(nullptr, cmdWalker);
 
+        auto cmdSBA = (STATE_BASE_ADDRESS *)cmdStateBaseAddress;
+        EXPECT_NE(nullptr, cmdSBA);
+
         auto offsetCrossThreadData = cmdWalker->getIndirectDataStartAddress();
         EXPECT_LT(offsetCrossThreadData, cmdSBA->getIndirectObjectBufferSize() * MemoryConstants::pageSize);
 
+        offsetCrossThreadData -= static_cast<uint32_t>(ioh.getGraphicsAllocation()->getGpuAddressToPatch());
+
         // Get the base of cross thread
         auto pCrossThreadData = ptrOffset(
-            reinterpret_cast<const void *>(cmdSBA->getIndirectObjectBaseAddress()),
+            reinterpret_cast<const void *>(ioh.getCpuBase()),
             offsetCrossThreadData);
 
         // Determine where the argument is
diff --git a/unit_tests/helpers/kernel_commands_tests.cpp b/unit_tests/helpers/kernel_commands_tests.cpp
@@ -205,14 +205,15 @@ HWTEST_F(KernelCommandsTest, givenSendCrossThreadDataWhenWhenAddPatchInfoComment
 }
 
 HWTEST_F(KernelCommandsTest, givenIndirectHeapNotAllocatedFromInternalPoolWhenSendCrossThreadDataIsCalledThenOffsetZeroIsReturned) {
-    CommandQueueHw<FamilyType> cmdQ(pContext, pDevice, 0);
-    auto &indirectHeap = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
+    auto nonInternalAllocation = pDevice->getMemoryManager()->allocateGraphicsMemory(4096);
+    IndirectHeap indirectHeap(nonInternalAllocation, false);
 
     MockKernelWithInternals mockKernelWithInternal(*pDevice);
     auto offset = KernelCommandsHelper<FamilyType>::sendCrossThreadData(
         indirectHeap,
         *mockKernelWithInternal.mockKernel);
     EXPECT_EQ(0u, offset);
+    pDevice->getMemoryManager()->freeGraphicsMemory(nonInternalAllocation);
 }
 
 HWTEST_F(KernelCommandsTest, givenIndirectHeapAllocatedFromInternalPoolWhenSendCrossThreadDataIsCalledThenHeapBaseOffsetIsReturned) {
diff --git a/unit_tests/indirect_heap/indirect_heap_tests.cpp b/unit_tests/indirect_heap/indirect_heap_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (c) 2017, Intel Corporation`
	`2`	`+ * Copyright (c) 2017 - 2018, Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* Permission is hereby granted, free of charge, to any person obtaining a`
`5`	`5`	`* copy of this software and associated documentation files (the "Software"),`
`@@ -281,7 +281,7 @@ HWTEST_F(EnqueueCopyBufferTest, argumentZeroShouldMatchSourceAddress) {`
`281`	`281`	`ASSERT_NE(nullptr, kernel);`
`282`	`282`
`283`	`283`	`// Determine where the argument is`
`284`		`- auto pArgument = (void *)getStatelessArgumentPointer<FamilyType>(kernel, 0u);`
	`284`	`+ auto pArgument = (void *)getStatelessArgumentPointer<FamilyType>(kernel, 0u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));`
`285`	`285`
`286`	`286`	`EXPECT_EQ((void )((uintptr_t)srcBuffer->getGraphicsAllocation()->getGpuAddress()), pArgument);`
`287`	`287`	`}`
`@@ -308,7 +308,7 @@ HWTEST_F(EnqueueCopyBufferTest, argumentOneShouldMatchDestAddress) {`
`308`	`308`	`ASSERT_NE(nullptr, kernel);`
`309`	`309`
`310`	`310`	`// Determine where the argument is`
`311`		`- auto pArgument = (void *)getStatelessArgumentPointer<FamilyType>(kernel, 1);`
	`311`	`+ auto pArgument = (void *)getStatelessArgumentPointer<FamilyType>(kernel, 1u, pCmdQ->getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 0));`
`312`	`312`
`313`	`313`	`EXPECT_EQ((void )((uintptr_t)dstBuffer->getGraphicsAllocation()->getGpuAddress()), pArgument);`
`314`	`314`	`}`