refactor: unify blit memory fill methods and pass BlitProperties 2

Related-To: NEO-13003 Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
2025-12-19 06:24:51 +08:00 · 2025-01-29 10:45:02 +00:00
parent 9ebb2f1227
commit 4846fbe410
14 changed files with 157 additions and 73 deletions
--- a/shared/source/gen12lp/command_stream_receiver_hw_gen12lp.cpp
+++ b/shared/source/gen12lp/command_stream_receiver_hw_gen12lp.cpp
@@ -108,8 +108,8 @@ void BlitCommandsHelper<Family>::appendBlitCommandsForImages(const BlitPropertie
 }

 template <>
-void BlitCommandsHelper<Family>::dispatchBlitMemoryByteFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment) {
-    NEO::BlitCommandsHelper<Family>::dispatchBlitMemoryFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment, COLOR_DEPTH::COLOR_DEPTH_8_BIT_COLOR, 1);
+void BlitCommandsHelper<Family>::dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
+    NEO::BlitCommandsHelper<Family>::dispatchBlitMemoryFill(blitProperties, linearStream, rootDeviceEnvironment);
 }

 template <>
--- a/shared/source/helpers/blit_commands_helper.h
+++ b/shared/source/helpers/blit_commands_helper.h
@@ -49,9 +49,9 @@ struct BlitCommandsHelper {
    static void dispatchBlitCommandsForBufferRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
    static void dispatchBlitCommandsForBufferPerRow(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
    static void dispatchBlitCommandsForImageRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
-    static void dispatchBlitMemoryColorFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, size_t patternSize, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment);
-    static void dispatchBlitMemoryByteFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment);
-    static void dispatchBlitMemoryFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment, COLOR_DEPTH depth, size_t patternSize);
+    static void dispatchBlitMemoryColorFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
+    static void dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
+    static void dispatchBlitMemoryFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
    static void dispatchDummyBlit(LinearStream &linearStream, EncodeDummyBlitWaArgs &waArgs);
    static size_t getDummyBlitSize(const EncodeDummyBlitWaArgs &waArgs);
    static bool isDummyBlitWaNeeded(const EncodeDummyBlitWaArgs &waArgs);
@@ -67,9 +67,9 @@ struct BlitCommandsHelper {
    template <typename T = typename GfxFamily::XY_BLOCK_COPY_BLT>
    static void appendColorDepth(const BlitProperties &blitProperties, T &blitCmd);
    static void appendBlitMemoryOptionsForFillBuffer(NEO::GraphicsAllocation *dstAlloc, typename GfxFamily::XY_COLOR_BLT &blitCmd, const RootDeviceEnvironment &rootDeviceEnvironment);
-    static void appendBlitFillCommand(typename GfxFamily::XY_COLOR_BLT &blitCmd);
+    static void appendBlitFillCommand(const BlitProperties &blitProperties, typename GfxFamily::XY_COLOR_BLT &blitCmd);
    static void appendBlitMemSetCompressionFormat(void *blitCmd, NEO::GraphicsAllocation *dstAlloc, uint32_t compressionFormat);
-    static void appendBlitMemSetCommand(void *blitCmd);
+    static void appendBlitMemSetCommand(const BlitProperties &blitProperties, void *blitCmd);
    static void appendSurfaceType(const BlitProperties &blitProperties, typename GfxFamily::XY_BLOCK_COPY_BLT &blitCmd);
    static void appendTilingEnable(typename GfxFamily::XY_COLOR_BLT &blitCmd);
    static void appendTilingType(const GMM_TILE_TYPE srcTilingType, const GMM_TILE_TYPE dstTilingType, typename GfxFamily::XY_BLOCK_COPY_BLT &blitCmd);
--- a/shared/source/helpers/blit_commands_helper_base.inl
+++ b/shared/source/helpers/blit_commands_helper_base.inl
@@ -11,6 +11,7 @@
 #include "shared/source/helpers/gfx_core_helper.h"
 #include "shared/source/helpers/register_offsets.h"
 #include "shared/source/helpers/timestamp_packet.h"
+#include "shared/source/utilities/lookup_array.h"

 #include <cmath>

@@ -253,22 +254,37 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferPerRow(const Bl
 }

 template <typename GfxFamily>
-void BlitCommandsHelper<GfxFamily>::appendBlitMemSetCommand(void *blitCmd) {}
+void BlitCommandsHelper<GfxFamily>::appendBlitMemSetCommand(const BlitProperties &blitProperties, void *blitCmd) {}

 template <typename GfxFamily>
-void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment, COLOR_DEPTH depth, size_t patternSize) {
+void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
    using XY_COLOR_BLT = typename GfxFamily::XY_COLOR_BLT;
    auto blitCmd = GfxFamily::cmdInitXyColorBlt;
    const auto maxWidth = getMaxBlitWidth(rootDeviceEnvironment);
    const auto maxHeight = getMaxBlitHeight(rootDeviceEnvironment, true);

-    blitCmd.setFillColor(pattern);
-    blitCmd.setColorDepth(depth);
+    auto colorDepth = COLOR_DEPTH::COLOR_DEPTH_128_BIT_COLOR;

-    uint64_t sizeToFill = size / patternSize;
+    const LookupArray<size_t, COLOR_DEPTH, 4> colorDepthLookup({{
+        {1, COLOR_DEPTH::COLOR_DEPTH_8_BIT_COLOR},
+        {2, COLOR_DEPTH::COLOR_DEPTH_16_BIT_COLOR},
+        {4, COLOR_DEPTH::COLOR_DEPTH_32_BIT_COLOR},
+        {8, COLOR_DEPTH::COLOR_DEPTH_64_BIT_COLOR},
+    }});
+
+    auto colorDepthV = colorDepthLookup.find(blitProperties.fillPatternSize);
+    if (colorDepthV.has_value()) {
+        colorDepth = *colorDepthV;
+    }
+
+    blitCmd.setFillColor(blitProperties.fillPattern);
+    blitCmd.setColorDepth(colorDepth);
+
+    uint64_t sizeToFill = blitProperties.copySize.x / blitProperties.fillPatternSize;
+    uint64_t offset = blitProperties.dstOffset.x;
    while (sizeToFill != 0) {
        auto tmpCmd = blitCmd;
-        tmpCmd.setDestinationBaseAddress(ptrOffset(dstAlloc->getGpuAddress(), static_cast<size_t>(offset)));
+        tmpCmd.setDestinationBaseAddress(ptrOffset(blitProperties.dstAllocation->getGpuAddress(), static_cast<size_t>(offset)));
        uint64_t height = 0;
        uint64_t width = 0;
        if (sizeToFill <= maxWidth) {
@@ -283,15 +299,15 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(NEO::GraphicsAllocati
        }
        tmpCmd.setDestinationX2CoordinateRight(static_cast<uint32_t>(width));
        tmpCmd.setDestinationY2CoordinateBottom(static_cast<uint32_t>(height));
-        tmpCmd.setDestinationPitch(static_cast<uint32_t>(width * patternSize));
+        tmpCmd.setDestinationPitch(static_cast<uint32_t>(width * blitProperties.fillPatternSize));

-        appendBlitMemoryOptionsForFillBuffer(dstAlloc, tmpCmd, rootDeviceEnvironment);
-        appendBlitFillCommand(tmpCmd);
+        appendBlitMemoryOptionsForFillBuffer(blitProperties.dstAllocation, tmpCmd, rootDeviceEnvironment);
+        appendBlitFillCommand(blitProperties, tmpCmd);

        auto cmd = linearStream.getSpaceForCmd<XY_COLOR_BLT>();
        *cmd = tmpCmd;
        auto blitSize = width * height;
-        offset += (blitSize * patternSize);
+        offset += (blitSize * blitProperties.fillPatternSize);
        sizeToFill -= blitSize;
    }
 }
@@ -554,25 +570,14 @@ template <typename GfxFamily>
 void BlitCommandsHelper<GfxFamily>::adjustControlSurfaceType(const BlitProperties &blitProperties, typename GfxFamily::XY_BLOCK_COPY_BLT &blitCmd) {}

 template <typename GfxFamily>
-void BlitCommandsHelper<GfxFamily>::appendBlitFillCommand(typename GfxFamily::XY_COLOR_BLT &blitCmd) {}
+void BlitCommandsHelper<GfxFamily>::appendBlitFillCommand(const BlitProperties &blitProperties, typename GfxFamily::XY_COLOR_BLT &blitCmd) {}

 template <typename GfxFamily>
-void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryColorFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, size_t patternSize, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment) {
-    switch (patternSize) {
-    case 1:
-        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment);
-        break;
-    case 2:
-        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment, COLOR_DEPTH::COLOR_DEPTH_16_BIT_COLOR, 2);
-        break;
-    case 4:
-        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment, COLOR_DEPTH::COLOR_DEPTH_32_BIT_COLOR, 4);
-        break;
-    case 8:
-        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment, COLOR_DEPTH::COLOR_DEPTH_64_BIT_COLOR, 8);
-        break;
-    default:
-        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment, COLOR_DEPTH::COLOR_DEPTH_128_BIT_COLOR, 16);
+void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryColorFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
+    if (blitProperties.fillPatternSize == 1) {
+        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(blitProperties, linearStream, rootDeviceEnvironment);
+    } else {
+        NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(blitProperties, linearStream, rootDeviceEnvironment);
    }
 }

--- a/shared/source/helpers/blit_commands_helper_pvc_and_later.inl
+++ b/shared/source/helpers/blit_commands_helper_pvc_and_later.inl
@@ -12,7 +12,7 @@
 namespace NEO {

 template <typename GfxFamily>
-void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment) {
+void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
    using MEM_SET = typename Family::MEM_SET;
    auto blitCmd = Family::cmdInitMemSet;

@@ -23,19 +23,20 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(NEO::GraphicsAllo
    blitCmd.setDestinationMOCS(mocs);

    uint32_t compressionFormat = 0;
-    if (dstAlloc->isCompressionEnabled()) {
-        auto resourceFormat = dstAlloc->getDefaultGmm()->gmmResourceInfo->getResourceFormat();
+    if (blitProperties.dstAllocation->isCompressionEnabled()) {
+        auto resourceFormat = blitProperties.dstAllocation->getDefaultGmm()->gmmResourceInfo->getResourceFormat();
        compressionFormat = static_cast<uint32_t>(rootDeviceEnvironment.getGmmClientContext()->getSurfaceStateCompressionFormat(resourceFormat));
    }

-    appendBlitMemSetCompressionFormat(&blitCmd, dstAlloc, compressionFormat);
+    appendBlitMemSetCompressionFormat(&blitCmd, blitProperties.dstAllocation, compressionFormat);

-    blitCmd.setFillData(*pattern);
+    blitCmd.setFillData(*blitProperties.fillPattern);

-    auto sizeToFill = size;
+    auto sizeToFill = blitProperties.copySize.x;
+    uint64_t offset = blitProperties.dstOffset.x;
    while (sizeToFill != 0) {
        auto tmpCmd = blitCmd;
-        tmpCmd.setDestinationStartAddress(ptrOffset(dstAlloc->getGpuAddress(), static_cast<size_t>(offset)));
+        tmpCmd.setDestinationStartAddress(ptrOffset(blitProperties.dstAllocation->getGpuAddress(), static_cast<size_t>(offset)));
        size_t height = 0;
        size_t width = 0;
        if (sizeToFill <= BlitterConstants::maxBlitSetWidth) {
@@ -52,7 +53,7 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(NEO::GraphicsAllo
        tmpCmd.setFillHeight(static_cast<uint32_t>(height));
        tmpCmd.setDestinationPitch(static_cast<uint32_t>(width));

-        appendBlitMemSetCommand(&tmpCmd);
+        appendBlitMemSetCommand(blitProperties, &tmpCmd);

        auto cmd = linearStream.getSpaceForCmd<MEM_SET>();
        *cmd = tmpCmd;
--- a/shared/source/helpers/blit_commands_helper_xehp_and_later.inl
+++ b/shared/source/helpers/blit_commands_helper_xehp_and_later.inl
@@ -367,7 +367,10 @@ void BlitCommandsHelper<GfxFamily>::dispatchDummyBlit(LinearStream &linearStream

        appendTilingEnable(blitCmd);
        appendBlitMemoryOptionsForFillBuffer(dummyAllocation, blitCmd, *rootDeviceEnvironment);
-        appendBlitFillCommand(blitCmd);
+
+        BlitProperties blitProperties = {};
+
+        appendBlitFillCommand(blitProperties, blitCmd);

        auto cmd = linearStream.getSpaceForCmd<XY_COLOR_BLT>();
        *cmd = blitCmd;
--- a/shared/source/helpers/blit_properties.cpp
+++ b/shared/source/helpers/blit_properties.cpp
@@ -13,6 +13,18 @@

 namespace NEO {

+BlitProperties BlitProperties::constructPropertiesForMemoryFill(GraphicsAllocation *dstAllocation, size_t size, uint32_t *pattern, size_t patternSize, size_t offset) {
+    return {
+        .blitDirection = BlitterConstants::BlitDirection::fill,
+        .dstAllocation = dstAllocation,
+        .fillPattern = pattern,
+        .copySize = {size, 1, 1},
+        .dstOffset = {offset, 0, 0},
+        .srcOffset = {0, 0, 0},
+        .fillPatternSize = patternSize,
+        .isSystemMemoryPoolUsed = MemoryPoolHelper::isSystemMemoryPool(dstAllocation->getMemoryPool())};
+}
+
 BlitProperties BlitProperties::constructPropertiesForReadWrite(BlitterConstants::BlitDirection blitDirection,
                                                               CommandStreamReceiver &commandStreamReceiver,
                                                               GraphicsAllocation *memObjAllocation,
--- a/shared/source/helpers/blit_properties.h
+++ b/shared/source/helpers/blit_properties.h
@@ -43,6 +43,7 @@ struct BlitSyncProperties {
 };

 struct BlitProperties {
+    static BlitProperties constructPropertiesForMemoryFill(GraphicsAllocation *dstAllocation, size_t size, uint32_t *pattern, size_t patternSize, size_t offset);
    static BlitProperties constructPropertiesForReadWrite(BlitterConstants::BlitDirection blitDirection,
                                                          CommandStreamReceiver &commandStreamReceiver,
                                                          GraphicsAllocation *memObjAllocation,
@@ -75,6 +76,7 @@ struct BlitProperties {
    GraphicsAllocation *dstAllocation = nullptr;
    GraphicsAllocation *srcAllocation = nullptr;
    GraphicsAllocation *clearColorAllocation = nullptr;
+    uint32_t *fillPattern = nullptr;
    uint64_t dstGpuAddress = 0;
    uint64_t srcGpuAddress = 0;

@@ -86,6 +88,7 @@ struct BlitProperties {
    size_t dstSlicePitch = 0;
    size_t srcRowPitch = 0;
    size_t srcSlicePitch = 0;
+    size_t fillPatternSize = 0;
    Vec3<size_t> dstSize = 0;
    Vec3<size_t> srcSize = 0;
    size_t bytesPerPixel = 1;
--- a/shared/source/helpers/constants.h
+++ b/shared/source/helpers/constants.h
@@ -70,9 +70,10 @@ enum class BlitDirection : uint32_t {
    bufferToHostPtr,
    hostPtrToBuffer,
    bufferToBuffer,
+    fill,
    hostPtrToImage,
    imageToHostPtr,
-    imageToImage
+    imageToImage,
 };

 enum PostBlitMode : int32_t {
--- a/shared/source/xe_hpg_core/command_stream_receiver_hw_xe_hpg_core.cpp
+++ b/shared/source/xe_hpg_core/command_stream_receiver_hw_xe_hpg_core.cpp
@@ -150,8 +150,8 @@ void BlitCommandsHelper<Family>::appendBlitCommandsBlockCopy(const BlitPropertie
 }

 template <>
-void BlitCommandsHelper<Family>::dispatchBlitMemoryByteFill(NEO::GraphicsAllocation *dstAlloc, uint64_t offset, uint32_t *pattern, LinearStream &linearStream, size_t size, RootDeviceEnvironment &rootDeviceEnvironment) {
-    NEO::BlitCommandsHelper<Family>::dispatchBlitMemoryFill(dstAlloc, offset, pattern, linearStream, size, rootDeviceEnvironment, COLOR_DEPTH::COLOR_DEPTH_8_BIT_COLOR, 1);
+void BlitCommandsHelper<Family>::dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
+    NEO::BlitCommandsHelper<Family>::dispatchBlitMemoryFill(blitProperties, linearStream, rootDeviceEnvironment);
 }

 template <>