Fix surfaceState for multisample images

MaciejPlewka · Compute-Runtime-Automation · commit d58b9840b8f0 · 2019-02-05T12:44:57.000+01:00
Change-Id: I2d4b17e162f61892ca1a86c241a722ef0c51ee42
Signed-off-by: Maciej Plewka &lt;maciej.plewka@intel.com&gt;
diff --git a/runtime/gen10/image_gen10.cpp b/runtime/gen10/image_gen10.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,6 +8,7 @@
 #include "hw_cmds.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/mem_obj/image.inl"
+#include "runtime/mem_obj/image_base.inl"
 #include <map>
 
 namespace OCLRT {
diff --git a/runtime/gen8/image_gen8.cpp b/runtime/gen8/image_gen8.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,6 +8,7 @@
 #include "hw_cmds.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/mem_obj/image.inl"
+#include "runtime/mem_obj/image_base.inl"
 #include <map>
 
 namespace OCLRT {
diff --git a/runtime/gen9/image_gen9.cpp b/runtime/gen9/image_gen9.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2018 Intel Corporation
+ * Copyright (C) 2017-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,6 +8,7 @@
 #include "hw_cmds.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/mem_obj/image.inl"
+#include "runtime/mem_obj/image_base.inl"
 #include <map>
 
 namespace OCLRT {
diff --git a/runtime/gmm_helper/gmm.cpp b/runtime/gmm_helper/gmm.cpp
@@ -249,4 +249,7 @@ bool Gmm::unifiedAuxTranslationCapable() const {
     return gmmFlags->Gpu.CCS && gmmFlags->Gpu.UnifiedAuxSurface && gmmFlags->Info.RenderCompressed;
 }
 
+bool Gmm::hasMultisampleControlSurface() const {
+    return this->gmmResourceInfo->getResourceFlags()->Gpu.MCS;
+}
 } // namespace OCLRT
diff --git a/runtime/gmm_helper/gmm.h b/runtime/gmm_helper/gmm.h
@@ -37,6 +37,7 @@ class Gmm {
     void applyMemoryFlags(bool systemMemoryPool);
 
     bool unifiedAuxTranslationCapable() const;
+    bool hasMultisampleControlSurface() const;
 
     uint32_t queryQPitch(GMM_RESOURCE_TYPE resType);
     void updateImgInfo(ImageInfo &imgInfo, cl_image_desc &imgDesc, cl_uint arrayIndex);
diff --git a/runtime/mem_obj/CMakeLists.txt b/runtime/mem_obj/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2018 Intel Corporation
+# Copyright (C) 2018-2019 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -13,6 +13,7 @@ set(RUNTIME_SRCS_MEM_OBJ
   ${CMAKE_CURRENT_SOURCE_DIR}/image.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/image.h
   ${CMAKE_CURRENT_SOURCE_DIR}/image.inl
+  ${CMAKE_CURRENT_SOURCE_DIR}/image_base.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/image_factory_init.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/map_operations_handler.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/map_operations_handler.h
diff --git a/runtime/mem_obj/image.h b/runtime/mem_obj/image.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Intel Corporation
+ * Copyright (C) 2018-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -264,7 +264,9 @@ class ImageHw : public Image {
     void setImageArg(void *memory, bool setAsMediaBlockImage, uint32_t mipLevel) override;
     void setAuxParamsForMultisamples(RENDER_SURFACE_STATE *surfaceState);
     void setAuxParamsForCCS(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm);
+    void setUnifiedAuxBaseAddress(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm);
     MOCKABLE_VIRTUAL void setClearColorParams(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm);
+    MOCKABLE_VIRTUAL void setAuxParamsForMCSCCS(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm);
     void setMediaImageArg(void *memory) override;
     void setMediaSurfaceRotation(void *memory) override;
     void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override;
diff --git a/runtime/mem_obj/image.inl b/runtime/mem_obj/image.inl
@@ -165,7 +165,11 @@ void ImageHw<GfxFamily>::setAuxParamsForMultisamples(RENDER_SURFACE_STATE *surfa
     if (getMcsAllocation()) {
         auto mcsGmm = getMcsAllocation()->gmm;
 
-        if (mcsGmm->unifiedAuxTranslationCapable()) { // Ignore MCS allocation when Color Control Surface is available
+        if (mcsGmm->unifiedAuxTranslationCapable() && mcsGmm->hasMultisampleControlSurface()) {
+            setAuxParamsForMCSCCS(surfaceState, mcsGmm);
+            setClearColorParams(surfaceState, mcsGmm);
+            setUnifiedAuxBaseAddress(surfaceState, mcsGmm);
+        } else if (mcsGmm->unifiedAuxTranslationCapable()) {
             setAuxParamsForCCS(surfaceState, mcsGmm);
         } else {
             surfaceState->setAuxiliarySurfaceMode((typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE)1);
@@ -183,10 +187,14 @@ void ImageHw<GfxFamily>::setAuxParamsForCCS(RENDER_SURFACE_STATE *surfaceState,
     // Its expected to not program pitch/qpitch/baseAddress for Aux surface in CCS scenarios
     surfaceState->setAuxiliarySurfaceMode(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
     setClearColorParams(surfaceState, gmm);
+    setUnifiedAuxBaseAddress(surfaceState, gmm);
 }
 
 template <typename GfxFamily>
-void ImageHw<GfxFamily>::setClearColorParams(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
+void ImageHw<GfxFamily>::setUnifiedAuxBaseAddress(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
+    uint64_t baseAddress = surfaceState->getSurfaceBaseAddress() +
+                           gmm->gmmResourceInfo->getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_SURF);
+    surfaceState->setAuxiliarySurfaceBaseAddress(baseAddress);
 }
 
 template <typename GfxFamily>
diff --git a/runtime/mem_obj/image_base.inl b/runtime/mem_obj/image_base.inl
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+namespace OCLRT {
+
+template <typename GfxFamily>
+void ImageHw<GfxFamily>::setClearColorParams(RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
+}
+
+template <typename GfxFamily>
+void ImageHw<GfxFamily>::setAuxParamsForMCSCCS(RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) {
+}
+} // namespace OCLRT
diff --git a/runtime/sharings/gl/gl_texture.cpp b/runtime/sharings/gl/gl_texture.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Intel Corporation
+ * Copyright (C) 2018-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -130,6 +130,10 @@ Image *GlTexture::createSharedGlTexture(Context *context, cl_mem_flags flags, cl
     }
 
     auto glTexture = new GlTexture(sharingFunctions, getClGlObjectType(target), texture, texInfo, target, std::max(miplevel, 0));
+
+    if (alloc->gmm->unifiedAuxTranslationCapable()) {
+        alloc->gmm->isRenderCompressed = context->getMemoryManager()->mapAuxGpuVA(alloc);
+    }
     return Image::createSharedImage(context, glTexture, mcsSurfaceInfo, alloc, mcsAlloc, flags, imgInfo, cubeFaceIndex,
                                     std::max(miplevel, 0), imgDesc.num_mip_levels);
 }
diff --git a/unit_tests/gmm_helper/gmm_helper_tests.cpp b/unit_tests/gmm_helper/gmm_helper_tests.cpp
@@ -661,6 +661,18 @@ TEST(GmmTest, whenResourceIsCreatedThenHandleItsOwnership) {
     EXPECT_NE(myMockResourceInfo1.resourceInfo.get(), myMockResourceInfo2.resourceInfo.get());
 }
 
+TEST(GmmTest, givenGmmWithNotSetMCSInResourceInfoGpuFlagsWhenCallHasMultisampleControlSurfaceThenReturnFalse) {
+    auto gmm = std::unique_ptr<Gmm>(new Gmm(nullptr, 1, false));
+    EXPECT_FALSE(gmm->hasMultisampleControlSurface());
+}
+
+TEST(GmmTest, givenGmmWithSetMCSInResourceInfoGpuFlagsWhenCallhasMultisampleControlSurfaceThenReturnTrue) {
+    auto gmm = std::unique_ptr<Gmm>(new Gmm(nullptr, 1, false));
+    auto mockResource = reinterpret_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
+    mockResource->setMultisampleControlSurface();
+    EXPECT_TRUE(gmm->hasMultisampleControlSurface());
+}
+
 TEST(GmmSimplifiedCacheSelectionPolicy, givenGmmInSimplifiedCacheSelectionPolicyWhenItIsAskedForUncachedIndexThen0IsReturned) {
     GmmHelper gmmHelper(*platformDevices);
     gmmHelper.setSimplifiedMocsTableUsage(true);
diff --git a/unit_tests/mem_obj/image_set_arg_tests.cpp b/unit_tests/mem_obj/image_set_arg_tests.cpp
@@ -586,7 +586,35 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
     EXPECT_TRUE(surfaceState->getAuxiliarySurfaceMode() == AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
     EXPECT_EQ(1u, surfaceState->getAuxiliarySurfacePitch());
     EXPECT_EQ(0u, surfaceState->getAuxiliarySurfaceQpitch());
-    EXPECT_EQ(0u, surfaceState->getAuxiliarySurfaceBaseAddress());
+}
+
+HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapabilityAndMcsThenAuxBaseAddressIsSet) {
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+    using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
+
+    McsSurfaceInfo msi = {10, 20, 3};
+    auto mcsAlloc = context->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
+    mcsAlloc->gmm = new Gmm(nullptr, 1, false);
+    cl_image_desc imgDesc = Image2dDefaults::imageDesc;
+    imgDesc.num_samples = 8;
+
+    auto image = std::unique_ptr<Image>(Image2dHelper<>::create(context, &imgDesc));
+    image->setMcsSurfaceInfo(msi);
+    image->setMcsAllocation(mcsAlloc);
+    cl_mem memObj = image.get();
+
+    auto mockMcsGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(mcsAlloc->gmm->gmmResourceInfo.get());
+    mockMcsGmmResInfo->setUnifiedAuxTranslationCapable();
+    mockMcsGmmResInfo->setMultisampleControlSurface();
+    EXPECT_TRUE(mcsAlloc->gmm->unifiedAuxTranslationCapable());
+
+    retVal = clSetKernelArg(pKernel, 0, sizeof(memObj), &memObj);
+    ASSERT_EQ(CL_SUCCESS, retVal);
+
+    auto surfaceState = reinterpret_cast<const RENDER_SURFACE_STATE *>(ptrOffset(pKernel->getSurfaceStateHeap(),
+                                                                                 pKernelInfo->kernelArgInfo[0].offsetHeap));
+
+    EXPECT_NE(0u, surfaceState->getAuxiliarySurfaceBaseAddress());
 }
 
 HWTEST_F(ImageSetArgTest, clSetKernelArgImage1Dbuffer) {
@@ -709,7 +737,6 @@ HWTEST_F(ImageSetArgTest, givenRenderCompressedResourceWhenSettingImgArgThenSetC
     EXPECT_TRUE(surfaceState.getAuxiliarySurfaceMode() == AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
     EXPECT_EQ(1u, surfaceState.getAuxiliarySurfacePitch());
     EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceQpitch());
-    EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceBaseAddress());
 }
 
 HWTEST_F(ImageSetArgTest, givenNonRenderCompressedResourceWhenSettingImgArgThenDontSetAuxParams) {
diff --git a/unit_tests/mem_obj/image_tests.cpp b/unit_tests/mem_obj/image_tests.cpp
@@ -1399,20 +1399,47 @@ HWTEST_F(ImageTransformTest, givenSurfaceStateWhenTransformImage2dArrayTo3dIsCal
     EXPECT_FALSE(surfaceState.getSurfaceArray());
 }
 
+HWTEST_F(ImageTransformTest, givenSurfaceBaseAddressAndUnifiedSurfaceWhenSetUnifiedAuxAddressCalledThenAddressIsSet) {
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+    using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
+    MockContext context;
+    auto image = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(&context));
+    auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
+    auto imageHw = static_cast<ImageHw<FamilyType> *>(image.get());
+    auto gmm = std::unique_ptr<Gmm>(new Gmm(nullptr, 1, false));
+    uint64_t surfBsaseAddress = 0xABCDEF1000;
+    surfaceState.setSurfaceBaseAddress(surfBsaseAddress);
+    auto mockResource = reinterpret_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
+    mockResource->setUnifiedAuxTranslationCapable();
+
+    EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceBaseAddress());
+
+    imageHw->setUnifiedAuxBaseAddress(&surfaceState, gmm.get());
+    uint64_t offset = gmm->gmmResourceInfo->getUnifiedAuxSurfaceOffset(GMM_UNIFIED_AUX_TYPE::GMM_AUX_SURF);
+
+    EXPECT_EQ(surfBsaseAddress + offset, surfaceState.getAuxiliarySurfaceBaseAddress());
+}
+
 template <typename FamilyName>
 class MockImageHw : public ImageHw<FamilyName> {
   public:
     MockImageHw(Context *context, const cl_image_format &format, const cl_image_desc &desc, SurfaceFormatInfo &surfaceFormatInfo, GraphicsAllocation *graphicsAllocation) : ImageHw<FamilyName>(context, 0, 0, nullptr, format, desc, false, graphicsAllocation, false, false, 0, 0, surfaceFormatInfo) {
     }
 
     void setClearColorParams(typename FamilyName::RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) override;
+    void setAuxParamsForMCSCCS(typename FamilyName::RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) override;
     bool setClearColorParamsCalled = false;
+    bool setAuxParamsForMCSCCSCalled = false;
 };
 
 template <typename FamilyName>
 void MockImageHw<FamilyName>::setClearColorParams(typename FamilyName::RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
     this->setClearColorParamsCalled = true;
 }
+template <typename FamilyName>
+void MockImageHw<FamilyName>::setAuxParamsForMCSCCS(typename FamilyName::RENDER_SURFACE_STATE *surfaceState, Gmm *gmm) {
+    this->setAuxParamsForMCSCCSCalled = true;
+}
 
 using HwImageTest = ::testing::Test;
 HWTEST_F(HwImageTest, givenImageHwWhenSettingCCSParamsThenSetClearColorParamsIsCalled) {
@@ -1447,3 +1474,45 @@ HWTEST_F(HwImageTest, givenImageHwWhenSettingCCSParamsThenSetClearColorParamsIsC
     mockImage->setAuxParamsForCCS(&surfaceState, graphicsAllocation->gmm);
     EXPECT_TRUE(mockImage->setClearColorParamsCalled);
 }
+
+using HwImageTest = ::testing::Test;
+HWTEST_F(HwImageTest, givenImageHwWithUnifiedSurfaceAndMcsWhenSettingParamsForMultisampleImageThenSetParamsForCcsMcsIsCalled) {
+
+    MockContext context;
+    OsAgnosticMemoryManager memoryManager(false, false, *context.getDevice(0)->getExecutionEnvironment());
+    context.setMemoryManager(&memoryManager);
+
+    cl_image_desc imgDesc = {};
+    imgDesc.num_samples = 8;
+    cl_image_format format = {};
+
+    auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
+    AllocationProperties allocProperties = MemObjHelper::getAllocationProperties(&imgInfo, true);
+    DevicesBitfield devices = 0;
+
+    auto graphicsAllocation = memoryManager.allocateGraphicsMemoryInPreferredPool(allocProperties, devices, nullptr);
+
+    SurfaceFormatInfo formatInfo = {};
+    std::unique_ptr<MockImageHw<FamilyType>> mockImage(new MockImageHw<FamilyType>(&context, format, imgDesc, formatInfo, graphicsAllocation));
+
+    McsSurfaceInfo msi = {10, 20, 3};
+    auto mcsAlloc = context.getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
+    mcsAlloc->gmm = new Gmm(nullptr, 1, false);
+
+    auto mockMcsGmmResInfo = reinterpret_cast<::testing::NiceMock<MockGmmResourceInfo> *>(mcsAlloc->gmm->gmmResourceInfo.get());
+    mockMcsGmmResInfo->setUnifiedAuxTranslationCapable();
+    mockMcsGmmResInfo->setMultisampleControlSurface();
+    EXPECT_TRUE(mcsAlloc->gmm->unifiedAuxTranslationCapable());
+    EXPECT_TRUE(mcsAlloc->gmm->hasMultisampleControlSurface());
+
+    mockImage->setMcsSurfaceInfo(msi);
+    mockImage->setMcsAllocation(mcsAlloc);
+
+    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
+    auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
+
+    EXPECT_FALSE(mockImage->setAuxParamsForMCSCCSCalled);
+    mockImage->setAuxParamsForMultisamples(&surfaceState);
+
+    EXPECT_TRUE(mockImage->setAuxParamsForMCSCCSCalled);
+}
diff --git a/unit_tests/mocks/mock_gmm_resource_info.cpp b/unit_tests/mocks/mock_gmm_resource_info.cpp
@@ -115,6 +115,10 @@ void MockGmmResourceInfo::setUnifiedAuxTranslationCapable() {
     mockResourceCreateParams.Flags.Info.RenderCompressed = 1;
 }
 
+void MockGmmResourceInfo::setMultisampleControlSurface() {
+    mockResourceCreateParams.Flags.Gpu.MCS = 1;
+}
+
 uint32_t MockGmmResourceInfo::getTileModeSurfaceState() {
     if (mockResourceCreateParams.Type == GMM_RESOURCE_TYPE::RESOURCE_2D ||
         mockResourceCreateParams.Type == GMM_RESOURCE_TYPE::RESOURCE_3D) {
diff --git a/unit_tests/mocks/mock_gmm_resource_info.h b/unit_tests/mocks/mock_gmm_resource_info.h
@@ -81,6 +81,7 @@ class MockGmmResourceInfo : public GmmResourceInfo {
     void overrideReturnedSize(size_t newSize) { size = newSize; }
 
     void setUnifiedAuxTranslationCapable();
+    void setMultisampleControlSurface();
 
     uint32_t getOffsetCalled = 0u;
     uint32_t arrayIndexPassedToGetOffset = 0;
diff --git a/unit_tests/sharings/gl/gl_texture_tests.cpp b/unit_tests/sharings/gl/gl_texture_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Intel Corporation
+ * Copyright (C) 2018-2019 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -36,6 +36,11 @@ class GlSharingTextureTests : public ::testing::Test {
             }
             OsAgnosticMemoryManager::freeGraphicsMemoryImpl(gfxAllocation);
         }
+        bool mapAuxGpuVA(GraphicsAllocation *graphicsAllocation) override {
+            mapAuxGpuVACalled++;
+            return false;
+        }
+        uint32_t mapAuxGpuVACalled = 0u;
         size_t forceAllocationSize;
         std::unique_ptr<Gmm> forceGmm;
         bool useForcedGmm = true;
@@ -68,6 +73,12 @@ class GlSharingTextureTests : public ::testing::Test {
         delete glSharing;
     }
 
+    void setUnifiedAuxSurf() {
+        tempMM->useForcedGmm = true;
+        auto mockGmmResInfo = reinterpret_cast<::testing::NiceMock<MockGmmResourceInfo> *>(tempMM->forceGmm->gmmResourceInfo.get());
+        mockGmmResInfo->setUnifiedAuxTranslationCapable();
+    }
+
     ExecutionEnvironment executionEnvironment;
     cl_image_desc imgDesc;
     TempMM *tempMM;
@@ -516,6 +527,15 @@ TEST_F(GlSharingTextureTests, givenMockGlWhenGlTextureIsCreatedFromFormatNotIncl
     EXPECT_EQ(CL_INVALID_GL_OBJECT, retVal);
 }
 
+TEST_F(GlSharingTextureTests, givenMockGlWhenGlTextureIsCreatedWithUnifiedAuxSurfThenMapAuxGpuVaIsCalled) {
+    cl_int retVal = CL_SUCCESS;
+    setUnifiedAuxSurf();
+    EXPECT_EQ(0u, tempMM->mapAuxGpuVACalled);
+
+    auto glTexture = std::unique_ptr<Image>(GlTexture::createSharedGlTexture(clContext.get(), CL_MEM_WRITE_ONLY, GL_SRGB8_ALPHA8, 0, textureId, &retVal));
+
+    EXPECT_EQ(1u, tempMM->mapAuxGpuVACalled);
+}
 class GetGlTextureInfoTests : public GlSharingTextureTests,
                               public ::testing::WithParamInterface<unsigned int /*cl_GLenum*/> {
 };

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2017-2018 Intel Corporation`
	`2`	`+ * Copyright (C) 2017-2019 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -8,6 +8,7 @@`
`8`	`8`	`#include "hw_cmds.h"`
`9`	`9`	`#include "runtime/mem_obj/image.h"`
`10`	`10`	`#include "runtime/mem_obj/image.inl"`
	`11`	`+#include "runtime/mem_obj/image_base.inl"`
`11`	`12`	`#include <map>`
`12`	`13`
`13`	`14`	`namespace OCLRT {`
Original file line number	Diff line number	Diff line change
`@@ -249,4 +249,7 @@ bool Gmm::unifiedAuxTranslationCapable() const {`
`249`	`249`	`return gmmFlags->Gpu.CCS && gmmFlags->Gpu.UnifiedAuxSurface && gmmFlags->Info.RenderCompressed;`
`250`	`250`	`}`
`251`	`251`
	`252`	`+bool Gmm::hasMultisampleControlSurface() const {`
	`253`	`+ return this->gmmResourceInfo->getResourceFlags()->Gpu.MCS;`
	`254`	`+}`
`252`	`255`	`} // namespace OCLRT`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`#`
`2`		`-# Copyright (C) 2018 Intel Corporation`
	`2`	`+# Copyright (C) 2018-2019 Intel Corporation`
`3`	`3`	`#`
`4`	`4`	`# SPDX-License-Identifier: MIT`
`5`	`5`	`#`
`@@ -13,6 +13,7 @@ set(RUNTIME_SRCS_MEM_OBJ`
`13`	`13`	`${CMAKE_CURRENT_SOURCE_DIR}/image.cpp`
`14`	`14`	`${CMAKE_CURRENT_SOURCE_DIR}/image.h`
`15`	`15`	`${CMAKE_CURRENT_SOURCE_DIR}/image.inl`
	`16`	`+ ${CMAKE_CURRENT_SOURCE_DIR}/image_base.inl`
`16`	`17`	`${CMAKE_CURRENT_SOURCE_DIR}/image_factory_init.inl`
`17`	`18`	`${CMAKE_CURRENT_SOURCE_DIR}/map_operations_handler.cpp`
`18`	`19`	`${CMAKE_CURRENT_SOURCE_DIR}/map_operations_handler.h`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2018 Intel Corporation`
	`2`	`+ * Copyright (C) 2018-2019 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -130,6 +130,10 @@ Image GlTexture::createSharedGlTexture(Context context, cl_mem_flags flags, cl`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`auto glTexture = new GlTexture(sharingFunctions, getClGlObjectType(target), texture, texInfo, target, std::max(miplevel, 0));`
	`133`	`+`
	`134`	`+ if (alloc->gmm->unifiedAuxTranslationCapable()) {`
	`135`	`+ alloc->gmm->isRenderCompressed = context->getMemoryManager()->mapAuxGpuVA(alloc);`
	`136`	`+ }`
`133`	`137`	`return Image::createSharedImage(context, glTexture, mcsSurfaceInfo, alloc, mcsAlloc, flags, imgInfo, cubeFaceIndex,`
`134`	`138`	`std::max(miplevel, 0), imgDesc.num_mip_levels);`
`135`	`139`	`}`