intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 22:12:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: patch counter values with additional blit properties

Browse Source 
Modified BlitCommandsHelper and CommandListHw to patch counter values
when using additional blit properties and in order command list is
enabled.

Related-To: NEO-13003

Signed-off-by: Young Jin Yoon <young.jin.yoon@intel.com>
This commit is contained in:
Young Jin Yoon
2025-05-09 07:04:35 +00:00
committed by Compute-Runtime-Automation
parent 27ca91419f
commit 5221b5b00e
20 changed files with 528 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
shared/source/helpers/blit_commands_helper.h
View File

@@ -24,6 +24,10 @@ struct RootDeviceEnvironment;
class ProductHelper;
struct EncodeDummyBlitWaArgs;
struct BlitCommandsResult {
void *lastBlitCommand = nullptr;
};
template <typename GfxFamily>
struct BlitCommandsHelper {
using COLOR_DEPTH = typename GfxFamily::XY_COLOR_BLT::COLOR_DEPTH;
@@ -31,6 +35,8 @@ struct BlitCommandsHelper {
static uint64_t getMaxBlitWidthOverride(const RootDeviceEnvironment &rootDeviceEnvironment);
static uint64_t getMaxBlitHeight(const RootDeviceEnvironment &rootDeviceEnvironment, bool isSystemMemoryPoolUsed);
static uint64_t getMaxBlitHeightOverride(const RootDeviceEnvironment &rootDeviceEnvironment, bool isSystemMemoryPoolUsed);
static uint64_t getMaxBlitSetWidth(const RootDeviceEnvironment &rootDeviceEnvironment);
static uint64_t getMaxBlitSetHeight(const RootDeviceEnvironment &rootDeviceEnvironment);
static void dispatchPreBlitCommand(LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
static size_t estimatePreBlitCommandSize();
static void dispatchPostBlitCommand(LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
@@ -46,12 +52,12 @@ struct BlitCommandsHelper {
static uint64_t calculateBlitCommandDestinationBaseAddressCopyRegion(const BlitProperties &blitProperties, size_t slice);
static uint64_t calculateBlitCommandSourceBaseAddressCopyRegion(const BlitProperties &blitProperties, size_t slice);
static void dispatchBlitCommands(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
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(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 BlitCommandsResult dispatchBlitCommandsForBufferRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
static BlitCommandsResult dispatchBlitCommandsForBufferPerRow(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
static BlitCommandsResult dispatchBlitCommandsForImageRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
static BlitCommandsResult dispatchBlitMemoryColorFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
static BlitCommandsResult dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment);
static BlitCommandsResult 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);

77
shared/source/helpers/blit_commands_helper_base.inl
View File

@@ -41,6 +41,22 @@ uint64_t BlitCommandsHelper<GfxFamily>::getMaxBlitHeight(const RootDeviceEnviron
return BlitterConstants::maxBlitHeight;
}
template <typename GfxFamily>
uint64_t BlitCommandsHelper<GfxFamily>::getMaxBlitSetWidth(const RootDeviceEnvironment &rootDeviceEnvironment) {
if (debugManager.flags.LimitBlitterMaxSetWidth.get() != -1) {
return static_cast<uint64_t>(debugManager.flags.LimitBlitterMaxSetWidth.get());
}
return BlitterConstants::maxBlitSetWidth;
}
template <typename GfxFamily>
uint64_t BlitCommandsHelper<GfxFamily>::getMaxBlitSetHeight(const RootDeviceEnvironment &rootDeviceEnvironment) {
if (debugManager.flags.LimitBlitterMaxSetHeight.get() != -1) {
return static_cast<uint64_t>(debugManager.flags.LimitBlitterMaxSetHeight.get());
}
return BlitterConstants::maxBlitSetHeight;
}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchPreBlitCommand(LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
if (BlitCommandsHelper<GfxFamily>::preBlitCommandWARequired()) {
@@ -195,7 +211,7 @@ uint64_t BlitCommandsHelper<GfxFamily>::calculateBlitCommandSourceBaseAddress(co
}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferPerRow(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
BlitCommandsResult BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferPerRow(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
uint64_t width = 1;
uint64_t height = 1;
@@ -211,6 +227,7 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferPerRow(const Bl
const bool useAdditionalBlitProperties = rootDeviceEnvironment.getHelper<ProductHelper>().useAdditionalBlitProperties();
BlitCommandsResult result{};
bool firstCommand = true;
for (uint64_t slice = 0; slice < blitProperties.copySize.z; slice++) {
for (uint64_t row = 0; row < blitProperties.copySize.y; row++) {
@@ -253,7 +270,9 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferPerRow(const Bl
auto bltStream = linearStream.getSpaceForCmd<typename GfxFamily::XY_COPY_BLT>();
*bltStream = tmpCmd;
if (lastCommand) {
result.lastBlitCommand = bltStream;
}
dispatchPostBlitCommand(linearStream, rootDeviceEnvironment);
sizeToBlit -= blitSize;
@@ -261,13 +280,14 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferPerRow(const Bl
}
}
}
return result;
}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::appendBlitMemSetCommand(const BlitProperties &blitProperties, void *blitCmd) {}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
BlitCommandsResult 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);
@@ -293,6 +313,7 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(const BlitProperties
blitCmd.setColorDepth(colorDepth);
const bool useAdditionalBlitProperties = rootDeviceEnvironment.getHelper<ProductHelper>().useAdditionalBlitProperties();
BlitCommandsResult result{};
bool firstCommand = true;
uint64_t sizeToFill = blitProperties.copySize.x / patternSize;
uint64_t offset = blitProperties.dstOffset.x;
@@ -326,13 +347,17 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(const BlitProperties
}
auto cmd = linearStream.getSpaceForCmd<XY_COLOR_BLT>();
*cmd = tmpCmd;
if (lastCommand) {
result.lastBlitCommand = cmd;
}
offset += (blitSize * patternSize);
sizeToFill -= blitSize;
}
return result;
}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForImageRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
BlitCommandsResult BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForImageRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
auto srcSlicePitch = static_cast<uint32_t>(blitProperties.srcSlicePitch);
auto dstSlicePitch = static_cast<uint32_t>(blitProperties.dstSlicePitch);
@@ -359,6 +384,7 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForImageRegion(const Bli
dispatchPreBlitCommand(linearStream, rootDeviceEnvironment);
const bool useAdditionalBlitProperties = rootDeviceEnvironment.getHelper<ProductHelper>().useAdditionalBlitProperties();
BlitCommandsResult result{};
for (uint32_t i = 0; i < blitProperties.copySize.z; i++) {
auto tmpCmd = bltCmd;
appendSliceOffsets(blitProperties, tmpCmd, i, rootDeviceEnvironment, srcSlicePitch, dstSlicePitch);
@@ -372,8 +398,12 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForImageRegion(const Bli
}
auto cmd = linearStream.getSpaceForCmd<typename GfxFamily::XY_BLOCK_COPY_BLT>();
*cmd = tmpCmd;
if (lastCommand) {
result.lastBlitCommand = cmd;
}
dispatchPostBlitCommand(linearStream, rootDeviceEnvironment);
}
return result;
}
template <typename GfxFamily>
@@ -449,7 +479,7 @@ void BlitCommandsHelper<GfxFamily>::appendBlitCommandsMemCopy(const BlitProperti
}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
BlitCommandsResult BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferRegion(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
const auto maxWidthToCopy = getMaxBlitWidth(rootDeviceEnvironment);
const auto maxHeightToCopy = getMaxBlitHeight(rootDeviceEnvironment, blitProperties.isSystemMemoryPoolUsed);
@@ -461,28 +491,44 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferRegion(const Bl
bltCmd.setDestinationPitch(static_cast<uint32_t>(blitProperties.dstRowPitch));
appendColorDepth(blitProperties, bltCmd);
const bool useAdditionalBlitProperties = rootDeviceEnvironment.getHelper<ProductHelper>().useAdditionalBlitProperties();
BlitCommandsResult result{};
bool firstCommand = true;
for (size_t slice = 0u; slice < blitProperties.copySize.z; ++slice) {
auto srcAddress = calculateBlitCommandSourceBaseAddressCopyRegion(blitProperties, slice);
auto dstAddress = calculateBlitCommandDestinationBaseAddressCopyRegion(blitProperties, slice);
auto heightToCopy = blitProperties.copySize.y;
while (heightToCopy > 0) {
auto height = static_cast<uint32_t>(std::min(heightToCopy, static_cast<size_t>(maxHeightToCopy)));
auto widthToCopy = blitProperties.copySize.x;
bool lastIteration = (slice == blitProperties.copySize.z - 1) && ((heightToCopy - height) == 0);
while (widthToCopy > 0) {
auto tmpCmd = bltCmd;
auto width = static_cast<uint32_t>(std::min(widthToCopy, static_cast<size_t>(maxWidthToCopy)));
bltCmd.setSourceBaseAddress(srcAddress);
bltCmd.setDestinationBaseAddress(dstAddress);
bltCmd.setDestinationX2CoordinateRight(width);
bltCmd.setDestinationY2CoordinateBottom(height);
bool lastCommand = lastIteration && ((widthToCopy - width) == 0);
appendBlitCommandsForBuffer(blitProperties, bltCmd, rootDeviceEnvironment);
tmpCmd.setSourceBaseAddress(srcAddress);
tmpCmd.setDestinationBaseAddress(dstAddress);
tmpCmd.setDestinationX2CoordinateRight(width);
tmpCmd.setDestinationY2CoordinateBottom(height);
appendBlitCommandsForBuffer(blitProperties, tmpCmd, rootDeviceEnvironment);
if (useAdditionalBlitProperties && (firstCommand || lastCommand)) {
applyAdditionalBlitProperties(blitProperties, tmpCmd, rootDeviceEnvironment, lastCommand);
firstCommand = false;
}
auto cmd = linearStream.getSpaceForCmd<typename GfxFamily::XY_COPY_BLT>();
*cmd = bltCmd;
*cmd = tmpCmd;
if (lastCommand) {
result.lastBlitCommand = cmd;
}
dispatchPostBlitCommand(linearStream, rootDeviceEnvironment);
srcAddress += width;
@@ -497,6 +543,7 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitCommandsForBufferRegion(const Bl
dstAddress += (blitProperties.dstRowPitch * (height - 1));
}
}
return result;
}
template <typename GfxFamily>
@@ -601,11 +648,11 @@ template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::appendBlitFillCommand(const BlitProperties &blitProperties, typename GfxFamily::XY_COLOR_BLT &blitCmd) {}
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryColorFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
BlitCommandsResult BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryColorFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
if (blitProperties.fillPatternSize == 1) {
NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(blitProperties, linearStream, rootDeviceEnvironment);
return NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(blitProperties, linearStream, rootDeviceEnvironment);
} else {
NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(blitProperties, linearStream, rootDeviceEnvironment);
return NEO::BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryFill(blitProperties, linearStream, rootDeviceEnvironment);
}
}

24
shared/source/helpers/blit_commands_helper_pvc_and_later.inl
View File

@@ -12,9 +12,11 @@
namespace NEO {
template <typename GfxFamily>
void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
BlitCommandsResult BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(const BlitProperties &blitProperties, LinearStream &linearStream, RootDeviceEnvironment &rootDeviceEnvironment) {
using MEM_SET = typename Family::MEM_SET;
auto blitCmd = Family::cmdInitMemSet;
const auto maxBlitSetWidth = getMaxBlitSetWidth(rootDeviceEnvironment);
const auto maxBlitSetHeight = getMaxBlitSetHeight(rootDeviceEnvironment);
auto mocs = rootDeviceEnvironment.getGmmHelper()->getL3EnabledMOCS();
if (debugManager.flags.OverrideBlitterMocs.get() != -1) {
@@ -34,25 +36,26 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(const BlitPropert
const bool useAdditionalBlitProperties = rootDeviceEnvironment.getHelper<ProductHelper>().useAdditionalBlitProperties();
auto sizeToFill = blitProperties.copySize.x;
uint64_t sizeToFill = blitProperties.copySize.x;
uint64_t offset = blitProperties.dstOffset.x;
BlitCommandsResult result{};
bool firstCommand = true;
while (sizeToFill != 0) {
auto tmpCmd = blitCmd;
tmpCmd.setDestinationStartAddress(ptrOffset(blitProperties.dstAllocation->getGpuAddress(), static_cast<size_t>(offset)));
size_t height = 0;
size_t width = 0;
if (sizeToFill <= BlitterConstants::maxBlitSetWidth) {
uint64_t height = 0;
uint64_t width = 0;
if (sizeToFill <= maxBlitSetWidth) {
width = sizeToFill;
height = 1;
} else {
width = BlitterConstants::maxBlitSetWidth;
height = std::min<size_t>((sizeToFill / width), BlitterConstants::maxBlitSetHeight);
width = maxBlitSetWidth;
height = std::min<uint64_t>((sizeToFill / width), maxBlitSetHeight);
if (height > 1) {
tmpCmd.setFillType(MEM_SET::FILL_TYPE::FILL_TYPE_MATRIX_FILL);
}
}
auto blitSize = width * height;
auto blitSize = static_cast<uint64_t>(width * height);
auto lastCommand = (sizeToFill - blitSize == 0);
tmpCmd.setFillWidth(static_cast<uint32_t>(width));
tmpCmd.setFillHeight(static_cast<uint32_t>(height));
@@ -66,10 +69,13 @@ void BlitCommandsHelper<GfxFamily>::dispatchBlitMemoryByteFill(const BlitPropert
auto cmd = linearStream.getSpaceForCmd<MEM_SET>();
*cmd = tmpCmd;
if (lastCommand) {
result.lastBlitCommand = cmd;
}
offset += blitSize;
sizeToFill -= blitSize;
}
return result;
}
} // namespace NEO

1
shared/source/helpers/blit_properties.h
View File

@@ -85,6 +85,7 @@ struct BlitProperties {
GraphicsAllocation *dstAllocation = nullptr;
GraphicsAllocation *srcAllocation = nullptr;
GraphicsAllocation *clearColorAllocation = nullptr;
void *lastBlitCommand = nullptr;
uint32_t *fillPattern = nullptr;
uint64_t dstGpuAddress = 0;
uint64_t srcGpuAddress = 0;

13
shared/source/helpers/in_order_cmd_helpers.h
View File

@@ -141,7 +141,11 @@ enum class PatchCmdType {
sdi,
semaphore,
walker,
pipeControl
pipeControl,
xyCopyBlt,
xyBlockCopyBlt,
xyColorBlt,
memSet
};
template <typename GfxFamily>
@@ -173,6 +177,12 @@ struct PatchCmd {
case PatchCmdType::pipeControl:
patchPipeControl(appendCounterValue);
break;
case PatchCmdType::xyCopyBlt:
case PatchCmdType::xyBlockCopyBlt:
case PatchCmdType::xyColorBlt:
case PatchCmdType::memSet:
patchBlitterCommand(appendCounterValue, patchCmdType);
break;
default:
UNRECOVERABLE_IF(true);
break;
@@ -218,6 +228,7 @@ struct PatchCmd {
}
void patchComputeWalker(uint64_t appendCounterValue);
void patchBlitterCommand(uint64_t appendCounterValue, PatchCmdType patchCmdType);
void patchPipeControl(uint64_t appendCounterValue) {
auto pcCmd = reinterpret_cast<typename GfxFamily::PIPE_CONTROL *>(cmd1);