Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Change virtual class HardwareInterface to static

Browse Source 
Change-Id: I4f1f59ecb51b95041dc6dcc6c606b94595813f53
Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2018-09-27 15:22:36 +02:00
committed by sys_ocldev
parent f3b1d73e88
commit b16bd14f37
20 changed files with 268 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -534,7 +534,6 @@ include_directories(${IGDRCL_SOURCE_DIR}/runtime/gen_common/reg_configs${BRANCH_
include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/${BRANCH_DIR_SUFFIX})
include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/client_context${BRANCH_DIR_SUFFIX})
include_directories(${IGDRCL_SOURCE_DIR}/runtime/gmm_helper/gmm_memory${BRANCH_DIR_SUFFIX})
include_directories(${IGDRCL_SOURCE_DIR}/runtime/command_queue/hardware_interface${BRANCH_DIR_SUFFIX})
set(HW_SRC_INCLUDE_PATH ${IGDRCL_SOURCE_DIR}/runtime/gen_common)

4
runtime/command_queue/CMakeLists.txt
View File

@ -34,14 +34,14 @@ set(RUNTIME_SRCS_COMMAND_QUEUE
${CMAKE_CURRENT_SOURCE_DIR}/flush.h
${CMAKE_CURRENT_SOURCE_DIR}/gpgpu_walker.h
${CMAKE_CURRENT_SOURCE_DIR}/gpgpu_walker.inl
${CMAKE_CURRENT_SOURCE_DIR}/hardware_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware_interface.inl
${CMAKE_CURRENT_SOURCE_DIR}/local_id_gen.cpp
${CMAKE_CURRENT_SOURCE_DIR}/local_id_gen.h
${CMAKE_CURRENT_SOURCE_DIR}/local_id_gen.inl
${CMAKE_CURRENT_SOURCE_DIR}/local_id_gen_avx2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/local_id_gen_sse4.cpp
${CMAKE_CURRENT_SOURCE_DIR}/local_work_size.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hardware_interface${BRANCH_DIR_SUFFIX}/hardware_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware_interface${BRANCH_DIR_SUFFIX}/hardware_interface.inl
)
target_sources(${NEO_STATIC_LIB_NAME} PRIVATE ${RUNTIME_SRCS_COMMAND_QUEUE})
set_property(GLOBAL PROPERTY RUNTIME_SRCS_COMMAND_QUEUE ${RUNTIME_SRCS_COMMAND_QUEUE})

3
runtime/command_queue/enqueue_common.h
View File

@ -12,6 +12,7 @@
#include "runtime/builtin_kernels_simulation/scheduler_simulation.h"
#include "runtime/command_queue/command_queue_hw.h"
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/command_stream/command_stream_receiver.h"
#include "runtime/event/event_builder.h"
#include "runtime/gtpin/gtpin_notify.h"
@ -266,7 +267,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
}
}
GpgpuWalkerHelper<GfxFamily>::dispatchWalker(
HardwareInterface<GfxFamily>::dispatchWalker(
*this,
multiDispatchInfo,
numEventsInWaitList,

17
runtime/command_queue/gpgpu_walker.h
View File

@ -31,9 +31,6 @@ using WALKER_HANDLE = void *;
template <typename GfxFamily>
using WALKER_TYPE = typename GfxFamily::WALKER_TYPE;
template <typename GfxFamily>
using HARDWARE_INTERFACE = typename GfxFamily::HARDWARE_INTERFACE;
constexpr int32_t NUM_ALU_INST_FOR_READ_MODIFY_WRITE = 4;
constexpr int32_t L3SQC_BIT_LQSC_RO_PERF_DIS = 0x08000000;
@ -188,20 +185,6 @@ class GpgpuWalkerHelper {
OCLRT::HwPerfCounter &hwPerfCounter,
OCLRT::LinearStream *commandStream);
static void dispatchWalker(
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
KernelOperation **blockedCommandsData,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
TagNode<TimestampPacket> *previousTimestampPacketNode,
TimestampPacket *currentTimestampPacket,
PreemptionMode preemptionMode,
bool blockQueue,
uint32_t commandType = 0);
static void setupTimestampPacket(
LinearStream *cmdStream,
WALKER_HANDLE walkerHandle,

33
runtime/command_queue/gpgpu_walker.inl
View File

@ -7,8 +7,6 @@
#pragma once
#include "runtime/command_queue/gpgpu_walker.h"
#include "hardware_interface.h"
#include "hardware_interface.inl"
#include "runtime/command_queue/command_queue.h"
#include "runtime/command_queue/local_id_gen.h"
#include "runtime/command_stream/command_stream_receiver.h"
@ -416,37 +414,6 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsEnd(
perfCounters->setCpuTimestamp();
}
template <typename GfxFamily>
void GpgpuWalkerHelper<GfxFamily>::dispatchWalker(
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
KernelOperation **blockedCommandsData,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
TagNode<TimestampPacket> *previousTimestampPacketNode,
TimestampPacket *currentTimestampPacket,
PreemptionMode preemptionMode,
bool blockQueue,
uint32_t commandType) {
HARDWARE_INTERFACE<GfxFamily> hardwareInterface;
hardwareInterface.dispatchWalker(
commandQueue,
multiDispatchInfo,
numEventsInWaitList,
eventWaitList,
blockedCommandsData,
hwTimeStamps,
hwPerfCounter,
previousTimestampPacketNode,
currentTimestampPacket,
preemptionMode,
blockQueue,
commandType);
}
template <typename GfxFamily>
inline void GpgpuWalkerHelper<GfxFamily>::dispatchOnDeviceWaitlistSemaphores(LinearStream *commandStream, Device &currentDevice,
cl_uint numEventsInWaitList, const cl_event *eventWaitList) {

88
runtime/command_queue/hardware_interface.h Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright (C) 2018 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "CL/cl.h"
#include <cstdint>
namespace OCLRT {
class CommandQueue;
class DispatchInfo;
class IndirectHeap;
class Kernel;
class LinearStream;
class TimestampPacket;
enum class PreemptionMode : uint32_t;
struct HwPerfCounter;
struct HwTimeStamps;
struct KernelOperation;
struct MultiDispatchInfo;
template <class T>
struct TagNode;
using WALKER_HANDLE = void *;
template <typename GfxFamily>
class HardwareInterface {
public:
using INTERFACE_DESCRIPTOR_DATA = typename GfxFamily::INTERFACE_DESCRIPTOR_DATA;
static void dispatchWalker(
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
KernelOperation **blockedCommandsData,
HwTimeStamps *hwTimeStamps,
HwPerfCounter *hwPerfCounter,
TagNode<TimestampPacket> *previousTimestampPacketNode,
TimestampPacket *currentTimestampPacket,
PreemptionMode preemptionMode,
bool blockQueue,
uint32_t commandType = 0);
static void getDefaultDshSpace(
const size_t &offsetInterfaceDescriptorTable,
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
size_t &totalInterfaceDescriptorTableSize,
Kernel *parentKernel,
IndirectHeap *dsh,
LinearStream *commandStream);
static INTERFACE_DESCRIPTOR_DATA *obtainInterfaceDescriptorData(
WALKER_HANDLE pCmdData);
static void setOffsetCrossThreadData(
WALKER_HANDLE pCmdData,
size_t &offsetCrossThreadData,
uint32_t &interfaceDescriptorIndex);
static void dispatchWorkarounds(
LinearStream *commandStream,
CommandQueue &commandQueue,
Kernel &kernel,
const bool &enable);
static void dispatchProfilingPerfStartCommands(
const DispatchInfo &dispatchInfo,
const MultiDispatchInfo &multiDispatchInfo,
HwTimeStamps *hwTimeStamps,
HwPerfCounter *hwPerfCounter,
LinearStream *commandStream,
CommandQueue &commandQueue);
static void dispatchProfilingPerfEndCommands(
HwTimeStamps *hwTimeStamps,
HwPerfCounter *hwPerfCounter,
LinearStream *commandStream,
CommandQueue &commandQueue);
};
} // namespace OCLRT

104
runtime/command_queue/hardware_interface/hardware_interface.inl → runtime/command_queue/hardware_interface.inl
View File

@ -6,8 +6,9 @@
*/
#pragma once
#include "runtime/command_queue/hardware_interface/hardware_interface.h"
#include "runtime/utilities/tag_allocator.h"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/helpers/kernel_commands.h"
#include "runtime/helpers/task_information.h"
namespace OCLRT {
@ -19,15 +20,15 @@ void HardwareInterface<GfxFamily>::dispatchWalker(
const cl_event *eventWaitList,
KernelOperation **blockedCommandsData,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
HwPerfCounter *hwPerfCounter,
TagNode<TimestampPacket> *previousTimestampPacketNode,
TimestampPacket *currentTimestampPacket,
PreemptionMode preemptionMode,
bool blockQueue,
uint32_t commandType) {
OCLRT::LinearStream *commandStream = nullptr;
OCLRT::IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
LinearStream *commandStream = nullptr;
IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
auto parentKernel = multiDispatchInfo.peekParentKernel();
for (auto &dispatchInfo : multiDispatchInfo) {
@ -245,97 +246,4 @@ void HardwareInterface<GfxFamily>::dispatchWalker(
dispatchProfilingPerfEndCommands(hwTimeStamps, hwPerfCounter, commandStream, commandQueue);
}
template <typename GfxFamily>
inline void BaseInterfaceVersion<GfxFamily>::getDefaultDshSpace(
const size_t &offsetInterfaceDescriptorTable,
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
size_t &totalInterfaceDescriptorTableSize,
OCLRT::Kernel *parentKernel,
OCLRT::IndirectHeap *dsh,
OCLRT::LinearStream *commandStream) {
size_t numDispatches = multiDispatchInfo.size();
totalInterfaceDescriptorTableSize *= numDispatches;
if (!parentKernel) {
dsh->getSpace(totalInterfaceDescriptorTableSize);
} else {
dsh->getSpace(commandQueue.getContext().getDefaultDeviceQueue()->getDshOffset() - dsh->getUsed());
}
}
template <typename GfxFamily>
inline typename BaseInterfaceVersion<GfxFamily>::INTERFACE_DESCRIPTOR_DATA *
BaseInterfaceVersion<GfxFamily>::obtainInterfaceDescriptorData(
WALKER_HANDLE pCmdData) {
return nullptr;
}
template <typename GfxFamily>
inline void BaseInterfaceVersion<GfxFamily>::setOffsetCrossThreadData(
WALKER_HANDLE pCmdData,
size_t &offsetCrossThreadData,
uint32_t &interfaceDescriptorIndex) {
WALKER_TYPE<GfxFamily> *pCmd = static_cast<WALKER_TYPE<GfxFamily> *>(pCmdData);
pCmd->setIndirectDataStartAddress(static_cast<uint32_t>(offsetCrossThreadData));
pCmd->setInterfaceDescriptorOffset(interfaceDescriptorIndex++);
}
template <typename GfxFamily>
inline void BaseInterfaceVersion<GfxFamily>::dispatchWorkarounds(
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue,
OCLRT::Kernel &kernel,
const bool &enable) {
if (enable) {
PreemptionHelper::applyPreemptionWaCmdsBegin<GfxFamily>(commandStream, commandQueue.getDevice());
// Implement enabling special WA DisableLSQCROPERFforOCL if needed
GpgpuWalkerHelper<GfxFamily>::applyWADisableLSQCROPERFforOCL(commandStream, kernel, enable);
} else {
// Implement disabling special WA DisableLSQCROPERFforOCL if needed
GpgpuWalkerHelper<GfxFamily>::applyWADisableLSQCROPERFforOCL(commandStream, kernel, enable);
PreemptionHelper::applyPreemptionWaCmdsEnd<GfxFamily>(commandStream, commandQueue.getDevice());
}
}
template <typename GfxFamily>
inline void BaseInterfaceVersion<GfxFamily>::dispatchProfilingPerfStartCommands(
const OCLRT::DispatchInfo &dispatchInfo,
const MultiDispatchInfo &multiDispatchInfo,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue) {
if (&dispatchInfo == &*multiDispatchInfo.begin()) {
// If hwTimeStampAlloc is passed (not nullptr), then we know that profiling is enabled
if (hwTimeStamps != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsStart(*hwTimeStamps, commandStream);
}
if (hwPerfCounter != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsStart(commandQueue, *hwPerfCounter, commandStream);
}
}
}
template <typename GfxFamily>
inline void BaseInterfaceVersion<GfxFamily>::dispatchProfilingPerfEndCommands(
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue) {
// If hwTimeStamps is passed (not nullptr), then we know that profiling is enabled
if (hwTimeStamps != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(*hwTimeStamps, commandStream);
}
if (hwPerfCounter != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsEnd(commandQueue, *hwPerfCounter, commandStream);
}
}
} // namespace OCLRT

129
runtime/command_queue/hardware_interface/hardware_interface.h
View File

@ -1,129 +0,0 @@
/*
* Copyright (C) 2018 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "runtime/command_queue/command_queue.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/context/context.h"
#include "runtime/event/perf_counter.h"
#include "runtime/indirect_heap/indirect_heap.h"
#include "runtime/kernel/kernel.h"
#include "runtime/command_stream/linear_stream.h"
#include "runtime/event/hw_timestamps.h"
#include "runtime/command_stream/preemption.h"
#include "runtime/device_queue/device_queue_hw.h"
#include "runtime/helpers/dispatch_info.h"
#include "runtime/helpers/kernel_commands.h"
#include "runtime/helpers/task_information.h"
#include "runtime/helpers/timestamp_packet.h"
#include "runtime/program/kernel_info.h"
#include "runtime/utilities/vec.h"
namespace OCLRT {
using WALKER_HANDLE = void *;
template <typename GfxFamily>
class HardwareInterface {
public:
using INTERFACE_DESCRIPTOR_DATA = typename GfxFamily::INTERFACE_DESCRIPTOR_DATA;
void dispatchWalker(
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
cl_uint numEventsInWaitList,
const cl_event *eventWaitList,
KernelOperation **blockedCommandsData,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
TagNode<TimestampPacket> *previousTimestampPacketNode,
TimestampPacket *currentTimestampPacket,
PreemptionMode preemptionMode,
bool blockQueue,
uint32_t commandType = 0);
virtual void getDefaultDshSpace(
const size_t &offsetInterfaceDescriptorTable,
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
size_t &totalInterfaceDescriptorTableSize,
OCLRT::Kernel *parentKernel,
OCLRT::IndirectHeap *dsh,
OCLRT::LinearStream *commandStream) = 0;
virtual INTERFACE_DESCRIPTOR_DATA *obtainInterfaceDescriptorData(
WALKER_HANDLE pCmdData) = 0;
virtual void setOffsetCrossThreadData(
WALKER_HANDLE pCmdData,
size_t &offsetCrossThreadData,
uint32_t &interfaceDescriptorIndex) = 0;
virtual void dispatchWorkarounds(
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue,
OCLRT::Kernel &kernel,
const bool &enable) = 0;
virtual void dispatchProfilingPerfStartCommands(
const OCLRT::DispatchInfo &dispatchInfo,
const MultiDispatchInfo &multiDispatchInfo,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue) = 0;
virtual void dispatchProfilingPerfEndCommands(
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue) = 0;
};
template <typename GfxFamily>
class BaseInterfaceVersion : public HardwareInterface<GfxFamily> {
using INTERFACE_DESCRIPTOR_DATA = typename GfxFamily::INTERFACE_DESCRIPTOR_DATA;
void getDefaultDshSpace(
const size_t &offsetInterfaceDescriptorTable,
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
size_t &totalInterfaceDescriptorTableSize,
OCLRT::Kernel *parentKernel,
OCLRT::IndirectHeap *dsh,
OCLRT::LinearStream *commandStream) override;
INTERFACE_DESCRIPTOR_DATA *obtainInterfaceDescriptorData(
WALKER_HANDLE pCmdData) override;
void setOffsetCrossThreadData(
WALKER_HANDLE pCmdData,
size_t &offsetCrossThreadData,
uint32_t &interfaceDescriptorIndex) override;
void dispatchWorkarounds(
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue,
OCLRT::Kernel &kernel,
const bool &enable) override;
void dispatchProfilingPerfStartCommands(
const OCLRT::DispatchInfo &dispatchInfo,
const MultiDispatchInfo &multiDispatchInfo,
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue) override;
void dispatchProfilingPerfEndCommands(
HwTimeStamps *hwTimeStamps,
OCLRT::HwPerfCounter *hwPerfCounter,
OCLRT::LinearStream *commandStream,
CommandQueue &commandQueue) override;
};
} // namespace OCLRT

106
runtime/command_queue/hardware_interface_base.inl Normal file
View File

@ -0,0 +1,106 @@
/*
* Copyright (C) 2018 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "runtime/command_queue/hardware_interface.h"
namespace OCLRT {
template <typename GfxFamily>
inline void HardwareInterface<GfxFamily>::getDefaultDshSpace(
const size_t &offsetInterfaceDescriptorTable,
CommandQueue &commandQueue,
const MultiDispatchInfo &multiDispatchInfo,
size_t &totalInterfaceDescriptorTableSize,
Kernel *parentKernel,
IndirectHeap *dsh,
LinearStream *commandStream) {
size_t numDispatches = multiDispatchInfo.size();
totalInterfaceDescriptorTableSize *= numDispatches;
if (!parentKernel) {
dsh->getSpace(totalInterfaceDescriptorTableSize);
} else {
dsh->getSpace(commandQueue.getContext().getDefaultDeviceQueue()->getDshOffset() - dsh->getUsed());
}
}
template <typename GfxFamily>
inline typename HardwareInterface<GfxFamily>::INTERFACE_DESCRIPTOR_DATA *
HardwareInterface<GfxFamily>::obtainInterfaceDescriptorData(
WALKER_HANDLE pCmdData) {
return nullptr;
}
template <typename GfxFamily>
inline void HardwareInterface<GfxFamily>::setOffsetCrossThreadData(
WALKER_HANDLE pCmdData,
size_t &offsetCrossThreadData,
uint32_t &interfaceDescriptorIndex) {
WALKER_TYPE<GfxFamily> *pCmd = static_cast<WALKER_TYPE<GfxFamily> *>(pCmdData);
pCmd->setIndirectDataStartAddress(static_cast<uint32_t>(offsetCrossThreadData));
pCmd->setInterfaceDescriptorOffset(interfaceDescriptorIndex++);
}
template <typename GfxFamily>
inline void HardwareInterface<GfxFamily>::dispatchWorkarounds(
LinearStream *commandStream,
CommandQueue &commandQueue,
Kernel &kernel,
const bool &enable) {
if (enable) {
PreemptionHelper::applyPreemptionWaCmdsBegin<GfxFamily>(commandStream, commandQueue.getDevice());
// Implement enabling special WA DisableLSQCROPERFforOCL if needed
GpgpuWalkerHelper<GfxFamily>::applyWADisableLSQCROPERFforOCL(commandStream, kernel, enable);
} else {
// Implement disabling special WA DisableLSQCROPERFforOCL if needed
GpgpuWalkerHelper<GfxFamily>::applyWADisableLSQCROPERFforOCL(commandStream, kernel, enable);
PreemptionHelper::applyPreemptionWaCmdsEnd<GfxFamily>(commandStream, commandQueue.getDevice());
}
}
template <typename GfxFamily>
inline void HardwareInterface<GfxFamily>::dispatchProfilingPerfStartCommands(
const DispatchInfo &dispatchInfo,
const MultiDispatchInfo &multiDispatchInfo,
HwTimeStamps *hwTimeStamps,
HwPerfCounter *hwPerfCounter,
LinearStream *commandStream,
CommandQueue &commandQueue) {
if (&dispatchInfo == &*multiDispatchInfo.begin()) {
// If hwTimeStampAlloc is passed (not nullptr), then we know that profiling is enabled
if (hwTimeStamps != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsStart(*hwTimeStamps, commandStream);
}
if (hwPerfCounter != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsStart(commandQueue, *hwPerfCounter, commandStream);
}
}
}
template <typename GfxFamily>
inline void HardwareInterface<GfxFamily>::dispatchProfilingPerfEndCommands(
HwTimeStamps *hwTimeStamps,
HwPerfCounter *hwPerfCounter,
LinearStream *commandStream,
CommandQueue &commandQueue) {
// If hwTimeStamps is passed (not nullptr), then we know that profiling is enabled
if (hwTimeStamps != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchProfilingCommandsEnd(*hwTimeStamps, commandStream);
}
if (hwPerfCounter != nullptr) {
GpgpuWalkerHelper<GfxFamily>::dispatchPerfCountersCommandsEnd(commandQueue, *hwPerfCounter, commandStream);
}
}
} // namespace OCLRT

5
runtime/gen10/gpgpu_walker_gen10.cpp
View File

@ -8,9 +8,14 @@
#include "runtime/gen10/hw_info.h"
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/gpgpu_walker.inl"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/command_queue/hardware_interface.inl"
#include "runtime/command_queue/hardware_interface_base.inl"
namespace OCLRT {
template class HardwareInterface<CNLFamily>;
template class GpgpuWalkerHelper<CNLFamily>;
template struct EnqueueOperation<CNLFamily>;

10
runtime/gen10/hw_cmds.h
View File

@ -16,19 +16,15 @@
struct CnlParse;
namespace OCLRT {
template <class GfxFamily>
class BaseInterfaceVersion;
struct GEN10 {
#include "runtime/gen10/hw_cmds_generated_patched.h"
#include "runtime/gen10/hw_cmds_generated.h"
};
struct CNLFamily : public GEN10 {
typedef CnlParse PARSE;
typedef CNLFamily GfxFamily;
typedef GPGPU_WALKER WALKER_TYPE;
using HARDWARE_INTERFACE = BaseInterfaceVersion<CNLFamily>;
using PARSE = CnlParse;
using GfxFamily = CNLFamily;
using WALKER_TYPE = GPGPU_WALKER;
static const GPGPU_WALKER cmdInitGpgpuWalker;
static const INTERFACE_DESCRIPTOR_DATA cmdInitInterfaceDescriptorData;
static const MEDIA_INTERFACE_DESCRIPTOR_LOAD cmdInitMediaInterfaceDescriptorLoad;

5
runtime/gen8/gpgpu_walker_gen8.cpp
View File

@ -8,6 +8,9 @@
#include "runtime/gen8/hw_info.h"
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/gpgpu_walker.inl"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/command_queue/hardware_interface.inl"
#include "runtime/command_queue/hardware_interface_base.inl"
namespace OCLRT {
@ -51,6 +54,8 @@ size_t GpgpuWalkerHelper<BDWFamily>::getSizeForWADisableLSQCROPERFforOCL(const K
return n;
}
template class HardwareInterface<BDWFamily>;
template class GpgpuWalkerHelper<BDWFamily>;
template struct EnqueueOperation<BDWFamily>;

10
runtime/gen8/hw_cmds_base.h
View File

@ -16,18 +16,14 @@
struct BdwParse;
namespace OCLRT {
template <class GfxFamily>
class BaseInterfaceVersion;
struct GEN8 {
#include "runtime/gen8/hw_cmds_generated.h"
#include "runtime/gen8/hw_cmds_generated_patched.h"
};
struct BDWFamily : public GEN8 {
typedef BdwParse PARSE;
typedef BDWFamily GfxFamily;
typedef GPGPU_WALKER WALKER_TYPE;
using HARDWARE_INTERFACE = BaseInterfaceVersion<BDWFamily>;
using PARSE = BdwParse;
using GfxFamily = BDWFamily;
using WALKER_TYPE = GPGPU_WALKER;
static const GPGPU_WALKER cmdInitGpgpuWalker;
static const INTERFACE_DESCRIPTOR_DATA cmdInitInterfaceDescriptorData;
static const MEDIA_INTERFACE_DESCRIPTOR_LOAD cmdInitMediaInterfaceDescriptorLoad;

5
runtime/gen9/gpgpu_walker_gen9.cpp
View File

@ -8,6 +8,9 @@
#include "runtime/gen9/hw_cmds_base.h"
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/gpgpu_walker.inl"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/command_queue/hardware_interface.inl"
#include "runtime/command_queue/hardware_interface_base.inl"
namespace OCLRT {
@ -51,6 +54,8 @@ size_t GpgpuWalkerHelper<SKLFamily>::getSizeForWADisableLSQCROPERFforOCL(const K
return n;
}
template class HardwareInterface<SKLFamily>;
template class GpgpuWalkerHelper<SKLFamily>;
template struct EnqueueOperation<SKLFamily>;

10
runtime/gen9/hw_cmds_base.h
View File

@ -16,19 +16,15 @@ struct SklParse;
namespace OCLRT {
template <class GfxFamily>
class BaseInterfaceVersion;
struct GEN9 {
#include "runtime/gen9/hw_cmds_generated_patched.h"
#include "runtime/gen9/hw_cmds_generated.h"
};
struct SKLFamily : public GEN9 {
typedef SklParse PARSE;
typedef SKLFamily GfxFamily;
typedef GPGPU_WALKER WALKER_TYPE;
using HARDWARE_INTERFACE = BaseInterfaceVersion<SKLFamily>;
using PARSE = SklParse;
using GfxFamily = SKLFamily;
using WALKER_TYPE = GPGPU_WALKER;
static const GPGPU_WALKER cmdInitGpgpuWalker;
static const INTERFACE_DESCRIPTOR_DATA cmdInitInterfaceDescriptorData;
static const MEDIA_INTERFACE_DESCRIPTOR_LOAD cmdInitMediaInterfaceDescriptorLoad;

49
unit_tests/command_queue/dispatch_walker_tests.cpp
View File

@ -7,6 +7,7 @@
#include "test.h"
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/event/perf_counter.h"
#include "runtime/helpers/aligned_memory.h"
#include "runtime/helpers/kernel_commands.h"
@ -128,7 +129,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, shouldntChangeCommandStreamMemor
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -177,7 +178,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, noLocalIdsShouldntCrash) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -208,7 +209,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithDefaultLwsAlgorithm)
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimension, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -240,7 +241,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithSquaredLwsAlgorithm)
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimension, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -270,7 +271,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithNDLwsAlgorithm) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimension, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -301,7 +302,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterWorkDimensionswithOldLwsAlgorithm) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimension, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -332,7 +333,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNumWorkGroups) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, workGroupSize, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -365,7 +366,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithOutComputeND) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -397,7 +398,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithComputeND) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -430,7 +431,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithComputeSquared) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -463,7 +464,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterNoLocalWorkSizeWithOutComputeSquaredAn
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -494,7 +495,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSize) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, workGroupSize, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -528,7 +529,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizes) {
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, workGroupSize, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -566,7 +567,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizeForSplitKernel) {
MockMultiDispatchInfo multiDispatchInfo(std::vector<DispatchInfo *>({&di1, &di2}));
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -618,7 +619,7 @@ HWTEST_F(DispatchWalkerTest, dataParameterLocalWorkSizesForSplitWalker) {
multiDispatchInfo.push(di1);
multiDispatchInfo.push(di2);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -674,7 +675,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerDoesntConsumeCommandStreamWhenQueueIs
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, workGroupSize, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -715,7 +716,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromKernelW
DispatchInfo dispatchInfo(const_cast<MockKernel *>(&kernel), dimensions, workItems, workGroupSize, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -754,7 +755,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerShouldGetRequiredHeapSizesFromMdiWhen
KernelOperation *blockedCommandsData = nullptr;
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -788,7 +789,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfo) {
MockMultiDispatchInfo multiDispatchInfo(std::vector<Kernel *>({&kernel1, &kernel2}));
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -831,7 +832,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
indirectHeap.align(KernelCommandsHelper<FamilyType>::alignInterfaceDescriptorData);
auto dshBeforeMultiDisptach = indirectHeap.getUsed();
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -917,7 +918,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
// create commandStream
auto &cmdStream = pCmdQ->getCS(0);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -964,7 +965,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
// create commandStream
auto &cmdStream = pCmdQ->getCS(0);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -1016,7 +1017,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispat
// create commandStream
auto &cmdStream = pCmdQ->getCS(0);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -1069,7 +1070,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, givenMultiDispatchWhenWhiteliste
DispatchInfo di2(&kernel, 1, Vec3<size_t>(1, 1, 1), Vec3<size_t>(1, 1, 1), Vec3<size_t>(0, 0, 0));
MockMultiDispatchInfo multiDispatchInfo(std::vector<DispatchInfo *>({&di1, &di2}));
GpgpuWalkerHelper<FamilyType>::dispatchWalker(*pCmdQ, multiDispatchInfo, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, pDevice->getPreemptionMode(), false);
HardwareInterface<FamilyType>::dispatchWalker(*pCmdQ, multiDispatchInfo, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, pDevice->getPreemptionMode(), false);
hwParser.parseCommands<FamilyType>(cmdStream, 0);

17
unit_tests/execution_model/parent_kernel_dispatch_tests.cpp
View File

@ -6,6 +6,7 @@
*/
#include "runtime/command_queue/enqueue_kernel.h"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/event/perf_counter.h"
#include "runtime/kernel/kernel.h"
#include "runtime/sampler/sampler.h"
@ -41,7 +42,7 @@ HWTEST_P(ParentKernelDispatchTest, givenParentKernelWhenQueueIsNotBlockedThenDev
DispatchInfo dispatchInfo(pKernel, 1, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo(pKernel);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -98,7 +99,7 @@ HWTEST_P(ParentKernelDispatchTest, givenParentKernelWhenQueueIsNotBlockedThenDef
DispatchInfo dispatchInfo(pKernel, 1, workItems, nullptr, globalOffsets);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -125,7 +126,7 @@ HWTEST_P(ParentKernelDispatchTest, givenParentKernelWhenQueueIsNotBlockedThenSSH
MockMultiDispatchInfo multiDispatchInfo(pKernel);
DispatchInfo dispatchInfo(pKernel, 1, workItems, nullptr, globalOffsets);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -162,7 +163,7 @@ HWTEST_P(ParentKernelDispatchTest, givenParentKernelWhenQueueIsBlockedThenSSHSiz
DispatchInfo dispatchInfo(pKernel, 1, workItems, nullptr, globalOffsets);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -261,7 +262,7 @@ HWTEST_F(MockParentKernelDispatch, GivenBlockedQueueWhenParentKernelIsDispatched
DispatchInfo dispatchInfo(mockParentKernel, 1, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo(mockParentKernel);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -296,7 +297,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, MockParentKernelDispatch, GivenParentKernelWhenDispa
DispatchInfo dispatchInfo(mockParentKernel, 1, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo(mockParentKernel);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -354,7 +355,7 @@ HWTEST_F(MockParentKernelDispatch, GivenUsedSSHHeapWhenParentKernelIsDispatchedT
DispatchInfo dispatchInfo(mockParentKernel, 1, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo(mockParentKernel);
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,
@ -391,7 +392,7 @@ HWTEST_F(MockParentKernelDispatch, GivenNotUsedSSHHeapWhenParentKernelIsDispatch
DispatchInfo dispatchInfo(mockParentKernel, 1, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo;
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,

3
unit_tests/execution_model/submit_blocked_parent_kernel_tests.cpp
View File

@ -6,6 +6,7 @@
*/
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/event/hw_timestamps.h"
#include "runtime/helpers/kernel_commands.h"
#include "runtime/helpers/task_information.h"
@ -419,7 +420,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenBlockedCommand
DispatchInfo dispatchInfo(parentKernel.get(), 1, workItems, nullptr, globalOffsets);
MultiDispatchInfo multiDispatchInfo(parentKernel.get());
multiDispatchInfo.push(dispatchInfo);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*pCmdQ,
multiDispatchInfo,
0,

5
unit_tests/helpers/timestamp_packet_tests.cpp
View File

@ -6,6 +6,7 @@
*/
#include "runtime/command_queue/gpgpu_walker.h"
#include "runtime/command_queue/hardware_interface.h"
#include "runtime/helpers/options.h"
#include "runtime/helpers/timestamp_packet.h"
#include "runtime/utilities/tag_allocator.h"
@ -247,7 +248,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, TimestampPacketTests, givenTimestampPacketWhenDispat
auto &cmdStream = mockCmdQ->getCS(0);
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*mockCmdQ,
multiDispatchInfo,
0,
@ -505,7 +506,7 @@ HWTEST_F(TimestampPacketTests, givenTimestampPacketWriteEnabledWhenDispatchingTh
cl_event waitlist[] = {&event1, &event2, &event3, &event4, &event5, &event6};
GpgpuWalkerHelper<FamilyType>::dispatchWalker(
HardwareInterface<FamilyType>::dispatchWalker(
*mockCmdQ,
multiDispatchInfo,
eventsOnWaitlist,

6
unit_tests/libult/mock_gfx_family.h
View File

@ -11,9 +11,6 @@
namespace OCLRT {
template <class GfxFamily>
class BaseInterfaceVersion;
extern HwHelper *hwHelperFactory[IGFX_MAX_CORE];
struct GENX {
@ -374,8 +371,7 @@ struct GENX {
inline void setMemoryAddressHigh(uint32_t) {}
} MI_ATOMIC;
using HARDWARE_INTERFACE = BaseInterfaceVersion<GENX>;
typedef GPGPU_WALKER WALKER_TYPE;
using WALKER_TYPE = GPGPU_WALKER;
static GPGPU_WALKER cmdInitGpgpuWalker;
static INTERFACE_DESCRIPTOR_DATA cmdInitInterfaceDescriptorData;
static MEDIA_STATE_FLUSH cmdInitMediaStateFlush;