Correct programming width of media block surface

Programmed value should be a number of all dwords, rounded up

Related-To: NEO-6466
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

Author: JablonskiMateusz

level_zero/core/source/image/image_hw.inl

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -204,8 +204,7 @@ void ImageCoreFamily<gfxCoreFamily>::copySurfaceStateToSSH(void *surfaceStateHea
              &surfaceState, sizeof(RENDER_SURFACE_STATE));
     if (isMediaBlockArg) {
         RENDER_SURFACE_STATE *dstRss = static_cast<RENDER_SURFACE_STATE *>(destSurfaceState);
-        uint32_t elSize = static_cast<uint32_t>(imgInfo.surfaceFormat->ImageElementSizeInBytes);
-        dstRss->setWidth(static_cast<uint32_t>((imgInfo.imgDesc.imageWidth * elSize) / sizeof(uint32_t)));
+        NEO::setWidthForMediaBlockSurfaceState<GfxFamily>(dstRss, imgInfo);
     }
 }
 

opencl/source/mem_obj/image.inl

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -61,8 +61,7 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
     } else {
         setImageSurfaceStateDimensions<GfxFamily>(surfaceState, imgInfo, cubeFaceIndex, surfaceType);
         if (setAsMediaBlockImage) {
-            uint32_t elSize = static_cast<uint32_t>(getSurfaceFormatInfo().surfaceFormat.ImageElementSizeInBytes);
-            surfaceState->setWidth(static_cast<uint32_t>((getImageDesc().image_width * elSize) / sizeof(uint32_t)));
+            setWidthForMediaBlockSurfaceState<GfxFamily>(surfaceState, imgInfo);
         }
     }
 

shared/source/image/image_surface_state.h

@@ -124,6 +124,13 @@ inline void setImageSurfaceStateDimensions(typename GfxFamily::RENDER_SURFACE_ST
     surfaceState->setSurfaceType(surfaceType);
 }
 
+template <typename GfxFamily>
+inline void setWidthForMediaBlockSurfaceState(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const ImageInfo &imageInfo) {
+    auto elSize = imageInfo.surfaceFormat->ImageElementSizeInBytes;
+    auto numDwords = static_cast<uint32_t>(Math::divideAndRoundUp(imageInfo.imgDesc.imageWidth * elSize, sizeof(uint32_t)));
+    surfaceState->setWidth(numDwords);
+}
+
 template <typename GfxFamily>
 inline void setUnifiedAuxBaseAddress(typename GfxFamily::RENDER_SURFACE_STATE *surfaceState, const Gmm *gmm) {
     uint64_t baseAddress = surfaceState->getSurfaceBaseAddress() +

shared/test/unit_test/image/image_surface_state_tests.cpp

@@ -222,3 +222,63 @@ HWTEST_F(ImageSurfaceStateTests, givenImage1DWhen2dImageWAIsEnabledThenArrayFlag
     setImageSurfaceState<FamilyType>(castSurfaceState, imageInfo, mockGmm.get(), *gmmHelper, cubeFaceIndex, gpuAddress, surfaceOffsets, true);
     EXPECT_FALSE(castSurfaceState->getSurfaceArray());
 }
+
+struct ImageWidthTest : ImageSurfaceStateTests {
+
+    struct ImageWidthParams {
+        uint32_t imageWidth;
+        uint32_t expectedWidthInDwords;
+    };
+
+    template <typename FamilyType>
+    void verifyProgramming(typename FamilyType::RENDER_SURFACE_STATE &renderSurfaceState, const std::array<ImageWidthParams, 6> &params) {
+        for (auto &param : params) {
+            imageInfo.imgDesc.imageWidth = param.imageWidth;
+            setWidthForMediaBlockSurfaceState<FamilyType>(&renderSurfaceState, imageInfo);
+            EXPECT_EQ(param.expectedWidthInDwords, renderSurfaceState.getWidth());
+        }
+    }
+};
+
+HWTEST_F(ImageWidthTest, givenMediaBlockWhenProgrammingWidthInSurfaceStateThenCorrectValueIsProgrammed) {
+    SurfaceFormatInfo surfaceFormatInfo{};
+    imageInfo.surfaceFormat = &surfaceFormatInfo;
+
+    auto renderSurfaceState = FamilyType::cmdInitRenderSurfaceState;
+    {
+        surfaceFormatInfo.ImageElementSizeInBytes = 1u;
+        constexpr std::array<ImageWidthParams, 6> params = {{
+            {1, 1},
+            {2, 1},
+            {3, 1},
+            {4, 1},
+            {5, 2},
+            {6, 2},
+        }};
+        verifyProgramming<FamilyType>(renderSurfaceState, params);
+    }
+    {
+        surfaceFormatInfo.ImageElementSizeInBytes = 2u;
+        constexpr std::array<ImageWidthParams, 6> params = {{
+            {1, 1},
+            {2, 1},
+            {3, 2},
+            {4, 2},
+            {5, 3},
+            {6, 3},
+        }};
+        verifyProgramming<FamilyType>(renderSurfaceState, params);
+    }
+    {
+        surfaceFormatInfo.ImageElementSizeInBytes = 4u;
+        constexpr std::array<ImageWidthParams, 6> params = {{
+            {1, 1},
+            {2, 2},
+            {3, 3},
+            {4, 4},
+            {5, 5},
+            {6, 6},
+        }};
+        verifyProgramming<FamilyType>(renderSurfaceState, params);
+    }
+}