Select GMM_RESOURCE_USAGE_OCL_BUFFER_CONST policy for read-only OCL buffers

Change-Id: I338d1a1cf90c5b48009357d79b036d6d50e54b4a
Signed-off-by: Maciej Dziuban <maciej.dziuban@intel.com>

Author: DziubanMaciejIntel

runtime/mem_obj/buffer.h

@@ -38,9 +38,9 @@ extern BufferFuncs bufferFactory[IGFX_MAX_CORE];
 
 class Buffer : public MemObj {
   public:
-    const static size_t maxBufferSizeForReadWriteOnCpu = 10 * MB;
-    const static cl_ulong maskMagic = 0xFFFFFFFFFFFFFFFFLL;
-    static const cl_ulong objectMagic = MemObj::objectMagic | 0x02;
+    constexpr static size_t maxBufferSizeForReadWriteOnCpu = 10 * MB;
+    constexpr static cl_ulong maskMagic = 0xFFFFFFFFFFFFFFFFLL;
+    constexpr static cl_ulong objectMagic = MemObj::objectMagic | 0x02;
     bool forceDisallowCPUCopy = false;
 
     ~Buffer() override;

runtime/mem_obj/buffer.inl

@@ -66,11 +66,11 @@ void BufferHw<GfxFamily>::setArgStateful(void *memory, bool forceNonAuxMode, boo
     surfaceState->setTileMode(RENDER_SURFACE_STATE::TILE_MODE_LINEAR);
     surfaceState->setVerticalLineStride(0);
     surfaceState->setVerticalLineStrideOffset(0);
-    if (!disableL3Cache &&
-        ((isAligned<MemoryConstants::cacheLineSize>(bufferAddress) && isAligned<MemoryConstants::cacheLineSize>(bufferSize)) ||
-         isValueSet(getFlags(), CL_MEM_READ_ONLY) || !this->isMemObjZeroCopy()) &&
-        !this->isMemObjUncacheable()) {
-        surfaceState->setMemoryObjectControlState(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER));
+    const bool readOnlyMemObj = isValueSet(getFlags(), CL_MEM_READ_ONLY);
+    const bool alignedMemObj = isAligned<MemoryConstants::cacheLineSize>(bufferAddress) && isAligned<MemoryConstants::cacheLineSize>(bufferSize);
+    if (!disableL3Cache && !this->isMemObjUncacheable() && (alignedMemObj || readOnlyMemObj || !this->isMemObjZeroCopy())) {
+        const auto usage = readOnlyMemObj ? GMM_RESOURCE_USAGE_OCL_BUFFER_CONST : GMM_RESOURCE_USAGE_OCL_BUFFER;
+        surfaceState->setMemoryObjectControlState(gmmHelper->getMOCS(usage));
     } else {
         surfaceState->setMemoryObjectControlState(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED));
     }

runtime/mem_obj/mem_obj.h

@@ -33,8 +33,8 @@ struct OpenCLObjectMapper<_cl_mem> {
 
 class MemObj : public BaseObject<_cl_mem> {
   public:
-    const static cl_ulong maskMagic = 0xFFFFFFFFFFFFFF00LL;
-    static const cl_ulong objectMagic = 0xAB2212340CACDD00LL;
+    constexpr static cl_ulong maskMagic = 0xFFFFFFFFFFFFFF00LL;
+    constexpr static cl_ulong objectMagic = 0xAB2212340CACDD00LL;
 
     MemObj(Context *context,
            cl_mem_object_type memObjectType,

unit_tests/mem_obj/buffer_tests.cpp

@@ -1205,7 +1205,7 @@ HWTEST_F(BufferSetSurfaceTests, givenBufferSetSurfaceThatMemoryIsUnalignedToCach
 
     auto mocs = surfaceState.getMemoryObjectControlState();
     auto gmmHelper = device->getGmmHelper();
-    EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER), mocs);
+    EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST), mocs);
 
     alignedFree(ptr);
 }
@@ -1363,6 +1363,56 @@ HWTEST_F(BufferSetSurfaceTests, givenBufferWhenSetArgStatefulWithL3ChacheDisable
     alignedFree(ptr);
 }
 
+HWTEST_F(BufferSetSurfaceTests, givenAlignedCacheableReadOnlyBufferThenChoseOclBufferConstPolicy) {
+    MockContext context;
+    const auto size = MemoryConstants::pageSize;
+    const auto ptr = (void *)alignedMalloc(size * 2, MemoryConstants::pageSize);
+    const auto flags = CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY;
+
+    auto retVal = CL_SUCCESS;
+    auto buffer = std::unique_ptr<Buffer>(Buffer::create(
+        &context,
+        flags,
+        size,
+        ptr,
+        retVal));
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    typename FamilyType::RENDER_SURFACE_STATE surfaceState = {};
+    buffer->setArgStateful(&surfaceState, false, false);
+
+    const auto expectedMocs = device->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST);
+    const auto actualMocs = surfaceState.getMemoryObjectControlState();
+    EXPECT_EQ(expectedMocs, actualMocs);
+
+    alignedFree(ptr);
+}
+
+HWTEST_F(BufferSetSurfaceTests, givenAlignedCacheableNonReadOnlyBufferThenChooseOclBufferPolicy) {
+    MockContext context;
+    const auto size = MemoryConstants::pageSize;
+    const auto ptr = (void *)alignedMalloc(size * 2, MemoryConstants::pageSize);
+    const auto flags = CL_MEM_USE_HOST_PTR;
+
+    auto retVal = CL_SUCCESS;
+    auto buffer = std::unique_ptr<Buffer>(Buffer::create(
+        &context,
+        flags,
+        size,
+        ptr,
+        retVal));
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    typename FamilyType::RENDER_SURFACE_STATE surfaceState = {};
+    buffer->setArgStateful(&surfaceState, false, false);
+
+    const auto expectedMocs = device->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER);
+    const auto actualMocs = surfaceState.getMemoryObjectControlState();
+    EXPECT_EQ(expectedMocs, actualMocs);
+
+    alignedFree(ptr);
+}
+
 HWTEST_F(BufferSetSurfaceTests, givenRenderCompressedGmmResourceWhenSurfaceStateIsProgrammedThenSetAuxParams) {
     using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
     using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;

unit_tests/mocks/mock_gmm_client_context_base.cpp

@@ -14,8 +14,19 @@ MockGmmClientContextBase::MockGmmClientContextBase(GMM_CLIENT clientType, GmmExp
 MEMORY_OBJECT_CONTROL_STATE MockGmmClientContextBase::cachePolicyGetMemoryObject(GMM_RESOURCE_INFO *pResInfo, GMM_RESOURCE_USAGE_TYPE usage) {
     MEMORY_OBJECT_CONTROL_STATE retVal = {};
     memset(&retVal, 0, sizeof(MEMORY_OBJECT_CONTROL_STATE));
-    if (usage != GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) {
+    switch (usage) {
+    case GMM_RESOURCE_USAGE_OCL_BUFFER:
+        retVal.DwordValue = 6u;
+        break;
+    case GMM_RESOURCE_USAGE_OCL_BUFFER_CONST:
+        retVal.DwordValue = 5u;
+        break;
+    case GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED:
+        retVal.DwordValue = 0u;
+        break;
+    default:
         retVal.DwordValue = 4u;
+        break;
     }
     return retVal;
 }