intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 08:53:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move dispatch builder to seperate file

Browse Source 
Change-Id: I309986902fda41a389e9facbf186bc8b2740af7a
Signed-off-by: Maciej Plewka <maciej.plewka@intel.com>
This commit is contained in:
Maciej Plewka
2020-02-21 11:37:14 +01:00
committed by sys_ocldev
parent 1a126a443a
commit 13e59b26b5
45 changed files with 936 additions and 910 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/built_ins/CMakeLists.txt
View File

@@ -7,6 +7,7 @@
set(RUNTIME_SRCS_BUILT_INS
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/aux_translation_builtin.h
${CMAKE_CURRENT_SOURCE_DIR}/builtins_dispatch_builder.cpp
${CMAKE_CURRENT_SOURCE_DIR}/builtins_dispatch_builder.h
${CMAKE_CURRENT_SOURCE_DIR}/built_ins_storage.cpp
${CMAKE_CURRENT_SOURCE_DIR}/built_ins.cpp

732
runtime/built_ins/built_ins.cpp
View File

@@ -11,7 +11,6 @@
#include "core/helpers/basic_math.h"
#include "core/helpers/debug_helpers.h"
#include "runtime/built_ins/aux_translation_builtin.h"
#include "runtime/built_ins/built_ins.inl"
#include "runtime/built_ins/sip.h"
#include "runtime/device/cl_device.h"
#include "runtime/helpers/built_ins_helper.h"
@@ -71,737 +70,6 @@ const SipKernel &BuiltIns::getSipKernel(SipKernelType type, Device &device) {
return *sipBuiltIn.first;
}
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToBuffer> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToBuffer,
"",
"CopyBufferToBufferLeftLeftover", kernLeftLeftover,
"CopyBufferToBufferMiddle", kernMiddle,
"CopyBufferToBufferRightLeftover", kernRightLeftover);
}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d1D, SplitDispatch::SplitMode::KernelSplit> kernelSplit1DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
uintptr_t start = reinterpret_cast<uintptr_t>(operationParams.dstPtr) + operationParams.dstOffset.x;
size_t middleAlignment = MemoryConstants::cacheLineSize;
size_t middleElSize = sizeof(uint32_t) * 4;
uintptr_t leftSize = start % middleAlignment;
leftSize = (leftSize > 0) ? (middleAlignment - leftSize) : 0; // calc left leftover size
leftSize = std::min(leftSize, operationParams.size.x); // clamp left leftover size to requested size
uintptr_t rightSize = (start + operationParams.size.x) % middleAlignment; // calc right leftover size
rightSize = std::min(rightSize, operationParams.size.x - leftSize); // clamp
uintptr_t middleSizeBytes = operationParams.size.x - leftSize - rightSize; // calc middle size
if (!isAligned<4>(reinterpret_cast<uintptr_t>(operationParams.srcPtr) + operationParams.srcOffset.x + leftSize)) {
//corner case - src relative to dst does not have DWORD alignment
leftSize += middleSizeBytes;
middleSizeBytes = 0;
}
auto middleSizeEls = middleSizeBytes / middleElSize; // num work items in middle walker
// Set-up ISA
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Left, kernLeftLeftover);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Middle, kernMiddle);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Right, kernRightLeftover);
// Set-up common kernel args
if (operationParams.srcSvmAlloc) {
kernelSplit1DBuilder.setArgSvmAlloc(0, operationParams.srcPtr, operationParams.srcSvmAlloc);
} else if (operationParams.srcMemObj) {
kernelSplit1DBuilder.setArg(0, operationParams.srcMemObj);
} else {
kernelSplit1DBuilder.setArgSvm(0, operationParams.size.x + operationParams.srcOffset.x, operationParams.srcPtr, nullptr, CL_MEM_READ_ONLY);
}
if (operationParams.dstSvmAlloc) {
kernelSplit1DBuilder.setArgSvmAlloc(1, operationParams.dstPtr, operationParams.dstSvmAlloc);
} else if (operationParams.dstMemObj) {
kernelSplit1DBuilder.setArg(1, operationParams.dstMemObj);
} else {
kernelSplit1DBuilder.setArgSvm(1, operationParams.size.x + operationParams.dstOffset.x, operationParams.dstPtr, nullptr, 0u);
}
kernelSplit1DBuilder.setUnifiedMemorySyncRequirement(operationParams.unifiedMemoryArgsRequireMemSync);
// Set-up srcOffset
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 2, static_cast<OffsetType>(operationParams.srcOffset.x));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 2, static_cast<OffsetType>(operationParams.srcOffset.x + leftSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 2, static_cast<OffsetType>(operationParams.srcOffset.x + leftSize + middleSizeBytes));
// Set-up dstOffset
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 3, static_cast<OffsetType>(operationParams.dstOffset.x));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 3, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 3, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize + middleSizeBytes));
// Set-up work sizes
// Note for split walker, it would be just builder.SetDipatchGeometry(GWS, ELWS, OFFSET)
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Left, Vec3<size_t>{leftSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Middle, Vec3<size_t>{middleSizeEls, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Right, Vec3<size_t>{rightSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.bake(multiDispatchInfo);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernLeftLeftover = nullptr;
Kernel *kernMiddle = nullptr;
Kernel *kernRightLeftover = nullptr;
BuiltInOp(BuiltIns &kernelsLib)
: BuiltinDispatchInfoBuilder(kernelsLib) {
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToBufferStateless> : public BuiltInOp<EBuiltInOps::CopyBufferToBuffer> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyBufferToBuffer>(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToBufferStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyBufferToBufferLeftLeftover", kernLeftLeftover,
"CopyBufferToBufferMiddle", kernMiddle,
"CopyBufferToBufferRightLeftover", kernRightLeftover);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferRect> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib), kernelBytes{nullptr} {
populate(device,
EBuiltInOps::CopyBufferRect,
"",
"CopyBufferRectBytes2d", kernelBytes[0],
"CopyBufferRectBytes2d", kernelBytes[1],
"CopyBufferRectBytes3d", kernelBytes[2]);
}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
size_t hostPtrSize = 0;
bool is3D = false;
if (operationParams.srcMemObj && operationParams.dstMemObj) {
DEBUG_BREAK_IF(!((operationParams.srcPtr == nullptr) && (operationParams.dstPtr == nullptr)));
is3D = (operationParams.size.z > 1) || (operationParams.srcOffset.z > 0) || (operationParams.dstOffset.z > 0);
} else {
if (operationParams.srcPtr) {
size_t origin[] = {operationParams.srcOffset.x, operationParams.srcOffset.y, operationParams.srcOffset.z};
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
hostPtrSize = Buffer::calculateHostPtrSize(origin, region, operationParams.srcRowPitch, operationParams.srcSlicePitch);
is3D = (operationParams.size.z > 1) || (operationParams.dstOffset.z > 0);
} else if (operationParams.dstPtr) {
size_t origin[] = {operationParams.dstOffset.x, operationParams.dstOffset.y, operationParams.dstOffset.z};
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
hostPtrSize = Buffer::calculateHostPtrSize(origin, region, operationParams.dstRowPitch, operationParams.dstSlicePitch);
is3D = (operationParams.size.z > 1) || (operationParams.srcOffset.z > 0);
} else {
DEBUG_BREAK_IF(!false);
}
}
// Set-up ISA
int dimensions = is3D ? 3 : 2;
kernelNoSplit3DBuilder.setKernel(kernelBytes[dimensions - 1]);
size_t srcOffsetFromAlignedPtr = 0;
size_t dstOffsetFromAlignedPtr = 0;
// arg0 = src
if (operationParams.srcMemObj) {
kernelNoSplit3DBuilder.setArg(0, operationParams.srcMemObj);
} else {
void *srcPtrToSet = operationParams.srcPtr;
if (!is3D) {
auto srcPtr = ptrOffset(operationParams.srcPtr, operationParams.srcOffset.z * operationParams.srcSlicePitch);
srcPtrToSet = alignDown(srcPtr, 4);
srcOffsetFromAlignedPtr = ptrDiff(srcPtr, srcPtrToSet);
}
kernelNoSplit3DBuilder.setArgSvm(0, hostPtrSize, srcPtrToSet, nullptr, CL_MEM_READ_ONLY);
}
// arg1 = dst
if (operationParams.dstMemObj) {
kernelNoSplit3DBuilder.setArg(1, operationParams.dstMemObj);
} else {
void *dstPtrToSet = operationParams.dstPtr;
if (!is3D) {
auto dstPtr = ptrOffset(operationParams.dstPtr, operationParams.dstOffset.z * operationParams.dstSlicePitch);
dstPtrToSet = alignDown(dstPtr, 4);
dstOffsetFromAlignedPtr = ptrDiff(dstPtr, dstPtrToSet);
}
kernelNoSplit3DBuilder.setArgSvm(1, hostPtrSize, dstPtrToSet, nullptr, 0u);
}
// arg2 = srcOrigin
OffsetType kSrcOrigin[4] = {static_cast<OffsetType>(operationParams.srcOffset.x + srcOffsetFromAlignedPtr), static_cast<OffsetType>(operationParams.srcOffset.y), static_cast<OffsetType>(operationParams.srcOffset.z), 0};
kernelNoSplit3DBuilder.setArg(2, sizeof(OffsetType) * 4, kSrcOrigin);
// arg3 = dstOrigin
OffsetType kDstOrigin[4] = {static_cast<OffsetType>(operationParams.dstOffset.x + dstOffsetFromAlignedPtr), static_cast<OffsetType>(operationParams.dstOffset.y), static_cast<OffsetType>(operationParams.dstOffset.z), 0};
kernelNoSplit3DBuilder.setArg(3, sizeof(OffsetType) * 4, kDstOrigin);
// arg4 = srcPitch
OffsetType kSrcPitch[2] = {static_cast<OffsetType>(operationParams.srcRowPitch), static_cast<OffsetType>(operationParams.srcSlicePitch)};
kernelNoSplit3DBuilder.setArg(4, sizeof(OffsetType) * 2, kSrcPitch);
// arg5 = dstPitch
OffsetType kDstPitch[2] = {static_cast<OffsetType>(operationParams.dstRowPitch), static_cast<OffsetType>(operationParams.dstSlicePitch)};
kernelNoSplit3DBuilder.setArg(5, sizeof(OffsetType) * 2, kDstPitch);
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernelBytes[3];
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib), kernelBytes{nullptr} {};
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferRectStateless> : public BuiltInOp<EBuiltInOps::CopyBufferRect> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyBufferRect>(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferRectStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyBufferRectBytes2d", kernelBytes[0],
"CopyBufferRectBytes2d", kernelBytes[1],
"CopyBufferRectBytes3d", kernelBytes[2]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::FillBuffer> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::FillBuffer,
"",
"FillBufferLeftLeftover", kernLeftLeftover,
"FillBufferMiddle", kernMiddle,
"FillBufferRightLeftover", kernRightLeftover);
}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d1D, SplitDispatch::SplitMode::KernelSplit> kernelSplit1DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
uintptr_t start = reinterpret_cast<uintptr_t>(operationParams.dstPtr) + operationParams.dstOffset.x;
size_t middleAlignment = MemoryConstants::cacheLineSize;
size_t middleElSize = sizeof(uint32_t);
uintptr_t leftSize = start % middleAlignment;
leftSize = (leftSize > 0) ? (middleAlignment - leftSize) : 0; // calc left leftover size
leftSize = std::min(leftSize, operationParams.size.x); // clamp left leftover size to requested size
uintptr_t rightSize = (start + operationParams.size.x) % middleAlignment; // calc right leftover size
rightSize = std::min(rightSize, operationParams.size.x - leftSize); // clamp
uintptr_t middleSizeBytes = operationParams.size.x - leftSize - rightSize; // calc middle size
auto middleSizeEls = middleSizeBytes / middleElSize; // num work items in middle walker
// Set-up ISA
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Left, kernLeftLeftover);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Middle, kernMiddle);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Right, kernRightLeftover);
DEBUG_BREAK_IF((operationParams.srcMemObj == nullptr) || (operationParams.srcOffset != 0));
DEBUG_BREAK_IF((operationParams.dstMemObj == nullptr) && (operationParams.dstSvmAlloc == nullptr));
// Set-up dstMemObj with buffer
if (operationParams.dstSvmAlloc) {
kernelSplit1DBuilder.setArgSvmAlloc(0, operationParams.dstPtr, operationParams.dstSvmAlloc);
} else {
kernelSplit1DBuilder.setArg(0, operationParams.dstMemObj);
}
// Set-up dstOffset
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 1, static_cast<OffsetType>(operationParams.dstOffset.x));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 1, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 1, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize + middleSizeBytes));
// Set-up srcMemObj with pattern
kernelSplit1DBuilder.setArgSvm(2, operationParams.srcMemObj->getSize(), operationParams.srcMemObj->getGraphicsAllocation()->getUnderlyingBuffer(), operationParams.srcMemObj->getGraphicsAllocation(), CL_MEM_READ_ONLY);
// Set-up patternSizeInEls
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 3, static_cast<OffsetType>(operationParams.srcMemObj->getSize()));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 3, static_cast<OffsetType>(operationParams.srcMemObj->getSize() / middleElSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 3, static_cast<OffsetType>(operationParams.srcMemObj->getSize()));
// Set-up work sizes
// Note for split walker, it would be just builder.SetDipatchGeomtry(GWS, ELWS, OFFSET)
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Left, Vec3<size_t>{leftSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Middle, Vec3<size_t>{middleSizeEls, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Right, Vec3<size_t>{rightSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.bake(multiDispatchInfo);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernLeftLeftover = nullptr;
Kernel *kernMiddle = nullptr;
Kernel *kernRightLeftover = nullptr;
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib) {}
};
template <>
class BuiltInOp<EBuiltInOps::FillBufferStateless> : public BuiltInOp<EBuiltInOps::FillBuffer> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device) : BuiltInOp<EBuiltInOps::FillBuffer>(kernelsLib) {
populate(device,
EBuiltInOps::FillBufferStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"FillBufferLeftLeftover", kernLeftLeftover,
"FillBufferMiddle", kernMiddle,
"FillBufferRightLeftover", kernRightLeftover);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToImage3d> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToImage3d,
"",
"CopyBufferToImage3dBytes", kernelBytes[0],
"CopyBufferToImage3d2Bytes", kernelBytes[1],
"CopyBufferToImage3d4Bytes", kernelBytes[2],
"CopyBufferToImage3d8Bytes", kernelBytes[3],
"CopyBufferToImage3d16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernelBytes[5] = {nullptr};
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib){};
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!(((operationParams.srcPtr != nullptr) || (operationParams.srcMemObj != nullptr)) && (operationParams.dstPtr == nullptr)));
auto dstImage = castToObjectOrAbort<Image>(operationParams.dstMemObj);
// Redescribe image to be byte-copy
auto dstImageRedescribed = dstImage->redescribe();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(dstImageRedescribed)); // life range same as mdi's
// Calculate srcRowPitch and srcSlicePitch
auto bytesPerPixel = dstImage->getSurfaceFormatInfo().surfaceFormat.ImageElementSizeInBytes;
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
auto srcRowPitch = operationParams.dstRowPitch ? operationParams.dstRowPitch : region[0] * bytesPerPixel;
auto srcSlicePitch =
operationParams.dstSlicePitch ? operationParams.dstSlicePitch : ((dstImage->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY ? 1 : region[1]) * srcRowPitch);
// Determine size of host ptr surface for residency purposes
size_t hostPtrSize = operationParams.srcPtr ? Image::calculateHostPtrSize(region, srcRowPitch, srcSlicePitch, bytesPerPixel, dstImage->getImageDesc().image_type) : 0;
hostPtrSize += operationParams.srcOffset.x;
// Set-up kernel
auto bytesExponent = Math::log2(bytesPerPixel);
DEBUG_BREAK_IF(bytesExponent >= 5);
kernelNoSplit3DBuilder.setKernel(kernelBytes[bytesExponent]);
// Set-up source host ptr / buffer
if (operationParams.srcPtr) {
kernelNoSplit3DBuilder.setArgSvm(0, hostPtrSize, operationParams.srcPtr, nullptr, CL_MEM_READ_ONLY);
} else {
kernelNoSplit3DBuilder.setArg(0, operationParams.srcMemObj);
}
// Set-up destination image
kernelNoSplit3DBuilder.setArg(1, dstImageRedescribed, operationParams.dstMipLevel);
// Set-up srcOffset
kernelNoSplit3DBuilder.setArg(2, static_cast<OffsetType>(operationParams.srcOffset.x));
// Set-up dstOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.dstOffset.x),
static_cast<uint32_t>(operationParams.dstOffset.y),
static_cast<uint32_t>(operationParams.dstOffset.z),
0};
kernelNoSplit3DBuilder.setArg(3, sizeof(origin), origin);
}
// Set-up srcRowPitch
{
OffsetType pitch[] = {
static_cast<OffsetType>(srcRowPitch),
static_cast<OffsetType>(srcSlicePitch)};
kernelNoSplit3DBuilder.setArg(4, sizeof(pitch), pitch);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToImage3dStateless> : public BuiltInOp<EBuiltInOps::CopyBufferToImage3d> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyBufferToImage3d>(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToImage3dStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyBufferToImage3dBytes", kernelBytes[0],
"CopyBufferToImage3d2Bytes", kernelBytes[1],
"CopyBufferToImage3d4Bytes", kernelBytes[2],
"CopyBufferToImage3d8Bytes", kernelBytes[3],
"CopyBufferToImage3d16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyImage3dToBuffer> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::CopyImage3dToBuffer,
"",
"CopyImage3dToBufferBytes", kernelBytes[0],
"CopyImage3dToBuffer2Bytes", kernelBytes[1],
"CopyImage3dToBuffer4Bytes", kernelBytes[2],
"CopyImage3dToBuffer8Bytes", kernelBytes[3],
"CopyImage3dToBuffer16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernelBytes[5] = {nullptr};
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib) {}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!((operationParams.srcPtr == nullptr) && ((operationParams.dstPtr != nullptr) || (operationParams.dstMemObj != nullptr))));
auto srcImage = castToObjectOrAbort<Image>(operationParams.srcMemObj);
// Redescribe image to be byte-copy
auto srcImageRedescribed = srcImage->redescribe();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(srcImageRedescribed)); // life range same as mdi's
// Calculate dstRowPitch and dstSlicePitch
auto bytesPerPixel = srcImage->getSurfaceFormatInfo().surfaceFormat.ImageElementSizeInBytes;
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
auto dstRowPitch = operationParams.srcRowPitch ? operationParams.srcRowPitch : region[0] * bytesPerPixel;
auto dstSlicePitch =
operationParams.srcSlicePitch ? operationParams.srcSlicePitch : ((srcImage->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY ? 1 : region[1]) * dstRowPitch);
// Determine size of host ptr surface for residency purposes
size_t hostPtrSize = operationParams.dstPtr ? Image::calculateHostPtrSize(region, dstRowPitch, dstSlicePitch, bytesPerPixel, srcImage->getImageDesc().image_type) : 0;
hostPtrSize += operationParams.dstOffset.x;
// Set-up ISA
auto bytesExponent = Math::log2(bytesPerPixel);
DEBUG_BREAK_IF(bytesExponent >= 5);
kernelNoSplit3DBuilder.setKernel(kernelBytes[bytesExponent]);
// Set-up source image
kernelNoSplit3DBuilder.setArg(0, srcImageRedescribed, operationParams.srcMipLevel);
// Set-up destination host ptr / buffer
if (operationParams.dstPtr) {
kernelNoSplit3DBuilder.setArgSvm(1, hostPtrSize, operationParams.dstPtr, nullptr, 0u);
} else {
kernelNoSplit3DBuilder.setArg(1, operationParams.dstMemObj);
}
// Set-up srcOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.srcOffset.x),
static_cast<uint32_t>(operationParams.srcOffset.y),
static_cast<uint32_t>(operationParams.srcOffset.z),
0};
kernelNoSplit3DBuilder.setArg(2, sizeof(origin), origin);
}
// Set-up dstOffset
kernelNoSplit3DBuilder.setArg(3, static_cast<OffsetType>(operationParams.dstOffset.x));
// Set-up dstRowPitch
{
OffsetType pitch[] = {
static_cast<OffsetType>(dstRowPitch),
static_cast<OffsetType>(dstSlicePitch)};
kernelNoSplit3DBuilder.setArg(4, sizeof(pitch), pitch);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyImage3dToBufferStateless> : public BuiltInOp<EBuiltInOps::CopyImage3dToBuffer> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyImage3dToBuffer>(kernelsLib) {
populate(device,
EBuiltInOps::CopyImage3dToBufferStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyImage3dToBufferBytes", kernelBytes[0],
"CopyImage3dToBuffer2Bytes", kernelBytes[1],
"CopyImage3dToBuffer4Bytes", kernelBytes[2],
"CopyImage3dToBuffer8Bytes", kernelBytes[3],
"CopyImage3dToBuffer16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyImageToImage3d> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib), kernel(nullptr) {
populate(device,
EBuiltInOps::CopyImageToImage3d,
"",
"CopyImageToImage3d", kernel);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!((operationParams.srcPtr == nullptr) && (operationParams.dstPtr == nullptr)));
auto srcImage = castToObjectOrAbort<Image>(operationParams.srcMemObj);
auto dstImage = castToObjectOrAbort<Image>(operationParams.dstMemObj);
// Redescribe images to be byte-copies
auto srcImageRedescribed = srcImage->redescribe();
auto dstImageRedescribed = dstImage->redescribe();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(srcImageRedescribed)); // life range same as mdi's
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(dstImageRedescribed)); // life range same as mdi's
// Set-up kernel
kernelNoSplit3DBuilder.setKernel(kernel);
// Set-up source image
kernelNoSplit3DBuilder.setArg(0, srcImageRedescribed, operationParams.srcMipLevel);
// Set-up destination image
kernelNoSplit3DBuilder.setArg(1, dstImageRedescribed, operationParams.dstMipLevel);
// Set-up srcOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.srcOffset.x),
static_cast<uint32_t>(operationParams.srcOffset.y),
static_cast<uint32_t>(operationParams.srcOffset.z),
0};
kernelNoSplit3DBuilder.setArg(2, sizeof(origin), origin);
}
// Set-up dstOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.dstOffset.x),
static_cast<uint32_t>(operationParams.dstOffset.y),
static_cast<uint32_t>(operationParams.dstOffset.z),
0};
kernelNoSplit3DBuilder.setArg(3, sizeof(origin), origin);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
protected:
Kernel *kernel;
};
template <>
class BuiltInOp<EBuiltInOps::FillImage3d> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib), kernel(nullptr) {
populate(device,
EBuiltInOps::FillImage3d,
"",
"FillImage3d", kernel);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!((operationParams.srcMemObj == nullptr) && (operationParams.srcPtr != nullptr) && (operationParams.dstPtr == nullptr)));
auto image = castToObjectOrAbort<Image>(operationParams.dstMemObj);
// Redescribe image to be byte-copy
auto imageRedescribed = image->redescribeFillImage();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(imageRedescribed));
// Set-up kernel
kernelNoSplit3DBuilder.setKernel(kernel);
// Set-up destination image
kernelNoSplit3DBuilder.setArg(0, imageRedescribed);
// Set-up fill color
int iFillColor[4] = {0};
const void *fillColor = operationParams.srcPtr;
convertFillColor(fillColor,
iFillColor,
image->getSurfaceFormatInfo().OCLImageFormat,
imageRedescribed->getSurfaceFormatInfo().OCLImageFormat);
kernelNoSplit3DBuilder.setArg(1, 4 * sizeof(int32_t), iFillColor);
// Set-up dstOffset
{
uint32_t offset[] = {
static_cast<uint32_t>(operationParams.dstOffset.x),
static_cast<uint32_t>(operationParams.dstOffset.y),
static_cast<uint32_t>(operationParams.dstOffset.z),
0};
kernelNoSplit3DBuilder.setArg(2, sizeof(offset), offset);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
protected:
Kernel *kernel;
};
BuiltinDispatchInfoBuilder &BuiltIns::getBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Device &device) {
uint32_t operationId = static_cast<uint32_t>(operation);
auto &operationBuilder = BuiltinOpsBuilders[operationId];
switch (operation) {
case EBuiltInOps::CopyBufferToBuffer:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToBuffer>>(*this, device); });
break;
case EBuiltInOps::CopyBufferToBufferStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToBufferStateless>>(*this, device); });
break;
case EBuiltInOps::CopyBufferRect:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferRect>>(*this, device); });
break;
case EBuiltInOps::CopyBufferRectStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferRectStateless>>(*this, device); });
break;
case EBuiltInOps::FillBuffer:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillBuffer>>(*this, device); });
break;
case EBuiltInOps::FillBufferStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillBufferStateless>>(*this, device); });
break;
case EBuiltInOps::CopyBufferToImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToImage3d>>(*this, device); });
break;
case EBuiltInOps::CopyBufferToImage3dStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToImage3dStateless>>(*this, device); });
break;
case EBuiltInOps::CopyImage3dToBuffer:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyImage3dToBuffer>>(*this, device); });
break;
case EBuiltInOps::CopyImage3dToBufferStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyImage3dToBufferStateless>>(*this, device); });
break;
case EBuiltInOps::CopyImageToImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyImageToImage3d>>(*this, device); });
break;
case EBuiltInOps::FillImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillImage3d>>(*this, device); });
break;
case EBuiltInOps::AuxTranslation:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::AuxTranslation>>(*this, device); });
break;
default:
return getUnknownDispatchInfoBuilder(operation, device);
}
return *operationBuilder.first;
}
BuiltInOwnershipWrapper::BuiltInOwnershipWrapper(BuiltinDispatchInfoBuilder &inputBuilder, Context *context) {
takeOwnership(inputBuilder, context);
}

5
runtime/built_ins/built_ins.h
View File

@@ -167,11 +167,6 @@ class BuiltinDispatchInfoBuilder;
class BuiltIns {
public:
std::pair<std::unique_ptr<BuiltinDispatchInfoBuilder>, std::once_flag> BuiltinOpsBuilders[static_cast<uint32_t>(EBuiltInOps::COUNT)];
BuiltinDispatchInfoBuilder &getBuiltinDispatchInfoBuilder(EBuiltInOps::Type op, Device &device);
BuiltinDispatchInfoBuilder &getUnknownDispatchInfoBuilder(EBuiltInOps::Type op, Device &device);
std::unique_ptr<BuiltinDispatchInfoBuilder> setBuiltinDispatchInfoBuilder(EBuiltInOps::Type op, Device &device,
std::unique_ptr<BuiltinDispatchInfoBuilder> newBuilder);
BuiltIns();
virtual ~BuiltIns();

763
runtime/built_ins/builtins_dispatch_builder.cpp Normal file
View File

@@ -0,0 +1,763 @@
/*
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/built_ins/builtins_dispatch_builder.h"
#include "core/compiler_interface/compiler_interface.h"
#include "core/helpers/basic_math.h"
#include "core/helpers/debug_helpers.h"
#include "runtime/built_ins/aux_translation_builtin.h"
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/built_ins.inl"
#include "runtime/built_ins/sip.h"
#include "runtime/built_ins/vme_dispatch_builder.h"
#include "runtime/device/cl_device.h"
#include "runtime/helpers/built_ins_helper.h"
#include "runtime/helpers/convert_color.h"
#include "runtime/helpers/dispatch_info_builder.h"
#include "runtime/kernel/kernel.h"
#include "runtime/mem_obj/image.h"
#include "runtime/program/program.h"
#include "compiler_options.h"
#include <cstdint>
#include <sstream>
namespace NEO {
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToBuffer> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToBuffer,
"",
"CopyBufferToBufferLeftLeftover", kernLeftLeftover,
"CopyBufferToBufferMiddle", kernMiddle,
"CopyBufferToBufferRightLeftover", kernRightLeftover);
}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d1D, SplitDispatch::SplitMode::KernelSplit> kernelSplit1DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
uintptr_t start = reinterpret_cast<uintptr_t>(operationParams.dstPtr) + operationParams.dstOffset.x;
size_t middleAlignment = MemoryConstants::cacheLineSize;
size_t middleElSize = sizeof(uint32_t) * 4;
uintptr_t leftSize = start % middleAlignment;
leftSize = (leftSize > 0) ? (middleAlignment - leftSize) : 0; // calc left leftover size
leftSize = std::min(leftSize, operationParams.size.x); // clamp left leftover size to requested size
uintptr_t rightSize = (start + operationParams.size.x) % middleAlignment; // calc right leftover size
rightSize = std::min(rightSize, operationParams.size.x - leftSize); // clamp
uintptr_t middleSizeBytes = operationParams.size.x - leftSize - rightSize; // calc middle size
if (!isAligned<4>(reinterpret_cast<uintptr_t>(operationParams.srcPtr) + operationParams.srcOffset.x + leftSize)) {
//corner case - src relative to dst does not have DWORD alignment
leftSize += middleSizeBytes;
middleSizeBytes = 0;
}
auto middleSizeEls = middleSizeBytes / middleElSize; // num work items in middle walker
// Set-up ISA
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Left, kernLeftLeftover);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Middle, kernMiddle);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Right, kernRightLeftover);
// Set-up common kernel args
if (operationParams.srcSvmAlloc) {
kernelSplit1DBuilder.setArgSvmAlloc(0, operationParams.srcPtr, operationParams.srcSvmAlloc);
} else if (operationParams.srcMemObj) {
kernelSplit1DBuilder.setArg(0, operationParams.srcMemObj);
} else {
kernelSplit1DBuilder.setArgSvm(0, operationParams.size.x + operationParams.srcOffset.x, operationParams.srcPtr, nullptr, CL_MEM_READ_ONLY);
}
if (operationParams.dstSvmAlloc) {
kernelSplit1DBuilder.setArgSvmAlloc(1, operationParams.dstPtr, operationParams.dstSvmAlloc);
} else if (operationParams.dstMemObj) {
kernelSplit1DBuilder.setArg(1, operationParams.dstMemObj);
} else {
kernelSplit1DBuilder.setArgSvm(1, operationParams.size.x + operationParams.dstOffset.x, operationParams.dstPtr, nullptr, 0u);
}
kernelSplit1DBuilder.setUnifiedMemorySyncRequirement(operationParams.unifiedMemoryArgsRequireMemSync);
// Set-up srcOffset
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 2, static_cast<OffsetType>(operationParams.srcOffset.x));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 2, static_cast<OffsetType>(operationParams.srcOffset.x + leftSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 2, static_cast<OffsetType>(operationParams.srcOffset.x + leftSize + middleSizeBytes));
// Set-up dstOffset
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 3, static_cast<OffsetType>(operationParams.dstOffset.x));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 3, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 3, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize + middleSizeBytes));
// Set-up work sizes
// Note for split walker, it would be just builder.SetDipatchGeometry(GWS, ELWS, OFFSET)
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Left, Vec3<size_t>{leftSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Middle, Vec3<size_t>{middleSizeEls, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Right, Vec3<size_t>{rightSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.bake(multiDispatchInfo);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernLeftLeftover = nullptr;
Kernel *kernMiddle = nullptr;
Kernel *kernRightLeftover = nullptr;
BuiltInOp(BuiltIns &kernelsLib)
: BuiltinDispatchInfoBuilder(kernelsLib) {
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToBufferStateless> : public BuiltInOp<EBuiltInOps::CopyBufferToBuffer> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyBufferToBuffer>(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToBufferStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyBufferToBufferLeftLeftover", kernLeftLeftover,
"CopyBufferToBufferMiddle", kernMiddle,
"CopyBufferToBufferRightLeftover", kernRightLeftover);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferRect> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib), kernelBytes{nullptr} {
populate(device,
EBuiltInOps::CopyBufferRect,
"",
"CopyBufferRectBytes2d", kernelBytes[0],
"CopyBufferRectBytes2d", kernelBytes[1],
"CopyBufferRectBytes3d", kernelBytes[2]);
}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
size_t hostPtrSize = 0;
bool is3D = false;
if (operationParams.srcMemObj && operationParams.dstMemObj) {
DEBUG_BREAK_IF(!((operationParams.srcPtr == nullptr) && (operationParams.dstPtr == nullptr)));
is3D = (operationParams.size.z > 1) || (operationParams.srcOffset.z > 0) || (operationParams.dstOffset.z > 0);
} else {
if (operationParams.srcPtr) {
size_t origin[] = {operationParams.srcOffset.x, operationParams.srcOffset.y, operationParams.srcOffset.z};
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
hostPtrSize = Buffer::calculateHostPtrSize(origin, region, operationParams.srcRowPitch, operationParams.srcSlicePitch);
is3D = (operationParams.size.z > 1) || (operationParams.dstOffset.z > 0);
} else if (operationParams.dstPtr) {
size_t origin[] = {operationParams.dstOffset.x, operationParams.dstOffset.y, operationParams.dstOffset.z};
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
hostPtrSize = Buffer::calculateHostPtrSize(origin, region, operationParams.dstRowPitch, operationParams.dstSlicePitch);
is3D = (operationParams.size.z > 1) || (operationParams.srcOffset.z > 0);
} else {
DEBUG_BREAK_IF(!false);
}
}
// Set-up ISA
int dimensions = is3D ? 3 : 2;
kernelNoSplit3DBuilder.setKernel(kernelBytes[dimensions - 1]);
size_t srcOffsetFromAlignedPtr = 0;
size_t dstOffsetFromAlignedPtr = 0;
// arg0 = src
if (operationParams.srcMemObj) {
kernelNoSplit3DBuilder.setArg(0, operationParams.srcMemObj);
} else {
void *srcPtrToSet = operationParams.srcPtr;
if (!is3D) {
auto srcPtr = ptrOffset(operationParams.srcPtr, operationParams.srcOffset.z * operationParams.srcSlicePitch);
srcPtrToSet = alignDown(srcPtr, 4);
srcOffsetFromAlignedPtr = ptrDiff(srcPtr, srcPtrToSet);
}
kernelNoSplit3DBuilder.setArgSvm(0, hostPtrSize, srcPtrToSet, nullptr, CL_MEM_READ_ONLY);
}
// arg1 = dst
if (operationParams.dstMemObj) {
kernelNoSplit3DBuilder.setArg(1, operationParams.dstMemObj);
} else {
void *dstPtrToSet = operationParams.dstPtr;
if (!is3D) {
auto dstPtr = ptrOffset(operationParams.dstPtr, operationParams.dstOffset.z * operationParams.dstSlicePitch);
dstPtrToSet = alignDown(dstPtr, 4);
dstOffsetFromAlignedPtr = ptrDiff(dstPtr, dstPtrToSet);
}
kernelNoSplit3DBuilder.setArgSvm(1, hostPtrSize, dstPtrToSet, nullptr, 0u);
}
// arg2 = srcOrigin
OffsetType kSrcOrigin[4] = {static_cast<OffsetType>(operationParams.srcOffset.x + srcOffsetFromAlignedPtr), static_cast<OffsetType>(operationParams.srcOffset.y), static_cast<OffsetType>(operationParams.srcOffset.z), 0};
kernelNoSplit3DBuilder.setArg(2, sizeof(OffsetType) * 4, kSrcOrigin);
// arg3 = dstOrigin
OffsetType kDstOrigin[4] = {static_cast<OffsetType>(operationParams.dstOffset.x + dstOffsetFromAlignedPtr), static_cast<OffsetType>(operationParams.dstOffset.y), static_cast<OffsetType>(operationParams.dstOffset.z), 0};
kernelNoSplit3DBuilder.setArg(3, sizeof(OffsetType) * 4, kDstOrigin);
// arg4 = srcPitch
OffsetType kSrcPitch[2] = {static_cast<OffsetType>(operationParams.srcRowPitch), static_cast<OffsetType>(operationParams.srcSlicePitch)};
kernelNoSplit3DBuilder.setArg(4, sizeof(OffsetType) * 2, kSrcPitch);
// arg5 = dstPitch
OffsetType kDstPitch[2] = {static_cast<OffsetType>(operationParams.dstRowPitch), static_cast<OffsetType>(operationParams.dstSlicePitch)};
kernelNoSplit3DBuilder.setArg(5, sizeof(OffsetType) * 2, kDstPitch);
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernelBytes[3];
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib), kernelBytes{nullptr} {};
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferRectStateless> : public BuiltInOp<EBuiltInOps::CopyBufferRect> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyBufferRect>(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferRectStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyBufferRectBytes2d", kernelBytes[0],
"CopyBufferRectBytes2d", kernelBytes[1],
"CopyBufferRectBytes3d", kernelBytes[2]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::FillBuffer> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::FillBuffer,
"",
"FillBufferLeftLeftover", kernLeftLeftover,
"FillBufferMiddle", kernMiddle,
"FillBufferRightLeftover", kernRightLeftover);
}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d1D, SplitDispatch::SplitMode::KernelSplit> kernelSplit1DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
uintptr_t start = reinterpret_cast<uintptr_t>(operationParams.dstPtr) + operationParams.dstOffset.x;
size_t middleAlignment = MemoryConstants::cacheLineSize;
size_t middleElSize = sizeof(uint32_t);
uintptr_t leftSize = start % middleAlignment;
leftSize = (leftSize > 0) ? (middleAlignment - leftSize) : 0; // calc left leftover size
leftSize = std::min(leftSize, operationParams.size.x); // clamp left leftover size to requested size
uintptr_t rightSize = (start + operationParams.size.x) % middleAlignment; // calc right leftover size
rightSize = std::min(rightSize, operationParams.size.x - leftSize); // clamp
uintptr_t middleSizeBytes = operationParams.size.x - leftSize - rightSize; // calc middle size
auto middleSizeEls = middleSizeBytes / middleElSize; // num work items in middle walker
// Set-up ISA
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Left, kernLeftLeftover);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Middle, kernMiddle);
kernelSplit1DBuilder.setKernel(SplitDispatch::RegionCoordX::Right, kernRightLeftover);
DEBUG_BREAK_IF((operationParams.srcMemObj == nullptr) || (operationParams.srcOffset != 0));
DEBUG_BREAK_IF((operationParams.dstMemObj == nullptr) && (operationParams.dstSvmAlloc == nullptr));
// Set-up dstMemObj with buffer
if (operationParams.dstSvmAlloc) {
kernelSplit1DBuilder.setArgSvmAlloc(0, operationParams.dstPtr, operationParams.dstSvmAlloc);
} else {
kernelSplit1DBuilder.setArg(0, operationParams.dstMemObj);
}
// Set-up dstOffset
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 1, static_cast<OffsetType>(operationParams.dstOffset.x));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 1, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 1, static_cast<OffsetType>(operationParams.dstOffset.x + leftSize + middleSizeBytes));
// Set-up srcMemObj with pattern
kernelSplit1DBuilder.setArgSvm(2, operationParams.srcMemObj->getSize(), operationParams.srcMemObj->getGraphicsAllocation()->getUnderlyingBuffer(), operationParams.srcMemObj->getGraphicsAllocation(), CL_MEM_READ_ONLY);
// Set-up patternSizeInEls
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Left, 3, static_cast<OffsetType>(operationParams.srcMemObj->getSize()));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Middle, 3, static_cast<OffsetType>(operationParams.srcMemObj->getSize() / middleElSize));
kernelSplit1DBuilder.setArg(SplitDispatch::RegionCoordX::Right, 3, static_cast<OffsetType>(operationParams.srcMemObj->getSize()));
// Set-up work sizes
// Note for split walker, it would be just builder.SetDipatchGeomtry(GWS, ELWS, OFFSET)
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Left, Vec3<size_t>{leftSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Middle, Vec3<size_t>{middleSizeEls, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.setDispatchGeometry(SplitDispatch::RegionCoordX::Right, Vec3<size_t>{rightSize, 0, 0}, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelSplit1DBuilder.bake(multiDispatchInfo);
return true;
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernLeftLeftover = nullptr;
Kernel *kernMiddle = nullptr;
Kernel *kernRightLeftover = nullptr;
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib) {}
};
template <>
class BuiltInOp<EBuiltInOps::FillBufferStateless> : public BuiltInOp<EBuiltInOps::FillBuffer> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device) : BuiltInOp<EBuiltInOps::FillBuffer>(kernelsLib) {
populate(device,
EBuiltInOps::FillBufferStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"FillBufferLeftLeftover", kernLeftLeftover,
"FillBufferMiddle", kernMiddle,
"FillBufferRightLeftover", kernRightLeftover);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToImage3d> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToImage3d,
"",
"CopyBufferToImage3dBytes", kernelBytes[0],
"CopyBufferToImage3d2Bytes", kernelBytes[1],
"CopyBufferToImage3d4Bytes", kernelBytes[2],
"CopyBufferToImage3d8Bytes", kernelBytes[3],
"CopyBufferToImage3d16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernelBytes[5] = {nullptr};
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib){};
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!(((operationParams.srcPtr != nullptr) || (operationParams.srcMemObj != nullptr)) && (operationParams.dstPtr == nullptr)));
auto dstImage = castToObjectOrAbort<Image>(operationParams.dstMemObj);
// Redescribe image to be byte-copy
auto dstImageRedescribed = dstImage->redescribe();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(dstImageRedescribed)); // life range same as mdi's
// Calculate srcRowPitch and srcSlicePitch
auto bytesPerPixel = dstImage->getSurfaceFormatInfo().surfaceFormat.ImageElementSizeInBytes;
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
auto srcRowPitch = operationParams.dstRowPitch ? operationParams.dstRowPitch : region[0] * bytesPerPixel;
auto srcSlicePitch =
operationParams.dstSlicePitch ? operationParams.dstSlicePitch : ((dstImage->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY ? 1 : region[1]) * srcRowPitch);
// Determine size of host ptr surface for residency purposes
size_t hostPtrSize = operationParams.srcPtr ? Image::calculateHostPtrSize(region, srcRowPitch, srcSlicePitch, bytesPerPixel, dstImage->getImageDesc().image_type) : 0;
hostPtrSize += operationParams.srcOffset.x;
// Set-up kernel
auto bytesExponent = Math::log2(bytesPerPixel);
DEBUG_BREAK_IF(bytesExponent >= 5);
kernelNoSplit3DBuilder.setKernel(kernelBytes[bytesExponent]);
// Set-up source host ptr / buffer
if (operationParams.srcPtr) {
kernelNoSplit3DBuilder.setArgSvm(0, hostPtrSize, operationParams.srcPtr, nullptr, CL_MEM_READ_ONLY);
} else {
kernelNoSplit3DBuilder.setArg(0, operationParams.srcMemObj);
}
// Set-up destination image
kernelNoSplit3DBuilder.setArg(1, dstImageRedescribed, operationParams.dstMipLevel);
// Set-up srcOffset
kernelNoSplit3DBuilder.setArg(2, static_cast<OffsetType>(operationParams.srcOffset.x));
// Set-up dstOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.dstOffset.x),
static_cast<uint32_t>(operationParams.dstOffset.y),
static_cast<uint32_t>(operationParams.dstOffset.z),
0};
kernelNoSplit3DBuilder.setArg(3, sizeof(origin), origin);
}
// Set-up srcRowPitch
{
OffsetType pitch[] = {
static_cast<OffsetType>(srcRowPitch),
static_cast<OffsetType>(srcSlicePitch)};
kernelNoSplit3DBuilder.setArg(4, sizeof(pitch), pitch);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyBufferToImage3dStateless> : public BuiltInOp<EBuiltInOps::CopyBufferToImage3d> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyBufferToImage3d>(kernelsLib) {
populate(device,
EBuiltInOps::CopyBufferToImage3dStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyBufferToImage3dBytes", kernelBytes[0],
"CopyBufferToImage3d2Bytes", kernelBytes[1],
"CopyBufferToImage3d4Bytes", kernelBytes[2],
"CopyBufferToImage3d8Bytes", kernelBytes[3],
"CopyBufferToImage3d16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyImage3dToBuffer> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib) {
populate(device,
EBuiltInOps::CopyImage3dToBuffer,
"",
"CopyImage3dToBufferBytes", kernelBytes[0],
"CopyImage3dToBuffer2Bytes", kernelBytes[1],
"CopyImage3dToBuffer4Bytes", kernelBytes[2],
"CopyImage3dToBuffer8Bytes", kernelBytes[3],
"CopyImage3dToBuffer16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint32_t>(multiDispatchInfo, operationParams);
}
protected:
Kernel *kernelBytes[5] = {nullptr};
BuiltInOp(BuiltIns &kernelsLib) : BuiltinDispatchInfoBuilder(kernelsLib) {}
template <typename OffsetType>
bool buildDispatchInfosTyped(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!((operationParams.srcPtr == nullptr) && ((operationParams.dstPtr != nullptr) || (operationParams.dstMemObj != nullptr))));
auto srcImage = castToObjectOrAbort<Image>(operationParams.srcMemObj);
// Redescribe image to be byte-copy
auto srcImageRedescribed = srcImage->redescribe();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(srcImageRedescribed)); // life range same as mdi's
// Calculate dstRowPitch and dstSlicePitch
auto bytesPerPixel = srcImage->getSurfaceFormatInfo().surfaceFormat.ImageElementSizeInBytes;
size_t region[] = {operationParams.size.x, operationParams.size.y, operationParams.size.z};
auto dstRowPitch = operationParams.srcRowPitch ? operationParams.srcRowPitch : region[0] * bytesPerPixel;
auto dstSlicePitch =
operationParams.srcSlicePitch ? operationParams.srcSlicePitch : ((srcImage->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY ? 1 : region[1]) * dstRowPitch);
// Determine size of host ptr surface for residency purposes
size_t hostPtrSize = operationParams.dstPtr ? Image::calculateHostPtrSize(region, dstRowPitch, dstSlicePitch, bytesPerPixel, srcImage->getImageDesc().image_type) : 0;
hostPtrSize += operationParams.dstOffset.x;
// Set-up ISA
auto bytesExponent = Math::log2(bytesPerPixel);
DEBUG_BREAK_IF(bytesExponent >= 5);
kernelNoSplit3DBuilder.setKernel(kernelBytes[bytesExponent]);
// Set-up source image
kernelNoSplit3DBuilder.setArg(0, srcImageRedescribed, operationParams.srcMipLevel);
// Set-up destination host ptr / buffer
if (operationParams.dstPtr) {
kernelNoSplit3DBuilder.setArgSvm(1, hostPtrSize, operationParams.dstPtr, nullptr, 0u);
} else {
kernelNoSplit3DBuilder.setArg(1, operationParams.dstMemObj);
}
// Set-up srcOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.srcOffset.x),
static_cast<uint32_t>(operationParams.srcOffset.y),
static_cast<uint32_t>(operationParams.srcOffset.z),
0};
kernelNoSplit3DBuilder.setArg(2, sizeof(origin), origin);
}
// Set-up dstOffset
kernelNoSplit3DBuilder.setArg(3, static_cast<OffsetType>(operationParams.dstOffset.x));
// Set-up dstRowPitch
{
OffsetType pitch[] = {
static_cast<OffsetType>(dstRowPitch),
static_cast<OffsetType>(dstSlicePitch)};
kernelNoSplit3DBuilder.setArg(4, sizeof(pitch), pitch);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyImage3dToBufferStateless> : public BuiltInOp<EBuiltInOps::CopyImage3dToBuffer> {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltInOp<EBuiltInOps::CopyImage3dToBuffer>(kernelsLib) {
populate(device,
EBuiltInOps::CopyImage3dToBufferStateless,
CompilerOptions::greaterThan4gbBuffersRequired,
"CopyImage3dToBufferBytes", kernelBytes[0],
"CopyImage3dToBuffer2Bytes", kernelBytes[1],
"CopyImage3dToBuffer4Bytes", kernelBytes[2],
"CopyImage3dToBuffer8Bytes", kernelBytes[3],
"CopyImage3dToBuffer16Bytes", kernelBytes[4]);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
return buildDispatchInfosTyped<uint64_t>(multiDispatchInfo, operationParams);
}
};
template <>
class BuiltInOp<EBuiltInOps::CopyImageToImage3d> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib), kernel(nullptr) {
populate(device,
EBuiltInOps::CopyImageToImage3d,
"",
"CopyImageToImage3d", kernel);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!((operationParams.srcPtr == nullptr) && (operationParams.dstPtr == nullptr)));
auto srcImage = castToObjectOrAbort<Image>(operationParams.srcMemObj);
auto dstImage = castToObjectOrAbort<Image>(operationParams.dstMemObj);
// Redescribe images to be byte-copies
auto srcImageRedescribed = srcImage->redescribe();
auto dstImageRedescribed = dstImage->redescribe();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(srcImageRedescribed)); // life range same as mdi's
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(dstImageRedescribed)); // life range same as mdi's
// Set-up kernel
kernelNoSplit3DBuilder.setKernel(kernel);
// Set-up source image
kernelNoSplit3DBuilder.setArg(0, srcImageRedescribed, operationParams.srcMipLevel);
// Set-up destination image
kernelNoSplit3DBuilder.setArg(1, dstImageRedescribed, operationParams.dstMipLevel);
// Set-up srcOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.srcOffset.x),
static_cast<uint32_t>(operationParams.srcOffset.y),
static_cast<uint32_t>(operationParams.srcOffset.z),
0};
kernelNoSplit3DBuilder.setArg(2, sizeof(origin), origin);
}
// Set-up dstOrigin
{
uint32_t origin[] = {
static_cast<uint32_t>(operationParams.dstOffset.x),
static_cast<uint32_t>(operationParams.dstOffset.y),
static_cast<uint32_t>(operationParams.dstOffset.z),
0};
kernelNoSplit3DBuilder.setArg(3, sizeof(origin), origin);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
protected:
Kernel *kernel;
};
template <>
class BuiltInOp<EBuiltInOps::FillImage3d> : public BuiltinDispatchInfoBuilder {
public:
BuiltInOp(BuiltIns &kernelsLib, Device &device)
: BuiltinDispatchInfoBuilder(kernelsLib), kernel(nullptr) {
populate(device,
EBuiltInOps::FillImage3d,
"",
"FillImage3d", kernel);
}
bool buildDispatchInfos(MultiDispatchInfo &multiDispatchInfo, const BuiltinOpParams &operationParams) const override {
DispatchInfoBuilder<SplitDispatch::Dim::d3D, SplitDispatch::SplitMode::NoSplit> kernelNoSplit3DBuilder;
multiDispatchInfo.setBuiltinOpParams(operationParams);
DEBUG_BREAK_IF(!((operationParams.srcMemObj == nullptr) && (operationParams.srcPtr != nullptr) && (operationParams.dstPtr == nullptr)));
auto image = castToObjectOrAbort<Image>(operationParams.dstMemObj);
// Redescribe image to be byte-copy
auto imageRedescribed = image->redescribeFillImage();
multiDispatchInfo.pushRedescribedMemObj(std::unique_ptr<MemObj>(imageRedescribed));
// Set-up kernel
kernelNoSplit3DBuilder.setKernel(kernel);
// Set-up destination image
kernelNoSplit3DBuilder.setArg(0, imageRedescribed);
// Set-up fill color
int iFillColor[4] = {0};
const void *fillColor = operationParams.srcPtr;
convertFillColor(fillColor,
iFillColor,
image->getSurfaceFormatInfo().OCLImageFormat,
imageRedescribed->getSurfaceFormatInfo().OCLImageFormat);
kernelNoSplit3DBuilder.setArg(1, 4 * sizeof(int32_t), iFillColor);
// Set-up dstOffset
{
uint32_t offset[] = {
static_cast<uint32_t>(operationParams.dstOffset.x),
static_cast<uint32_t>(operationParams.dstOffset.y),
static_cast<uint32_t>(operationParams.dstOffset.z),
0};
kernelNoSplit3DBuilder.setArg(2, sizeof(offset), offset);
}
// Set-up work sizes
kernelNoSplit3DBuilder.setDispatchGeometry(operationParams.size, Vec3<size_t>{0, 0, 0}, Vec3<size_t>{0, 0, 0});
kernelNoSplit3DBuilder.bake(multiDispatchInfo);
return true;
}
protected:
Kernel *kernel;
};
BuiltinDispatchInfoBuilder &BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Device &device) {
uint32_t operationId = static_cast<uint32_t>(operation);
auto kernelsLib = device.getExecutionEnvironment()->getBuiltIns();
auto &operationBuilder = kernelsLib->BuiltinOpsBuilders[operationId];
switch (operation) {
case EBuiltInOps::CopyBufferToBuffer:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToBuffer>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyBufferToBufferStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToBufferStateless>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyBufferRect:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferRect>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyBufferRectStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferRectStateless>>(*kernelsLib, device); });
break;
case EBuiltInOps::FillBuffer:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillBuffer>>(*kernelsLib, device); });
break;
case EBuiltInOps::FillBufferStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillBufferStateless>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyBufferToImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToImage3d>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyBufferToImage3dStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyBufferToImage3dStateless>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyImage3dToBuffer:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyImage3dToBuffer>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyImage3dToBufferStateless:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyImage3dToBufferStateless>>(*kernelsLib, device); });
break;
case EBuiltInOps::CopyImageToImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::CopyImageToImage3d>>(*kernelsLib, device); });
break;
case EBuiltInOps::FillImage3d:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::FillImage3d>>(*kernelsLib, device); });
break;
case EBuiltInOps::AuxTranslation:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::AuxTranslation>>(*kernelsLib, device); });
break;
default:
return getUnknownDispatchInfoBuilder(operation, device);
}
return *operationBuilder.first;
}
} // namespace NEO

9
runtime/built_ins/builtins_dispatch_builder.h
View File

@@ -11,6 +11,7 @@
#include "runtime/kernel/kernel.h"
#include "CL/cl.h"
#include "built_in_ops.h"
#include <array>
#include <cstdint>
@@ -99,4 +100,12 @@ class BuiltinDispatchInfoBuilder {
BuiltIns &kernelsLib;
};
class BuiltInDispatchBuilderOp {
public:
static BuiltinDispatchInfoBuilder &getBuiltinDispatchInfoBuilder(EBuiltInOps::Type op, Device &device);
static BuiltinDispatchInfoBuilder &getUnknownDispatchInfoBuilder(EBuiltInOps::Type op, Device &device);
std::unique_ptr<BuiltinDispatchInfoBuilder> setBuiltinDispatchInfoBuilder(EBuiltInOps::Type op, Device &device,
std::unique_ptr<BuiltinDispatchInfoBuilder> newBuilder);
};
} // namespace NEO

3
runtime/built_ins/unknown_built_in_name.cpp
View File

@@ -6,6 +6,7 @@
*/
#include "runtime/built_ins/built_ins.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
namespace NEO {
@@ -13,7 +14,7 @@ const char *getUnknownBuiltinAsString(EBuiltInOps::Type builtin) {
return "unknown";
}
BuiltinDispatchInfoBuilder &BuiltIns::getUnknownDispatchInfoBuilder(EBuiltInOps::Type operation, Device &device) {
BuiltinDispatchInfoBuilder &BuiltInDispatchBuilderOp::getUnknownDispatchInfoBuilder(EBuiltInOps::Type operation, Device &device) {
throw std::runtime_error("getBuiltinDispatchInfoBuilder failed");
}
} // namespace NEO

2
runtime/built_ins/vme_builtin.cpp
View File

@@ -104,7 +104,7 @@ BuiltinDispatchInfoBuilder &Vme::getBuiltinDispatchInfoBuilder(EBuiltInOps::Type
auto &operationBuilder = builtins.BuiltinOpsBuilders[operationId];
switch (operation) {
default:
return builtins.getBuiltinDispatchInfoBuilder(operation, device);
return BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(operation, device);
case EBuiltInOps::VmeBlockMotionEstimateIntel:
std::call_once(operationBuilder.second, [&] { operationBuilder.first = std::make_unique<BuiltInOp<EBuiltInOps::VmeBlockMotionEstimateIntel>>(builtins, device); });
break;

2
runtime/command_queue/command_queue_hw_base.inl
View File

@@ -108,7 +108,7 @@ void CommandQueueHw<Family>::dispatchAuxTranslationBuiltin(MultiDispatchInfo &mu
return;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, getDevice());
auto &auxTranslationBuilder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(builder);
BuiltinOpParams dispatchParams;

2
runtime/command_queue/enqueue_common.h
View File

@@ -61,7 +61,7 @@ void CommandQueueHw<GfxFamily>::enqueueHandler(Surface *(&surfaces)[surfaceCount
forceDispatchScheduler(multiDispatchInfo);
} else {
if (kernel->isAuxTranslationRequired()) {
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, getDevice());
builtInLock.takeOwnership(builder, this->context);
kernel->fillWithBuffersForAuxTranslation(memObjsForAuxTranslation);
multiDispatchInfo.setMemObjsForAuxTranslation(memObjsForAuxTranslation);

4
runtime/command_queue/enqueue_copy_buffer.h
View File

@@ -36,8 +36,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueCopyBuffer(
eBuiltInOpsType = EBuiltInOps::CopyBufferToBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOpsType,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOpsType,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);

4
runtime/command_queue/enqueue_copy_buffer_rect.h
View File

@@ -37,8 +37,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueCopyBufferRect(
eBuiltInOps = EBuiltInOps::CopyBufferRectStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
MemObjSurface srcBufferSurf(srcBuffer);

4
runtime/command_queue/enqueue_copy_buffer_to_image.h
View File

@@ -35,8 +35,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueCopyBufferToImage(
eBuiltInOpsType = EBuiltInOps::CopyBufferToImage3dStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOpsType,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOpsType,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
MemObjSurface srcBufferSurf(srcBuffer);

4
runtime/command_queue/enqueue_copy_image.h
View File

@@ -33,8 +33,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueCopyImage(
MultiDispatchInfo di;
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
MemObjSurface srcImgSurf(srcImage);

4
runtime/command_queue/enqueue_copy_image_to_buffer.h
View File

@@ -34,8 +34,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueCopyImageToBuffer(
if (forceStateless(dstBuffer->getSize())) {
eBuiltInOpsType = EBuiltInOps::CopyImage3dToBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOpsType,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOpsType,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
MemObjSurface srcImgSurf(srcImage);

4
runtime/command_queue/enqueue_fill_buffer.h
View File

@@ -49,8 +49,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueFillBuffer(
eBuiltInOps = EBuiltInOps::FillBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);

4
runtime/command_queue/enqueue_fill_image.h
View File

@@ -31,8 +31,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueFillImage(
MultiDispatchInfo di;
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::FillImage3d,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillImage3d,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
MemObjSurface dstImgSurf(image);

4
runtime/command_queue/enqueue_read_buffer.h
View File

@@ -75,8 +75,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBuffer(
if (forceStateless(buffer->getSize())) {
eBuiltInOps = EBuiltInOps::CopyBufferToBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
void *dstPtr = ptr;

4
runtime/command_queue/enqueue_read_buffer_rect.h
View File

@@ -50,8 +50,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadBufferRect(
if (forceStateless(buffer->getSize())) {
eBuiltInOps = EBuiltInOps::CopyBufferRectStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
size_t hostPtrSize = Buffer::calculateHostPtrSize(hostOrigin, region, hostRowPitch, hostSlicePitch);

4
runtime/command_queue/enqueue_read_image.h
View File

@@ -54,8 +54,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueReadImage(
numEventsInWaitList, eventWaitList, event);
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);

16
runtime/command_queue/enqueue_svm.h
View File

@@ -106,8 +106,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueSVMMap(cl_bool blockingMap,
}
MultiDispatchInfo dispatchInfo;
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
GeneralSurface dstSurface(svmData->cpuAllocation);
@@ -199,8 +199,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueSVMUnmap(void *svmPtr,
svmData->gpuAllocation->setTbxWritable(true, GraphicsAllocation::defaultBank);
MultiDispatchInfo dispatchInfo;
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
GeneralSurface dstSurface(svmData->gpuAllocation);
@@ -334,8 +334,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueSVMMemcpy(cl_bool blockingCopy,
builtInType = EBuiltInOps::CopyBufferToBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(builtInType,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(builtInType,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
MultiDispatchInfo dispatchInfo;
BuiltinOpParams operationParams;
@@ -476,8 +476,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueSVMMemFill(void *svmPtr,
builtInType = EBuiltInOps::FillBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(builtInType,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(builtInType,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);

4
runtime/command_queue/enqueue_write_buffer.h
View File

@@ -71,8 +71,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteBuffer(
if (forceStateless(buffer->getSize())) {
eBuiltInOps = EBuiltInOps::CopyBufferToBufferStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);

4
runtime/command_queue/enqueue_write_buffer_rect.h
View File

@@ -49,8 +49,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteBufferRect(
if (forceStateless(buffer->getSize())) {
eBuiltInOps = EBuiltInOps::CopyBufferRectStateless;
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(eBuiltInOps,
this->getDevice());
BuiltInOwnershipWrapper builtInLock(builder, this->context);
size_t hostPtrSize = Buffer::calculateHostPtrSize(hostOrigin, region, hostRowPitch, hostSlicePitch);

4
runtime/command_queue/enqueue_write_image.h
View File

@@ -45,8 +45,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueWriteImage(
return enqueueMarkerForReadWriteOperation(dstImage, const_cast<void *>(ptr), CL_COMMAND_WRITE_IMAGE, blockingWrite,
numEventsInWaitList, eventWaitList, event);
}
auto &builder = getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
this->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
this->getDevice());
BuiltInOwnershipWrapper lock(builder, this->context);

36
unit_tests/built_ins/built_in_tests.cpp
View File

@@ -155,7 +155,7 @@ TEST_F(BuiltInTests, SourceConsistency) {
}
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderCopyBufferToBuffer) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
MockBuffer *srcPtr = new MockBuffer();
MockBuffer *dstPtr = new MockBuffer();
@@ -218,7 +218,7 @@ TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderCopyBufferToBuffer) {
}
HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingNonAuxDispatchInfoForAuxTranslationThenPickAndSetupCorrectKernels) {
BuiltinDispatchInfoBuilder &baseBuilder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@@ -265,7 +265,7 @@ HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingNonAuxDispatchInfoForAuxTrans
}
HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxDispatchInfoForAuxTranslationThenPickAndSetupCorrectKernels) {
BuiltinDispatchInfoBuilder &baseBuilder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@@ -312,7 +312,7 @@ HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxDispatchInfoForAuxTranslat
}
HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxTranslationDispatchThenPickDifferentKernelsDependingOnRequest) {
BuiltinDispatchInfoBuilder &baseBuilder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@@ -347,7 +347,7 @@ HWTEST_F(BuiltInTests, givenInputBufferWhenBuildingAuxTranslationDispatchThenPic
}
HWTEST_F(BuiltInTests, givenInvalidAuxTranslationDirectionWhenBuildingDispatchInfosThenAbort) {
BuiltinDispatchInfoBuilder &baseBuilder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MemObjsForAuxTranslation memObjsForAuxTranslation;
@@ -421,7 +421,7 @@ TEST_F(BuiltInTests, givenkAuxBuiltInWhenResizeIsCalledThenCloneAllNewInstancesF
}
HWTEST_F(BuiltInTests, givenKernelWithAuxTranslationRequiredWhenEnqueueCalledThenLockOnBuiltin) {
pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto mockAuxBuiltInOp = new MockAuxBuilInOp(*pBuiltIns, *pContext, *pDevice);
pBuiltIns->BuiltinOpsBuilders[static_cast<uint32_t>(EBuiltInOps::AuxTranslation)].first.reset(mockAuxBuiltInOp);
@@ -601,7 +601,7 @@ HWTEST_F(BuiltInTests, givenNonAuxToAuxTranslationWhenSettingSurfaceStateThenSet
}
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderCopyBufferToBufferAligned) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
AlignedBuffer src;
AlignedBuffer dst;
@@ -640,7 +640,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToBufferStateless
GTEST_SKIP();
}
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless, *pDevice);
uint64_t bigSize = 10ull * MemoryConstants::gigaByte;
uint64_t bigOffset = 4ull * MemoryConstants::gigaByte;
@@ -671,7 +671,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToBufferRectState
GTEST_SKIP();
}
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless, *pDevice);
uint64_t bigSize = 10ull * MemoryConstants::gigaByte;
uint64_t bigOffset = 4ull * MemoryConstants::gigaByte;
@@ -705,7 +705,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderFillBufferStatelessIsUsedTh
GTEST_SKIP();
}
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless, *pDevice);
uint64_t bigSize = 10ull * MemoryConstants::gigaByte;
uint64_t bigOffset = 4ull * MemoryConstants::gigaByte;
@@ -742,7 +742,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyBufferToImageStatelessI
std ::unique_ptr<Image> pDstImage(Image2dHelper<>::create(pContext));
ASSERT_NE(nullptr, pDstImage.get());
auto &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3dStateless, *pDevice);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3dStateless, *pDevice);
BuiltinOpParams dc;
dc.srcPtr = &srcBuffer;
@@ -778,7 +778,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyImageToBufferStatelessI
std ::unique_ptr<Image> pSrcImage(Image2dHelper<>::create(pContext));
ASSERT_NE(nullptr, pSrcImage.get());
auto &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBufferStateless, *pDevice);
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBufferStateless, *pDevice);
BuiltinOpParams dc;
dc.srcMemObj = pSrcImage.get();
@@ -799,7 +799,7 @@ TEST_F(BuiltInTests, givenBigOffsetAndSizeWhenBuilderCopyImageToBufferStatelessI
}
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderCopyBufferToBufferWithSourceOffsetUnalignedToFour) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
AlignedBuffer src;
AlignedBuffer dst;
@@ -824,7 +824,7 @@ TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderCopyBufferToBufferWithSourceOffse
}
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderReadBufferAligned) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
AlignedBuffer srcMemObj;
auto size = 10 * MemoryConstants::cacheLineSize;
@@ -859,7 +859,7 @@ TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderReadBufferAligned) {
}
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderWriteBufferAligned) {
BuiltinDispatchInfoBuilder &builder = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
auto size = 10 * MemoryConstants::cacheLineSize;
auto srcPtr = alignedMalloc(size, MemoryConstants::cacheLineSize);
@@ -894,8 +894,8 @@ TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderWriteBufferAligned) {
}
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderGetBuilderTwice) {
BuiltinDispatchInfoBuilder &builder1 = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder2 = pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder1 = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
BuiltinDispatchInfoBuilder &builder2 = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer, *pDevice);
EXPECT_EQ(&builder1, &builder2);
}
@@ -903,7 +903,7 @@ TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderGetBuilderTwice) {
TEST_F(BuiltInTests, BuiltinDispatchInfoBuilderGetBuilderForUnknownBuiltInOp) {
bool caughtException = false;
try {
pBuiltIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pDevice);
BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::COUNT, *pDevice);
} catch (const std::runtime_error &) {
caughtException = true;
}

2
unit_tests/command_queue/command_queue_hw_tests.cpp
View File

@@ -751,7 +751,7 @@ struct BuiltinParamsCommandQueueHwTests : public CommandQueueHwTest {
*pDevice,
std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuilder(*builtIns)));
mockBuilder = static_cast<MockBuilder *>(&builtIns->getBuiltinDispatchInfoBuilder(
mockBuilder = static_cast<MockBuilder *>(&BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
operation,
*pDevice));
}

8
unit_tests/command_queue/dispatch_walker_tests.cpp
View File

@@ -1240,9 +1240,7 @@ TEST(DispatchWalker, WhenCalculatingDispatchDimensionsThenCorrectValuesAreReturn
}
HWTEST_F(DispatchWalkerTest, givenKernelWhenAuxToNonAuxWhenTranslationRequiredThenPipeControlWithStallAndDCFlushAdded) {
auto executionEnvironment = pDevice->getExecutionEnvironment();
auto builtIns = executionEnvironment->getBuiltIns();
BuiltinDispatchInfoBuilder &baseBuilder = builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MockKernel kernel(program.get(), kernelInfo, *pClDevice);
@@ -1295,9 +1293,7 @@ HWTEST_F(DispatchWalkerTest, givenKernelWhenAuxToNonAuxWhenTranslationRequiredTh
}
HWTEST_F(DispatchWalkerTest, givenKernelWhenNonAuxToAuxWhenTranslationRequiredThenPipeControlWithStallAdded) {
auto executionEnvironment = pDevice->getExecutionEnvironment();
auto builtIns = executionEnvironment->getBuiltIns();
BuiltinDispatchInfoBuilder &baseBuilder = builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
BuiltinDispatchInfoBuilder &baseBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::AuxTranslation, *pDevice);
auto &builder = static_cast<BuiltInOp<EBuiltInOps::AuxTranslation> &>(baseBuilder);
MockKernel kernel(program.get(), kernelInfo, *pClDevice);

8
unit_tests/command_queue/enqueue_copy_buffer_rect_tests.cpp
View File

@@ -158,8 +158,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, WhenCopyingBufferRect2DTh
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -187,8 +187,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, WhenCopyingBufferRect2DTh
HWTEST_F(EnqueueCopyBufferRectTest, WhenCopyingBufferRectStatelessThenStatelessKernelIsUsed) {
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRectStateless,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

16
unit_tests/command_queue/enqueue_copy_buffer_tests.cpp
View File

@@ -134,8 +134,8 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenIndirectDataGetsAdded) {
enqueueCopyBuffer();
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -162,8 +162,8 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferStatelessThenStatelessKernelIsU
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<>::create());
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBufferStateless,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -252,8 +252,8 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenArgumentZeroMatchesSourceAd
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -279,8 +279,8 @@ HWTEST_F(EnqueueCopyBufferTest, WhenCopyingBufferThenArgumentOneMatchesDestinati
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

6
unit_tests/command_queue/enqueue_copy_buffer_to_image_tests.cpp
View File

@@ -194,7 +194,7 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
auto image_type = (cl_mem_object_type)GetParam();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
@@ -254,8 +254,8 @@ HWTEST_P(MipMapCopyBufferToImageTest, GivenImageWithMipLevelNonZeroWhenCopyBuffe
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);

6
unit_tests/command_queue/enqueue_copy_image_tests.cpp
View File

@@ -203,7 +203,7 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
std::tie(srcImageType, dstImageType) = GetParam();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice());
// substitute original builder with mock builder
@@ -297,8 +297,8 @@ HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCall
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedSrcMipLevel, params->srcMipLevel);

6
unit_tests/command_queue/enqueue_copy_image_to_buffer_tests.cpp
View File

@@ -195,7 +195,7 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
auto image_type = (cl_mem_object_type)GetParam();
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
@@ -254,8 +254,8 @@ HWTEST_P(MipMapCopyImageToBufferTest, GivenImageWithMipLevelNonZeroWhenCopyImage
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);

40
unit_tests/command_queue/enqueue_fill_buffer_tests.cpp
View File

@@ -95,9 +95,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferThenIndirectDataGetsAdded)
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
MultiDispatchInfo multiDispatchInfo;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -127,9 +126,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferRightLeftover) {
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
MultiDispatchInfo mdi;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -154,9 +152,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferMiddle) {
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
MultiDispatchInfo mdi;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -181,9 +178,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferLeftLeftover) {
EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
MultiDispatchInfo mdi;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -275,9 +271,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferThenArgumentZeroShouldMatch
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -311,9 +306,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, DISABLED_WhenFillingBufferThenArgumentOneSho
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -344,9 +338,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferThenArgumentTwoShouldMatchP
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -373,9 +366,8 @@ HWTEST_F(EnqueueFillBufferCmdTests, WhenFillingBufferStatelessThenStatelessKerne
auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{EnqueueFillBufferTraits::patternSize});
// Extract the kernel used
auto &builtIns = *pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns();
auto &builder = builtIns.getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBufferStateless,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

4
unit_tests/command_queue/enqueue_read_buffer_rect_tests.cpp
View File

@@ -172,8 +172,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, WhenReadingBufferThenIndi
// Extract the kernel used
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

4
unit_tests/command_queue/enqueue_read_buffer_tests.cpp
View File

@@ -140,8 +140,8 @@ HWTEST_F(EnqueueReadBufferTypeTest, addsIndirectData) {
EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

12
unit_tests/command_queue/enqueue_read_image_tests.cpp
View File

@@ -244,7 +244,7 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::CopyImage3dToBuffer;
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getDevice());
@@ -264,8 +264,8 @@ HWTEST_F(EnqueueReadImageTest, GivenImage1DarrayWhenReadImageIsCalledThenRowPitc
EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, CL_TRUE, origin, region, rowPitch, slicePitch);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(params->srcRowPitch, slicePitch);
@@ -490,7 +490,7 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto image_type = (cl_mem_object_type)GetParam();
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
@@ -553,8 +553,8 @@ HWTEST_P(MipMapReadImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalled
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->srcMipLevel);

12
unit_tests/command_queue/enqueue_svm_mem_copy_tests.cpp
View File

@@ -70,7 +70,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
// retrieve original builder
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
@@ -104,7 +104,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);
@@ -147,7 +147,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
size_t hostPtrOffset = 2;
// retrieve original builder
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
@@ -181,7 +181,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);
@@ -229,7 +229,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
size_t hostPtrOffset = 2;
// retrieve original builder
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
@@ -263,7 +263,7 @@ HWTEST_F(EnqueueSvmMemCopyTest, givenEnqueueSVMMemcpyWhenUsingCopyBufferToBuffer
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);

4
unit_tests/command_queue/enqueue_svm_mem_fill_tests.cpp
View File

@@ -77,7 +77,7 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
// retrieve original builder
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &origBuilder);
@@ -111,7 +111,7 @@ HWTEST_P(EnqueueSvmMemFillTest, givenEnqueueSVMMemFillWhenUsingFillBufferBuilder
EXPECT_NE(nullptr, newBuilder);
// check if original builder is restored correctly
auto &restoredBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &restoredBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
EXPECT_EQ(&origBuilder, &restoredBuilder);

4
unit_tests/command_queue/enqueue_write_buffer_rect_tests.cpp
View File

@@ -146,8 +146,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, WhenWritingBufferThenInd
enqueueWriteBufferRect2D<FamilyType>();
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferRect,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

4
unit_tests/command_queue/enqueue_write_buffer_tests.cpp
View File

@@ -138,8 +138,8 @@ HWTEST_F(EnqueueWriteBufferTypeTest, WhenWritingBufferThenIndirectDataIsAdded) {
EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), EnqueueWriteBufferTraits::blocking);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

12
unit_tests/command_queue/enqueue_write_image_tests.cpp
View File

@@ -224,7 +224,7 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
EBuiltInOps::Type copyBuiltIn = EBuiltInOps::CopyBufferToImage3d;
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
copyBuiltIn,
pCmdQ->getDevice());
@@ -245,8 +245,8 @@ HWTEST_F(EnqueueWriteImageTest, GivenImage1DarrayWhenWriteImageIsCalledThenRowPi
EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, destImage, CL_FALSE, origin, region, rowPitch, slicePitch);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(copyBuiltIn,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(params->dstRowPitch, slicePitch);
@@ -419,7 +419,7 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
auto builtIns = new MockBuiltins();
pCmdQ->getDevice().getExecutionEnvironment()->builtins.reset(builtIns);
auto &origBuilder = builtIns->getBuiltinDispatchInfoBuilder(
auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
@@ -485,8 +485,8 @@ HWTEST_P(MipMapWriteImageTest, GivenImageWithMipLevelNonZeroWhenReadImageIsCalle
EXPECT_EQ(CL_SUCCESS, retVal);
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(builtIns->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice()));
auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice()));
auto params = mockBuilder.getBuiltinOpParams();
EXPECT_EQ(expectedMipLevel, params->dstMipLevel);

28
unit_tests/command_queue/get_size_required_buffer_tests.cpp
View File

@@ -76,8 +76,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenFillingBufferThenHeapsAndCommandBufferCo
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -129,8 +129,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenCopyingBufferThenHeapsAndCommandBufferCo
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -183,8 +183,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenReadingBufferNonBlockingThenHeapsAndComm
CL_FALSE);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -237,8 +237,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenReadingBufferBlockingThenThenHeapsAndCom
CL_TRUE);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -291,8 +291,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenWritingBufferNonBlockingThenHeapsAndComm
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -342,8 +342,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenWritingBufferBlockingThenHeapsAndCommand
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -377,8 +377,8 @@ HWTEST_F(GetSizeRequiredBufferTest, WhenWritingBufferBlockingThenHeapsAndCommand
HWTEST_F(GetSizeRequiredBufferTest, givenMultipleKernelRequiringSshWhenTotalSizeIsComputedThenItIsProperlyAligned) {
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

20
unit_tests/command_queue/get_size_required_image_tests.cpp
View File

@@ -67,8 +67,8 @@ HWTEST_F(GetSizeRequiredImageTest, WhenCopyingImageThenHeapsAndCommandBufferCons
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -170,8 +170,8 @@ HWTEST_F(GetSizeRequiredImageTest, WhenReadingImageNonBlockingThenHeapsAndComman
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -224,8 +224,8 @@ HWTEST_F(GetSizeRequiredImageTest, WhenReadingImageBlockingThenHeapsAndCommandBu
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImage3dToBuffer,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -278,8 +278,8 @@ HWTEST_F(GetSizeRequiredImageTest, WhenWritingImageNonBlockingThenHeapsAndComman
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -332,8 +332,8 @@ HWTEST_F(GetSizeRequiredImageTest, WhenWritingImageBlockingThenHeapsAndCommandBu
EXPECT_EQ(CL_SUCCESS, retVal);
MultiDispatchInfo multiDispatchInfo;
auto &builder = pCmdQ->getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
pCmdQ->getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

20
unit_tests/helpers/hardware_commands_helper_tests.cpp
View File

@@ -64,8 +64,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, programInterfaceDescriptorData
ASSERT_NE(nullptr, dstImage.get());
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -136,8 +136,8 @@ HWTEST_F(HardwareCommandsTest, sendCrossThreadDataResourceUsage) {
ASSERT_NE(nullptr, dstImage.get());
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -284,8 +284,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, sendIndirectStateResourceUsage
ASSERT_NE(nullptr, dstImage.get());
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;
@@ -502,8 +502,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, whenSendingIndirectStateThenKe
std::unique_ptr<Image> img(Image2dHelper<>::create(pContext));
MultiDispatchInfo multiDispatchInfo;
auto &builder = cmdQ.getDevice().getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
cmdQ.getDevice());
BuiltinOpParams dc;
dc.srcMemObj = img.get();
@@ -584,8 +584,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, usedBindingTableStatePointer)
ASSERT_NE(nullptr, dstImage.get());
MultiDispatchInfo multiDispatchInfo;
auto &builder = pDevice->getExecutionEnvironment()->getBuiltIns()->getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
cmdQ.getDevice());
auto &builder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToImage3d,
cmdQ.getDevice());
ASSERT_NE(nullptr, &builder);
BuiltinOpParams dc;

4
unit_tests/mocks/mock_builtins.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
* Copyright (C) 2017-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -7,6 +7,8 @@
#include "unit_tests/mocks/mock_builtins.h"
#include "runtime/built_ins/builtins_dispatch_builder.h"
namespace NEO {
std::unique_ptr<BuiltinDispatchInfoBuilder> MockBuiltins::setBuiltinDispatchInfoBuilder(EBuiltInOps::Type operation, Context &context, Device &device, std::unique_ptr<BuiltinDispatchInfoBuilder> builder) {

3
unit_tests/mocks/mock_builtins.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2019 Intel Corporation
* Copyright (C) 2018-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -15,7 +15,6 @@
#include <memory>
namespace NEO {
class MockBuiltins : public BuiltIns {
public:
const SipKernel &getSipKernel(SipKernelType type, Device &device) override {