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

refactor: rename WALKER_TYPE to DefaultWalkerType

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-12-04 12:20:54 +00:00
committed by Compute-Runtime-Automation
parent 306142eefa
commit 9486cd2a26
83 changed files with 883 additions and 883 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
opencl/source/command_queue/gpgpu_walker.h
View File

@@ -25,7 +25,7 @@ using MI_STORE_REG_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM_CMD;
template <typename GfxFamily>
class GpgpuWalkerHelper {
using WALKER_TYPE = typename GfxFamily::WALKER_TYPE;
using DefaultWalkerType = typename GfxFamily::DefaultWalkerType;
public:
static void applyWADisableLSQCROPERFforOCL(LinearStream *pCommandStream,

2
opencl/source/command_queue/gpgpu_walker_base.inl
View File

@@ -247,7 +247,7 @@ size_t EnqueueOperation<GfxFamily>::getSizeRequiredCS(uint32_t cmdType, bool res
if (isCommandWithoutKernel(cmdType)) {
return EnqueueOperation<GfxFamily>::getSizeRequiredCSNonKernel(reserveProfilingCmdsSpace, reservePerfCounters, commandQueue);
} else {
return EnqueueOperation<GfxFamily>::getSizeRequiredCSKernel<typename GfxFamily::WALKER_TYPE>(reserveProfilingCmdsSpace, reservePerfCounters, commandQueue, pKernel, dispatchInfo);
return EnqueueOperation<GfxFamily>::getSizeRequiredCSKernel<typename GfxFamily::DefaultWalkerType>(reserveProfilingCmdsSpace, reservePerfCounters, commandQueue, pKernel, dispatchInfo);
}
}

4
opencl/source/command_queue/gpgpu_walker_bdw_and_later.inl
View File

@@ -45,11 +45,11 @@ inline size_t GpgpuWalkerHelper<GfxFamily>::setGpgpuWalkerThreadData(
if (!executionMask)
executionMask = ~executionMask;
using SIMD_SIZE = typename WALKER_TYPE::SIMD_SIZE;
using SIMD_SIZE = typename DefaultWalkerType::SIMD_SIZE;
walkerCmd->setRightExecutionMask(static_cast<uint32_t>(executionMask));
walkerCmd->setBottomExecutionMask(static_cast<uint32_t>(0xffffffff));
walkerCmd->setSimdSize(getSimdConfig<WALKER_TYPE>(simd));
walkerCmd->setSimdSize(getSimdConfig<DefaultWalkerType>(simd));
walkerCmd->setThreadGroupIdStartingX(static_cast<uint32_t>(startWorkGroups[0]));
walkerCmd->setThreadGroupIdStartingY(static_cast<uint32_t>(startWorkGroups[1]));

2
opencl/source/command_queue/hardware_interface.h
View File

@@ -53,7 +53,7 @@ template <typename GfxFamily>
class HardwareInterface {
public:
using INTERFACE_DESCRIPTOR_DATA = typename GfxFamily::INTERFACE_DESCRIPTOR_DATA;
using WALKER_TYPE = typename GfxFamily::WALKER_TYPE;
using DefaultWalkerType = typename GfxFamily::DefaultWalkerType;
template <typename WalkerType>
static void dispatchWalker(

2
opencl/source/command_queue/hardware_interface_base.inl
View File

@@ -32,7 +32,7 @@ inline WalkerType *HardwareInterface<GfxFamily>::allocateWalkerSpace(LinearStrea
template <typename GfxFamily>
inline void HardwareInterface<GfxFamily>::dispatchWalkerCommon(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs) {
dispatchWalker<typename GfxFamily::WALKER_TYPE>(commandQueue, multiDispatchInfo, csrDependencies, walkerArgs);
dispatchWalker<typename GfxFamily::DefaultWalkerType>(commandQueue, multiDispatchInfo, csrDependencies, walkerArgs);
}
template <typename GfxFamily>

14
opencl/source/gen11/gpgpu_walker_gen11.cpp
View File

@@ -17,15 +17,15 @@ using Family = Gen11Family;
template class HardwareInterface<Family>;
template void HardwareInterface<Family>::dispatchWalker<Family::WALKER_TYPE>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::WALKER_TYPE>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::WALKER_TYPE>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::WALKER_TYPE *HardwareInterface<Family>::allocateWalkerSpace<Family::WALKER_TYPE>(LinearStream &commandStream, const Kernel &kernel);
template void HardwareInterface<Family>::dispatchWalker<Family::DefaultWalkerType>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::DefaultWalkerType>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::DefaultWalkerType>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::DefaultWalkerType *HardwareInterface<Family>::allocateWalkerSpace<Family::DefaultWalkerType>(LinearStream &commandStream, const Kernel &kernel);
template class GpgpuWalkerHelper<Family>;
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::WALKER_TYPE>(LinearStream *cmdStream, Family::WALKER_TYPE *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::WALKER_TYPE>(Family::WALKER_TYPE *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::DefaultWalkerType>(LinearStream *cmdStream, Family::DefaultWalkerType *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::DefaultWalkerType>(Family::DefaultWalkerType *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template struct EnqueueOperation<Family>;

16
opencl/source/gen11/hardware_commands_helper_gen11.cpp
View File

@@ -16,7 +16,7 @@ namespace NEO {
using FamilyType = Gen11Family;
template struct HardwareCommandsHelper<FamilyType>;
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
LinearStream &commandStream,
IndirectHeap &dsh,
IndirectHeap &ioh,
@@ -29,21 +29,21 @@ template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType
const uint64_t offsetInterfaceDescriptorTable,
uint32_t &interfaceDescriptorIndex,
PreemptionMode preemptionMode,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor,
bool localIdsGenerationByRuntime,
uint64_t scratchAddress,
const Device &device);
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::WALKER_TYPE>(
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::DefaultWalkerType>(
IndirectHeap &indirectHeap,
Kernel &kernel,
bool inlineDataProgrammingRequired,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
uint32_t &sizeCrossThreadData,
uint64_t scratchAddress);
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
const IndirectHeap &indirectHeap,
uint64_t offsetInterfaceDescriptor,
uint64_t kernelStartOffset,
@@ -58,11 +58,11 @@ template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<
uint32_t bindingTablePrefetchSize,
PreemptionMode preemptionMode,
const Device &device,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor);
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::WALKER_TYPE>(
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::DefaultWalkerType>(
Kernel &kernel,
FamilyType::WALKER_TYPE *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
FamilyType::DefaultWalkerType *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
} // namespace NEO

14
opencl/source/gen12lp/gpgpu_walker_gen12lp.cpp
View File

@@ -54,15 +54,15 @@ size_t GpgpuWalkerHelper<Family>::getSizeForWaDisableRccRhwoOptimization(const K
template class HardwareInterface<Family>;
template void HardwareInterface<Family>::dispatchWalker<Family::WALKER_TYPE>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::WALKER_TYPE>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::WALKER_TYPE>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::WALKER_TYPE *HardwareInterface<Family>::allocateWalkerSpace<Family::WALKER_TYPE>(LinearStream &commandStream, const Kernel &kernel);
template void HardwareInterface<Family>::dispatchWalker<Family::DefaultWalkerType>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::DefaultWalkerType>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::DefaultWalkerType>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::DefaultWalkerType *HardwareInterface<Family>::allocateWalkerSpace<Family::DefaultWalkerType>(LinearStream &commandStream, const Kernel &kernel);
template class GpgpuWalkerHelper<Family>;
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::WALKER_TYPE>(LinearStream *cmdStream, Family::WALKER_TYPE *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::WALKER_TYPE>(Family::WALKER_TYPE *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::DefaultWalkerType>(LinearStream *cmdStream, Family::DefaultWalkerType *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::DefaultWalkerType>(Family::DefaultWalkerType *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template struct EnqueueOperation<Family>;

16
opencl/source/gen12lp/hardware_commands_helper_gen12lp.cpp
View File

@@ -24,7 +24,7 @@ size_t HardwareCommandsHelper<FamilyType>::getSizeRequiredCS() {
template struct HardwareCommandsHelper<FamilyType>;
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
LinearStream &commandStream,
IndirectHeap &dsh,
IndirectHeap &ioh,
@@ -37,21 +37,21 @@ template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType
const uint64_t offsetInterfaceDescriptorTable,
uint32_t &interfaceDescriptorIndex,
PreemptionMode preemptionMode,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor,
bool localIdsGenerationByRuntime,
uint64_t scratchAddress,
const Device &device);
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::WALKER_TYPE>(
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::DefaultWalkerType>(
IndirectHeap &indirectHeap,
Kernel &kernel,
bool inlineDataProgrammingRequired,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
uint32_t &sizeCrossThreadData,
uint64_t scratchAddress);
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
const IndirectHeap &indirectHeap,
uint64_t offsetInterfaceDescriptor,
uint64_t kernelStartOffset,
@@ -66,11 +66,11 @@ template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<
uint32_t bindingTablePrefetchSize,
PreemptionMode preemptionMode,
const Device &device,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor);
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::WALKER_TYPE>(
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::DefaultWalkerType>(
Kernel &kernel,
FamilyType::WALKER_TYPE *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
FamilyType::DefaultWalkerType *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
} // namespace NEO

14
opencl/source/gen8/gpgpu_walker_gen8.cpp
View File

@@ -58,15 +58,15 @@ size_t GpgpuWalkerHelper<Family>::getSizeForWADisableLSQCROPERFforOCL(const Kern
template class HardwareInterface<Family>;
template void HardwareInterface<Family>::dispatchWalker<Family::WALKER_TYPE>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::WALKER_TYPE>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::WALKER_TYPE>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::WALKER_TYPE *HardwareInterface<Family>::allocateWalkerSpace<Family::WALKER_TYPE>(LinearStream &commandStream, const Kernel &kernel);
template void HardwareInterface<Family>::dispatchWalker<Family::DefaultWalkerType>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::DefaultWalkerType>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::DefaultWalkerType>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::DefaultWalkerType *HardwareInterface<Family>::allocateWalkerSpace<Family::DefaultWalkerType>(LinearStream &commandStream, const Kernel &kernel);
template class GpgpuWalkerHelper<Family>;
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::WALKER_TYPE>(LinearStream *cmdStream, Family::WALKER_TYPE *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::WALKER_TYPE>(Family::WALKER_TYPE *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::DefaultWalkerType>(LinearStream *cmdStream, Family::DefaultWalkerType *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::DefaultWalkerType>(Family::DefaultWalkerType *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template struct EnqueueOperation<Family>;

16
opencl/source/gen8/hardware_commands_helper_gen8.cpp
View File

@@ -15,7 +15,7 @@ namespace NEO {
using FamilyType = Gen8Family;
template struct HardwareCommandsHelper<FamilyType>;
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
LinearStream &commandStream,
IndirectHeap &dsh,
IndirectHeap &ioh,
@@ -28,21 +28,21 @@ template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType
const uint64_t offsetInterfaceDescriptorTable,
uint32_t &interfaceDescriptorIndex,
PreemptionMode preemptionMode,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor,
bool localIdsGenerationByRuntime,
uint64_t scratchAddress,
const Device &device);
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::WALKER_TYPE>(
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::DefaultWalkerType>(
IndirectHeap &indirectHeap,
Kernel &kernel,
bool inlineDataProgrammingRequired,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
uint32_t &sizeCrossThreadData,
uint64_t scratchAddress);
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
const IndirectHeap &indirectHeap,
uint64_t offsetInterfaceDescriptor,
uint64_t kernelStartOffset,
@@ -57,11 +57,11 @@ template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<
uint32_t bindingTablePrefetchSize,
PreemptionMode preemptionMode,
const Device &device,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor);
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::WALKER_TYPE>(
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::DefaultWalkerType>(
Kernel &kernel,
FamilyType::WALKER_TYPE *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
FamilyType::DefaultWalkerType *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
} // namespace NEO

14
opencl/source/gen9/gpgpu_walker_gen9.cpp
View File

@@ -58,15 +58,15 @@ size_t GpgpuWalkerHelper<Family>::getSizeForWADisableLSQCROPERFforOCL(const Kern
template class HardwareInterface<Family>;
template void HardwareInterface<Family>::dispatchWalker<Family::WALKER_TYPE>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::WALKER_TYPE>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::WALKER_TYPE>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::WALKER_TYPE *HardwareInterface<Family>::allocateWalkerSpace<Family::WALKER_TYPE>(LinearStream &commandStream, const Kernel &kernel);
template void HardwareInterface<Family>::dispatchWalker<Family::DefaultWalkerType>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::DefaultWalkerType>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::DefaultWalkerType>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::DefaultWalkerType *HardwareInterface<Family>::allocateWalkerSpace<Family::DefaultWalkerType>(LinearStream &commandStream, const Kernel &kernel);
template class GpgpuWalkerHelper<Family>;
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::WALKER_TYPE>(LinearStream *cmdStream, Family::WALKER_TYPE *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::WALKER_TYPE>(Family::WALKER_TYPE *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::DefaultWalkerType>(LinearStream *cmdStream, Family::DefaultWalkerType *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::DefaultWalkerType>(Family::DefaultWalkerType *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template struct EnqueueOperation<Family>;

16
opencl/source/gen9/hardware_commands_helper_gen9.cpp
View File

@@ -17,7 +17,7 @@ namespace NEO {
using FamilyType = Gen9Family;
template struct HardwareCommandsHelper<FamilyType>;
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
LinearStream &commandStream,
IndirectHeap &dsh,
IndirectHeap &ioh,
@@ -30,21 +30,21 @@ template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType
const uint64_t offsetInterfaceDescriptorTable,
uint32_t &interfaceDescriptorIndex,
PreemptionMode preemptionMode,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor,
bool localIdsGenerationByRuntime,
uint64_t scratchAddress,
const Device &device);
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::WALKER_TYPE>(
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::DefaultWalkerType>(
IndirectHeap &indirectHeap,
Kernel &kernel,
bool inlineDataProgrammingRequired,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
uint32_t &sizeCrossThreadData,
uint64_t scratchAddress);
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
const IndirectHeap &indirectHeap,
uint64_t offsetInterfaceDescriptor,
uint64_t kernelStartOffset,
@@ -59,11 +59,11 @@ template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<
uint32_t bindingTablePrefetchSize,
PreemptionMode preemptionMode,
const Device &device,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor);
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::WALKER_TYPE>(
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::DefaultWalkerType>(
Kernel &kernel,
FamilyType::WALKER_TYPE *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
FamilyType::DefaultWalkerType *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
} // namespace NEO

4
opencl/source/helpers/hardware_commands_helper.h
View File

@@ -23,7 +23,7 @@ struct MultiDispatchInfo;
template <typename GfxFamily>
struct HardwareCommandsHelper : public PerThreadDataHelper {
using WALKER_TYPE = typename GfxFamily::WALKER_TYPE;
using DefaultWalkerType = typename GfxFamily::DefaultWalkerType;
using BINDING_TABLE_STATE = typename GfxFamily::BINDING_TABLE_STATE;
using RENDER_SURFACE_STATE = typename GfxFamily::RENDER_SURFACE_STATE;
using INTERFACE_DESCRIPTOR_DATA = typename GfxFamily::INTERFACE_DESCRIPTOR_DATA;
@@ -123,7 +123,7 @@ struct HardwareCommandsHelper : public PerThreadDataHelper {
const MultiDispatchInfo &multiDispatchInfo);
static void setInterfaceDescriptorOffset(
WALKER_TYPE *walkerCmd,
DefaultWalkerType *walkerCmd,
uint32_t &interfaceDescriptorIndex);
static bool kernelUsesLocalIds(const Kernel &kernel);

4
opencl/source/helpers/hardware_commands_helper_base.inl
View File

@@ -50,7 +50,7 @@ template <typename GfxFamily>
size_t HardwareCommandsHelper<GfxFamily>::getSizeRequiredIOH(const Kernel &kernel,
const size_t localWorkSizes[3]) {
auto localWorkSize = Math::computeTotalElementsCount(localWorkSizes);
typedef typename GfxFamily::WALKER_TYPE WALKER_TYPE;
typedef typename GfxFamily::DefaultWalkerType DefaultWalkerType;
const auto &kernelDescriptor = kernel.getDescriptor();
const auto &hwInfo = kernel.getHardwareInfo();
const auto &gfxCoreHelper = kernel.getGfxCoreHelper();
@@ -76,7 +76,7 @@ size_t HardwareCommandsHelper<GfxFamily>::getSizeRequiredIOH(const Kernel &kerne
if (pImplicitArgs) {
size += ImplicitArgsHelper::getSizeForImplicitArgsPatching(pImplicitArgs, kernelDescriptor, isHwLocalIdGeneration, gfxCoreHelper);
}
return alignUp(size, WALKER_TYPE::INDIRECTDATASTARTADDRESS_ALIGN_SIZE);
return alignUp(size, DefaultWalkerType::INDIRECTDATASTARTADDRESS_ALIGN_SIZE);
}
template <typename GfxFamily>

2
opencl/source/helpers/hardware_commands_helper_bdw_and_later.inl
View File

@@ -111,7 +111,7 @@ size_t HardwareCommandsHelper<GfxFamily>::sendCrossThreadData(
template <typename GfxFamily>
void HardwareCommandsHelper<GfxFamily>::setInterfaceDescriptorOffset(
WALKER_TYPE *walkerCmd,
DefaultWalkerType *walkerCmd,
uint32_t &interfaceDescriptorIndex) {
walkerCmd->setInterfaceDescriptorOffset(interfaceDescriptorIndex++);

2
opencl/source/helpers/hardware_commands_helper_xehp_and_later.inl
View File

@@ -137,7 +137,7 @@ size_t HardwareCommandsHelper<GfxFamily>::sendCrossThreadData(
template <typename GfxFamily>
void HardwareCommandsHelper<GfxFamily>::setInterfaceDescriptorOffset(
WALKER_TYPE *walkerCmd,
DefaultWalkerType *walkerCmd,
uint32_t &interfaceDescriptorIndex) {
}

14
opencl/source/xe_hpc_core/gpgpu_walker_xe_hpc_core.cpp
View File

@@ -15,16 +15,16 @@ namespace NEO {
using Family = XeHpcCoreFamily;
template class GpgpuWalkerHelper<Family>;
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::WALKER_TYPE>(LinearStream *cmdStream, Family::WALKER_TYPE *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::WALKER_TYPE>(Family::WALKER_TYPE *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::DefaultWalkerType>(LinearStream *cmdStream, Family::DefaultWalkerType *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::DefaultWalkerType>(Family::DefaultWalkerType *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template class HardwareInterface<Family>;
template void HardwareInterface<Family>::dispatchWalker<Family::WALKER_TYPE>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::WALKER_TYPE>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::WALKER_TYPE>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::WALKER_TYPE *HardwareInterface<Family>::allocateWalkerSpace<Family::WALKER_TYPE>(LinearStream &commandStream, const Kernel &kernel);
template void HardwareInterface<Family>::dispatchWalker<Family::DefaultWalkerType>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::DefaultWalkerType>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::DefaultWalkerType>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::DefaultWalkerType *HardwareInterface<Family>::allocateWalkerSpace<Family::DefaultWalkerType>(LinearStream &commandStream, const Kernel &kernel);
template struct EnqueueOperation<Family>;

16
opencl/source/xe_hpc_core/hardware_commands_helper_xe_hpc_core.cpp
View File

@@ -16,7 +16,7 @@ namespace NEO {
using FamilyType = XeHpcCoreFamily;
template struct HardwareCommandsHelper<FamilyType>;
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
LinearStream &commandStream,
IndirectHeap &dsh,
IndirectHeap &ioh,
@@ -29,21 +29,21 @@ template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType
const uint64_t offsetInterfaceDescriptorTable,
uint32_t &interfaceDescriptorIndex,
PreemptionMode preemptionMode,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor,
bool localIdsGenerationByRuntime,
uint64_t scratchAddress,
const Device &device);
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::WALKER_TYPE>(
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::DefaultWalkerType>(
IndirectHeap &indirectHeap,
Kernel &kernel,
bool inlineDataProgrammingRequired,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
uint32_t &sizeCrossThreadData,
uint64_t scratchAddress);
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
const IndirectHeap &indirectHeap,
uint64_t offsetInterfaceDescriptor,
uint64_t kernelStartOffset,
@@ -58,11 +58,11 @@ template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<
uint32_t bindingTablePrefetchSize,
PreemptionMode preemptionMode,
const Device &device,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor);
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::WALKER_TYPE>(
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::DefaultWalkerType>(
Kernel &kernel,
FamilyType::WALKER_TYPE *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
FamilyType::DefaultWalkerType *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
} // namespace NEO

14
opencl/source/xe_hpg_core/gpgpu_walker_xe_hpg_core.cpp
View File

@@ -15,16 +15,16 @@ namespace NEO {
using Family = XeHpgCoreFamily;
template class GpgpuWalkerHelper<Family>;
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::WALKER_TYPE>(LinearStream *cmdStream, Family::WALKER_TYPE *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::WALKER_TYPE>(Family::WALKER_TYPE *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template void GpgpuWalkerHelper<Family>::setupTimestampPacket<Family::DefaultWalkerType>(LinearStream *cmdStream, Family::DefaultWalkerType *walkerCmd, TagNodeBase *timestampPacketNode, const RootDeviceEnvironment &rootDeviceEnvironment);
template size_t GpgpuWalkerHelper<Family>::setGpgpuWalkerThreadData<Family::DefaultWalkerType>(Family::DefaultWalkerType *walkerCmd, const KernelDescriptor &kernelDescriptor, const size_t globalOffsets[3], const size_t startWorkGroups[3],
const size_t numWorkGroups[3], const size_t localWorkSizesIn[3], uint32_t simd, uint32_t workDim, bool localIdsGenerationByRuntime, bool inlineDataProgrammingRequired, uint32_t requiredWorkGroupOrder);
template class HardwareInterface<Family>;
template void HardwareInterface<Family>::dispatchWalker<Family::WALKER_TYPE>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::WALKER_TYPE>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::WALKER_TYPE>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::WALKER_TYPE *HardwareInterface<Family>::allocateWalkerSpace<Family::WALKER_TYPE>(LinearStream &commandStream, const Kernel &kernel);
template void HardwareInterface<Family>::dispatchWalker<Family::DefaultWalkerType>(CommandQueue &commandQueue, const MultiDispatchInfo &multiDispatchInfo, const CsrDependencies &csrDependencies, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::programWalker<Family::DefaultWalkerType>(LinearStream &commandStream, Kernel &kernel, CommandQueue &commandQueue, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, const DispatchInfo &dispatchInfo, HardwareInterfaceWalkerArgs &walkerArgs);
template void HardwareInterface<Family>::dispatchKernelCommands<Family::DefaultWalkerType>(CommandQueue &commandQueue, const DispatchInfo &dispatchInfo, LinearStream &commandStream, IndirectHeap &dsh, IndirectHeap &ioh, IndirectHeap &ssh, HardwareInterfaceWalkerArgs &walkerArgs);
template Family::DefaultWalkerType *HardwareInterface<Family>::allocateWalkerSpace<Family::DefaultWalkerType>(LinearStream &commandStream, const Kernel &kernel);
template struct EnqueueOperation<Family>;

16
opencl/source/xe_hpg_core/hardware_commands_helper_xe_hpg_core.cpp
View File

@@ -16,7 +16,7 @@ namespace NEO {
using FamilyType = XeHpgCoreFamily;
template struct HardwareCommandsHelper<FamilyType>;
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
LinearStream &commandStream,
IndirectHeap &dsh,
IndirectHeap &ioh,
@@ -29,21 +29,21 @@ template size_t HardwareCommandsHelper<FamilyType>::sendIndirectState<FamilyType
const uint64_t offsetInterfaceDescriptorTable,
uint32_t &interfaceDescriptorIndex,
PreemptionMode preemptionMode,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor,
bool localIdsGenerationByRuntime,
uint64_t scratchAddress,
const Device &device);
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::WALKER_TYPE>(
template size_t HardwareCommandsHelper<FamilyType>::sendCrossThreadData<FamilyType::DefaultWalkerType>(
IndirectHeap &indirectHeap,
Kernel &kernel,
bool inlineDataProgrammingRequired,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
uint32_t &sizeCrossThreadData,
uint64_t scratchAddress);
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::WALKER_TYPE, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<FamilyType::DefaultWalkerType, FamilyType::INTERFACE_DESCRIPTOR_DATA>(
const IndirectHeap &indirectHeap,
uint64_t offsetInterfaceDescriptor,
uint64_t kernelStartOffset,
@@ -58,10 +58,10 @@ template size_t HardwareCommandsHelper<FamilyType>::sendInterfaceDescriptorData<
uint32_t bindingTablePrefetchSize,
PreemptionMode preemptionMode,
const Device &device,
FamilyType::WALKER_TYPE *walkerCmd,
FamilyType::DefaultWalkerType *walkerCmd,
FamilyType::INTERFACE_DESCRIPTOR_DATA *inlineInterfaceDescriptor);
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::WALKER_TYPE>(
template void HardwareCommandsHelper<FamilyType>::programInlineData<FamilyType::DefaultWalkerType>(
Kernel &kernel,
FamilyType::WALKER_TYPE *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
FamilyType::DefaultWalkerType *walkerCmd, uint64_t indirectDataAddress, uint64_t scratchAddress);
} // namespace NEO