Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: split kernel residency into internal and argument containers 

Related-To: NEO-11719

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz 2024-07-23 12:14:04 +00:00 committed by Compute-Runtime-Automation
parent ae68df3832
commit 1c1e437d4b
16 changed files with 93 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/core/source/cmdlist/cmdlist_hw_skl_to_tgllp.inl
View File

@ -254,8 +254,12 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
appendSignalEventPostWalker(event, nullptr, nullptr, false, false, false); appendSignalEventPostWalker(event, nullptr, nullptr, false, false, false);
commandContainer.addToResidencyContainer(kernelImmutableData->getIsaGraphicsAllocation()); commandContainer.addToResidencyContainer(kernelImmutableData->getIsaGraphicsAllocation());
auto &residencyContainer = kernel->getResidencyContainer(); auto &argumentsResidencyContainer = kernel->getArgumentsResidencyContainer();
for (auto resource : residencyContainer) { for (auto resource : argumentsResidencyContainer) {
commandContainer.addToResidencyContainer(resource);
}
auto &internalResidencyContainer = kernel->getInternalResidencyContainer();
for (auto resource : internalResidencyContainer) {
commandContainer.addToResidencyContainer(resource); commandContainer.addToResidencyContainer(resource);
} }

29
level_zero/core/source/cmdlist/cmdlist_hw_xehp_and_later.inl
View File

@ -225,15 +225,20 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
bool isKernelUsingSystemAllocation = false; bool isKernelUsingSystemAllocation = false;
if (!launchParams.isBuiltInKernel) { if (!launchParams.isBuiltInKernel) {
auto &kernelAllocations = kernel->getResidencyContainer(); auto verifyKernelUsingSystemAllocations = [&isKernelUsingSystemAllocation](const NEO::ResidencyContainer &kernelResidencyContainer) {
for (auto &allocation : kernelAllocations) { for (const auto &allocation : kernelResidencyContainer) {
if (allocation == nullptr) { if (allocation == nullptr) {
continue; continue;
}
if (allocation->getAllocationType() == NEO::AllocationType::bufferHostMemory) {
isKernelUsingSystemAllocation = true;
}
} }
if (allocation->getAllocationType() == NEO::AllocationType::bufferHostMemory) { };
isKernelUsingSystemAllocation = true;
} verifyKernelUsingSystemAllocations(kernel->getArgumentsResidencyContainer());
} verifyKernelUsingSystemAllocations(kernel->getInternalResidencyContainer());
} else { } else {
isKernelUsingSystemAllocation = launchParams.isDestinationAllocationInSystemMemory; isKernelUsingSystemAllocation = launchParams.isDestinationAllocationInSystemMemory;
} }
@ -437,9 +442,13 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
// Attach kernel residency to our CommandList residency // Attach kernel residency to our CommandList residency
{ {
commandContainer.addToResidencyContainer(kernelImmutableData->getIsaGraphicsAllocation()); commandContainer.addToResidencyContainer(kernelImmutableData->getIsaGraphicsAllocation());
auto &internalResidencyContainer = kernel->getInternalResidencyContainer();
for (auto resource : internalResidencyContainer) {
commandContainer.addToResidencyContainer(resource);
}
if (!launchParams.omitAddingKernelResidency) { if (!launchParams.omitAddingKernelResidency) {
auto &residencyContainer = kernel->getResidencyContainer(); auto &argumentsResidencyContainer = kernel->getArgumentsResidencyContainer();
for (auto resource : residencyContainer) { for (auto resource : argumentsResidencyContainer) {
commandContainer.addToResidencyContainer(resource); commandContainer.addToResidencyContainer(resource);
} }
} }

3
level_zero/core/source/kernel/kernel.h
View File

@ -148,7 +148,8 @@ struct Kernel : _ze_kernel_handle_t, virtual NEO::DispatchKernelEncoderI {
virtual const KernelImmutableData *getImmutableData() const = 0; virtual const KernelImmutableData *getImmutableData() const = 0;
virtual const std::vector<NEO::GraphicsAllocation *> &getResidencyContainer() const = 0; virtual const std::vector<NEO::GraphicsAllocation *> &getArgumentsResidencyContainer() const = 0;
virtual const std::vector<NEO::GraphicsAllocation *> &getInternalResidencyContainer() const = 0;
virtual UnifiedMemoryControls getUnifiedMemoryControls() const = 0; virtual UnifiedMemoryControls getUnifiedMemoryControls() const = 0;
virtual bool hasIndirectAllocationsAllowed() const = 0; virtual bool hasIndirectAllocationsAllowed() const = 0;

36
level_zero/core/source/kernel/kernel_imp.cpp
View File

@ -586,7 +586,7 @@ ze_result_t KernelImp::setArgImmediate(uint32_t argIndex, size_t argSize, const
ze_result_t KernelImp::setArgRedescribedImage(uint32_t argIndex, ze_image_handle_t argVal) { ze_result_t KernelImp::setArgRedescribedImage(uint32_t argIndex, ze_image_handle_t argVal) {
const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescImage>(); const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescImage>();
if (argVal == nullptr) { if (argVal == nullptr) {
residencyContainer[argIndex] = nullptr; argumentsResidencyContainer[argIndex] = nullptr;
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }
@ -620,7 +620,7 @@ ze_result_t KernelImp::setArgRedescribedImage(uint32_t argIndex, ze_image_handle
} else { } else {
image->copyRedescribedSurfaceStateToSSH(surfaceStateHeapData.get(), arg.bindful); image->copyRedescribedSurfaceStateToSSH(surfaceStateHeapData.get(), arg.bindful);
} }
residencyContainer[argIndex] = image->getAllocation(); argumentsResidencyContainer[argIndex] = image->getAllocation();
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }
@ -656,7 +656,7 @@ ze_result_t KernelImp::setArgBufferWithAlloc(uint32_t argIndex, uintptr_t argVal
} }
this->setKernelArgUncached(argIndex, argIsUncacheable); this->setKernelArgUncached(argIndex, argIsUncacheable);
} }
residencyContainer[argIndex] = allocation; argumentsResidencyContainer[argIndex] = allocation;
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }
@ -727,7 +727,7 @@ ze_result_t KernelImp::setArgBuffer(uint32_t argIndex, size_t argSize, const voi
} }
if (nullptr == argVal) { if (nullptr == argVal) {
residencyContainer[argIndex] = nullptr; argumentsResidencyContainer[argIndex] = nullptr;
const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescPointer>(); const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescPointer>();
uintptr_t nullBufferValue = 0; uintptr_t nullBufferValue = 0;
NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize), arg, nullBufferValue); NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize), arg, nullBufferValue);
@ -774,7 +774,7 @@ ze_result_t KernelImp::setArgBuffer(uint32_t argIndex, size_t argSize, const voi
for (const auto &mappedAllocationData : allocData->virtualReservationData->mappedAllocations) { for (const auto &mappedAllocationData : allocData->virtualReservationData->mappedAllocations) {
// Add additional allocations to the residency container if the virtual reservation spans multiple allocations. // Add additional allocations to the residency container if the virtual reservation spans multiple allocations.
if (requestedAddress != mappedAllocationData.second->ptr) { if (requestedAddress != mappedAllocationData.second->ptr) {
this->residencyContainer.push_back(mappedAllocationData.second->mappedAllocation->allocation); this->argumentsResidencyContainer.push_back(mappedAllocationData.second->mappedAllocation->allocation);
} }
} }
} }
@ -784,7 +784,7 @@ ze_result_t KernelImp::setArgBuffer(uint32_t argIndex, size_t argSize, const voi
ze_result_t KernelImp::setArgImage(uint32_t argIndex, size_t argSize, const void *argVal) { ze_result_t KernelImp::setArgImage(uint32_t argIndex, size_t argSize, const void *argVal) {
if (argVal == nullptr) { if (argVal == nullptr) {
residencyContainer[argIndex] = nullptr; argumentsResidencyContainer[argIndex] = nullptr;
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
} }
@ -824,10 +824,10 @@ ze_result_t KernelImp::setArgImage(uint32_t argIndex, size_t argSize, const void
image->copySurfaceStateToSSH(surfaceStateHeapData.get(), arg.bindful, isMediaBlockImage); image->copySurfaceStateToSSH(surfaceStateHeapData.get(), arg.bindful, isMediaBlockImage);
} }
residencyContainer[argIndex] = image->getAllocation(); argumentsResidencyContainer[argIndex] = image->getAllocation();
if (image->getImplicitArgsAllocation()) { if (image->getImplicitArgsAllocation()) {
this->residencyContainer.push_back(image->getImplicitArgsAllocation()); this->argumentsResidencyContainer.push_back(image->getImplicitArgsAllocation());
} }
auto imageInfo = image->getImageInfo(); auto imageInfo = image->getImageInfo();
@ -1091,13 +1091,13 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
} }
} }
residencyContainer.resize(this->kernelArgHandlers.size(), nullptr); argumentsResidencyContainer.resize(this->kernelArgHandlers.size(), nullptr);
auto &kernelAttributes = kernelDescriptor.kernelAttributes; auto &kernelAttributes = kernelDescriptor.kernelAttributes;
if ((kernelAttributes.perHwThreadPrivateMemorySize != 0U) && (false == module->shouldAllocatePrivateMemoryPerDispatch())) { if ((kernelAttributes.perHwThreadPrivateMemorySize != 0U) && (false == module->shouldAllocatePrivateMemoryPerDispatch())) {
this->privateMemoryGraphicsAllocation = allocatePrivateMemoryGraphicsAllocation(); this->privateMemoryGraphicsAllocation = allocatePrivateMemoryGraphicsAllocation();
this->patchCrossthreadDataWithPrivateAllocation(this->privateMemoryGraphicsAllocation); this->patchCrossthreadDataWithPrivateAllocation(this->privateMemoryGraphicsAllocation);
this->residencyContainer.push_back(this->privateMemoryGraphicsAllocation); this->internalResidencyContainer.push_back(this->privateMemoryGraphicsAllocation);
} }
this->createPrintfBuffer(); this->createPrintfBuffer();
@ -1106,8 +1106,8 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
this->setAssertBuffer(); this->setAssertBuffer();
residencyContainer.insert(residencyContainer.end(), kernelImmData->getResidencyContainer().begin(), internalResidencyContainer.insert(internalResidencyContainer.end(), kernelImmData->getResidencyContainer().begin(),
kernelImmData->getResidencyContainer().end()); kernelImmData->getResidencyContainer().end());
ModuleImp *moduleImp = reinterpret_cast<ModuleImp *>(this->module); ModuleImp *moduleImp = reinterpret_cast<ModuleImp *>(this->module);
const auto indirectDetectionVersion = moduleImp->getTranslationUnit()->programInfo.indirectDetectionVersion; const auto indirectDetectionVersion = moduleImp->getTranslationUnit()->programInfo.indirectDetectionVersion;
@ -1138,7 +1138,7 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
} }
for (auto rtStack : rtDispatchGlobalsInfo->rtStacks) { for (auto rtStack : rtDispatchGlobalsInfo->rtStacks) {
this->residencyContainer.push_back(rtStack); this->internalResidencyContainer.push_back(rtStack);
} }
auto address = rtDispatchGlobalsInfo->rtDispatchGlobalsArray->getGpuAddressToPatch(); auto address = rtDispatchGlobalsInfo->rtDispatchGlobalsArray->getGpuAddressToPatch();
@ -1151,7 +1151,7 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
pImplicitArgs->rtGlobalBufferPtr = address; pImplicitArgs->rtGlobalBufferPtr = address;
} }
this->residencyContainer.push_back(rtDispatchGlobalsInfo->rtDispatchGlobalsArray); this->internalResidencyContainer.push_back(rtDispatchGlobalsInfo->rtDispatchGlobalsArray);
} }
this->midThreadPreemptionDisallowedForRayTracingKernels = productHelper.isMidThreadPreemptionDisallowedForRayTracingKernels(); this->midThreadPreemptionDisallowedForRayTracingKernels = productHelper.isMidThreadPreemptionDisallowedForRayTracingKernels();
return ZE_RESULT_SUCCESS; return ZE_RESULT_SUCCESS;
@ -1160,7 +1160,7 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
void KernelImp::createPrintfBuffer() { void KernelImp::createPrintfBuffer() {
if (this->kernelImmData->getDescriptor().kernelAttributes.flags.usesPrintf || pImplicitArgs) { if (this->kernelImmData->getDescriptor().kernelAttributes.flags.usesPrintf || pImplicitArgs) {
this->printfBuffer = PrintfHandler::createPrintfBuffer(this->module->getDevice()); this->printfBuffer = PrintfHandler::createPrintfBuffer(this->module->getDevice());
this->residencyContainer.push_back(printfBuffer); this->internalResidencyContainer.push_back(printfBuffer);
if (this->kernelImmData->getDescriptor().kernelAttributes.flags.usesPrintf) { if (this->kernelImmData->getDescriptor().kernelAttributes.flags.usesPrintf) {
NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize), NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize),
this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.printfSurfaceAddress, this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.printfSurfaceAddress,
@ -1186,14 +1186,14 @@ bool KernelImp::usesRegionGroupBarrier() const {
} }
void KernelImp::patchSyncBuffer(NEO::GraphicsAllocation *gfxAllocation, size_t bufferOffset) { void KernelImp::patchSyncBuffer(NEO::GraphicsAllocation *gfxAllocation, size_t bufferOffset) {
this->residencyContainer.push_back(gfxAllocation); this->internalResidencyContainer.push_back(gfxAllocation);
NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize), NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize),
this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.syncBufferAddress, this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.syncBufferAddress,
static_cast<uintptr_t>(ptrOffset(gfxAllocation->getGpuAddressToPatch(), bufferOffset))); static_cast<uintptr_t>(ptrOffset(gfxAllocation->getGpuAddressToPatch(), bufferOffset)));
} }
void KernelImp::patchRegionGroupBarrier(NEO::GraphicsAllocation *gfxAllocation, size_t bufferOffset) { void KernelImp::patchRegionGroupBarrier(NEO::GraphicsAllocation *gfxAllocation, size_t bufferOffset) {
this->residencyContainer.push_back(gfxAllocation); this->internalResidencyContainer.push_back(gfxAllocation);
NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize), NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize),
this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.regionGroupBarrierBuffer, this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.regionGroupBarrierBuffer,
@ -1335,7 +1335,7 @@ void KernelImp::setAssertBuffer() {
NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize), NEO::patchPointer(ArrayRef<uint8_t>(crossThreadData.get(), crossThreadDataSize),
this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.assertBufferAddress, this->getImmutableData()->getDescriptor().payloadMappings.implicitArgs.assertBufferAddress,
static_cast<uintptr_t>(assertHandler->getAssertBuffer()->getGpuAddressToPatch())); static_cast<uintptr_t>(assertHandler->getAssertBuffer()->getGpuAddressToPatch()));
this->residencyContainer.push_back(assertHandler->getAssertBuffer()); this->internalResidencyContainer.push_back(assertHandler->getAssertBuffer());
if (pImplicitArgs) { if (pImplicitArgs) {
pImplicitArgs->assertBufferPtr = static_cast<uintptr_t>(assertHandler->getAssertBuffer()->getGpuAddressToPatch()); pImplicitArgs->assertBufferPtr = static_cast<uintptr_t>(assertHandler->getAssertBuffer()->getGpuAddressToPatch());

11
level_zero/core/source/kernel/kernel_imp.h
View File

@ -75,8 +75,12 @@ struct KernelImp : Kernel {
const uint8_t *getCrossThreadData() const override { return crossThreadData.get(); } const uint8_t *getCrossThreadData() const override { return crossThreadData.get(); }
uint32_t getCrossThreadDataSize() const override { return crossThreadDataSize; } uint32_t getCrossThreadDataSize() const override { return crossThreadDataSize; }
const std::vector<NEO::GraphicsAllocation *> &getResidencyContainer() const override { const std::vector<NEO::GraphicsAllocation *> &getArgumentsResidencyContainer() const override {
return residencyContainer; return argumentsResidencyContainer;
}
const std::vector<NEO::GraphicsAllocation *> &getInternalResidencyContainer() const override {
return internalResidencyContainer;
} }
ze_result_t setArgImmediate(uint32_t argIndex, size_t argSize, const void *argVal); ze_result_t setArgImmediate(uint32_t argIndex, size_t argSize, const void *argVal);
@ -210,7 +214,8 @@ struct KernelImp : Kernel {
typedef ze_result_t (KernelImp::*KernelArgHandler)(uint32_t argIndex, size_t argSize, const void *argVal); typedef ze_result_t (KernelImp::*KernelArgHandler)(uint32_t argIndex, size_t argSize, const void *argVal);
std::vector<KernelArgInfo> kernelArgInfos; std::vector<KernelArgInfo> kernelArgInfos;
std::vector<KernelImp::KernelArgHandler> kernelArgHandlers; std::vector<KernelImp::KernelArgHandler> kernelArgHandlers;
std::vector<NEO::GraphicsAllocation *> residencyContainer; std::vector<NEO::GraphicsAllocation *> argumentsResidencyContainer;
std::vector<NEO::GraphicsAllocation *> internalResidencyContainer;
std::mutex *devicePrintfKernelMutex = nullptr; std::mutex *devicePrintfKernelMutex = nullptr;
NEO::GraphicsAllocation *printfBuffer = nullptr; NEO::GraphicsAllocation *printfBuffer = nullptr;

3
level_zero/core/test/unit_tests/fixtures/module_fixture.h
View File

@ -77,10 +77,12 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
class MockKernel : public WhiteBox<L0::KernelImp> { class MockKernel : public WhiteBox<L0::KernelImp> {
public: public:
using KernelImp::argumentsResidencyContainer;
using KernelImp::crossThreadData; using KernelImp::crossThreadData;
using KernelImp::crossThreadDataSize; using KernelImp::crossThreadDataSize;
using KernelImp::dynamicStateHeapData; using KernelImp::dynamicStateHeapData;
using KernelImp::dynamicStateHeapDataSize; using KernelImp::dynamicStateHeapDataSize;
using KernelImp::internalResidencyContainer;
using KernelImp::kernelArgHandlers; using KernelImp::kernelArgHandlers;
using KernelImp::kernelHasIndirectAccess; using KernelImp::kernelHasIndirectAccess;
using KernelImp::kernelImmData; using KernelImp::kernelImmData;
@ -92,7 +94,6 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
using KernelImp::printfBuffer; using KernelImp::printfBuffer;
using KernelImp::privateMemoryGraphicsAllocation; using KernelImp::privateMemoryGraphicsAllocation;
using KernelImp::requiredWorkgroupOrder; using KernelImp::requiredWorkgroupOrder;
using KernelImp::residencyContainer;
using KernelImp::surfaceStateHeapData; using KernelImp::surfaceStateHeapData;
using KernelImp::surfaceStateHeapDataSize; using KernelImp::surfaceStateHeapDataSize;
using KernelImp::unifiedMemoryControls; using KernelImp::unifiedMemoryControls;

4
level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
View File

@ -738,7 +738,7 @@ class MockCommandListImmediateHw : public WhiteBox<::L0::CommandListCoreFamilyIm
struct CmdListHelper { struct CmdListHelper {
NEO::GraphicsAllocation *isaAllocation = nullptr; NEO::GraphicsAllocation *isaAllocation = nullptr;
NEO::ResidencyContainer residencyContainer; NEO::ResidencyContainer argumentsResidencyContainer;
ze_group_count_t threadGroupDimensions; ze_group_count_t threadGroupDimensions;
const uint32_t *groupSize = nullptr; const uint32_t *groupSize = nullptr;
uint32_t useOnlyGlobalTimestamp = std::numeric_limits<uint32_t>::max(); uint32_t useOnlyGlobalTimestamp = std::numeric_limits<uint32_t>::max();
@ -760,7 +760,7 @@ class MockCommandListForAppendLaunchKernel : public WhiteBox<::L0::CommandListCo
const auto kernel = Kernel::fromHandle(kernelHandle); const auto kernel = Kernel::fromHandle(kernelHandle);
cmdListHelper.isaAllocation = kernel->getIsaAllocation(); cmdListHelper.isaAllocation = kernel->getIsaAllocation();
cmdListHelper.residencyContainer = kernel->getResidencyContainer(); cmdListHelper.argumentsResidencyContainer = kernel->getArgumentsResidencyContainer();
cmdListHelper.groupSize = kernel->getGroupSize(); cmdListHelper.groupSize = kernel->getGroupSize();
cmdListHelper.threadGroupDimensions = threadGroupDimensions; cmdListHelper.threadGroupDimensions = threadGroupDimensions;

3
level_zero/core/test/unit_tests/mocks/mock_kernel.h
View File

@ -38,12 +38,14 @@ template <>
struct WhiteBox<::L0::KernelImp> : public ::L0::KernelImp { struct WhiteBox<::L0::KernelImp> : public ::L0::KernelImp {
using BaseClass = ::L0::KernelImp; using BaseClass = ::L0::KernelImp;
using BaseClass::BaseClass; using BaseClass::BaseClass;
using ::L0::KernelImp::argumentsResidencyContainer;
using ::L0::KernelImp::createPrintfBuffer; using ::L0::KernelImp::createPrintfBuffer;
using ::L0::KernelImp::crossThreadData; using ::L0::KernelImp::crossThreadData;
using ::L0::KernelImp::crossThreadDataSize; using ::L0::KernelImp::crossThreadDataSize;
using ::L0::KernelImp::dynamicStateHeapData; using ::L0::KernelImp::dynamicStateHeapData;
using ::L0::KernelImp::dynamicStateHeapDataSize; using ::L0::KernelImp::dynamicStateHeapDataSize;
using ::L0::KernelImp::groupSize; using ::L0::KernelImp::groupSize;
using ::L0::KernelImp::internalResidencyContainer;
using ::L0::KernelImp::isBindlessOffsetSet; using ::L0::KernelImp::isBindlessOffsetSet;
using ::L0::KernelImp::kernelHasIndirectAccess; using ::L0::KernelImp::kernelHasIndirectAccess;
using ::L0::KernelImp::kernelImmData; using ::L0::KernelImp::kernelImmData;
@ -60,7 +62,6 @@ struct WhiteBox<::L0::KernelImp> : public ::L0::KernelImp {
using ::L0::KernelImp::pImplicitArgs; using ::L0::KernelImp::pImplicitArgs;
using ::L0::KernelImp::printfBuffer; using ::L0::KernelImp::printfBuffer;
using ::L0::KernelImp::requiredWorkgroupOrder; using ::L0::KernelImp::requiredWorkgroupOrder;
using ::L0::KernelImp::residencyContainer;
using ::L0::KernelImp::setAssertBuffer; using ::L0::KernelImp::setAssertBuffer;
using ::L0::KernelImp::slmArgsTotalSize; using ::L0::KernelImp::slmArgsTotalSize;
using ::L0::KernelImp::suggestGroupSizeCache; using ::L0::KernelImp::suggestGroupSizeCache;

2
level_zero/core/test/unit_tests/sources/assert/test_assert.cpp
View File

@ -102,7 +102,7 @@ TEST(KernelAssert, GivenKernelWithAssertWhenSettingAssertBufferThenAssertBufferI
auto assertBufferAddress = assertHandler->getAssertBuffer()->getGpuAddressToPatch(); auto assertBufferAddress = assertHandler->getAssertBuffer()->getGpuAddressToPatch();
EXPECT_TRUE(memcmp(kernel.crossThreadData.get(), &assertBufferAddress, sizeof(assertBufferAddress)) == 0); EXPECT_TRUE(memcmp(kernel.crossThreadData.get(), &assertBufferAddress, sizeof(assertBufferAddress)) == 0);
EXPECT_TRUE(std::find(kernel.getResidencyContainer().begin(), kernel.getResidencyContainer().end(), assertHandler->getAssertBuffer()) != kernel.getResidencyContainer().end()); EXPECT_TRUE(std::find(kernel.getInternalResidencyContainer().begin(), kernel.getInternalResidencyContainer().end(), assertHandler->getAssertBuffer()) != kernel.getInternalResidencyContainer().end());
} }
TEST(KernelAssert, GivenKernelWithAssertAndImplicitArgsWhenInitializingKernelThenImplicitArgsAssertBufferPtrIsSet) { TEST(KernelAssert, GivenKernelWithAssertAndImplicitArgsWhenInitializingKernelThenImplicitArgsAssertBufferPtrIsSet) {

6
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_5.cpp
View File

@ -83,7 +83,7 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
bool containsDstPtr = false; bool containsDstPtr = false;
bool gpuTimeStampAlloc = false; bool gpuTimeStampAlloc = false;
for (auto &residentGfxAlloc : commandList.cmdListHelper.residencyContainer) { for (auto &residentGfxAlloc : commandList.cmdListHelper.argumentsResidencyContainer) {
if (residentGfxAlloc != nullptr) { if (residentGfxAlloc != nullptr) {
if (residentGfxAlloc->getGpuAddress() == if (residentGfxAlloc->getGpuAddress() ==
reinterpret_cast<uint64_t>(alloc)) { reinterpret_cast<uint64_t>(alloc)) {
@ -148,7 +148,7 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
bool containsDstPtr = false; bool containsDstPtr = false;
for (auto &a : commandList.cmdListHelper.residencyContainer) { for (auto &a : commandList.cmdListHelper.argumentsResidencyContainer) {
if (a != nullptr && a->getGpuAddress() == reinterpret_cast<uint64_t>(alloc)) { if (a != nullptr && a->getGpuAddress() == reinterpret_cast<uint64_t>(alloc)) {
containsDstPtr = true; containsDstPtr = true;
} }
@ -158,7 +158,7 @@ HWTEST2_F(AppendQueryKernelTimestamps, givenCommandListWhenAppendQueryKernelTime
bool containOffsetPtr = false; bool containOffsetPtr = false;
for (auto &a : commandList.cmdListHelper.residencyContainer) { for (auto &a : commandList.cmdListHelper.argumentsResidencyContainer) {
if (a != nullptr && a->getGpuAddress() == reinterpret_cast<uint64_t>(offsetAlloc)) { if (a != nullptr && a->getGpuAddress() == reinterpret_cast<uint64_t>(offsetAlloc)) {
containOffsetPtr = true; containOffsetPtr = true;
} }

2
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
View File

@ -1491,7 +1491,7 @@ HWTEST2_F(CommandListAppendLaunchKernelMockModule,
IsAtLeastXeHpCore) { IsAtLeastXeHpCore) {
NEO::MockGraphicsAllocation mockAllocation; NEO::MockGraphicsAllocation mockAllocation;
NEO::GraphicsAllocation *allocation = &mockAllocation; NEO::GraphicsAllocation *allocation = &mockAllocation;
kernel->residencyContainer.push_back(allocation); kernel->argumentsResidencyContainer.push_back(allocation);
ze_group_count_t groupCount{1, 1, 1}; ze_group_count_t groupCount{1, 1, 1};
ze_result_t returnValue; ze_result_t returnValue;

2
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_2.cpp
View File

@ -790,7 +790,7 @@ HWTEST2_F(DeviceWithDualStorage, givenCmdListWithAppendedKernelAndUsmTransferAnd
size, alignment, &ptr); size, alignment, &ptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, res); EXPECT_EQ(ZE_RESULT_SUCCESS, res);
auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(ptr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto gpuAlloc = device->getDriverHandle()->getSvmAllocsManager()->getSVMAllocs()->get(ptr)->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
kernel.residencyContainer.push_back(gpuAlloc); kernel.argumentsResidencyContainer.push_back(gpuAlloc);
ze_group_count_t dispatchKernelArguments{1, 1, 1}; ze_group_count_t dispatchKernelArguments{1, 1, 1};
CmdListKernelLaunchParams launchParams = {}; CmdListKernelLaunchParams launchParams = {};

21
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -58,12 +58,14 @@ template <GFXCORE_FAMILY gfxCoreFamily>
struct WhiteBoxKernelHw : public KernelHw<gfxCoreFamily> { struct WhiteBoxKernelHw : public KernelHw<gfxCoreFamily> {
using BaseClass = KernelHw<gfxCoreFamily>; using BaseClass = KernelHw<gfxCoreFamily>;
using BaseClass::BaseClass; using BaseClass::BaseClass;
using ::L0::KernelImp::argumentsResidencyContainer;
using ::L0::KernelImp::createPrintfBuffer; using ::L0::KernelImp::createPrintfBuffer;
using ::L0::KernelImp::crossThreadData; using ::L0::KernelImp::crossThreadData;
using ::L0::KernelImp::crossThreadDataSize; using ::L0::KernelImp::crossThreadDataSize;
using ::L0::KernelImp::dynamicStateHeapData; using ::L0::KernelImp::dynamicStateHeapData;
using ::L0::KernelImp::dynamicStateHeapDataSize; using ::L0::KernelImp::dynamicStateHeapDataSize;
using ::L0::KernelImp::groupSize; using ::L0::KernelImp::groupSize;
using ::L0::KernelImp::internalResidencyContainer;
using ::L0::KernelImp::isBindlessOffsetSet; using ::L0::KernelImp::isBindlessOffsetSet;
using ::L0::KernelImp::kernelImmData; using ::L0::KernelImp::kernelImmData;
using ::L0::KernelImp::kernelRequiresGenerationOfLocalIdsByRuntime; using ::L0::KernelImp::kernelRequiresGenerationOfLocalIdsByRuntime;
@ -75,7 +77,6 @@ struct WhiteBoxKernelHw : public KernelHw<gfxCoreFamily> {
using ::L0::KernelImp::perThreadDataSizeForWholeThreadGroup; using ::L0::KernelImp::perThreadDataSizeForWholeThreadGroup;
using ::L0::KernelImp::printfBuffer; using ::L0::KernelImp::printfBuffer;
using ::L0::KernelImp::requiredWorkgroupOrder; using ::L0::KernelImp::requiredWorkgroupOrder;
using ::L0::KernelImp::residencyContainer;
using ::L0::KernelImp::surfaceStateHeapData; using ::L0::KernelImp::surfaceStateHeapData;
using ::L0::KernelImp::surfaceStateHeapDataSize; using ::L0::KernelImp::surfaceStateHeapDataSize;
using ::L0::KernelImp::unifiedMemoryControls; using ::L0::KernelImp::unifiedMemoryControls;
@ -940,7 +941,7 @@ TEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenCont
createKernel(kernelWithPrivateMemory.get()); createKernel(kernelWithPrivateMemory.get());
EXPECT_NE(nullptr, kernelWithPrivateMemory->privateMemoryGraphicsAllocation); EXPECT_NE(nullptr, kernelWithPrivateMemory->privateMemoryGraphicsAllocation);
size_t sizeContainerWithPrivateMemory = kernelWithPrivateMemory->getResidencyContainer().size(); size_t sizeContainerWithPrivateMemory = kernelWithPrivateMemory->getInternalResidencyContainer().size();
perHwThreadPrivateMemorySizeRequested = 0u; perHwThreadPrivateMemorySizeRequested = 0u;
std::unique_ptr<MockImmutableData> mockKernelImmDataForModuleWithoutPrivateMemory = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested); std::unique_ptr<MockImmutableData> mockKernelImmDataForModuleWithoutPrivateMemory = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
@ -958,7 +959,7 @@ TEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenCont
createKernel(kernelWithoutPrivateMemory.get()); createKernel(kernelWithoutPrivateMemory.get());
EXPECT_EQ(nullptr, kernelWithoutPrivateMemory->privateMemoryGraphicsAllocation); EXPECT_EQ(nullptr, kernelWithoutPrivateMemory->privateMemoryGraphicsAllocation);
size_t sizeContainerWithoutPrivateMemory = kernelWithoutPrivateMemory->getResidencyContainer().size(); size_t sizeContainerWithoutPrivateMemory = kernelWithoutPrivateMemory->getInternalResidencyContainer().size();
EXPECT_EQ(sizeContainerWithoutPrivateMemory + 1u, sizeContainerWithPrivateMemory); EXPECT_EQ(sizeContainerWithoutPrivateMemory + 1u, sizeContainerWithPrivateMemory);
} }
@ -1043,7 +1044,7 @@ TEST_F(KernelImmutableDataTests, whenHasRTCallsIsTrueThenRayTracingIsInitialized
ASSERT_NE(nullptr, implicitArgs); ASSERT_NE(nullptr, implicitArgs);
EXPECT_EQ_VAL(implicitArgs->rtGlobalBufferPtr, rtDispatchGlobals->rtDispatchGlobalsArray->getGpuAddressToPatch()); EXPECT_EQ_VAL(implicitArgs->rtGlobalBufferPtr, rtDispatchGlobals->rtDispatchGlobalsArray->getGpuAddressToPatch());
auto &residencyContainer = kernel->getResidencyContainer(); auto &residencyContainer = kernel->getInternalResidencyContainer();
auto found = std::find(residencyContainer.begin(), residencyContainer.end(), rtMemoryBackedBuffer); auto found = std::find(residencyContainer.begin(), residencyContainer.end(), rtMemoryBackedBuffer);
EXPECT_EQ(residencyContainer.end(), found); EXPECT_EQ(residencyContainer.end(), found);
@ -2221,7 +2222,7 @@ TEST_F(KernelImpPatchBindlessTest, GivenKernelImpWhenPatchBindlessOffsetCalledTh
EXPECT_EQ(ssPtr, expectedSsInHeap.ssPtr); EXPECT_EQ(ssPtr, expectedSsInHeap.ssPtr);
EXPECT_TRUE(memcmp(const_cast<uint8_t *>(patchLocation), &patchValue, sizeof(patchValue)) == 0); EXPECT_TRUE(memcmp(const_cast<uint8_t *>(patchLocation), &patchValue, sizeof(patchValue)) == 0);
EXPECT_FALSE(std::find(kernel.getResidencyContainer().begin(), kernel.getResidencyContainer().end(), expectedSsInHeap.heapAllocation) != kernel.getResidencyContainer().end()); EXPECT_FALSE(std::find(kernel.getArgumentsResidencyContainer().begin(), kernel.getArgumentsResidencyContainer().end(), expectedSsInHeap.heapAllocation) != kernel.getArgumentsResidencyContainer().end());
neoDevice->decRefInternal(); neoDevice->decRefInternal();
} }
@ -2829,7 +2830,7 @@ HWTEST2_F(SetKernelArg, givenImageAndBindlessKernelWhenSetArgImageThenCopySurfac
EXPECT_EQ(imageHW->passedSurfaceStateOffset, 0u); EXPECT_EQ(imageHW->passedSurfaceStateOffset, 0u);
EXPECT_TRUE(kernel->isBindlessOffsetSet[3]); EXPECT_TRUE(kernel->isBindlessOffsetSet[3]);
EXPECT_FALSE(kernel->usingSurfaceStateHeap[3]); EXPECT_FALSE(kernel->usingSurfaceStateHeap[3]);
EXPECT_EQ(0, std::count(kernel->residencyContainer.begin(), kernel->residencyContainer.end(), expectedSsInHeap.heapAllocation)); EXPECT_EQ(0, std::count(kernel->argumentsResidencyContainer.begin(), kernel->argumentsResidencyContainer.end(), expectedSsInHeap.heapAllocation));
} }
HWTEST2_F(SetKernelArg, givenNoGlobalAllocatorAndBindlessKernelWhenSetArgImageThenBindlessOffsetIsNotSetAndSshIsUsed, ImageSupport) { HWTEST2_F(SetKernelArg, givenNoGlobalAllocatorAndBindlessKernelWhenSetArgImageThenBindlessOffsetIsNotSetAndSshIsUsed, ImageSupport) {
@ -2951,7 +2952,7 @@ HWTEST2_F(SetKernelArg, givenImageBindlessKernelAndGlobalBindlessHelperWhenSetAr
EXPECT_EQ(imageHW->passedRedescribedSurfaceStateOffset, 0u); EXPECT_EQ(imageHW->passedRedescribedSurfaceStateOffset, 0u);
EXPECT_TRUE(kernel->isBindlessOffsetSet[3]); EXPECT_TRUE(kernel->isBindlessOffsetSet[3]);
EXPECT_FALSE(kernel->usingSurfaceStateHeap[3]); EXPECT_FALSE(kernel->usingSurfaceStateHeap[3]);
EXPECT_EQ(0, std::count(kernel->residencyContainer.begin(), kernel->residencyContainer.end(), expectedSsInHeap.heapAllocation)); EXPECT_EQ(0, std::count(kernel->argumentsResidencyContainer.begin(), kernel->argumentsResidencyContainer.end(), expectedSsInHeap.heapAllocation));
} }
HWTEST2_F(SetKernelArg, givenGlobalBindlessHelperAndImageViewWhenAllocatingBindlessSlotThenViewHasDifferentSlotThanParentImage, ImageSupport) { HWTEST2_F(SetKernelArg, givenGlobalBindlessHelperAndImageViewWhenAllocatingBindlessSlotThenViewHasDifferentSlotThanParentImage, ImageSupport) {
@ -3091,7 +3092,7 @@ HWTEST2_F(SetKernelArg, givenImageAndBindlessKernelWhenSetArgRedescribedImageCal
mockKernel.surfaceStateHeapData = std::make_unique<uint8_t[]>(surfaceStateSize); mockKernel.surfaceStateHeapData = std::make_unique<uint8_t[]>(surfaceStateSize);
mockKernel.descriptor.initBindlessOffsetToSurfaceState(); mockKernel.descriptor.initBindlessOffsetToSurfaceState();
mockKernel.residencyContainer.resize(1); mockKernel.argumentsResidencyContainer.resize(1);
mockKernel.isBindlessOffsetSet.resize(1, 0); mockKernel.isBindlessOffsetSet.resize(1, 0);
mockKernel.usingSurfaceStateHeap.resize(1, false); mockKernel.usingSurfaceStateHeap.resize(1, false);
@ -3456,8 +3457,8 @@ TEST_F(PrintfTest, WhenCreatingPrintfBufferThenAllocationAddedToResidencyContain
auto printfBufferAllocation = mockKernel.getPrintfBufferAllocation(); auto printfBufferAllocation = mockKernel.getPrintfBufferAllocation();
EXPECT_NE(nullptr, printfBufferAllocation); EXPECT_NE(nullptr, printfBufferAllocation);
EXPECT_NE(0u, mockKernel.residencyContainer.size()); EXPECT_NE(0u, mockKernel.internalResidencyContainer.size());
EXPECT_EQ(mockKernel.residencyContainer[mockKernel.residencyContainer.size() - 1], printfBufferAllocation); EXPECT_EQ(mockKernel.internalResidencyContainer[mockKernel.internalResidencyContainer.size() - 1], printfBufferAllocation);
} }
TEST_F(PrintfTest, WhenCreatingPrintfBufferThenCrossThreadDataIsPatched) { TEST_F(PrintfTest, WhenCreatingPrintfBufferThenCrossThreadDataIsPatched) {

16
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@ -2597,7 +2597,7 @@ HWTEST_F(DeviceModuleSetArgBufferTest,
auto argBufferValue = *reinterpret_cast<uint64_t *>(const_cast<uint8_t *>(argBufferPtr)); auto argBufferValue = *reinterpret_cast<uint64_t *>(const_cast<uint8_t *>(argBufferPtr));
EXPECT_EQ(argBufferValue, reinterpret_cast<uint64_t>(validBufferPtr)); EXPECT_EQ(argBufferValue, reinterpret_cast<uint64_t>(validBufferPtr));
for (auto alloc : kernel->getResidencyContainer()) { for (auto alloc : kernel->getArgumentsResidencyContainer()) {
if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(validBufferPtr)) { if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(validBufferPtr)) {
EXPECT_EQ(rootDeviceIndex, alloc->getRootDeviceIndex()); EXPECT_EQ(rootDeviceIndex, alloc->getRootDeviceIndex());
} }
@ -2677,7 +2677,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
bool phys1Resident = false; bool phys1Resident = false;
bool phys2Resident = false; bool phys2Resident = false;
for (auto alloc : kernel->getResidencyContainer()) { for (auto alloc : kernel->getArgumentsResidencyContainer()) {
if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) { if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) {
phys1Resident = true; phys1Resident = true;
} }
@ -2747,7 +2747,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
bool phys1Resident = false; bool phys1Resident = false;
bool phys2Resident = false; bool phys2Resident = false;
for (auto alloc : kernel->getResidencyContainer()) { for (auto alloc : kernel->getArgumentsResidencyContainer()) {
if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) { if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) {
phys1Resident = true; phys1Resident = true;
} }
@ -2810,7 +2810,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
kernel->setArgBuffer(0, sizeof(ptr), &ptr); kernel->setArgBuffer(0, sizeof(ptr), &ptr);
bool phys1Resident = false; bool phys1Resident = false;
for (auto alloc : kernel->getResidencyContainer()) { for (auto alloc : kernel->getArgumentsResidencyContainer()) {
if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) { if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) {
phys1Resident = true; phys1Resident = true;
} }
@ -2884,7 +2884,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
bool phys1Resident = false; bool phys1Resident = false;
bool phys2Resident = false; bool phys2Resident = false;
for (auto alloc : kernel->getResidencyContainer()) { for (auto alloc : kernel->getArgumentsResidencyContainer()) {
if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) { if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) {
phys1Resident = true; phys1Resident = true;
} }
@ -2933,7 +2933,7 @@ HWTEST_F(MultiDeviceModuleSetArgBufferTest,
L0::KernelImp *kernel = reinterpret_cast<L0::KernelImp *>(Kernel::fromHandle(kernelHandle)); L0::KernelImp *kernel = reinterpret_cast<L0::KernelImp *>(Kernel::fromHandle(kernelHandle));
kernel->setArgBuffer(0, sizeof(ptr), &ptr); kernel->setArgBuffer(0, sizeof(ptr), &ptr);
for (auto alloc : kernel->getResidencyContainer()) { for (auto alloc : kernel->getArgumentsResidencyContainer()) {
if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) { if (alloc && alloc->getGpuAddress() == reinterpret_cast<uint64_t>(ptr)) {
EXPECT_EQ(rootDeviceIndex, alloc->getRootDeviceIndex()); EXPECT_EQ(rootDeviceIndex, alloc->getRootDeviceIndex());
} }
@ -3684,11 +3684,9 @@ HWTEST_F(PrintfModuleTest, GivenModuleWithPrintfWhenKernelIsCreatedThenPrintfAll
kernelDesc.pKernelName = "test"; kernelDesc.pKernelName = "test";
kernel->initialize(&kernelDesc); kernel->initialize(&kernelDesc);
auto &container = kernel->residencyContainer; auto &container = kernel->internalResidencyContainer;
auto printfPos = std::find(container.begin(), container.end(), kernel->getPrintfBufferAllocation()); auto printfPos = std::find(container.begin(), container.end(), kernel->getPrintfBufferAllocation());
EXPECT_NE(container.end(), printfPos); EXPECT_NE(container.end(), printfPos);
bool correctPos = printfPos >= container.begin() + kernel->getImmutableData()->getDescriptor().payloadMappings.explicitArgs.size();
EXPECT_TRUE(correctPos);
} }
TEST(BuildOptions, givenNoSrcOptionNameInSrcNamesWhenMovingBuildOptionsThenFalseIsReturned) { TEST(BuildOptions, givenNoSrcOptionNameInSrcNamesWhenMovingBuildOptionsThenFalseIsReturned) {

10
level_zero/core/test/unit_tests/xe2_hpg_core/test_cmdlist_xe2_hpg_core.cpp
View File

@ -54,7 +54,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXe2HpgCore, givenAppendKernelWhenKernelNo
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;
@ -116,7 +116,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXe2HpgCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;
@ -230,7 +230,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXe2HpgCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
kernel.unifiedMemoryControls.indirectHostAllocationsAllowed = true; kernel.unifiedMemoryControls.indirectHostAllocationsAllowed = true;
@ -296,7 +296,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXe2HpgCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;
@ -358,7 +358,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXe2HpgCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;

10
level_zero/core/test/unit_tests/xe_hpc_core/test_cmdlist_xe_hpc_core.cpp
View File

@ -756,7 +756,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;
@ -824,7 +824,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;
@ -950,7 +950,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
kernel.unifiedMemoryControls.indirectHostAllocationsAllowed = true; kernel.unifiedMemoryControls.indirectHostAllocationsAllowed = true;
@ -1022,7 +1022,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;
@ -1090,7 +1090,7 @@ HWTEST2_F(CommandListAppendLaunchKernelXeHpcCore,
ASSERT_NE(nullptr, allocData); ASSERT_NE(nullptr, allocData);
auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex()); auto kernelAllocation = allocData->gpuAllocations.getGraphicsAllocation(device->getRootDeviceIndex());
ASSERT_NE(nullptr, kernelAllocation); ASSERT_NE(nullptr, kernelAllocation);
kernel.residencyContainer.push_back(kernelAllocation); kernel.argumentsResidencyContainer.push_back(kernelAllocation);
ze_event_pool_desc_t eventPoolDesc = {}; ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1; eventPoolDesc.count = 1;