Add space calculation for SBA instruction

SebastianLuzynski · Compute-Runtime-Automation · commit c389db6f1c9e · 2021-07-13T12:19:30.000+02:00
Signed-off-by: Sebastian Luzynski &lt;sebastian.jozef.luzynski@intel.com&gt;
diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl
@@ -2006,7 +2006,6 @@ void CommandListCoreFamily<gfxCoreFamily>::programStateBaseAddress(NEO::CommandC
     args.hdcPipelineFlush = true;
     args.textureCacheInvalidationEnable = true;
     NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControl(*commandContainer.getCommandStream(), args);
-    auto &hwInfo = device->getHwInfo();
 
     STATE_BASE_ADDRESS sba;
     NEO::EncodeStateBaseAddress<GfxFamily>::encode(commandContainer, sba);
@@ -2021,8 +2020,6 @@ void CommandListCoreFamily<gfxCoreFamily>::programStateBaseAddress(NEO::CommandC
 
         device->getL0Debugger()->captureStateBaseAddress(commandContainer, sbaAddresses);
     }
-
-    NEO::EncodeStateBaseAddress<GfxFamily>::addStateBaseAddressIfRequired(commandContainer, sba, hwInfo);
 }
 
 template <GFXCORE_FAMILY gfxCoreFamily>
diff --git a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_plus.inl b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_plus.inl
@@ -11,6 +11,7 @@
 #include "shared/source/helpers/api_specific_config.h"
 #include "shared/source/helpers/hw_helper.h"
 #include "shared/source/helpers/state_base_address.h"
+#include "shared/source/os_interface/hw_info_config.h"
 
 #include "level_zero/core/source/cmdqueue/cmdqueue_hw.h"
 
@@ -48,6 +49,14 @@ void CommandQueueHw<gfxCoreFamily>::programStateBaseAddress(uint64_t gsba, bool
                                                                         NEO::MemoryCompressionState::NotApplicable,
                                                                         false,
                                                                         1u);
+        *pSbaCmd = sbaCmd;
+
+        auto &hwInfo = neoDevice->getHardwareInfo();
+        auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily);
+        if (hwInfoConfig.isAdditionalStateBaseAddressWARequired(hwInfo)) {
+            auto pSbaCmd = static_cast<STATE_BASE_ADDRESS *>(commandStream.getSpace(sizeof(STATE_BASE_ADDRESS)));
+            *pSbaCmd = sbaCmd;
+        }
 
         if (NEO::Debugger::isDebugEnabled(internalUsage) && device->getL0Debugger()) {
 
@@ -61,7 +70,6 @@ void CommandQueueHw<gfxCoreFamily>::programStateBaseAddress(uint64_t gsba, bool
 
             device->getL0Debugger()->programSbaTrackingCommands(commandStream, sbaAddresses);
         }
-        *pSbaCmd = sbaCmd;
 
         auto heap = neoDevice->getBindlessHeapsHelper()->getHeap(NEO::BindlessHeapsHelper::GLOBAL_SSH);
         auto cmd = GfxFamily::cmdInitStateBindingTablePoolAlloc;
@@ -81,12 +89,21 @@ size_t CommandQueueHw<gfxCoreFamily>::estimateStateBaseAddressCmdSize() {
     using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS;
     using PIPE_CONTROL = typename GfxFamily::PIPE_CONTROL;
     using _3DSTATE_BINDING_TABLE_POOL_ALLOC = typename GfxFamily::_3DSTATE_BINDING_TABLE_POOL_ALLOC;
+
+    NEO::Device *neoDevice = device->getNEODevice();
+    auto &hwInfo = neoDevice->getHardwareInfo();
+    auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily);
+    size_t size = 0;
+
     if (NEO::ApiSpecificConfig::getBindlessConfiguration()) {
-        size_t size = sizeof(STATE_BASE_ADDRESS) + sizeof(PIPE_CONTROL) + sizeof(_3DSTATE_BINDING_TABLE_POOL_ALLOC);
-        return size;
-    } else {
-        return 0;
+        size += sizeof(STATE_BASE_ADDRESS) + sizeof(PIPE_CONTROL) + sizeof(_3DSTATE_BINDING_TABLE_POOL_ALLOC);
+
+        if (hwInfoConfig.isAdditionalStateBaseAddressWARequired(hwInfo)) {
+            size += sizeof(STATE_BASE_ADDRESS);
+        }
     }
+
+    return size;
 }
 
 constexpr uint32_t maxPtssIndex = 15u;
diff --git a/shared/source/command_container/command_encoder.h b/shared/source/command_container/command_encoder.h
@@ -219,7 +219,7 @@ struct EncodeStateBaseAddress {
     using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS;
     static void encode(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd);
     static void encode(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, uint32_t statelessMocsIndex, bool useGlobalAtomics);
-    static void addStateBaseAddressIfRequired(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, const HardwareInfo &hwInfo);
+    static size_t getRequiredSizeForStateBaseAddress(Device &device, CommandContainer &container);
 };
 
 template <typename GfxFamily>
diff --git a/shared/source/command_container/command_encoder_bdw_plus.inl b/shared/source/command_container/command_encoder_bdw_plus.inl
@@ -387,7 +387,9 @@ void EncodeStateBaseAddress<Family>::encode(CommandContainer &container, STATE_B
 }
 
 template <typename Family>
-void EncodeStateBaseAddress<Family>::addStateBaseAddressIfRequired(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, const HardwareInfo &hwInfo) {}
+size_t EncodeStateBaseAddress<Family>::getRequiredSizeForStateBaseAddress(Device &device, CommandContainer &container) {
+    return sizeof(typename Family::STATE_BASE_ADDRESS) + 2 * EncodeWA<Family>::getAdditionalPipelineSelectSize(device);
+}
 
 template <typename Family>
 void EncodeL3State<Family>::encode(CommandContainer &container, bool enableSLM) {
diff --git a/shared/source/command_container/command_encoder_xehp_plus.inl b/shared/source/command_container/command_encoder_xehp_plus.inl
@@ -25,6 +25,7 @@
 #include "shared/source/helpers/state_base_address.h"
 #include "shared/source/kernel/dispatch_kernel_encoder_interface.h"
 #include "shared/source/kernel/kernel_descriptor.h"
+#include "shared/source/os_interface/hw_info_config.h"
 
 #include "pipe_control_args.h"
 
@@ -472,6 +473,13 @@ void EncodeStateBaseAddress<Family>::encode(CommandContainer &container, STATE_B
     auto pCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
     *pCmd = sbaCmd;
 
+    auto &hwInfo = container.getDevice()->getHardwareInfo();
+    auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
+    if (hwInfoConfig.isAdditionalStateBaseAddressWARequired(hwInfo)) {
+        pCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
+        *pCmd = sbaCmd;
+    }
+
     if (container.isHeapDirty(HeapType::SURFACE_STATE)) {
         auto heap = container.getIndirectHeap(HeapType::SURFACE_STATE);
         auto cmd = Family::cmdInitStateBindingTablePoolAlloc;
@@ -485,7 +493,21 @@ void EncodeStateBaseAddress<Family>::encode(CommandContainer &container, STATE_B
 }
 
 template <typename Family>
-void EncodeStateBaseAddress<Family>::addStateBaseAddressIfRequired(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, const HardwareInfo &hwInfo) {}
+size_t EncodeStateBaseAddress<Family>::getRequiredSizeForStateBaseAddress(Device &device, CommandContainer &container) {
+    auto &hwInfo = device.getHardwareInfo();
+    auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
+
+    size_t size = sizeof(typename Family::STATE_BASE_ADDRESS);
+    if (hwInfoConfig.isAdditionalStateBaseAddressWARequired(hwInfo)) {
+        size += sizeof(typename Family::STATE_BASE_ADDRESS);
+    }
+
+    if (container.isHeapDirty(HeapType::SURFACE_STATE)) {
+        size += sizeof(typename Family::_3DSTATE_BINDING_TABLE_POOL_ALLOC);
+    }
+
+    return size;
+}
 
 template <typename Family>
 void EncodeComputeMode<Family>::adjustComputeMode(LinearStream &csr, void *const stateComputeModePtr, StateComputeModeProperties &properties) {
@@ -650,5 +672,4 @@ template <typename Family>
 inline size_t EncodeWA<Family>::getAdditionalPipelineSelectSize(Device &device) {
     return 0u;
 }
-
 } // namespace NEO
diff --git a/shared/source/command_stream/command_stream_receiver_hw.h b/shared/source/command_stream/command_stream_receiver_hw.h
@@ -55,7 +55,7 @@ class CommandStreamReceiverHw : public CommandStreamReceiver {
     void addBatchBufferStart(MI_BATCH_BUFFER_START *commandBufferMemory, uint64_t startAddress, bool secondary);
     static void alignToCacheLine(LinearStream &commandStream);
 
-    size_t getRequiredStateBaseAddressSize() const;
+    size_t getRequiredStateBaseAddressSize(const Device &device) const;
     size_t getRequiredCmdStreamSize(const DispatchFlags &dispatchFlags, Device &device);
     size_t getRequiredCmdStreamSizeAligned(const DispatchFlags &dispatchFlags, Device &device);
     size_t getRequiredCmdSizeForPreamble(Device &device) const;
diff --git a/shared/source/command_stream/command_stream_receiver_hw_base.inl b/shared/source/command_stream/command_stream_receiver_hw_base.inl
@@ -774,7 +774,7 @@ size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSizeAligned(const
 template <typename GfxFamily>
 size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSize(const DispatchFlags &dispatchFlags, Device &device) {
     size_t size = getRequiredCmdSizeForPreamble(device);
-    size += getRequiredStateBaseAddressSize();
+    size += getRequiredStateBaseAddressSize(device);
     if (!this->isStateSipSent || device.isDebuggerActive()) {
         size += PreemptionHelper::getRequiredStateSipCmdSize<GfxFamily>(device);
     }
diff --git a/shared/source/command_stream/command_stream_receiver_hw_bdw_plus.inl b/shared/source/command_stream/command_stream_receiver_hw_bdw_plus.inl
@@ -35,7 +35,7 @@ inline void CommandStreamReceiverHw<GfxFamily>::programL3(LinearStream &csr, Dis
 }
 
 template <typename GfxFamily>
-size_t CommandStreamReceiverHw<GfxFamily>::getRequiredStateBaseAddressSize() const {
+size_t CommandStreamReceiverHw<GfxFamily>::getRequiredStateBaseAddressSize(const Device &device) const {
     using PIPELINE_SELECT = typename GfxFamily::PIPELINE_SELECT;
 
     size_t size = 0;
diff --git a/shared/source/command_stream/command_stream_receiver_hw_xehp_plus.inl b/shared/source/command_stream/command_stream_receiver_hw_xehp_plus.inl
@@ -11,6 +11,7 @@
 #include "shared/source/gmm_helper/gmm.h"
 #include "shared/source/helpers/preamble.h"
 #include "shared/source/kernel/grf_config.h"
+#include "shared/source/os_interface/hw_info_config.h"
 #include "shared/source/os_interface/os_interface.h"
 
 namespace NEO {
@@ -25,9 +26,18 @@ template <typename GfxFamily>
 void CommandStreamReceiverHw<GfxFamily>::programL3(LinearStream &csr, DispatchFlags &dispatchFlags, uint32_t &newL3Config) {}
 
 template <typename GfxFamily>
-size_t CommandStreamReceiverHw<GfxFamily>::getRequiredStateBaseAddressSize() const {
-    return sizeof(typename GfxFamily::STATE_BASE_ADDRESS) + sizeof(typename GfxFamily::_3DSTATE_BINDING_TABLE_POOL_ALLOC) +
-           sizeof(PIPE_CONTROL);
+size_t CommandStreamReceiverHw<GfxFamily>::getRequiredStateBaseAddressSize(const Device &device) const {
+    size_t size = sizeof(typename GfxFamily::STATE_BASE_ADDRESS);
+    size += sizeof(typename GfxFamily::_3DSTATE_BINDING_TABLE_POOL_ALLOC);
+    size += sizeof(PIPE_CONTROL);
+
+    auto &hwInfo = *device.getRootDeviceEnvironment().getHardwareInfo();
+    auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
+    if (hwInfoConfig.isAdditionalStateBaseAddressWARequired(hwInfo)) {
+        size += sizeof(typename GfxFamily::STATE_BASE_ADDRESS);
+    }
+
+    return size;
 }
 
 template <typename GfxFamily>
diff --git a/shared/test/unit_test/encoders/CMakeLists.txt b/shared/test/unit_test/encoders/CMakeLists.txt
@@ -6,6 +6,7 @@
 
 target_sources(${TARGET_NAME} PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_command_encoder.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_atomic.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_command_buffer.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_dispatch_kernel.cpp
diff --git a/shared/test/unit_test/encoders/test_command_encoder.cpp b/shared/test/unit_test/encoders/test_command_encoder.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/command_container/cmdcontainer.h"
+#include "shared/test/common/fixtures/device_fixture.h"
+
+#include "test.h"
+
+using namespace NEO;
+
+HWTEST_EXCLUDE_PRODUCT(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_Platforms, IGFX_ELKHARTLAKE);
+HWTEST_EXCLUDE_PRODUCT(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_Platforms, IGFX_TIGERLAKE_LP);
+HWTEST_EXCLUDE_PRODUCT(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_Platforms, IGFX_LAKEFIELD);
+HWTEST_EXCLUDE_PRODUCT(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_Platforms, IGFX_ROCKETLAKE);
+HWTEST_EXCLUDE_PRODUCT(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned_Platforms, IGFX_ICELAKE_LP);
+
+using CommandEncoderTest = Test<DeviceFixture>;
+
+using Platforms = IsWithinProducts<IGFX_SKYLAKE, IGFX_ROCKETLAKE>;
+HWTEST2_F(CommandEncoderTest, whenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, Platforms) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 76ul);
+}
+
+HWTEST2_F(CommandEncoderTest, givenGLLPWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsTGLLP) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 200ul);
+}
+
+HWTEST2_F(CommandEncoderTest, givenDG1WhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsDG1) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 200ul);
+}
+
+HWTEST2_F(CommandEncoderTest, givenEHLWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsEHL) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 88ul);
+}
+
+HWTEST2_F(CommandEncoderTest, givenRKLWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsRKL) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 104ul);
+}
+
+HWTEST2_F(CommandEncoderTest, givenLFKWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsLKF) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 88ul);
+}
+
+HWTEST2_F(CommandEncoderTest, givenICLLPWhenGettingRequiredSizeForStateBaseAddressCommandThenCorrectSizeIsReturned, IsICLLP) {
+    auto container = CommandContainer();
+    size_t size = EncodeStateBaseAddress<FamilyType>::getRequiredSizeForStateBaseAddress(*pDevice, container);
+    EXPECT_EQ(size, 88ul);
+}

Original file line number	Diff line number	Diff line change
`@@ -2006,7 +2006,6 @@ void CommandListCoreFamily<gfxCoreFamily>::programStateBaseAddress(NEO::CommandC`
`2006`	`2006`	`args.hdcPipelineFlush = true;`
`2007`	`2007`	`args.textureCacheInvalidationEnable = true;`
`2008`	`2008`	`NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControl(*commandContainer.getCommandStream(), args);`
`2009`		`- auto &hwInfo = device->getHwInfo();`
`2010`	`2009`
`2011`	`2010`	`STATE_BASE_ADDRESS sba;`
`2012`	`2011`	`NEO::EncodeStateBaseAddress<GfxFamily>::encode(commandContainer, sba);`
`@@ -2021,8 +2020,6 @@ void CommandListCoreFamily<gfxCoreFamily>::programStateBaseAddress(NEO::CommandC`
`2021`	`2020`
`2022`	`2021`	`device->getL0Debugger()->captureStateBaseAddress(commandContainer, sbaAddresses);`
`2023`	`2022`	`}`
`2024`		`-`
`2025`		`- NEO::EncodeStateBaseAddress<GfxFamily>::addStateBaseAddressIfRequired(commandContainer, sba, hwInfo);`
`2026`	`2023`	`}`
`2027`	`2024`
`2028`	`2025`	`template <GFXCORE_FAMILY gfxCoreFamily>`
Original file line number	Diff line number	Diff line change
`@@ -387,7 +387,9 @@ void EncodeStateBaseAddress<Family>::encode(CommandContainer &container, STATE_B`
`387`	`387`	`}`
`388`	`388`
`389`	`389`	`template <typename Family>`
`390`		`-void EncodeStateBaseAddress<Family>::addStateBaseAddressIfRequired(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, const HardwareInfo &hwInfo) {}`
	`390`	`+size_t EncodeStateBaseAddress<Family>::getRequiredSizeForStateBaseAddress(Device &device, CommandContainer &container) {`
	`391`	`+ return sizeof(typename Family::STATE_BASE_ADDRESS) + 2 * EncodeWA<Family>::getAdditionalPipelineSelectSize(device);`
	`392`	`+}`
`391`	`393`
`392`	`394`	`template <typename Family>`
`393`	`395`	`void EncodeL3State<Family>::encode(CommandContainer &container, bool enableSLM) {`
Original file line number	Diff line number	Diff line change
`@@ -774,7 +774,7 @@ size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSizeAligned(const`
`774`	`774`	`template <typename GfxFamily>`
`775`	`775`	`size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSize(const DispatchFlags &dispatchFlags, Device &device) {`
`776`	`776`	`size_t size = getRequiredCmdSizeForPreamble(device);`
`777`		`- size += getRequiredStateBaseAddressSize();`
	`777`	`+ size += getRequiredStateBaseAddressSize(device);`
`778`	`778`	`if (!this->isStateSipSent \|\| device.isDebuggerActive()) {`
`779`	`779`	`size += PreemptionHelper::getRequiredStateSipCmdSize<GfxFamily>(device);`
`780`	`780`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ inline void CommandStreamReceiverHw<GfxFamily>::programL3(LinearStream &csr, Dis`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`template <typename GfxFamily>`
`38`		`-size_t CommandStreamReceiverHw<GfxFamily>::getRequiredStateBaseAddressSize() const {`
	`38`	`+size_t CommandStreamReceiverHw<GfxFamily>::getRequiredStateBaseAddressSize(const Device &device) const {`
`39`	`39`	`using PIPELINE_SELECT = typename GfxFamily::PIPELINE_SELECT;`
`40`	`40`
`41`	`41`	`size_t size = 0;`