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

Store KernelInfo per root device in Program

Browse Source 
Related-To: NEO-5001
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2020-11-30 17:38:28 +00:00
committed by Compute-Runtime-Automation
parent ff069c1171
commit 2ee1d569c5
37 changed files with 230 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
opencl/source/api/api.cpp
View File

@@ -1713,7 +1713,8 @@ cl_kernel CL_API_CALL clCreateKernel(cl_program clProgram,
break;
}
const KernelInfo *pKernelInfo = pProgram->getKernelInfo(kernelName);
auto rootDeviceIndex = pProgram->getDevices()[0]->getRootDeviceIndex();
const KernelInfo *pKernelInfo = pProgram->getKernelInfo(kernelName, rootDeviceIndex);
if (!pKernelInfo) {
retVal = CL_INVALID_KERNEL_NAME;
break;
@@ -1746,9 +1747,9 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram,
"numKernels", numKernels,
"kernels", kernels,
"numKernelsRet", numKernelsRet);
auto program = castToObject<Program>(clProgram);
if (program) {
auto numKernelsInProgram = program->getNumKernels();
auto pProgram = castToObject<Program>(clProgram);
if (pProgram) {
auto numKernelsInProgram = pProgram->getNumKernels();
if (kernels) {
if (numKernels < numKernelsInProgram) {
@@ -1757,11 +1758,12 @@ cl_int CL_API_CALL clCreateKernelsInProgram(cl_program clProgram,
return retVal;
}
auto rootDeviceIndex = pProgram->getDevices()[0]->getRootDeviceIndex();
for (unsigned int i = 0; i < numKernelsInProgram; ++i) {
const auto kernelInfo = program->getKernelInfo(i);
const auto kernelInfo = pProgram->getKernelInfo(i, rootDeviceIndex);
DEBUG_BREAK_IF(kernelInfo == nullptr);
kernels[i] = Kernel::create(
program,
pProgram,
*kernelInfo,
nullptr);
gtpinNotifyKernelCreate(kernels[i]);

2
opencl/source/built_ins/builtins_dispatch_builder.h
View File

@@ -88,7 +88,7 @@ class BuiltinDispatchInfoBuilder {
protected:
template <typename KernelNameT, typename... KernelsDescArgsT>
void grabKernels(KernelNameT &&kernelName, Kernel *&kernelDst, KernelsDescArgsT &&... kernelsDesc) {
const KernelInfo *kernelInfo = prog->getKernelInfo(kernelName);
const KernelInfo *kernelInfo = prog->getKernelInfo(kernelName, prog->getDevices()[0]->getRootDeviceIndex());
UNRECOVERABLE_IF(nullptr == kernelInfo);
cl_int err = 0;
kernelDst = Kernel::create(prog.get(), *kernelInfo, &err);

2
opencl/source/context/context.cpp
View File

@@ -399,7 +399,7 @@ SchedulerKernel &Context::getSchedulerKernel() {
schedulerBuiltIn->pProgram = program;
auto kernelInfo = schedulerBuiltIn->pProgram->getKernelInfo(SchedulerKernel::schedulerName);
auto kernelInfo = schedulerBuiltIn->pProgram->getKernelInfo(SchedulerKernel::schedulerName, clDevice->getRootDeviceIndex());
DEBUG_BREAK_IF(!kernelInfo);
schedulerBuiltIn->pKernel = Kernel::create<SchedulerKernel>(

15
opencl/source/program/build.cpp
View File

@@ -172,25 +172,28 @@ cl_int Program::build(
}
if (isKernelDebugEnabled()) {
processDebugData();
for (auto &clDevice : deviceVector) {
if (BuildPhase::DebugDataNotification == phaseReached[clDevice->getRootDeviceIndex()]) {
auto rootDeviceIndex = clDevice->getRootDeviceIndex();
if (BuildPhase::DebugDataNotification == phaseReached[rootDeviceIndex]) {
continue;
}
processDebugData(rootDeviceIndex);
if (clDevice->getSourceLevelDebugger()) {
for (auto kernelInfo : kernelInfoArray) {
for (auto kernelInfo : buildInfos[rootDeviceIndex].kernelInfoArray) {
clDevice->getSourceLevelDebugger()->notifyKernelDebugData(&kernelInfo->debugData,
kernelInfo->kernelDescriptor.kernelMetadata.kernelName,
kernelInfo->heapInfo.pKernelHeap,
kernelInfo->heapInfo.KernelHeapSize);
}
}
phaseReached[clDevice->getRootDeviceIndex()] = BuildPhase::DebugDataNotification;
phaseReached[rootDeviceIndex] = BuildPhase::DebugDataNotification;
}
}
separateBlockKernels();
for (const auto &device : deviceVector) {
separateBlockKernels(device->getRootDeviceIndex());
}
} while (false);
if (retVal != CL_SUCCESS) {
@@ -229,7 +232,7 @@ cl_int Program::build(const ClDeviceVector &deviceVector, const char *buildOptio
return ret;
}
for (auto &ki : this->kernelInfoArray) {
for (auto &ki : buildInfos[deviceVector[0]->getRootDeviceIndex()].kernelInfoArray) {
auto fit = builtinsMap.find(ki->kernelDescriptor.kernelMetadata.kernelName);
if (fit == builtinsMap.end()) {
continue;

4
opencl/source/program/get_info.cpp
View File

@@ -77,7 +77,7 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
break;
case CL_PROGRAM_KERNEL_NAMES:
kernelNamesString = concatenateKernelNames(kernelInfoArray);
kernelNamesString = concatenateKernelNames(buildInfos[clDevices[0]->getRootDeviceIndex()].kernelInfoArray);
pSrc = kernelNamesString.c_str();
retSize = srcSize = kernelNamesString.length() + 1;
@@ -87,7 +87,7 @@ cl_int Program::getInfo(cl_program_info paramName, size_t paramValueSize,
break;
case CL_PROGRAM_NUM_KERNELS:
numKernels = kernelInfoArray.size();
numKernels = getNumKernels();
pSrc = &numKernels;
retSize = srcSize = sizeof(numKernels);

13
opencl/source/program/link.cpp
View File

@@ -146,6 +146,7 @@ cl_int Program::link(
if (!isCreateLibrary) {
for (const auto &device : deviceVector) {
auto rootDeviceIndex = device->getRootDeviceIndex();
inputArgs.outType = IGC::CodeType::oclGenBin;
NEO::TranslationOutput compilerOuput = {};
auto compilerErr = pCompilerInterface->link(device->getDevice(), inputArgs, compilerOuput);
@@ -156,7 +157,7 @@ cl_int Program::link(
break;
}
this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size, device->getRootDeviceIndex());
this->replaceDeviceBinary(std::move(compilerOuput.deviceBinary.mem), compilerOuput.deviceBinary.size, rootDeviceIndex);
this->debugData = std::move(compilerOuput.debugData.mem);
this->debugDataSize = compilerOuput.debugData.size;
@@ -167,11 +168,11 @@ cl_int Program::link(
binaryType = CL_PROGRAM_BINARY_TYPE_EXECUTABLE;
if (isKernelDebugEnabled()) {
if (kernelDebugDataNotified[device->getRootDeviceIndex()]) {
if (kernelDebugDataNotified[rootDeviceIndex]) {
continue;
}
processDebugData();
for (auto kernelInfo : kernelInfoArray) {
processDebugData(rootDeviceIndex);
for (auto kernelInfo : buildInfos[rootDeviceIndex].kernelInfoArray) {
device->getSourceLevelDebugger()->notifyKernelDebugData(&kernelInfo->debugData,
kernelInfo->kernelDescriptor.kernelMetadata.kernelName,
kernelInfo->heapInfo.pKernelHeap,
@@ -204,7 +205,9 @@ cl_int Program::link(
break;
}
updateNonUniformFlag(&*inputProgramsInternal.begin(), inputProgramsInternal.size());
separateBlockKernels();
for (const auto &device : deviceVector) {
separateBlockKernels(device->getRootDeviceIndex());
}
} while (false);
if (retVal != CL_SUCCESS) {

36
opencl/source/program/process_device_binary.cpp
View File

@@ -31,11 +31,13 @@ namespace NEO {
extern bool familyEnabled[];
const KernelInfo *Program::getKernelInfo(
const char *kernelName) const {
const char *kernelName, uint32_t rootDeviceIndex) const {
if (kernelName == nullptr) {
return nullptr;
}
auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
auto it = std::find_if(kernelInfoArray.begin(), kernelInfoArray.end(),
[=](const KernelInfo *kInfo) { return (0 == strcmp(kInfo->kernelDescriptor.kernelMetadata.kernelName.c_str(), kernelName)); });
@@ -43,10 +45,11 @@ const KernelInfo *Program::getKernelInfo(
}
size_t Program::getNumKernels() const {
return kernelInfoArray.size();
return buildInfos[clDevices[0]->getRootDeviceIndex()].kernelInfoArray.size();
}
const KernelInfo *Program::getKernelInfo(size_t ordinal) const {
const KernelInfo *Program::getKernelInfo(size_t ordinal, uint32_t rootDeviceIndex) const {
auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
DEBUG_BREAK_IF(ordinal >= kernelInfoArray.size());
return kernelInfoArray[ordinal];
}
@@ -57,6 +60,7 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
return CL_SUCCESS;
}
auto rootDeviceIndex = pDevice->getRootDeviceIndex();
auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
Linker linker(*linkerInput);
Linker::SegmentInfo globals;
Linker::SegmentInfo constants;
@@ -74,15 +78,15 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
if (linkerInput->getExportedFunctionsSegmentId() >= 0) {
// Exported functions reside in instruction heap of one of kernels
auto exportedFunctionHeapId = linkerInput->getExportedFunctionsSegmentId();
buildInfos[rootDeviceIndex].exportedFunctionsSurface = this->kernelInfoArray[exportedFunctionHeapId]->getGraphicsAllocation();
buildInfos[rootDeviceIndex].exportedFunctionsSurface = kernelInfoArray[exportedFunctionHeapId]->getGraphicsAllocation();
exportedFunctions.gpuAddress = static_cast<uintptr_t>(buildInfos[rootDeviceIndex].exportedFunctionsSurface->getGpuAddressToPatch());
exportedFunctions.segmentSize = buildInfos[rootDeviceIndex].exportedFunctionsSurface->getUnderlyingBufferSize();
}
Linker::PatchableSegments isaSegmentsForPatching;
std::vector<std::vector<char>> patchedIsaTempStorage;
if (linkerInput->getTraits().requiresPatchingOfInstructionSegments) {
patchedIsaTempStorage.reserve(this->kernelInfoArray.size());
for (const auto &kernelInfo : this->kernelInfoArray) {
patchedIsaTempStorage.reserve(kernelInfoArray.size());
for (const auto &kernelInfo : kernelInfoArray) {
auto &kernHeapInfo = kernelInfo->heapInfo;
const char *originalIsa = reinterpret_cast<const char *>(kernHeapInfo.pKernelHeap);
patchedIsaTempStorage.push_back(std::vector<char>(originalIsa, originalIsa + kernHeapInfo.KernelHeapSize));
@@ -95,22 +99,22 @@ cl_int Program::linkBinary(Device *pDevice, const void *constantsInitData, const
globalsForPatching, constantsForPatching,
isaSegmentsForPatching, unresolvedExternalsInfo,
pDevice, constantsInitData, variablesInitData);
setSymbols(pDevice->getRootDeviceIndex(), linker.extractRelocatedSymbols());
setSymbols(rootDeviceIndex, linker.extractRelocatedSymbols());
if (false == linkSuccess) {
std::vector<std::string> kernelNames;
for (const auto &kernelInfo : this->kernelInfoArray) {
for (const auto &kernelInfo : kernelInfoArray) {
kernelNames.push_back("kernel : " + kernelInfo->kernelDescriptor.kernelMetadata.kernelName);
}
auto error = constructLinkerErrorMessage(unresolvedExternalsInfo, kernelNames);
updateBuildLog(pDevice->getRootDeviceIndex(), error.c_str(), error.size());
return CL_INVALID_BINARY;
} else if (linkerInput->getTraits().requiresPatchingOfInstructionSegments) {
for (const auto &kernelInfo : this->kernelInfoArray) {
for (const auto &kernelInfo : kernelInfoArray) {
if (nullptr == kernelInfo->getGraphicsAllocation()) {
continue;
}
auto &kernHeapInfo = kernelInfo->heapInfo;
auto segmentId = &kernelInfo - &this->kernelInfoArray[0];
auto segmentId = &kernelInfo - &kernelInfoArray[0];
pDevice->getMemoryManager()->copyMemoryToAllocation(kernelInfo->getGraphicsAllocation(), 0,
isaSegmentsForPatching[segmentId].hostPointer,
kernHeapInfo.KernelHeapSize);
@@ -160,6 +164,7 @@ cl_int Program::processGenBinary(const ClDevice &clDevice) {
cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
auto rootDeviceIndex = clDevice.getRootDeviceIndex();
auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
size_t slmNeeded = getMaxInlineSlmNeeded(src);
size_t slmAvailable = 0U;
NEO::DeviceInfoKernelPayloadConstants deviceInfoConstants;
@@ -178,7 +183,7 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
return CL_OUT_OF_RESOURCES;
}
this->kernelInfoArray = std::move(src.kernelInfos);
kernelInfoArray = std::move(src.kernelInfos);
auto svmAllocsManager = context ? context->getSVMAllocsManager() : nullptr;
if (src.globalConstants.size != 0) {
buildInfos[rootDeviceIndex].constantSurface = allocateGlobalsSurface(svmAllocsManager, clDevice.getDevice(), src.globalConstants.size, true, linkerInput, src.globalConstants.initData);
@@ -193,7 +198,7 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
}
}
for (auto &kernelInfo : this->kernelInfoArray) {
for (auto &kernelInfo : kernelInfoArray) {
cl_int retVal = CL_SUCCESS;
if (kernelInfo->heapInfo.KernelHeapSize) {
retVal = kernelInfo->createKernelAllocation(clDevice.getDevice(), isBuiltIn) ? CL_SUCCESS : CL_OUT_OF_HOST_MEMORY;
@@ -204,10 +209,10 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
}
if (kernelInfo->hasDeviceEnqueue()) {
parentKernelInfoArray.push_back(kernelInfo);
buildInfos[rootDeviceIndex].parentKernelInfoArray.push_back(kernelInfo);
}
if (kernelInfo->requiresSubgroupIndependentForwardProgress()) {
subgroupKernelInfoArray.push_back(kernelInfo);
buildInfos[rootDeviceIndex].subgroupKernelInfoArray.push_back(kernelInfo);
}
kernelInfo->apply(deviceInfoConstants);
@@ -216,8 +221,9 @@ cl_int Program::processProgramInfo(ProgramInfo &src, const ClDevice &clDevice) {
return linkBinary(&clDevice.getDevice(), src.globalConstants.initData, src.globalVariables.initData);
}
void Program::processDebugData() {
void Program::processDebugData(uint32_t rootDeviceIndex) {
if (debugData != nullptr) {
auto &kernelInfoArray = buildInfos[rootDeviceIndex].kernelInfoArray;
SProgramDebugDataHeaderIGC *programDebugHeader = reinterpret_cast<SProgramDebugDataHeaderIGC *>(debugData.get());
DEBUG_BREAK_IF(programDebugHeader->NumberOfKernels != kernelInfoArray.size());

40
opencl/source/program/program.cpp
View File

@@ -294,26 +294,26 @@ const char *Program::getBuildLog(uint32_t rootDeviceIndex) const {
return currentLog.c_str();
}
void Program::separateBlockKernels() {
if ((0 == parentKernelInfoArray.size()) && (0 == subgroupKernelInfoArray.size())) {
void Program::separateBlockKernels(uint32_t rootDeviceIndex) {
if ((0 == buildInfos[rootDeviceIndex].parentKernelInfoArray.size()) && (0 == buildInfos[rootDeviceIndex].subgroupKernelInfoArray.size())) {
return;
}
auto allKernelInfos(kernelInfoArray);
kernelInfoArray.clear();
auto allKernelInfos(buildInfos[rootDeviceIndex].kernelInfoArray);
buildInfos[rootDeviceIndex].kernelInfoArray.clear();
for (auto &i : allKernelInfos) {
auto end = i->kernelDescriptor.kernelMetadata.kernelName.rfind("_dispatch_");
if (end != std::string::npos) {
bool baseKernelFound = false;
std::string baseKernelName(i->kernelDescriptor.kernelMetadata.kernelName, 0, end);
for (auto &j : parentKernelInfoArray) {
for (auto &j : buildInfos[rootDeviceIndex].parentKernelInfoArray) {
if (j->kernelDescriptor.kernelMetadata.kernelName.compare(baseKernelName) == 0) {
baseKernelFound = true;
break;
}
}
if (!baseKernelFound) {
for (auto &j : subgroupKernelInfoArray) {
for (auto &j : buildInfos[rootDeviceIndex].subgroupKernelInfoArray) {
if (j->kernelDescriptor.kernelMetadata.kernelName.compare(baseKernelName) == 0) {
baseKernelFound = true;
break;
@@ -324,11 +324,11 @@ void Program::separateBlockKernels() {
//Parent or subgroup kernel found -> child kernel
blockKernelManager->addBlockKernelInfo(i);
} else {
kernelInfoArray.push_back(i);
buildInfos[rootDeviceIndex].kernelInfoArray.push_back(i);
}
} else {
//Regular kernel found
kernelInfoArray.push_back(i);
buildInfos[rootDeviceIndex].kernelInfoArray.push_back(i);
}
}
allKernelInfos.clear();
@@ -375,21 +375,23 @@ void Program::freeBlockResources() {
}
void Program::cleanCurrentKernelInfo() {
for (auto &kernelInfo : kernelInfoArray) {
if (kernelInfo->kernelAllocation) {
//register cache flush in all csrs where kernel allocation was used
for (auto &engine : this->executionEnvironment.memoryManager->getRegisteredEngines()) {
auto contextId = engine.osContext->getContextId();
if (kernelInfo->kernelAllocation->isUsedByOsContext(contextId)) {
engine.commandStreamReceiver->registerInstructionCacheFlush();
for (auto &buildInfo : buildInfos) {
for (auto &kernelInfo : buildInfo.kernelInfoArray) {
if (kernelInfo->kernelAllocation) {
//register cache flush in all csrs where kernel allocation was used
for (auto &engine : this->executionEnvironment.memoryManager->getRegisteredEngines()) {
auto contextId = engine.osContext->getContextId();
if (kernelInfo->kernelAllocation->isUsedByOsContext(contextId)) {
engine.commandStreamReceiver->registerInstructionCacheFlush();
}
}
}
this->executionEnvironment.memoryManager->checkGpuUsageAndDestroyGraphicsAllocations(kernelInfo->kernelAllocation);
this->executionEnvironment.memoryManager->checkGpuUsageAndDestroyGraphicsAllocations(kernelInfo->kernelAllocation);
}
delete kernelInfo;
}
delete kernelInfo;
buildInfo.kernelInfoArray.clear();
}
kernelInfoArray.clear();
}
void Program::updateNonUniformFlag() {

15
opencl/source/program/program.h
View File

@@ -144,8 +144,8 @@ class Program : public BaseObject<_cl_program> {
MOCKABLE_VIRTUAL cl_int updateSpecializationConstant(cl_uint specId, size_t specSize, const void *specValue);
size_t getNumKernels() const;
const KernelInfo *getKernelInfo(const char *kernelName) const;
const KernelInfo *getKernelInfo(size_t ordinal) const;
const KernelInfo *getKernelInfo(const char *kernelName, uint32_t rootDeviceIndex) const;
const KernelInfo *getKernelInfo(size_t ordinal, uint32_t rootDeviceIndex) const;
cl_int getInfo(cl_program_info paramName, size_t paramValueSize,
void *paramValue, size_t *paramValueSizeRet);
@@ -173,7 +173,7 @@ class Program : public BaseObject<_cl_program> {
cl_int getSource(std::string &binary) const;
void processDebugData();
void processDebugData(uint32_t rootDeviceIndex);
void updateBuildLog(uint32_t rootDeviceIndex, const char *pErrorString, const size_t errorStringSize);
@@ -284,7 +284,7 @@ class Program : public BaseObject<_cl_program> {
MOCKABLE_VIRTUAL cl_int linkBinary(Device *pDevice, const void *constantsInitData, const void *variablesInitData);
void separateBlockKernels();
void separateBlockKernels(uint32_t rootDeviceIndex);
void updateNonUniformFlag();
void updateNonUniformFlag(const Program **inputProgram, size_t numInputPrograms);
@@ -310,10 +310,6 @@ class Program : public BaseObject<_cl_program> {
CreatedFrom createdFrom = CreatedFrom::UNKNOWN;
std::vector<KernelInfo *> kernelInfoArray;
std::vector<KernelInfo *> parentKernelInfoArray;
std::vector<KernelInfo *> subgroupKernelInfoArray;
struct DeviceBuildInfo {
StackVec<ClDevice *, 2> associatedSubDevices;
cl_build_status buildStatus = CL_BUILD_NONE;
@@ -331,6 +327,9 @@ class Program : public BaseObject<_cl_program> {
bool allowNonUniform = false;
struct BuildInfo : public NonCopyableClass {
std::vector<KernelInfo *> kernelInfoArray;
std::vector<KernelInfo *> parentKernelInfoArray;
std::vector<KernelInfo *> subgroupKernelInfoArray;
GraphicsAllocation *constantSurface = nullptr;
GraphicsAllocation *globalSurface = nullptr;
GraphicsAllocation *exportedFunctionsSurface = nullptr;

2
opencl/test/unit_test/api/cl_create_kernel_tests.inl
View File

@@ -142,7 +142,7 @@ TEST_F(clCreateKernelTests, GivenNullKernelNameWhenCreatingNewKernelThenInvalidV
KernelInfo *pKernelInfo = new KernelInfo();
std::unique_ptr<MockProgram> pMockProg = std::make_unique<MockProgram>(pContext, false, toClDeviceVector(*pDevice));
pMockProg->addKernelInfo(pKernelInfo);
pMockProg->addKernelInfo(pKernelInfo, testedRootDeviceIndex);
kernel = clCreateKernel(
pMockProg.get(),

8
opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp
View File

@@ -48,7 +48,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, ooqExecution) {
false);
ASSERT_EQ(CL_SUCCESS, retVal);
const KernelInfo *pKernelInfo0 = pProgram->getKernelInfo("simple_kernel_0");
const KernelInfo *pKernelInfo0 = pProgram->getKernelInfo("simple_kernel_0", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo0);
Kernel *pKernel0 = Kernel::create<MockKernel>(
@@ -57,7 +57,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, ooqExecution) {
&retVal);
ASSERT_NE(nullptr, pKernel0);
const KernelInfo *pKernelInfo1 = pProgram->getKernelInfo("simple_kernel_1");
const KernelInfo *pKernelInfo1 = pProgram->getKernelInfo("simple_kernel_1", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo1);
Kernel *pKernel1 = Kernel::create<MockKernel>(
@@ -66,7 +66,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, ooqExecution) {
&retVal);
ASSERT_NE(nullptr, pKernel1);
const KernelInfo *pKernelInfo2 = pProgram->getKernelInfo("simple_kernel_2");
const KernelInfo *pKernelInfo2 = pProgram->getKernelInfo("simple_kernel_2", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo2);
Kernel *pKernel2 = Kernel::create<MockKernel>(
@@ -271,7 +271,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, deviceSideVme) {
false);
ASSERT_EQ(CL_SUCCESS, retVal);
const KernelInfo *pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel");
const KernelInfo *pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel", rootDeviceIndex);
EXPECT_NE(nullptr, pKernelInfo);
Kernel *pKernel = Kernel::create<MockKernel>(

2
opencl/test/unit_test/built_ins/built_in_tests.cpp
View File

@@ -2017,7 +2017,7 @@ TEST_F(BuiltInTests, WhenGettingSipKernelThenReturnProgramCreatedFromIsaAcquired
const SipKernel &sipKern = mockBuiltins.getSipKernel(SipKernelType::Csr, pContext->getDevice(0)->getDevice());
const auto &sipKernelInfo = p->getKernelInfo(static_cast<size_t>(0));
const auto &sipKernelInfo = p->getKernelInfo(static_cast<size_t>(0), rootDeviceIndex);
auto compbinedKernelHeapSize = sipKernelInfo->heapInfo.KernelHeapSize;
auto sipOffset = sipKernelInfo->systemKernelOffset;

2
opencl/test/unit_test/command_queue/enqueue_debug_kernel_tests.cpp
View File

@@ -53,7 +53,7 @@ class EnqueueDebugKernelTest : public ProgramSimpleFixture,
// create a kernel
debugKernel = Kernel::create(
pProgram,
*pProgram->getKernelInfo("CopyBuffer"),
*pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex),
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);

14
opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
View File

@@ -47,7 +47,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDRangeKernel
cl_int retVal = CL_SUCCESS;
CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -86,7 +86,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalled
cl_int retVal = CL_SUCCESS;
CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -125,7 +125,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenSetKernelArgIsCalledForEachArgButAtLeas
cl_int retVal = CL_SUCCESS;
CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -248,7 +248,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreSetThenClEnqueueNDCountKernel
pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, true, false).osContext;
}
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -292,7 +292,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenNotAllArgsAreSetButSetKernelArgIsCalled
pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, true, false).osContext;
}
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -336,7 +336,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenSetKernelArgIsCalledForEachArgButAtLeas
pCmdQ2->getGpgpuEngine().osContext = pCmdQ2->getDevice().getEngine(aub_stream::ENGINE_CCS, true, false).osContext;
}
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
auto b0 = clCreateBuffer(context, 0, n * sizeof(float), nullptr, nullptr);
@@ -1263,7 +1263,7 @@ TEST_F(EnqueueKernelTest, givenKernelWhenAllArgsAreNotAndEventExistSetThenClEnqu
cl_int retVal = CL_SUCCESS;
CommandQueue *pCmdQ2 = createCommandQueue(pClDevice);
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
std::unique_ptr<Kernel> kernel(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_FALSE(kernel->isPatched());

4
opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
View File

@@ -738,7 +738,7 @@ TEST_F(EnqueueSvmTest, GivenSvmAllocationWhenEnqueingKernelThenSuccessIsReturned
std::unique_ptr<Program> program(Program::createBuiltInFromSource("FillBufferBytes", context, context->getDevices(), &retVal));
program->build(program->getDevices(), nullptr, false);
std::unique_ptr<MockKernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
std::unique_ptr<MockKernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes", rootDeviceIndex), &retVal));
kernel->setSvmKernelExecInfo(pSvmAlloc);
@@ -766,7 +766,7 @@ TEST_F(EnqueueSvmTest, givenEnqueueTaskBlockedOnUserEventWhenItIsEnqueuedThenSur
auto program = clUniquePtr(Program::createBuiltInFromSource("FillBufferBytes", context, context->getDevices(), &retVal));
program->build(program->getDevices(), nullptr, false);
auto kernel = clUniquePtr(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
auto kernel = clUniquePtr(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("FillBufferBytes", rootDeviceIndex), &retVal));
std::vector<Surface *> allSurfaces;
kernel->getResidency(allSurfaces, rootDeviceIndex);

2
opencl/test/unit_test/command_queue/get_size_required_image_tests.cpp
View File

@@ -121,7 +121,7 @@ HWTEST_F(GetSizeRequiredImageTest, WhenCopyingReadWriteImageThenHeapsAndCommandB
std::unique_ptr<Program> program(Program::createBuiltInFromSource("CopyImageToImage3d", context, context->getDevices(), nullptr));
program->build(program->getDevices(), nullptr, false);
std::unique_ptr<Kernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("CopyImageToImage3d"), nullptr));
std::unique_ptr<Kernel> kernel(Kernel::create<MockKernel>(program.get(), *program->getKernelInfo("CopyImageToImage3d", rootDeviceIndex), nullptr));
EXPECT_NE(nullptr, kernel);
// This kernel does not operate on OpenCL 2.0 Read and Write images

4
opencl/test/unit_test/context/driver_diagnostics_tests.h
View File

@@ -230,7 +230,7 @@ struct PerformanceHintEnqueueKernelTest : public PerformanceHintEnqueueTest,
CreateProgramFromBinary(context, context->getDevices(), "CopyBuffer_simd32");
retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
ASSERT_EQ(CL_SUCCESS, retVal);
kernel = Kernel::create<MockKernel>(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal);
kernel = Kernel::create<MockKernel>(pProgram, *pProgram->getKernelInfo("CopyBuffer", context->getDevice(0)->getRootDeviceIndex()), &retVal);
globalWorkGroupSize[0] = globalWorkGroupSize[1] = globalWorkGroupSize[2] = 1;
}
@@ -265,7 +265,7 @@ struct PerformanceHintEnqueueKernelPrintfTest : public PerformanceHintEnqueueTes
CreateProgramFromBinary(context, context->getDevices(), "printf");
retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
ASSERT_EQ(CL_SUCCESS, retVal);
kernel = Kernel::create(pProgram, *pProgram->getKernelInfo("test"), &retVal);
kernel = Kernel::create(pProgram, *pProgram->getKernelInfo("test", context->getDevice(0)->getRootDeviceIndex()), &retVal);
globalWorkGroupSize[0] = globalWorkGroupSize[1] = globalWorkGroupSize[2] = 1;
}

2
opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
View File

@@ -40,7 +40,7 @@ class ExecutionModelKernelFixture : public ProgramFromBinaryTest,
// create a kernel
pKernel = Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo(KernelName),
*pProgram->getKernelInfo(kernelName, rootDeviceIndex),
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);

2
opencl/test/unit_test/fixtures/hello_world_kernel_fixture.h
View File

@@ -77,7 +77,7 @@ struct HelloWorldKernelFixture : public ProgramFixture {
// create a kernel
pKernel = Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo(pKernelName->c_str()),
*pProgram->getKernelInfo(pKernelName->c_str(), pDevice->getRootDeviceIndex()),
&retVal);
EXPECT_NE(nullptr, pKernel);

2
opencl/test/unit_test/fixtures/kernel_data_fixture.cpp
View File

@@ -95,7 +95,7 @@ void KernelDataTest::buildAndDecode() {
EXPECT_EQ(CL_SUCCESS, error);
// extract the kernel info
pKernelInfo = program->Program::getKernelInfo(kernelName.c_str());
pKernelInfo = program->Program::getKernelInfo(kernelName.c_str(), rootDeviceIndex);
// validate name
EXPECT_STREQ(pKernelInfo->kernelDescriptor.kernelMetadata.kernelName.c_str(), kernelName.c_str());

2
opencl/test/unit_test/fixtures/kernel_data_fixture.h
View File

@@ -53,6 +53,7 @@ class KernelDataTest : public testing::Test {
void SetUp() override {
kernelBinaryHeader.KernelNameSize = kernelNameSize;
pContext = new MockContext;
rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
program = std::make_unique<MockProgram>(pContext, false, toClDeviceVector(*pContext->getDevice(0)));
}
@@ -91,4 +92,5 @@ class KernelDataTest : public testing::Test {
std::unique_ptr<MockProgram> program;
MockContext *pContext;
const KernelInfo *pKernelInfo;
uint32_t rootDeviceIndex = std::numeric_limits<uint32_t>::max();
};

2
opencl/test/unit_test/fixtures/media_kernel_fixture.h
View File

@@ -76,7 +76,7 @@ struct MediaKernelFixture : public HelloWorldFixture<FactoryType>,
// create the VME kernel
pVmeKernel = Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo("device_side_block_motion_estimate_intel"),
*pProgram->getKernelInfo("device_side_block_motion_estimate_intel", pProgram->getDevices()[0]->getRootDeviceIndex()),
&retVal);
ASSERT_NE(nullptr, pVmeKernel);

10
opencl/test/unit_test/fixtures/simple_arg_kernel_fixture.h
View File

@@ -110,7 +110,7 @@ class SimpleArgKernelFixture : public ProgramFixture {
// create a kernel
pKernel = Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo("SimpleArg"),
*pProgram->getKernelInfo("SimpleArg", pDevice->getRootDeviceIndex()),
&retVal);
ASSERT_NE(nullptr, pKernel);
@@ -156,7 +156,7 @@ class SimpleArgNonUniformKernelFixture : public ProgramFixture {
kernel = Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo("simpleNonUniform"),
*pProgram->getKernelInfo("simpleNonUniform", device->getRootDeviceIndex()),
&retVal);
ASSERT_NE(nullptr, kernel);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -202,7 +202,7 @@ class SimpleKernelFixture : public ProgramFixture {
kernelName.append(std::to_string(i));
kernels[i].reset(Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo(kernelName.c_str()),
*pProgram->getKernelInfo(kernelName.c_str(), device->getRootDeviceIndex()),
&retVal));
ASSERT_NE(nullptr, kernels[i]);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -251,7 +251,7 @@ class SimpleKernelStatelessFixture : public ProgramFixture {
kernel.reset(Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo("statelessKernel"),
*pProgram->getKernelInfo("statelessKernel", device->getRootDeviceIndex()),
&retVal));
ASSERT_NE(nullptr, kernel);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -294,7 +294,7 @@ class BindlessKernelFixture : public ProgramFixture {
kernel.reset(Kernel::create<MockKernel>(
pProgram,
*pProgram->getKernelInfo(kernelName.c_str()),
*pProgram->getKernelInfo(kernelName.c_str(), deviceCl->getRootDeviceIndex()),
&retVal));
ASSERT_NE(nullptr, kernel);
ASSERT_EQ(CL_SUCCESS, retVal);

2
opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
View File

@@ -1318,7 +1318,7 @@ HWTEST_F(KernelCacheFlushTests, givenLocallyUncachedBufferWhenGettingAllocations
DebugManagerStateRestore dbgRestore;
DebugManager.flags.EnableCacheFlushAfterWalker.set(-1);
auto kernel = clUniquePtr(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer"), &retVal));
auto kernel = clUniquePtr(Kernel::create(pProgram, *pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex), &retVal));
cl_mem_properties_intel bufferPropertiesUncachedResource[] = {CL_MEM_FLAGS_INTEL, CL_MEM_LOCALLY_UNCACHED_RESOURCE, 0};
auto bufferLocallyUncached = clCreateBufferWithPropertiesINTEL(context, bufferPropertiesUncachedResource, 0, 1, nullptr, nullptr);

4
opencl/test/unit_test/kernel/kernel_arg_info_tests.cpp
View File

@@ -40,7 +40,7 @@ class KernelArgInfoTest : public ProgramFromSourceTest {
// create a kernel
pKernel = Kernel::create(
pProgram,
*pProgram->getKernelInfo(KernelName),
*pProgram->getKernelInfo(kernelName, rootDeviceIndex),
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -87,7 +87,7 @@ class KernelArgInfoTest : public ProgramFromSourceTest {
};
TEST_P(KernelArgInfoTest, GivenNullWhenGettingKernelInfoThenNullIsReturned) {
auto kernelInfo = this->pProgram->getKernelInfo(nullptr);
auto kernelInfo = this->pProgram->getKernelInfo(nullptr, 0);
EXPECT_EQ(nullptr, kernelInfo);
}

5
opencl/test/unit_test/kernel/kernel_is_patched_tests.cpp
View File

@@ -18,18 +18,19 @@ using namespace NEO;
class PatchedKernelTest : public ::testing::Test {
public:
void SetUp() override {
device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), rootDeviceIndex));
context.reset(new MockContext(device.get()));
program.reset(Program::createBuiltInFromSource("FillBufferBytes", context.get(), context->getDevices(), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
program->build(program->getDevices(), nullptr, false);
kernel.reset(Kernel::create(program.get(), *program->getKernelInfo("FillBufferBytes"), &retVal));
kernel.reset(Kernel::create(program.get(), *program->getKernelInfo("FillBufferBytes", rootDeviceIndex), &retVal));
EXPECT_EQ(CL_SUCCESS, retVal);
}
void TearDown() override {
context.reset();
}
const uint32_t rootDeviceIndex = 0u;
std::unique_ptr<MockContext> context;
std::unique_ptr<MockClDevice> device;
std::unique_ptr<Program> program;

12
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

@@ -67,7 +67,7 @@ class KernelTest : public ProgramFromBinaryTest {
// create a kernel
pKernel = Kernel::create(
pProgram,
*pProgram->getKernelInfo(KernelName),
*pProgram->getKernelInfo(kernelName, rootDeviceIndex),
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -156,7 +156,7 @@ TEST_P(KernelTest, GivenKernelFunctionNameWhenGettingInfoThenKernelFunctionNameI
nullptr);
EXPECT_NE(nullptr, paramValue);
EXPECT_EQ(0, strcmp(paramValue, KernelName));
EXPECT_EQ(0, strcmp(paramValue, kernelName));
EXPECT_EQ(CL_SUCCESS, retVal);
delete[] paramValue;
@@ -351,7 +351,7 @@ TEST_F(KernelFromBinaryTests, GivenKernelNumArgsWhenGettingInfoThenNumberOfKerne
ASSERT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("test");
auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
// create a kernel
auto pKernel = Kernel::create(
@@ -389,7 +389,7 @@ TEST_F(KernelFromBinaryTests, WhenRegularKernelIsCreatedThenItIsNotBuiltIn) {
ASSERT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_0");
auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_0", rootDeviceIndex);
// create a kernel
auto pKernel = Kernel::create(
@@ -419,9 +419,9 @@ TEST_F(KernelFromBinaryTests, givenArgumentDeclaredAsConstantWhenKernelIsCreated
ASSERT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_6");
auto pKernelInfo = pProgram->getKernelInfo("simple_kernel_6", rootDeviceIndex);
EXPECT_TRUE(pKernelInfo->kernelArgInfo[1].isReadOnly);
pKernelInfo = pProgram->getKernelInfo("simple_kernel_1");
pKernelInfo = pProgram->getKernelInfo("simple_kernel_1", rootDeviceIndex);
EXPECT_TRUE(pKernelInfo->kernelArgInfo[0].isReadOnly);
}

16
opencl/test/unit_test/mocks/mock_program.h
View File

@@ -91,17 +91,17 @@ class MockProgram : public Program {
}
}
}
std::vector<KernelInfo *> &getKernelInfoArray() {
return kernelInfoArray;
std::vector<KernelInfo *> &getKernelInfoArray(uint32_t rootDeviceIndex) {
return buildInfos[rootDeviceIndex].kernelInfoArray;
}
void addKernelInfo(KernelInfo *inInfo) {
kernelInfoArray.push_back(inInfo);
void addKernelInfo(KernelInfo *inInfo, uint32_t rootDeviceIndex) {
buildInfos[rootDeviceIndex].kernelInfoArray.push_back(inInfo);
}
std::vector<KernelInfo *> &getParentKernelInfoArray() {
return parentKernelInfoArray;
std::vector<KernelInfo *> &getParentKernelInfoArray(uint32_t rootDeviceIndex) {
return buildInfos[rootDeviceIndex].parentKernelInfoArray;
}
std::vector<KernelInfo *> &getSubgroupKernelInfoArray() {
return subgroupKernelInfoArray;
std::vector<KernelInfo *> &getSubgroupKernelInfoArray(uint32_t rootDeviceIndex) {
return buildInfos[rootDeviceIndex].subgroupKernelInfoArray;
}
void setContext(Context *context) {
this->context = context;

8
opencl/test/unit_test/program/kernel_data.cpp
View File

@@ -408,7 +408,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentDoesntHaveDeviceEnqueueWhenBuild
buildAndDecode();
EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
EXPECT_EQ_VAL(0u, program->getParentKernelInfoArray().size());
EXPECT_EQ_VAL(0u, program->getParentKernelInfoArray(rootDeviceIndex).size());
}
TEST_F(KernelDataTest, GivenExecutionEnvironmentHasDeviceEnqueueWhenBuildingThenProgramIsCorrect) {
@@ -423,7 +423,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentHasDeviceEnqueueWhenBuildingThen
buildAndDecode();
EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
EXPECT_EQ_VAL(1u, program->getParentKernelInfoArray().size());
EXPECT_EQ_VAL(1u, program->getParentKernelInfoArray(rootDeviceIndex).size());
}
TEST_F(KernelDataTest, GivenExecutionEnvironmentDoesntRequireSubgroupIndependentForwardProgressWhenBuildingThenProgramIsCorrect) {
@@ -438,7 +438,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentDoesntRequireSubgroupIndependent
buildAndDecode();
EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
EXPECT_EQ_VAL(0u, program->getSubgroupKernelInfoArray().size());
EXPECT_EQ_VAL(0u, program->getSubgroupKernelInfoArray(rootDeviceIndex).size());
}
TEST_F(KernelDataTest, GivenExecutionEnvironmentRequiresSubgroupIndependentForwardProgressWhenBuildingThenProgramIsCorrect) {
@@ -453,7 +453,7 @@ TEST_F(KernelDataTest, GivenExecutionEnvironmentRequiresSubgroupIndependentForwa
buildAndDecode();
EXPECT_EQ_CONST(PATCH_TOKEN_EXECUTION_ENVIRONMENT, pKernelInfo->patchInfo.executionEnvironment->Token);
EXPECT_EQ_VAL(1u, program->getSubgroupKernelInfoArray().size());
EXPECT_EQ_VAL(1u, program->getSubgroupKernelInfoArray(rootDeviceIndex).size());
}
TEST_F(KernelDataTest, GivenKernelAttributesInfoWhenBuildingThenProgramIsCorrect) {

10
opencl/test/unit_test/program/process_debug_data_tests.cpp
View File

@@ -64,10 +64,10 @@ TEST_F(ProgramTests, GivenProgramWithDebugDataForTwoKernelsWhenPorcessedThenDebu
program->debugData = makeCopy(debugData.get(), debugDataSize);
program->debugDataSize = debugDataSize;
program->addKernelInfo(kernelInfo1);
program->addKernelInfo(kernelInfo2);
program->addKernelInfo(kernelInfo1, rootDeviceIndex);
program->addKernelInfo(kernelInfo2, rootDeviceIndex);
program->processDebugData();
program->processDebugData(rootDeviceIndex);
EXPECT_EQ(genIsaSize, kernelInfo1->debugData.genIsaSize);
EXPECT_EQ(visaSize, kernelInfo1->debugData.vIsaSize);
EXPECT_EQ(ptrDiff(vIsa1, debugData.get()), ptrDiff(kernelInfo1->debugData.vIsa, program->getDebugData()));
@@ -86,8 +86,8 @@ TEST_F(ProgramTests, GivenProgramWithoutDebugDataWhenPorcessedThenDebugDataIsNot
kernelInfo1->kernelDescriptor.kernelMetadata.kernelName = kernelName1;
auto program = std::make_unique<MockProgram>(toClDeviceVector(*pClDevice));
program->addKernelInfo(kernelInfo1);
program->processDebugData();
program->addKernelInfo(kernelInfo1, rootDeviceIndex);
program->processDebugData(rootDeviceIndex);
EXPECT_EQ(0u, kernelInfo1->debugData.genIsaSize);
EXPECT_EQ(0u, kernelInfo1->debugData.vIsaSize);

21
opencl/test/unit_test/program/program_data_tests.cpp
View File

@@ -51,6 +51,7 @@ class ProgramDataTestBase : public testing::Test,
void SetUp() override {
PlatformFixture::SetUp();
pClDevice = pPlatform->getClDevice(0);
rootDeviceIndex = pClDevice->getRootDeviceIndex();
cl_device_id device = pClDevice;
ContextFixture::SetUp(1, &device);
@@ -128,6 +129,7 @@ class ProgramDataTestBase : public testing::Test,
cl_int patchlistDecodeErrorCode = 0;
bool allowDecodeFailure = false;
ClDevice *pClDevice = nullptr;
uint32_t rootDeviceIndex;
};
void ProgramDataTestBase::buildAndDecodeProgramPatchList() {
@@ -555,6 +557,7 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
linkerInput->relocations.push_back(NEO::LinkerInput::Relocations{relocation});
linkerInput->traits.requiresPatchingOfInstructionSegments = true;
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
auto rootDeviceIndex = device->getRootDeviceIndex();
MockProgram program{nullptr, false, toClDeviceVector(*device)};
KernelInfo kernelInfo = {};
kernelInfo.kernelDescriptor.kernelMetadata.kernelName = "onlyKernel";
@@ -562,15 +565,15 @@ TEST(ProgramLinkBinaryTest, whenLinkerUnresolvedExternalThenLinkFailedAndBuildLo
kernelHeap.resize(32, 7);
kernelInfo.heapInfo.pKernelHeap = kernelHeap.data();
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
program.getKernelInfoArray().push_back(&kernelInfo);
program.setLinkerInput(device->getRootDeviceIndex(), std::move(linkerInput));
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
std::string buildLog = program.getBuildLog(device->getRootDeviceIndex());
EXPECT_TRUE(buildLog.empty());
auto ret = program.linkBinary(&device->getDevice(), nullptr, nullptr);
EXPECT_NE(CL_SUCCESS, ret);
program.getKernelInfoArray().clear();
buildLog = program.getBuildLog(device->getRootDeviceIndex());
program.getKernelInfoArray(rootDeviceIndex).clear();
buildLog = program.getBuildLog(rootDeviceIndex);
EXPECT_FALSE(buildLog.empty());
Linker::UnresolvedExternals expectedUnresolvedExternals;
expectedUnresolvedExternals.push_back(Linker::UnresolvedExternal{relocation, 0, false});
@@ -601,7 +604,7 @@ TEST_F(ProgramDataTest, whenLinkerInputValidThenIsaIsProperlyPatched) {
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
MockGraphicsAllocation kernelIsa(kernelHeap.data(), kernelHeap.size());
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray().push_back(&kernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
program.setLinkerInput(device->getRootDeviceIndex(), std::move(linkerInput));
buildInfo.exportedFunctionsSurface = kernelInfo.kernelAllocation;
@@ -626,7 +629,7 @@ TEST_F(ProgramDataTest, whenLinkerInputValidThenIsaIsProperlyPatched) {
EXPECT_EQ(static_cast<uintptr_t>(expectedPatch), *reinterpret_cast<uintptr_t *>(relocationAddress)) << i;
}
program.getKernelInfoArray().clear();
program.getKernelInfoArray(rootDeviceIndex).clear();
delete buildInfo.globalSurface;
buildInfo.globalSurface = nullptr;
delete buildInfo.constantSurface;
@@ -650,8 +653,8 @@ TEST_F(ProgramDataTest, whenRelocationsAreNotNeededThenIsaIsPreserved) {
kernelInfo.heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelHeap.size());
MockGraphicsAllocation kernelIsa(kernelHeap.data(), kernelHeap.size());
kernelInfo.kernelAllocation = &kernelIsa;
program.getKernelInfoArray().push_back(&kernelInfo);
program.setLinkerInput(device->getRootDeviceIndex(), std::move(linkerInput));
program.getKernelInfoArray(rootDeviceIndex).push_back(&kernelInfo);
program.setLinkerInput(rootDeviceIndex, std::move(linkerInput));
std::vector<char> globalVariablesBuffer;
globalVariablesBuffer.resize(32, 7);
@@ -666,7 +669,7 @@ TEST_F(ProgramDataTest, whenRelocationsAreNotNeededThenIsaIsPreserved) {
EXPECT_EQ(CL_SUCCESS, ret);
EXPECT_EQ(kernelHeapData, kernelHeap);
program.getKernelInfoArray().clear();
program.getKernelInfoArray(rootDeviceIndex).clear();
delete buildInfo.globalSurface;
buildInfo.globalSurface = nullptr;
delete buildInfo.constantSurface;

4
opencl/test/unit_test/program/program_from_binary.h
View File

@@ -30,7 +30,7 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
protected:
void SetUp() override {
std::tie(BinaryFileName, KernelName) = GetParam();
std::tie(BinaryFileName, kernelName) = GetParam();
ClDeviceFixture::SetUp();
@@ -56,7 +56,7 @@ class ProgramFromBinaryTest : public ClDeviceFixture,
}
const char *BinaryFileName = nullptr;
const char *KernelName = nullptr;
const char *kernelName = nullptr;
cl_int retVal = CL_SUCCESS;
std::string options;
};

8
opencl/test/unit_test/program/program_nonuniform.cpp
View File

@@ -166,6 +166,7 @@ class ProgramNonUniformTest : public ContextFixture,
void SetUp() override {
PlatformFixture::SetUp();
device = pPlatform->getClDevice(0);
rootDeviceIndex = pPlatform->getClDevice(0)->getRootDeviceIndex();
ContextFixture::SetUp(1, &device);
ProgramFixture::SetUp();
CommandQueueHwFixture::SetUp(pPlatform->getClDevice(0), 0);
@@ -178,6 +179,7 @@ class ProgramNonUniformTest : public ContextFixture,
PlatformFixture::TearDown();
}
cl_device_id device;
uint32_t rootDeviceIndex;
cl_int retVal = CL_SUCCESS;
};
@@ -195,7 +197,7 @@ TEST_F(ProgramNonUniformTest, GivenCl21WhenExecutingKernelWithNonUniformThenEnqu
false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size");
auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size", rootDeviceIndex);
EXPECT_NE(nullptr, pKernelInfo);
// create a kernel
@@ -234,7 +236,7 @@ TEST_F(ProgramNonUniformTest, GivenCl20WhenExecutingKernelWithNonUniformThenEnqu
false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size");
auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size", rootDeviceIndex);
EXPECT_NE(nullptr, pKernelInfo);
// create a kernel
@@ -271,7 +273,7 @@ TEST_F(ProgramNonUniformTest, GivenCl12WhenExecutingKernelWithNonUniformThenInva
false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size");
auto pKernelInfo = mockProgram->Program::getKernelInfo("test_get_local_size", rootDeviceIndex);
EXPECT_NE(nullptr, pKernelInfo);
// create a kernel

126
opencl/test/unit_test/program/program_tests.cpp
View File

@@ -277,7 +277,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
paramValueSize = paramValueSizeRet;
ASSERT_NE(paramValue, nullptr);
size_t expectedKernelsStringSize = strlen(KernelName) + 1;
size_t expectedKernelsStringSize = strlen(kernelName) + 1;
retVal = pProgram->getInfo(
CL_PROGRAM_KERNEL_NAMES,
paramValueSize,
@@ -285,7 +285,7 @@ TEST_P(ProgramFromBinaryTest, WhenGettingKernelNamesThenCorrectNameIsReturned) {
&paramValueSizeRet);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_STREQ(KernelName, (char *)paramValue.get());
EXPECT_STREQ(kernelName, (char *)paramValue.get());
EXPECT_EQ(expectedKernelsStringSize, paramValueSizeRet);
}
@@ -588,7 +588,7 @@ TEST_P(ProgramFromBinaryTest, GivenGlobalVariableTotalSizeSetWhenGettingBuildGlo
TEST_P(ProgramFromBinaryTest, givenProgramWhenItIsBeingBuildThenItContainsGraphicsAllocationInKernelInfo) {
pProgram->build(pProgram->getDevices(), nullptr, true);
auto kernelInfo = pProgram->getKernelInfo(size_t(0));
auto kernelInfo = pProgram->getKernelInfo(size_t(0), rootDeviceIndex);
auto graphicsAllocation = kernelInfo->getGraphicsAllocation();
ASSERT_NE(nullptr, graphicsAllocation);
@@ -629,7 +629,7 @@ HWTEST_P(ProgramFromBinaryTest, givenProgramWhenCleanCurrentKernelInfoIsCalledBu
auto &csr = pDevice->getGpgpuCommandStreamReceiver();
EXPECT_TRUE(csr.getTemporaryAllocations().peekIsEmpty());
pProgram->build(pProgram->getDevices(), nullptr, true);
auto kernelAllocation = pProgram->getKernelInfo(size_t(0))->getGraphicsAllocation();
auto kernelAllocation = pProgram->getKernelInfo(static_cast<size_t>(0u), rootDeviceIndex)->getGraphicsAllocation();
kernelAllocation->updateTaskCount(100, csr.getOsContext().getContextId());
*csr.getTagAddress() = 0;
pProgram->cleanCurrentKernelInfo();
@@ -644,7 +644,7 @@ HWTEST_P(ProgramFromBinaryTest, givenIsaAllocationUsedByMultipleCsrsWhenItIsDele
pProgram->build(pProgram->getDevices(), nullptr, true);
auto kernelAllocation = pProgram->getKernelInfo(size_t(0))->getGraphicsAllocation();
auto kernelAllocation = pProgram->getKernelInfo(static_cast<size_t>(0u), rootDeviceIndex)->getGraphicsAllocation();
csr0.makeResident(*kernelAllocation);
csr1.makeResident(*kernelAllocation);
@@ -909,6 +909,8 @@ std::map<const void *, uint32_t> Callback::watchList;
TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramThenKernelHashesAreDifferent) {
KernelBinaryHelper kbHelper(BinaryFileName, true);
auto rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
CreateProgramWithSource(
pContext,
SourceFileName);
@@ -918,14 +920,14 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
retVal = pProgram->build(pProgram->getDevices(), nullptr, true);
EXPECT_EQ(CL_SUCCESS, retVal);
auto hash1 = pProgram->getCachedFileName();
auto kernel1 = pProgram->getKernelInfo("CopyBuffer");
auto kernel1 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
Callback::watch(kernel1);
EXPECT_NE(nullptr, kernel1);
retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::fastRelaxedMath.data(), true);
EXPECT_EQ(CL_SUCCESS, retVal);
auto hash2 = pProgram->getCachedFileName();
auto kernel2 = pProgram->getKernelInfo("CopyBuffer");
auto kernel2 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
EXPECT_NE(nullptr, kernel2);
EXPECT_NE(hash1, hash2);
Callback::unwatch(kernel1);
@@ -934,7 +936,7 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::finiteMathOnly.data(), true);
EXPECT_EQ(CL_SUCCESS, retVal);
auto hash3 = pProgram->getCachedFileName();
auto kernel3 = pProgram->getKernelInfo("CopyBuffer");
auto kernel3 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
EXPECT_NE(nullptr, kernel3);
EXPECT_NE(hash1, hash3);
EXPECT_NE(hash2, hash3);
@@ -947,7 +949,7 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
retVal = pProgram->build(pProgram->getDevices(), nullptr, true);
EXPECT_EQ(CL_SUCCESS, retVal);
auto hash4 = pProgram->getCachedFileName();
auto kernel4 = pProgram->getKernelInfo("CopyBuffer");
auto kernel4 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
EXPECT_NE(nullptr, kernel4);
EXPECT_EQ(hash3, hash4);
Callback::unwatch(kernel3);
@@ -957,7 +959,7 @@ TEST_P(ProgramFromSourceTest, GivenDifferentCommpilerOptionsWhenBuildingProgramT
retVal = pProgram->build(pProgram->getDevices(), nullptr, true);
EXPECT_EQ(CL_SUCCESS, retVal);
auto hash5 = pProgram->getCachedFileName();
auto kernel5 = pProgram->getKernelInfo("CopyBuffer");
auto kernel5 = pProgram->getKernelInfo("CopyBuffer", rootDeviceIndex);
EXPECT_NE(nullptr, kernel5);
EXPECT_EQ(hash1, hash5);
Callback::unwatch(kernel4);
@@ -1310,7 +1312,7 @@ HWTEST_F(PatchTokenTests, givenKernelRequiringConstantAllocationWhenMakeResident
ASSERT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("test");
auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
EXPECT_NE(nullptr, pKernelInfo->patchInfo.pAllocateStatelessConstantMemorySurfaceWithInitialization);
ASSERT_NE(nullptr, pProgram->getConstantSurface(pClDevice->getRootDeviceIndex()));
@@ -1374,7 +1376,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenGwsIsSet) {
ASSERT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("test");
auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo->patchInfo.dataParameterStream);
ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.globalWorkSizeOffsets[0]);
@@ -1393,14 +1395,14 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenLwsIsSet) {
ASSERT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("test");
auto pKernelInfo = pProgram->getKernelInfo("test", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo->patchInfo.dataParameterStream);
ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[0]);
ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[1]);
ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[2]);
pKernelInfo = pProgram->getKernelInfo("test_get_local_size");
pKernelInfo = pProgram->getKernelInfo("test_get_local_size", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo->patchInfo.dataParameterStream);
ASSERT_NE(static_cast<uint32_t>(-1), pKernelInfo->workloadInfo.localWorkSizeOffsets[0]);
@@ -1424,7 +1426,7 @@ TEST_F(PatchTokenTests, WhenBuildingProgramThenConstantKernelArgsAreAvailable) {
EXPECT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("constant_kernel");
auto pKernelInfo = pProgram->getKernelInfo("constant_kernel", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo);
auto pKernel = Kernel::create(
@@ -1463,7 +1465,7 @@ TEST_F(PatchTokenTests, GivenVmeKernelWhenBuildingKernelThenArgAvailable) {
EXPECT_EQ(CL_SUCCESS, retVal);
auto pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel");
auto pKernelInfo = pProgram->getKernelInfo("device_side_block_motion_estimate_intel", rootDeviceIndex);
ASSERT_NE(nullptr, pKernelInfo);
EXPECT_EQ(true, pKernelInfo->isVmeWorkload);
@@ -2322,13 +2324,13 @@ TEST_F(ProgramTests, WhenLinkingTwoValidSpirvProgramsThenValidProgramIsReturned)
TEST_F(ProgramTests, givenSeparateBlockKernelsWhenNoParentAndSubgroupKernelsThenSeparateNoneKernel) {
MockProgram program(pContext, false, toClDeviceVector(*pClDevice));
EXPECT_EQ(0u, program.getKernelInfoArray().size());
EXPECT_EQ(0u, program.getParentKernelInfoArray().size());
EXPECT_EQ(0u, program.getSubgroupKernelInfoArray().size());
EXPECT_EQ(0u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0u, program.getParentKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0u, program.getSubgroupKernelInfoArray(rootDeviceIndex).size());
program.separateBlockKernels();
program.separateBlockKernels(rootDeviceIndex);
EXPECT_EQ(0u, program.getKernelInfoArray().size());
EXPECT_EQ(0u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
}
@@ -2337,19 +2339,19 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenRegularKernelsThenSeparateNone
auto pRegularKernel1Info = new KernelInfo();
pRegularKernel1Info->kernelDescriptor.kernelMetadata.kernelName = "regular_kernel_1";
program.getKernelInfoArray().push_back(pRegularKernel1Info);
program.getKernelInfoArray(rootDeviceIndex).push_back(pRegularKernel1Info);
auto pRegularKernel2Info = new KernelInfo();
pRegularKernel2Info->kernelDescriptor.kernelMetadata.kernelName = "regular_kernel_2";
program.getKernelInfoArray().push_back(pRegularKernel2Info);
program.getKernelInfoArray(rootDeviceIndex).push_back(pRegularKernel2Info);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
program.separateBlockKernels();
program.separateBlockKernels(rootDeviceIndex);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(0, strcmp("regular_kernel_1", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0, strcmp("regular_kernel_2", program.getKernelInfoArray().at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0, strcmp("regular_kernel_1", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0, strcmp("regular_kernel_2", program.getKernelInfoArray(rootDeviceIndex).at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
}
@@ -2359,21 +2361,21 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutParentKe
auto pParentKernelInfo = new KernelInfo();
pParentKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "another_parent_kernel";
program.getKernelInfoArray().push_back(pParentKernelInfo);
program.getParentKernelInfoArray().push_back(pParentKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
program.getParentKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "childlike_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(1u, program.getParentKernelInfoArray().size());
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(1u, program.getParentKernelInfoArray(rootDeviceIndex).size());
program.separateBlockKernels();
program.separateBlockKernels(rootDeviceIndex);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(0, strcmp("another_parent_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray().at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0, strcmp("another_parent_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray(rootDeviceIndex).at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
}
@@ -2383,21 +2385,21 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenChildLikeKernelWithoutSubgroup
auto pSubgroupKernelInfo = new KernelInfo();
pSubgroupKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "another_subgroup_kernel";
program.getKernelInfoArray().push_back(pSubgroupKernelInfo);
program.getSubgroupKernelInfoArray().push_back(pSubgroupKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
program.getSubgroupKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "childlike_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(1u, program.getSubgroupKernelInfoArray().size());
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(1u, program.getSubgroupKernelInfoArray(rootDeviceIndex).size());
program.separateBlockKernels();
program.separateBlockKernels(rootDeviceIndex);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(0, strcmp("another_subgroup_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray().at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0, strcmp("another_subgroup_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0, strcmp("childlike_kernel_dispatch_0", program.getKernelInfoArray(rootDeviceIndex).at(1)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(0u, program.getBlockKernelManager()->getCount());
}
@@ -2407,20 +2409,20 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenParentKernelWithChildKernelThe
auto pParentKernelInfo = new KernelInfo();
pParentKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "parent_kernel";
program.getKernelInfoArray().push_back(pParentKernelInfo);
program.getParentKernelInfoArray().push_back(pParentKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
program.getParentKernelInfoArray(rootDeviceIndex).push_back(pParentKernelInfo);
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "parent_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(1u, program.getParentKernelInfoArray().size());
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(1u, program.getParentKernelInfoArray(rootDeviceIndex).size());
program.separateBlockKernels();
program.separateBlockKernels(rootDeviceIndex);
EXPECT_EQ(1u, program.getKernelInfoArray().size());
EXPECT_EQ(0, strcmp("parent_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(1u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0, strcmp("parent_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(1u, program.getBlockKernelManager()->getCount());
EXPECT_EQ(0, strcmp("parent_kernel_dispatch_0", program.getBlockKernelManager()->getBlockKernelInfo(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
@@ -2431,20 +2433,20 @@ TEST_F(ProgramTests, givenSeparateBlockKernelsWhenSubgroupKernelWithChildKernelT
auto pSubgroupKernelInfo = new KernelInfo();
pSubgroupKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "subgroup_kernel";
program.getKernelInfoArray().push_back(pSubgroupKernelInfo);
program.getSubgroupKernelInfoArray().push_back(pSubgroupKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
program.getSubgroupKernelInfoArray(rootDeviceIndex).push_back(pSubgroupKernelInfo);
auto pChildKernelInfo = new KernelInfo();
pChildKernelInfo->kernelDescriptor.kernelMetadata.kernelName = "subgroup_kernel_dispatch_0";
program.getKernelInfoArray().push_back(pChildKernelInfo);
program.getKernelInfoArray(rootDeviceIndex).push_back(pChildKernelInfo);
EXPECT_EQ(2u, program.getKernelInfoArray().size());
EXPECT_EQ(1u, program.getSubgroupKernelInfoArray().size());
EXPECT_EQ(2u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(1u, program.getSubgroupKernelInfoArray(rootDeviceIndex).size());
program.separateBlockKernels();
program.separateBlockKernels(rootDeviceIndex);
EXPECT_EQ(1u, program.getKernelInfoArray().size());
EXPECT_EQ(0, strcmp("subgroup_kernel", program.getKernelInfoArray().at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(1u, program.getKernelInfoArray(rootDeviceIndex).size());
EXPECT_EQ(0, strcmp("subgroup_kernel", program.getKernelInfoArray(rootDeviceIndex).at(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));
EXPECT_EQ(1u, program.getBlockKernelManager()->getCount());
EXPECT_EQ(0, strcmp("subgroup_kernel_dispatch_0", program.getBlockKernelManager()->getBlockKernelInfo(0)->kernelDescriptor.kernelMetadata.kernelName.c_str()));

5
opencl/test/unit_test/program/program_with_block_kernels_tests.cpp
View File

@@ -53,6 +53,7 @@ class ProgramWithBlockKernelsTest : public ContextFixture,
TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuildingThenKernelInfosHaveCorrectNames) {
CreateProgramFromBinary(pContext, pContext->getDevices(), "simple_block_kernel", "-cl-std=CL2.0");
auto rootDeviceIndex = pContext->getDevice(0)->getRootDeviceIndex();
auto mockProgram = pProgram;
ASSERT_NE(nullptr, mockProgram);
@@ -62,10 +63,10 @@ TEST_F(ProgramWithBlockKernelsTest, GivenKernelWithBlockKernelsWhenProgramIsBuil
false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto kernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel");
auto kernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel", rootDeviceIndex);
EXPECT_NE(nullptr, kernelInfo);
auto blockKernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel_dispatch_0");
auto blockKernelInfo = mockProgram->Program::getKernelInfo("simple_block_kernel_dispatch_0", rootDeviceIndex);
EXPECT_EQ(nullptr, blockKernelInfo);
std::vector<const KernelInfo *> blockKernelInfos(mockProgram->blockKernelManager->getCount());

6
opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp
View File

@@ -232,7 +232,7 @@ TEST_F(ProgramWithKernelDebuggingTest, givenProgramWithKernelDebugEnabledWhenBui
auto retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::debugKernelEnable.data(), false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer");
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
EXPECT_NE(0u, kernelInfo->patchInfo.pAllocateSystemThreadSurface->PerThreadSystemThreadSurfaceSize);
}
@@ -249,9 +249,9 @@ TEST_F(ProgramWithKernelDebuggingTest, givenProgramWithKernelDebugEnabledWhenPro
auto retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
pProgram->processDebugData();
pProgram->processDebugData(pDevice->getRootDeviceIndex());
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer");
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
EXPECT_NE(0u, kernelInfo->debugData.vIsaSize);
EXPECT_NE(nullptr, kernelInfo->debugData.vIsa);

6
opencl/test/unit_test/program/program_with_source.h
View File

@@ -31,11 +31,12 @@ class ProgramFromSourceTest : public ContextFixture,
protected:
void SetUp() override {
std::tie(SourceFileName, BinaryFileName, KernelName) = GetParam();
std::tie(SourceFileName, BinaryFileName, kernelName) = GetParam();
kbHelper = new KernelBinaryHelper(BinaryFileName);
PlatformFixture::SetUp();
cl_device_id device = pPlatform->getClDevice(0);
rootDeviceIndex = pPlatform->getClDevice(0)->getRootDeviceIndex();
ContextFixture::SetUp(1, &device);
ProgramFixture::SetUp();
@@ -55,7 +56,8 @@ class ProgramFromSourceTest : public ContextFixture,
KernelBinaryHelper *kbHelper = nullptr;
const char *SourceFileName = nullptr;
const char *BinaryFileName = nullptr;
const char *KernelName = nullptr;
const char *kernelName = nullptr;
cl_int retVal = CL_SUCCESS;
uint32_t rootDeviceIndex = std::numeric_limits<uint32_t>::max();
};
} // namespace NEO