refactor: add ImplicitScaling stubs

Related-To: NEO-8210

Signed-off-by: Dunajski, Bartosz <[email protected]>

Author: BartoszDunajski

shared/source/command_container/CMakeLists.txt

@@ -19,6 +19,7 @@ set(NEO_CORE_COMMAND_CONTAINER
     ${CMAKE_CURRENT_SOURCE_DIR}/encode_surface_state.h
     ${CMAKE_CURRENT_SOURCE_DIR}/implicit_scaling.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/implicit_scaling.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/implicit_scaling_before_xe_hp.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/definitions/encode_surface_state_args_base.h
     ${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}encode_surface_state.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/definitions${BRANCH_DIR_SUFFIX}encode_surface_state_args.h

shared/source/command_container/implicit_scaling_before_xe_hp.inl

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/command_container/implicit_scaling.h"
+#include "shared/source/helpers/gfx_core_helper.h"
+
+namespace NEO {
+
+template <typename GfxFamily>
+template <typename WalkerType>
+size_t ImplicitScalingDispatch<GfxFamily>::getSize(bool apiSelfCleanup, bool preferStaticPartitioning, const DeviceBitfield &devices, const Vec3<size_t> &groupStart, const Vec3<size_t> &groupCount) {
+    return 0;
+}
+
+template <typename GfxFamily>
+template <typename WalkerType>
+void ImplicitScalingDispatch<GfxFamily>::dispatchCommands(LinearStream &commandStream, WalkerType &walkerCmd, void **outWalkerPtr, const DeviceBitfield &devices, NEO::RequiredPartitionDim requiredPartitionDim,
+                                                          uint32_t &partitionCount, bool useSecondaryBatchBuffer, bool apiSelfCleanup, bool dcFlush, bool forceExecutionOnSingleTile, uint64_t workPartitionAllocationGpuVa,
+                                                          const HardwareInfo &hwInfo) {
+}
+
+template <typename GfxFamily>
+bool &ImplicitScalingDispatch<GfxFamily>::getPipeControlStallRequired() {
+    return ImplicitScalingDispatch<GfxFamily>::pipeControlStallRequired;
+}
+
+template <typename GfxFamily>
+size_t ImplicitScalingDispatch<GfxFamily>::getBarrierSize(const RootDeviceEnvironment &rootDeviceEnvironment, bool apiSelfCleanup, bool usePostSync) {
+    return 0;
+}
+
+template <typename GfxFamily>
+void ImplicitScalingDispatch<GfxFamily>::dispatchBarrierCommands(LinearStream &commandStream, const DeviceBitfield &devices, PipeControlArgs &flushArgs, const RootDeviceEnvironment &rootDeviceEnvironment,
+                                                                 uint64_t gpuAddress, uint64_t immediateData, bool apiSelfCleanup, bool useSecondaryBatchBuffer) {
+}
+
+template <typename GfxFamily>
+inline size_t ImplicitScalingDispatch<GfxFamily>::getRegisterConfigurationSize() {
+    return 0;
+}
+
+template <typename GfxFamily>
+inline void ImplicitScalingDispatch<GfxFamily>::dispatchRegisterConfiguration(LinearStream &commandStream, uint64_t workPartitionSurfaceAddress, uint32_t addressOffset) {
+}
+
+template <typename GfxFamily>
+inline size_t ImplicitScalingDispatch<GfxFamily>::getOffsetRegisterSize() {
+    return 0;
+}
+
+template <typename GfxFamily>
+inline void ImplicitScalingDispatch<GfxFamily>::dispatchOffsetRegister(LinearStream &commandStream, uint32_t addressOffset) {
+}
+
+template <typename GfxFamily>
+inline uint32_t ImplicitScalingDispatch<GfxFamily>::getImmediateWritePostSyncOffset() {
+    return sizeof(uint64_t);
+}
+
+template <typename GfxFamily>
+inline uint32_t ImplicitScalingDispatch<GfxFamily>::getTimeStampPostSyncOffset() {
+    return static_cast<uint32_t>(GfxCoreHelperHw<GfxFamily>::getSingleTimestampPacketSizeHw());
+}
+
+template <typename GfxFamily>
+inline bool ImplicitScalingDispatch<GfxFamily>::platformSupportsImplicitScaling(const RootDeviceEnvironment &rootDeviceEnvironment) {
+    return false;
+}
+
+template <>
+bool ImplicitScalingDispatch<Family>::pipeControlStallRequired = true;
+
+template struct ImplicitScalingDispatch<Family>;
+template void ImplicitScalingDispatch<Family>::dispatchCommands<Family::DefaultWalkerType>(LinearStream &commandStream, Family::DefaultWalkerType &walkerCmd, void **outWalkerPtr, const DeviceBitfield &devices, NEO::RequiredPartitionDim requiredPartitionDim, uint32_t &partitionCount, bool useSecondaryBatchBuffer, bool apiSelfCleanup, bool dcFlush, bool forceExecutionOnSingleTile, uint64_t workPartitionAllocationGpuVa, const HardwareInfo &hwInfo);
+template size_t ImplicitScalingDispatch<Family>::getSize<Family::DefaultWalkerType>(bool apiSelfCleanup, bool preferStaticPartitioning, const DeviceBitfield &devices, const Vec3<size_t> &groupStart, const Vec3<size_t> &groupCount);
+
+} // namespace NEO

shared/source/gen11/command_encoder_gen11.cpp

@@ -81,3 +81,5 @@ template struct EncodeL3State<Family>;
 template void EncodeDispatchKernel<Family>::programBarrierEnable<Family::INTERFACE_DESCRIPTOR_DATA>(Family::INTERFACE_DESCRIPTOR_DATA &interfaceDescriptor, uint32_t value, const HardwareInfo &hwInfo);
 template void InOrderPatchCommandHelpers::PatchCmd<Family>::patchComputeWalker(uint64_t appendCounterValue);
 } // namespace NEO
+
+#include "shared/source/command_container/implicit_scaling_before_xe_hp.inl"

shared/source/gen12lp/command_encoder_gen12lp.cpp

@@ -121,3 +121,5 @@ template struct EncodeL3State<Family>;
 template void EncodeDispatchKernel<Family>::programBarrierEnable<Family::INTERFACE_DESCRIPTOR_DATA>(Family::INTERFACE_DESCRIPTOR_DATA &interfaceDescriptor, uint32_t value, const HardwareInfo &hwInfo);
 template void InOrderPatchCommandHelpers::PatchCmd<Family>::patchComputeWalker(uint64_t appendCounterValue);
 } // namespace NEO
+
+#include "shared/source/command_container/implicit_scaling_before_xe_hp.inl"

shared/source/gen8/command_encoder_gen8.cpp

@@ -65,3 +65,5 @@ template struct EncodeL3State<Family>;
 template void EncodeDispatchKernel<Family>::programBarrierEnable<Family::INTERFACE_DESCRIPTOR_DATA>(Family::INTERFACE_DESCRIPTOR_DATA &interfaceDescriptor, uint32_t value, const HardwareInfo &hwInfo);
 template void InOrderPatchCommandHelpers::PatchCmd<Family>::patchComputeWalker(uint64_t appendCounterValue);
 } // namespace NEO
+
+#include "shared/source/command_container/implicit_scaling_before_xe_hp.inl"

shared/source/gen9/command_encoder_gen9.cpp

@@ -66,3 +66,5 @@ template struct EncodeL3State<Family>;
 template void EncodeDispatchKernel<Family>::programBarrierEnable<Family::INTERFACE_DESCRIPTOR_DATA>(Family::INTERFACE_DESCRIPTOR_DATA &interfaceDescriptor, uint32_t value, const HardwareInfo &hwInfo);
 template void InOrderPatchCommandHelpers::PatchCmd<Family>::patchComputeWalker(uint64_t appendCounterValue);
 } // namespace NEO
+
+#include "shared/source/command_container/implicit_scaling_before_xe_hp.inl"

shared/test/unit_test/command_container/command_encoder_tests.cpp

@@ -7,12 +7,14 @@
 
 #include "shared/source/command_container/command_encoder.h"
 #include "shared/source/command_container/encode_surface_state.h"
+#include "shared/source/command_container/implicit_scaling.h"
 #include "shared/source/command_stream/linear_stream.h"
 #include "shared/source/gmm_helper/gmm_helper.h"
 #include "shared/source/gmm_helper/gmm_lib.h"
 #include "shared/source/helpers/definitions/command_encoder_args.h"
 #include "shared/source/helpers/gfx_core_helper.h"
 #include "shared/source/helpers/in_order_cmd_helpers.h"
+#include "shared/source/helpers/pipe_control_args.h"
 #include "shared/source/memory_manager/graphics_allocation.h"
 #include "shared/source/memory_manager/memory_manager.h"
 #include "shared/source/os_interface/product_helper.h"
@@ -475,4 +477,51 @@ HWTEST2_F(CommandEncoderTests, whenForcingLowQualityFilteringAndAppendSamplerSta
     EXPECT_EQ(SAMPLER_STATE::LOW_QUALITY_FILTER_DISABLE, state.getLowQualityFilter());
     productHelper.adjustSamplerState(&state, *defaultHwInfo);
     EXPECT_EQ(SAMPLER_STATE::LOW_QUALITY_FILTER_ENABLE, state.getLowQualityFilter());
+}
+
+HWTEST2_F(CommandEncoderTests, whenAskingForImplicitScalingValuesThenAlwaysReturnStubs, IsAtMostGen12lp) {
+    using WalkerType = typename FamilyType::DefaultWalkerType;
+
+    MockExecutionEnvironment executionEnvironment{};
+    auto rootExecEnv = executionEnvironment.rootDeviceEnvironments[0].get();
+
+    uint8_t buffer[128] = {};
+    LinearStream linearStream(buffer, sizeof(buffer));
+
+    WalkerType walkerCmd = {};
+
+    DeviceBitfield deviceBitField = 1;
+    uint32_t partitionCount = 1;
+
+    Vec3<size_t> vec3 = {1, 1, 1};
+
+    EXPECT_EQ(0u, ImplicitScalingDispatch<FamilyType>::template getSize<WalkerType>(false, false, deviceBitField, vec3, vec3));
+
+    void *ptr = nullptr;
+    ImplicitScalingDispatch<FamilyType>::dispatchCommands(linearStream, walkerCmd, &ptr, deviceBitField, RequiredPartitionDim::x, partitionCount, false, false, false, false, 0, *defaultHwInfo);
+    EXPECT_EQ(0u, linearStream.getUsed());
+
+    EXPECT_TRUE(ImplicitScalingDispatch<FamilyType>::getPipeControlStallRequired());
+
+    EXPECT_EQ(0u, ImplicitScalingDispatch<FamilyType>::getBarrierSize(*rootExecEnv, false, false));
+
+    PipeControlArgs pcArgs = {};
+    ImplicitScalingDispatch<FamilyType>::dispatchBarrierCommands(linearStream, deviceBitField, pcArgs, *rootExecEnv, 0, 0, false, false);
+    EXPECT_EQ(0u, linearStream.getUsed());
+
+    EXPECT_EQ(0u, ImplicitScalingDispatch<FamilyType>::getRegisterConfigurationSize());
+
+    ImplicitScalingDispatch<FamilyType>::dispatchRegisterConfiguration(linearStream, 0, 0);
+    EXPECT_EQ(0u, linearStream.getUsed());
+
+    EXPECT_EQ(0u, ImplicitScalingDispatch<FamilyType>::getOffsetRegisterSize());
+
+    ImplicitScalingDispatch<FamilyType>::dispatchOffsetRegister(linearStream, 0);
+    EXPECT_EQ(0u, linearStream.getUsed());
+
+    EXPECT_EQ(static_cast<uint32_t>(sizeof(uint64_t)), ImplicitScalingDispatch<FamilyType>::getImmediateWritePostSyncOffset());
+
+    EXPECT_EQ(static_cast<uint32_t>(GfxCoreHelperHw<FamilyType>::getSingleTimestampPacketSizeHw()), ImplicitScalingDispatch<FamilyType>::getTimeStampPostSyncOffset());
+
+    EXPECT_FALSE(ImplicitScalingDispatch<FamilyType>::platformSupportsImplicitScaling(*rootExecEnv));
 }