Add inline directive to smallest functions

zzdanowicz · Compute-Runtime-Automation · commit 4fa5041f27ac · 2021-06-10T09:27:07.000+02:00
Signed-off-by: Zbigniew Zdanowicz &lt;zbigniew.zdanowicz@intel.com&gt;
diff --git a/opencl/test/unit_test/helpers/timestamp_packet_tests.h b/opencl/test/unit_test/helpers/timestamp_packet_tests.h
@@ -83,7 +83,7 @@ struct TimestampPacketTests : public TimestampPacketSimpleTests {
         auto writeAddress = TimestampPacketHelper::getGpuDependenciesCountGpuAddress(*timestampPacketNode);
 
         EXPECT_EQ(MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_INCREMENT, miAtomicCmd->getAtomicOpcode());
-        EXPECT_EQ(writeAddress, UnitTestHelper<GfxFamily>::getMemoryAddress(*miAtomicCmd));
+        EXPECT_EQ(writeAddress, UnitTestHelper<GfxFamily>::getAtomicMemoryAddress(*miAtomicCmd));
     };
 
     void verifyDependencyCounterValues(TimestampPacketContainer *timestampPacketContainer, uint32_t expectedValue) {
diff --git a/opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp b/opencl/test/unit_test/mem_obj/buffer_bcs_tests.cpp
@@ -527,7 +527,7 @@ HWTEST_TEMPLATED_F(BcsBufferTests, givenWriteBufferEnqueueWhenProgrammingCommand
             miAtomicsCount++;
             auto dataAddress = TimestampPacketHelper::getGpuDependenciesCountGpuAddress(*timestampPacketNode);
             EXPECT_EQ(MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_INCREMENT, miAtomicCmd->getAtomicOpcode());
-            EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getMemoryAddress(*miAtomicCmd));
+            EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));
             EXPECT_EQ(1u, semaphoresCount);
         }
     }
@@ -572,7 +572,7 @@ HWTEST_TEMPLATED_F(BcsBufferTests, givenReadBufferEnqueueWhenProgrammingCommandS
             miAtomicsCount++;
             auto dataAddress = TimestampPacketHelper::getGpuDependenciesCountGpuAddress(*timestampPacketNode);
             EXPECT_EQ(MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_INCREMENT, miAtomicCmd->getAtomicOpcode());
-            EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getMemoryAddress(*miAtomicCmd));
+            EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));
             EXPECT_EQ(1u, semaphoresCount);
         }
     }
diff --git a/shared/source/command_container/command_encoder.h b/shared/source/command_container/command_encoder.h
@@ -332,7 +332,6 @@ struct EncodeAtomic {
                                 uint32_t operand1dword1);
 
     static void setMiAtomicAddress(MI_ATOMIC &atomic, uint64_t writeAddress);
-    static uint64_t getMiAtomicAddress(MI_ATOMIC &atomic);
 };
 
 template <typename GfxFamily>
diff --git a/shared/source/command_container/command_encoder.inl b/shared/source/command_container/command_encoder.inl
@@ -84,7 +84,7 @@ uint32_t EncodeStates<Family>::copySamplerState(IndirectHeap *dsh,
 } // namespace NEO
 
 template <typename Family>
-size_t EncodeStates<Family>::getAdjustStateComputeModeSize() {
+inline size_t EncodeStates<Family>::getAdjustStateComputeModeSize() {
     return 0;
 }
 
@@ -424,7 +424,7 @@ size_t EncodeSurfaceState<Family>::pushBindingTableAndSurfaceStates(IndirectHeap
 }
 
 template <typename Family>
-void EncodeSurfaceState<Family>::encodeExtraCacheSettings(R_SURFACE_STATE *surfaceState, const HardwareInfo &hwInfo) {}
+inline void EncodeSurfaceState<Family>::encodeExtraCacheSettings(R_SURFACE_STATE *surfaceState, const HardwareInfo &hwInfo) {}
 
 template <typename Family>
 void EncodeSurfaceState<Family>::setImageAuxParamsForCCS(R_SURFACE_STATE *surfaceState, Gmm *gmm) {
@@ -528,17 +528,17 @@ void EncodeIndirectParams<Family>::setGlobalWorkSizeIndirect(CommandContainer &c
 }
 
 template <typename Family>
-size_t EncodeIndirectParams<Family>::getCmdsSizeForIndirectParams() {
+inline size_t EncodeIndirectParams<Family>::getCmdsSizeForIndirectParams() {
     return 3 * sizeof(typename Family::MI_LOAD_REGISTER_MEM);
 }
 
 template <typename Family>
-size_t EncodeIndirectParams<Family>::getCmdsSizeForSetGroupCountIndirect() {
+inline size_t EncodeIndirectParams<Family>::getCmdsSizeForSetGroupCountIndirect() {
     return 3 * (sizeof(MI_STORE_REGISTER_MEM));
 }
 
 template <typename Family>
-size_t EncodeIndirectParams<Family>::getCmdsSizeForSetGroupSizeIndirect() {
+inline size_t EncodeIndirectParams<Family>::getCmdsSizeForSetGroupSizeIndirect() {
     return 3 * (sizeof(MI_LOAD_REGISTER_REG) + sizeof(MI_LOAD_REGISTER_IMM) + sizeof(MI_MATH) + sizeof(MI_MATH_ALU_INST_INLINE) + sizeof(MI_STORE_REGISTER_MEM));
 }
 
@@ -565,22 +565,16 @@ void EncodeSempahore<Family>::addMiSemaphoreWaitCommand(LinearStream &commandStr
 }
 
 template <typename Family>
-size_t EncodeSempahore<Family>::getSizeMiSemaphoreWait() {
+inline size_t EncodeSempahore<Family>::getSizeMiSemaphoreWait() {
     return sizeof(MI_SEMAPHORE_WAIT);
 }
 
 template <typename Family>
-void EncodeAtomic<Family>::setMiAtomicAddress(MI_ATOMIC &atomic, uint64_t writeAddress) {
+inline void EncodeAtomic<Family>::setMiAtomicAddress(MI_ATOMIC &atomic, uint64_t writeAddress) {
     atomic.setMemoryAddress(static_cast<uint32_t>(writeAddress & 0x0000FFFFFFFFULL));
     atomic.setMemoryAddressHigh(static_cast<uint32_t>(writeAddress >> 32));
 }
 
-template <typename Family>
-uint64_t EncodeAtomic<Family>::getMiAtomicAddress(MI_ATOMIC &atomic) {
-    uint64_t address = (static_cast<uint64_t>(atomic.getMemoryAddressHigh()) << 32) | (atomic.getMemoryAddress());
-    return address;
-}
-
 template <typename Family>
 void EncodeAtomic<Family>::programMiAtomic(MI_ATOMIC *atomic,
                                            uint64_t writeAddress,
@@ -663,10 +657,10 @@ size_t EncodeMiFlushDW<GfxFamily>::getMiFlushDwCmdSizeForDataWrite() {
 }
 
 template <typename GfxFamily>
-void EncodeMemoryPrefetch<GfxFamily>::programMemoryPrefetch(LinearStream &commandStream, const GraphicsAllocation &graphicsAllocation, uint32_t size, size_t offset, const HardwareInfo &hwInfo) {}
+inline void EncodeMemoryPrefetch<GfxFamily>::programMemoryPrefetch(LinearStream &commandStream, const GraphicsAllocation &graphicsAllocation, uint32_t size, size_t offset, const HardwareInfo &hwInfo) {}
 
 template <typename GfxFamily>
-size_t EncodeMemoryPrefetch<GfxFamily>::getSizeForMemoryPrefetch(size_t size) { return 0u; }
+inline size_t EncodeMemoryPrefetch<GfxFamily>::getSizeForMemoryPrefetch(size_t size) { return 0u; }
 
 template <typename Family>
 void EncodeMiArbCheck<Family>::program(LinearStream &commandStream) {
@@ -675,6 +669,6 @@ void EncodeMiArbCheck<Family>::program(LinearStream &commandStream) {
 }
 
 template <typename Family>
-size_t EncodeMiArbCheck<Family>::getCommandSize() { return sizeof(MI_ARB_CHECK); }
+inline size_t EncodeMiArbCheck<Family>::getCommandSize() { return sizeof(MI_ARB_CHECK); }
 
 } // namespace NEO
diff --git a/shared/source/command_container/command_encoder_bdw_plus.inl b/shared/source/command_container/command_encoder_bdw_plus.inl
@@ -245,12 +245,12 @@ void EncodeMediaInterfaceDescriptorLoad<Family>::encode(CommandContainer &contai
 }
 
 template <typename Family>
-bool EncodeDispatchKernel<Family>::isRuntimeLocalIdsGenerationRequired(uint32_t activeChannels,
-                                                                       size_t *lws,
-                                                                       std::array<uint8_t, 3> walkOrder,
-                                                                       bool requireInputWalkOrder,
-                                                                       uint32_t &requiredWalkOrder,
-                                                                       uint32_t simd) {
+inline bool EncodeDispatchKernel<Family>::isRuntimeLocalIdsGenerationRequired(uint32_t activeChannels,
+                                                                              size_t *lws,
+                                                                              std::array<uint8_t, 3> walkOrder,
+                                                                              bool requireInputWalkOrder,
+                                                                              uint32_t &requiredWalkOrder,
+                                                                              uint32_t simd) {
     requiredWalkOrder = 0u;
     return true;
 }
@@ -312,7 +312,7 @@ void EncodeDispatchKernel<Family>::programBarrierEnable(INTERFACE_DESCRIPTOR_DAT
 }
 
 template <typename Family>
-void EncodeDispatchKernel<Family>::encodeAdditionalWalkerFields(const HardwareInfo &hwInfo, WALKER_TYPE &walkerCmd) {}
+inline void EncodeDispatchKernel<Family>::encodeAdditionalWalkerFields(const HardwareInfo &hwInfo, WALKER_TYPE &walkerCmd) {}
 
 template <typename Family>
 void EncodeDispatchKernel<Family>::appendAdditionalIDDFields(INTERFACE_DESCRIPTOR_DATA *pInterfaceDescriptor, const HardwareInfo &hwInfo, const uint32_t threadsPerThreadGroup, uint32_t slmTotalSize, SlmPolicy slmPolicy) {}
@@ -340,11 +340,11 @@ size_t EncodeDispatchKernel<Family>::estimateEncodeDispatchKernelCmdsSize(Device
 }
 
 template <typename Family>
-void EncodeComputeMode<Family>::adjustComputeMode(LinearStream &csr, void *const stateComputeModePtr, StateComputeModeProperties &properties) {
+inline void EncodeComputeMode<Family>::adjustComputeMode(LinearStream &csr, void *const stateComputeModePtr, StateComputeModeProperties &properties) {
 }
 
 template <typename Family>
-void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &container, const NEO::KernelDescriptor &kernelDescriptor) {
+inline void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &container, const NEO::KernelDescriptor &kernelDescriptor) {
 }
 
 template <typename Family>
@@ -412,8 +412,8 @@ inline size_t EncodeWA<GfxFamily>::getAdditionalPipelineSelectSize(Device &devic
 }
 
 template <typename GfxFamily>
-void EncodeSurfaceState<GfxFamily>::encodeExtraBufferParams(R_SURFACE_STATE *surfaceState, GraphicsAllocation *allocation, GmmHelper *gmmHelper,
-                                                            bool isReadOnly, uint32_t numAvailableDevices, bool useGlobalAtomics, bool areMultipleSubDevicesInContext) {
+inline void EncodeSurfaceState<GfxFamily>::encodeExtraBufferParams(R_SURFACE_STATE *surfaceState, GraphicsAllocation *allocation, GmmHelper *gmmHelper,
+                                                                   bool isReadOnly, uint32_t numAvailableDevices, bool useGlobalAtomics, bool areMultipleSubDevicesInContext) {
     encodeExtraCacheSettings(surfaceState, *gmmHelper->getHardwareInfo());
 }
 
@@ -423,7 +423,7 @@ bool EncodeSurfaceState<GfxFamily>::doBindingTablePrefetch() {
 }
 
 template <typename Family>
-void EncodeSurfaceState<Family>::setCoherencyType(R_SURFACE_STATE *surfaceState, COHERENCY_TYPE coherencyType) {
+inline void EncodeSurfaceState<Family>::setCoherencyType(R_SURFACE_STATE *surfaceState, COHERENCY_TYPE coherencyType) {
     surfaceState->setCoherencyType(coherencyType);
 }
 
diff --git a/shared/source/command_container/encode_compute_mode_bdw_plus.inl b/shared/source/command_container/encode_compute_mode_bdw_plus.inl
@@ -11,25 +11,25 @@
 
 namespace NEO {
 template <typename Family>
-void EncodeStates<Family>::adjustStateComputeMode(LinearStream &csr, uint32_t numGrfRequired, void *const stateComputeModePtr,
-                                                  bool isMultiOsContextCapable, bool requiresCoherency, bool useGlobalAtomics,
-                                                  bool areMultipleSubDevicesInContext, uint32_t threadArbitrationPolicy) {
+inline void EncodeStates<Family>::adjustStateComputeMode(LinearStream &csr, uint32_t numGrfRequired, void *const stateComputeModePtr,
+                                                         bool isMultiOsContextCapable, bool requiresCoherency, bool useGlobalAtomics,
+                                                         bool areMultipleSubDevicesInContext, uint32_t threadArbitrationPolicy) {
 }
 
 template <typename Family>
-void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {
+inline void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {
 }
 
 template <typename Family>
-void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_MEM *pMiLoadReg) {
+inline void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_MEM *pMiLoadReg) {
 }
 
 template <typename Family>
-void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_REG *pMiLoadReg) {
+inline void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_REG *pMiLoadReg) {
 }
 
 template <typename Family>
-bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {
+inline bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {
     return false;
 }
 
diff --git a/shared/source/command_container/encode_compute_mode_tgllp_plus.inl b/shared/source/command_container/encode_compute_mode_tgllp_plus.inl
@@ -21,7 +21,7 @@ void EncodeStates<Family>::adjustStateComputeMode(LinearStream &csr, uint32_t nu
 }
 
 template <typename Family>
-void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {
+inline void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {
     pStoreRegMem->setMmioRemapEnable(true);
 }
 
@@ -43,7 +43,7 @@ void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_REG *pMiLoadReg) {
 }
 
 template <typename Family>
-bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {
+inline bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {
     return (0x2000 <= offset && offset <= 0x27ff) ||
            (0x4200 <= offset && offset <= 0x420f) ||
            (0x4400 <= offset && offset <= 0x441f);
diff --git a/shared/test/common/helpers/unit_test_helper.h b/shared/test/common/helpers/unit_test_helper.h
@@ -45,7 +45,7 @@ struct UnitTestHelper {
 
     static bool isAdditionalMiSemaphoreWait(const typename GfxFamily::MI_SEMAPHORE_WAIT &semaphoreWait);
 
-    static uint64_t getMemoryAddress(const typename GfxFamily::MI_ATOMIC &atomic);
+    static uint64_t getAtomicMemoryAddress(const typename GfxFamily::MI_ATOMIC &atomic);
 
     static bool requiresTimestampPacketsInSystemMemory();
 
diff --git a/shared/test/common/helpers/unit_test_helper.inl b/shared/test/common/helpers/unit_test_helper.inl
@@ -71,7 +71,7 @@ bool UnitTestHelper<GfxFamily>::isAdditionalMiSemaphoreWait(const typename GfxFa
 }
 
 template <typename GfxFamily>
-inline uint64_t UnitTestHelper<GfxFamily>::getMemoryAddress(const typename GfxFamily::MI_ATOMIC &atomic) {
+inline uint64_t UnitTestHelper<GfxFamily>::getAtomicMemoryAddress(const typename GfxFamily::MI_ATOMIC &atomic) {
     return atomic.getMemoryAddress() | ((static_cast<uint64_t>(atomic.getMemoryAddressHigh())) << 32);
 }
 
diff --git a/shared/test/unit_test/encoders/test_encode_atomic.cpp b/shared/test/unit_test/encoders/test_encode_atomic.cpp
@@ -9,6 +9,7 @@
 #include "shared/source/helpers/ptr_math.h"
 #include "shared/test/common/cmd_parse/gen_cmd_parse.h"
 #include "shared/test/common/fixtures/command_container_fixture.h"
+#include "shared/test/common/helpers/unit_test_helper.h"
 
 using namespace NEO;
 
@@ -37,7 +38,7 @@ HWTEST_F(CommandEncodeAtomic, WhenProgrammingMiAtomicThenExpectAllFieldsSetCorre
 
     EXPECT_EQ(ATOMIC_OPCODES::ATOMIC_4B_DECREMENT, miAtomicCmd->getAtomicOpcode());
     EXPECT_EQ(DATA_SIZE::DATA_SIZE_DWORD, miAtomicCmd->getDataSize());
-    EXPECT_EQ(address, EncodeAtomic<FamilyType>::getMiAtomicAddress(*miAtomicCmd));
+    EXPECT_EQ(address, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));
     EXPECT_EQ(0x1u, miAtomicCmd->getReturnDataControl());
     EXPECT_EQ(0x1u, miAtomicCmd->getCsStall());
 }
@@ -75,7 +76,7 @@ HWTEST_F(CommandEncodeAtomic, WhenProgrammingMiAtomicMoveOperationThenExpectInli
 
     EXPECT_EQ(ATOMIC_OPCODES::ATOMIC_4B_MOVE, miAtomicCmd->getAtomicOpcode());
     EXPECT_EQ(DATA_SIZE::DATA_SIZE_DWORD, miAtomicCmd->getDataSize());
-    EXPECT_EQ(address, EncodeAtomic<FamilyType>::getMiAtomicAddress(*miAtomicCmd));
+    EXPECT_EQ(address, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));
     EXPECT_EQ(0x0u, miAtomicCmd->getReturnDataControl());
     EXPECT_EQ(DWORD_LENGTH::DWORD_LENGTH_INLINE_DATA_1, miAtomicCmd->getDwordLength());
     EXPECT_EQ(0x1u, miAtomicCmd->getInlineData());
@@ -85,7 +86,7 @@ HWTEST_F(CommandEncodeAtomic, WhenProgrammingMiAtomicMoveOperationThenExpectInli
     miAtomicCmd++;
     EXPECT_EQ(ATOMIC_OPCODES::ATOMIC_8B_MOVE, miAtomicCmd->getAtomicOpcode());
     EXPECT_EQ(DATA_SIZE::DATA_SIZE_QWORD, miAtomicCmd->getDataSize());
-    EXPECT_EQ(address, EncodeAtomic<FamilyType>::getMiAtomicAddress(*miAtomicCmd));
+    EXPECT_EQ(address, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));
     EXPECT_EQ(0x0u, miAtomicCmd->getReturnDataControl());
     EXPECT_EQ(DWORD_LENGTH::DWORD_LENGTH_INLINE_DATA_1, miAtomicCmd->getDwordLength());
     EXPECT_EQ(0x1u, miAtomicCmd->getInlineData());

Original file line number	Diff line number	Diff line change
`@@ -527,7 +527,7 @@ HWTEST_TEMPLATED_F(BcsBufferTests, givenWriteBufferEnqueueWhenProgrammingCommand`
`527`	`527`	`miAtomicsCount++;`
`528`	`528`	`auto dataAddress = TimestampPacketHelper::getGpuDependenciesCountGpuAddress(*timestampPacketNode);`
`529`	`529`	`EXPECT_EQ(MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_INCREMENT, miAtomicCmd->getAtomicOpcode());`
`530`		`- EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getMemoryAddress(*miAtomicCmd));`
	`530`	`+ EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));`
`531`	`531`	`EXPECT_EQ(1u, semaphoresCount);`
`532`	`532`	`}`
`533`	`533`	`}`
`@@ -572,7 +572,7 @@ HWTEST_TEMPLATED_F(BcsBufferTests, givenReadBufferEnqueueWhenProgrammingCommandS`
`572`	`572`	`miAtomicsCount++;`
`573`	`573`	`auto dataAddress = TimestampPacketHelper::getGpuDependenciesCountGpuAddress(*timestampPacketNode);`
`574`	`574`	`EXPECT_EQ(MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_INCREMENT, miAtomicCmd->getAtomicOpcode());`
`575`		`- EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getMemoryAddress(*miAtomicCmd));`
	`575`	`+ EXPECT_EQ(dataAddress, UnitTestHelper<FamilyType>::getAtomicMemoryAddress(*miAtomicCmd));`
`576`	`576`	`EXPECT_EQ(1u, semaphoresCount);`
`577`	`577`	`}`
`578`	`578`	`}`
Original file line number	Diff line number	Diff line change
`@@ -245,12 +245,12 @@ void EncodeMediaInterfaceDescriptorLoad<Family>::encode(CommandContainer &contai`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`template <typename Family>`
`248`		`-bool EncodeDispatchKernel<Family>::isRuntimeLocalIdsGenerationRequired(uint32_t activeChannels,`
`249`		`- size_t *lws,`
`250`		`- std::array<uint8_t, 3> walkOrder,`
`251`		`- bool requireInputWalkOrder,`
`252`		`- uint32_t &requiredWalkOrder,`
`253`		`- uint32_t simd) {`
	`248`	`+inline bool EncodeDispatchKernel<Family>::isRuntimeLocalIdsGenerationRequired(uint32_t activeChannels,`
	`249`	`+ size_t *lws,`
	`250`	`+ std::array<uint8_t, 3> walkOrder,`
	`251`	`+ bool requireInputWalkOrder,`
	`252`	`+ uint32_t &requiredWalkOrder,`
	`253`	`+ uint32_t simd) {`
`254`	`254`	`requiredWalkOrder = 0u;`
`255`	`255`	`return true;`
`256`	`256`	`}`
`@@ -312,7 +312,7 @@ void EncodeDispatchKernel<Family>::programBarrierEnable(INTERFACE_DESCRIPTOR_DAT`
`312`	`312`	`}`
`313`	`313`
`314`	`314`	`template <typename Family>`
`315`		`-void EncodeDispatchKernel<Family>::encodeAdditionalWalkerFields(const HardwareInfo &hwInfo, WALKER_TYPE &walkerCmd) {}`
	`315`	`+inline void EncodeDispatchKernel<Family>::encodeAdditionalWalkerFields(const HardwareInfo &hwInfo, WALKER_TYPE &walkerCmd) {}`
`316`	`316`
`317`	`317`	`template <typename Family>`
`318`	`318`	`void EncodeDispatchKernel<Family>::appendAdditionalIDDFields(INTERFACE_DESCRIPTOR_DATA *pInterfaceDescriptor, const HardwareInfo &hwInfo, const uint32_t threadsPerThreadGroup, uint32_t slmTotalSize, SlmPolicy slmPolicy) {}`
`@@ -340,11 +340,11 @@ size_t EncodeDispatchKernel<Family>::estimateEncodeDispatchKernelCmdsSize(Device`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`template <typename Family>`
`343`		`-void EncodeComputeMode<Family>::adjustComputeMode(LinearStream &csr, void *const stateComputeModePtr, StateComputeModeProperties &properties) {`
	`343`	`+inline void EncodeComputeMode<Family>::adjustComputeMode(LinearStream &csr, void *const stateComputeModePtr, StateComputeModeProperties &properties) {`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`template <typename Family>`
`347`		`-void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &container, const NEO::KernelDescriptor &kernelDescriptor) {`
	`347`	`+inline void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &container, const NEO::KernelDescriptor &kernelDescriptor) {`
`348`	`348`	`}`
`349`	`349`
`350`	`350`	`template <typename Family>`
`@@ -412,8 +412,8 @@ inline size_t EncodeWA<GfxFamily>::getAdditionalPipelineSelectSize(Device &devic`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`template <typename GfxFamily>`
`415`		`-void EncodeSurfaceState<GfxFamily>::encodeExtraBufferParams(R_SURFACE_STATE surfaceState, GraphicsAllocation allocation, GmmHelper *gmmHelper,`
`416`		`- bool isReadOnly, uint32_t numAvailableDevices, bool useGlobalAtomics, bool areMultipleSubDevicesInContext) {`
	`415`	`+inline void EncodeSurfaceState<GfxFamily>::encodeExtraBufferParams(R_SURFACE_STATE surfaceState, GraphicsAllocation allocation, GmmHelper *gmmHelper,`
	`416`	`+ bool isReadOnly, uint32_t numAvailableDevices, bool useGlobalAtomics, bool areMultipleSubDevicesInContext) {`
`417`	`417`	`encodeExtraCacheSettings(surfaceState, *gmmHelper->getHardwareInfo());`
`418`	`418`	`}`
`419`	`419`
`@@ -423,7 +423,7 @@ bool EncodeSurfaceState<GfxFamily>::doBindingTablePrefetch() {`
`423`	`423`	`}`
`424`	`424`
`425`	`425`	`template <typename Family>`
`426`		`-void EncodeSurfaceState<Family>::setCoherencyType(R_SURFACE_STATE *surfaceState, COHERENCY_TYPE coherencyType) {`
	`426`	`+inline void EncodeSurfaceState<Family>::setCoherencyType(R_SURFACE_STATE *surfaceState, COHERENCY_TYPE coherencyType) {`
`427`	`427`	`surfaceState->setCoherencyType(coherencyType);`
`428`	`428`	`}`
`429`	`429`
Original file line number	Diff line number	Diff line change
`@@ -11,25 +11,25 @@`
`11`	`11`
`12`	`12`	`namespace NEO {`
`13`	`13`	`template <typename Family>`
`14`		`-void EncodeStates<Family>::adjustStateComputeMode(LinearStream &csr, uint32_t numGrfRequired, void *const stateComputeModePtr,`
`15`		`- bool isMultiOsContextCapable, bool requiresCoherency, bool useGlobalAtomics,`
`16`		`- bool areMultipleSubDevicesInContext, uint32_t threadArbitrationPolicy) {`
	`14`	`+inline void EncodeStates<Family>::adjustStateComputeMode(LinearStream &csr, uint32_t numGrfRequired, void *const stateComputeModePtr,`
	`15`	`+ bool isMultiOsContextCapable, bool requiresCoherency, bool useGlobalAtomics,`
	`16`	`+ bool areMultipleSubDevicesInContext, uint32_t threadArbitrationPolicy) {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`template <typename Family>`
`20`		`-void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {`
	`20`	`+inline void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`template <typename Family>`
`24`		`-void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_MEM *pMiLoadReg) {`
	`24`	`+inline void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_MEM *pMiLoadReg) {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`template <typename Family>`
`28`		`-void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_REG *pMiLoadReg) {`
	`28`	`+inline void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_REG *pMiLoadReg) {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`template <typename Family>`
`32`		`-bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {`
	`32`	`+inline bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {`
`33`	`33`	`return false;`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ void EncodeStates<Family>::adjustStateComputeMode(LinearStream &csr, uint32_t nu`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`template <typename Family>`
`24`		`-void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {`
	`24`	`+inline void EncodeStoreMMIO<Family>::remapOffset(MI_STORE_REGISTER_MEM *pStoreRegMem) {`
`25`	`25`	`pStoreRegMem->setMmioRemapEnable(true);`
`26`	`26`	`}`
`27`	`27`
`@@ -43,7 +43,7 @@ void EncodeSetMMIO<Family>::remapOffset(MI_LOAD_REGISTER_REG *pMiLoadReg) {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`template <typename Family>`
`46`		`-bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {`
	`46`	`+inline bool EncodeSetMMIO<Family>::isRemapApplicable(uint32_t offset) {`
`47`	`47`	`return (0x2000 <= offset && offset <= 0x27ff) \|\|`
`48`	`48`	`(0x4200 <= offset && offset <= 0x420f) \|\|`
`49`	`49`	`(0x4400 <= offset && offset <= 0x441f);`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ bool UnitTestHelper<GfxFamily>::isAdditionalMiSemaphoreWait(const typename GfxFa`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`template <typename GfxFamily>`
`74`		`-inline uint64_t UnitTestHelper<GfxFamily>::getMemoryAddress(const typename GfxFamily::MI_ATOMIC &atomic) {`
	`74`	`+inline uint64_t UnitTestHelper<GfxFamily>::getAtomicMemoryAddress(const typename GfxFamily::MI_ATOMIC &atomic) {`
`75`	`75`	`return atomic.getMemoryAddress() \| ((static_cast<uint64_t>(atomic.getMemoryAddressHigh())) << 32);`
`76`	`76`	`}`
`77`	`77`