Skip to content

Commit 2fa27eb

Browse files
Jaime ArteagaCompute-Runtime-Automation
Jaime Arteaga
authored and
Compute-Runtime-Automation
committed
Move ISA at kernel creation time (2)
For internal kernels, move ISA only at creation time. For user kernels, do it a module creation time. Related-To: LOCI-2009 Signed-off-by: Jaime Arteaga <[email protected]>
1 parent 5a7f844 commit 2fa27eb

File tree

3 files changed

+206
-24
lines changed

3 files changed

+206
-24
lines changed

‎level_zero/core/source/kernel/kernel_imp.cpp‎

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -111,6 +111,15 @@ void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, Device *device
111111
{neoDevice->getRootDeviceIndex(), kernelIsaSize, allocType, neoDevice->getDeviceBitfield()});
112112
UNRECOVERABLE_IF(allocation == nullptr);
113113

114+
auto &hwInfo = neoDevice->getHardwareInfo();
115+
auto &hwHelper = NEO::HwHelper::get(hwInfo.platform.eRenderCoreFamily);
116+
117+
if (kernelInfo->heapInfo.pKernelHeap != nullptr && internalKernel == false) {
118+
NEO::MemoryTransferHelper::transferMemoryToAllocation(hwHelper.isBlitCopyRequiredForLocalMemory(hwInfo, *allocation),
119+
*neoDevice, allocation, 0, kernelInfo->heapInfo.pKernelHeap,
120+
static_cast<size_t>(kernelIsaSize));
121+
}
122+
114123
isaGraphicsAllocation.reset(allocation);
115124
if (device->getL0Debugger() && kernelInfo->kernelDescriptor.external.debugData.get()) {
116125
device->getL0Debugger()->registerElf(kernelInfo->kernelDescriptor.external.debugData.get(), allocation);
@@ -596,11 +605,12 @@ ze_result_t KernelImp::initialize(const ze_kernel_desc_t *desc) {
596605
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
597606
}
598607

599-
if (this->kernelImmData->getKernelInfo()->heapInfo.pKernelHeap != nullptr) {
608+
auto isaAllocation = this->kernelImmData->getIsaGraphicsAllocation();
609+
if (this->kernelImmData->getKernelInfo()->heapInfo.pKernelHeap != nullptr &&
610+
isaAllocation->getAllocationType() == NEO::GraphicsAllocation::AllocationType::KERNEL_ISA_INTERNAL) {
600611
auto neoDevice = module->getDevice()->getNEODevice();
601612
auto &hwInfo = neoDevice->getHardwareInfo();
602613
auto &hwHelper = NEO::HwHelper::get(hwInfo.platform.eRenderCoreFamily);
603-
auto isaAllocation = this->kernelImmData->getIsaGraphicsAllocation();
604614
NEO::MemoryTransferHelper::transferMemoryToAllocation(hwHelper.isBlitCopyRequiredForLocalMemory(hwInfo, *isaAllocation),
605615
*neoDevice,
606616
isaAllocation,

‎level_zero/core/test/unit_tests/fixtures/module_fixture.h‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,6 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
3434
size_t destinationOffset,
3535
const void *memoryToCopy,
3636
size_t sizeToCopy) override {
37-
3837
copyMemoryToAllocationCalledTimes++;
3938
return true;
4039
}
@@ -81,16 +80,17 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
8180
};
8281

8382
struct MockModule : public L0::ModuleImp {
83+
using ModuleImp::translationUnit;
84+
using ModuleImp::type;
8485
MockModule(L0::Device *device,
8586
L0::ModuleBuildLog *moduleBuildLog,
8687
L0::ModuleType type,
87-
uint32_t perHwThreadPrivateMemorySize) : ModuleImp(device, moduleBuildLog, type) {
88-
mockKernelImmData = new MockImmutableData(perHwThreadPrivateMemorySize);
88+
uint32_t perHwThreadPrivateMemorySize,
89+
MockImmutableData *inMockKernelImmData) : ModuleImp(device, moduleBuildLog, type), mockKernelImmData(inMockKernelImmData) {
8990
mockKernelImmData->setDevice(device);
9091
}
9192

9293
~MockModule() {
93-
delete mockKernelImmData;
9494
}
9595

9696
const KernelImmutableData *getKernelImmutableData(const char *functionName) const override {
@@ -121,7 +121,7 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
121121
neoDevice->executionEnvironment->memoryManager.reset(memoryManager);
122122
}
123123

124-
void createModuleFromBinary(uint32_t perHwThreadPrivateMemorySize) {
124+
void createModuleFromBinary(uint32_t perHwThreadPrivateMemorySize, bool isInternal, MockImmutableData *mockKernelImmData) {
125125
std::string testFile;
126126
retrieveBinaryKernelFilenameNoRevision(testFile, binaryFilename + "_", ".bin");
127127

@@ -143,8 +143,10 @@ struct ModuleImmutableDataFixture : public DeviceFixture {
143143
module = std::make_unique<MockModule>(device,
144144
moduleBuildLog,
145145
ModuleType::User,
146-
perHwThreadPrivateMemorySize);
146+
perHwThreadPrivateMemorySize,
147+
mockKernelImmData);
147148

149+
module->type = isInternal ? ModuleType::Builtin : ModuleType::User;
148150
bool result = module->initialize(&moduleDesc, device->getNEODevice());
149151
EXPECT_TRUE(result);
150152
}

‎level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp‎

Lines changed: 186 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -268,7 +268,11 @@ class KernelImmutableDataTests : public ModuleImmutableDataFixture, public ::tes
268268

269269
HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithNoPrivateMemoryThenPrivateMemoryIsNull) {
270270
uint32_t perHwThreadPrivateMemorySizeRequested = 0u;
271-
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested);
271+
bool isInternal = false;
272+
273+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
274+
275+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
272276

273277
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
274278
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
@@ -280,7 +284,11 @@ HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithNoPrivateMemoryThen
280284

281285
HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenPrivateMemoryIsCreated) {
282286
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
283-
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested);
287+
bool isInternal = false;
288+
289+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
290+
291+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
284292

285293
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
286294
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
@@ -294,49 +302,207 @@ HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenPr
294302
EXPECT_EQ(expectedSize, kernel->privateMemoryGraphicsAllocation->getUnderlyingBufferSize());
295303
}
296304

297-
HWTEST_F(KernelImmutableDataTests, givenCallToCreateKernelThenIsaIsCopied) {
305+
using KernelImmutableDataIsaCopyTests = KernelImmutableDataTests;
306+
307+
HWTEST_F(KernelImmutableDataIsaCopyTests, whenUserKernelIsCreatedThenIsaIsaCopiedWhenModuleIsCreated) {
308+
MockImmutableMemoryManager *mockMemoryManager =
309+
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
310+
298311
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
299-
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested);
312+
bool isInternal = false;
313+
314+
uint32_t previouscopyMemoryToAllocationCalledTimes =
315+
mockMemoryManager->copyMemoryToAllocationCalledTimes;
316+
317+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
318+
319+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
320+
321+
uint32_t copyForGlobalSurface = 1u;
322+
uint32_t copyForIsa = 1u;
323+
uint32_t expectedPreviouscopyMemoryToAllocationCalledTimes = previouscopyMemoryToAllocationCalledTimes +
324+
copyForGlobalSurface + copyForIsa;
325+
EXPECT_EQ(expectedPreviouscopyMemoryToAllocationCalledTimes,
326+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
300327

301328
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
302329
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
303330

331+
createKernel(kernel.get());
332+
333+
EXPECT_EQ(expectedPreviouscopyMemoryToAllocationCalledTimes,
334+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
335+
}
336+
337+
HWTEST_F(KernelImmutableDataIsaCopyTests, whenInternalKernelIsCreatedThenIsaIsCopiedWhenCreateKernelIsCalled) {
304338
MockImmutableMemoryManager *mockMemoryManager =
305339
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
306340

341+
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
342+
bool isInternal = true;
343+
307344
uint32_t previouscopyMemoryToAllocationCalledTimes =
308345
mockMemoryManager->copyMemoryToAllocationCalledTimes;
309346

347+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
348+
349+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
350+
351+
uint32_t copyForGlobalSurface = 1u;
352+
uint32_t copyForIsa = 0u;
353+
uint32_t expectedPreviouscopyMemoryToAllocationCalledTimes = previouscopyMemoryToAllocationCalledTimes +
354+
copyForGlobalSurface + copyForIsa;
355+
EXPECT_EQ(expectedPreviouscopyMemoryToAllocationCalledTimes,
356+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
357+
358+
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
359+
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
360+
310361
createKernel(kernel.get());
311362

363+
expectedPreviouscopyMemoryToAllocationCalledTimes = previouscopyMemoryToAllocationCalledTimes + 1u;
364+
365+
EXPECT_EQ(expectedPreviouscopyMemoryToAllocationCalledTimes,
366+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
367+
}
368+
369+
HWTEST_F(KernelImmutableDataIsaCopyTests, whenImmutableDataIsInitializedForUserKernelThenIsaIsCopied) {
370+
MockImmutableMemoryManager *mockMemoryManager =
371+
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
372+
373+
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
374+
bool isInternal = false;
375+
376+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
377+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
378+
379+
uint32_t previouscopyMemoryToAllocationCalledTimes =
380+
mockMemoryManager->copyMemoryToAllocationCalledTimes;
381+
382+
mockKernelImmData->initialize(mockKernelImmData->mockKernelInfo, device,
383+
device->getNEODevice()->getDeviceInfo().computeUnitsUsedForScratch,
384+
module.get()->translationUnit->globalConstBuffer,
385+
module.get()->translationUnit->globalVarBuffer,
386+
isInternal);
387+
312388
EXPECT_EQ(previouscopyMemoryToAllocationCalledTimes + 1u,
313389
mockMemoryManager->copyMemoryToAllocationCalledTimes);
314390
}
315391

316-
HWTEST_F(KernelImmutableDataTests, givenCallToCreateKernelWithNullKernelHeapThenIsaIsNotCopied) {
392+
HWTEST_F(KernelImmutableDataIsaCopyTests, whenImmutableDataIsInitializedForInternalKernelThenIsaIsNotCopied) {
393+
MockImmutableMemoryManager *mockMemoryManager =
394+
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
395+
317396
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
318-
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested);
397+
bool isInternal = true;
319398

320-
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
321-
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
399+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
400+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
322401

323-
MockModule *mockModule = static_cast<MockModule *>(module.get());
324-
MockImmutableData *mockData = static_cast<MockImmutableData *>(mockModule->mockKernelImmData);
325-
auto previousKernelHeap = mockData->kernelInfo->heapInfo.pKernelHeap;
326-
mockData->kernelInfo->heapInfo.pKernelHeap = nullptr;
402+
uint32_t previouscopyMemoryToAllocationCalledTimes =
403+
mockMemoryManager->copyMemoryToAllocationCalledTimes;
327404

405+
mockKernelImmData->initialize(mockKernelImmData->mockKernelInfo, device,
406+
device->getNEODevice()->getDeviceInfo().computeUnitsUsedForScratch,
407+
module.get()->translationUnit->globalConstBuffer,
408+
module.get()->translationUnit->globalVarBuffer,
409+
isInternal);
410+
411+
EXPECT_EQ(previouscopyMemoryToAllocationCalledTimes,
412+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
413+
}
414+
415+
using KernelImmutableDataWithNullHeapTests = KernelImmutableDataTests;
416+
417+
HWTEST_F(KernelImmutableDataWithNullHeapTests, whenImmutableDataIsInitializedForUserKernelWithNullKernelHeapThenIsaIsNotCopied) {
328418
MockImmutableMemoryManager *mockMemoryManager =
329419
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
330420

421+
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
422+
bool isInternal = false;
423+
424+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
425+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
426+
427+
auto previousKernelHeap = mockKernelImmData->kernelInfo->heapInfo.pKernelHeap;
428+
mockKernelImmData->kernelInfo->heapInfo.pKernelHeap = nullptr;
429+
331430
uint32_t previouscopyMemoryToAllocationCalledTimes =
332431
mockMemoryManager->copyMemoryToAllocationCalledTimes;
333432

334-
createKernel(kernel.get());
433+
mockKernelImmData->initialize(mockKernelImmData->mockKernelInfo, device,
434+
device->getNEODevice()->getDeviceInfo().computeUnitsUsedForScratch,
435+
module.get()->translationUnit->globalConstBuffer,
436+
module.get()->translationUnit->globalVarBuffer,
437+
isInternal);
335438

336439
EXPECT_EQ(previouscopyMemoryToAllocationCalledTimes,
337440
mockMemoryManager->copyMemoryToAllocationCalledTimes);
338441

339-
mockData->kernelInfo->heapInfo.pKernelHeap = previousKernelHeap;
442+
mockKernelImmData->kernelInfo->heapInfo.pKernelHeap = previousKernelHeap;
443+
}
444+
445+
HWTEST_F(KernelImmutableDataWithNullHeapTests, whenImmutableDataIsInitializedForInternalKernelWithNullKernelHeapThenIsaIsNotCopied) {
446+
MockImmutableMemoryManager *mockMemoryManager =
447+
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
448+
449+
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
450+
bool isInternal = true;
451+
452+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
453+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
454+
455+
auto previousKernelHeap = mockKernelImmData->kernelInfo->heapInfo.pKernelHeap;
456+
mockKernelImmData->kernelInfo->heapInfo.pKernelHeap = nullptr;
457+
458+
uint32_t previouscopyMemoryToAllocationCalledTimes =
459+
mockMemoryManager->copyMemoryToAllocationCalledTimes;
460+
461+
mockKernelImmData->initialize(mockKernelImmData->mockKernelInfo, device,
462+
device->getNEODevice()->getDeviceInfo().computeUnitsUsedForScratch,
463+
module.get()->translationUnit->globalConstBuffer,
464+
module.get()->translationUnit->globalVarBuffer,
465+
isInternal);
466+
467+
EXPECT_EQ(previouscopyMemoryToAllocationCalledTimes,
468+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
469+
470+
mockKernelImmData->kernelInfo->heapInfo.pKernelHeap = previousKernelHeap;
471+
}
472+
473+
HWTEST_F(KernelImmutableDataWithNullHeapTests, whenInternalKernelIsCreatedWithNullKernelHeapThenIsaIsNotCopied) {
474+
MockImmutableMemoryManager *mockMemoryManager =
475+
static_cast<MockImmutableMemoryManager *>(device->getNEODevice()->getMemoryManager());
476+
477+
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
478+
bool isInternal = true;
479+
480+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
481+
482+
uint32_t previouscopyMemoryToAllocationCalledTimes =
483+
mockMemoryManager->copyMemoryToAllocationCalledTimes;
484+
485+
createModuleFromBinary(perHwThreadPrivateMemorySizeRequested, isInternal, mockKernelImmData.get());
486+
487+
uint32_t copyForGlobalSurface = 1u;
488+
uint32_t copyForIsa = 0u;
489+
uint32_t expectedPreviouscopyMemoryToAllocationCalledTimes = previouscopyMemoryToAllocationCalledTimes +
490+
copyForGlobalSurface + copyForIsa;
491+
EXPECT_EQ(expectedPreviouscopyMemoryToAllocationCalledTimes,
492+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
493+
494+
std::unique_ptr<ModuleImmutableDataFixture::MockKernel> kernel;
495+
kernel = std::make_unique<ModuleImmutableDataFixture::MockKernel>(module.get());
496+
497+
auto previousKernelHeap = mockKernelImmData->kernelInfo->heapInfo.pKernelHeap;
498+
mockKernelImmData->kernelInfo->heapInfo.pKernelHeap = nullptr;
499+
500+
createKernel(kernel.get());
501+
502+
EXPECT_EQ(expectedPreviouscopyMemoryToAllocationCalledTimes,
503+
mockMemoryManager->copyMemoryToAllocationCalledTimes);
504+
505+
mockKernelImmData->kernelInfo->heapInfo.pKernelHeap = previousKernelHeap;
340506
}
341507

342508
HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenContainerHasOneExtraSpaceForAllocation) {
@@ -357,10 +523,12 @@ HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenCo
357523
ModuleBuildLog *moduleBuildLog = nullptr;
358524

359525
uint32_t perHwThreadPrivateMemorySizeRequested = 32u;
526+
std::unique_ptr<MockImmutableData> mockKernelImmData = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
360527
std::unique_ptr<MockModule> moduleWithPrivateMemory = std::make_unique<MockModule>(device,
361528
moduleBuildLog,
362529
ModuleType::User,
363-
perHwThreadPrivateMemorySizeRequested);
530+
perHwThreadPrivateMemorySizeRequested,
531+
mockKernelImmData.get());
364532
bool result = moduleWithPrivateMemory->initialize(&moduleDesc, device->getNEODevice());
365533
EXPECT_TRUE(result);
366534

@@ -373,10 +541,12 @@ HWTEST_F(KernelImmutableDataTests, givenKernelInitializedWithPrivateMemoryThenCo
373541
size_t sizeContainerWithPrivateMemory = kernelWithPrivateMemory->getResidencyContainer().size();
374542

375543
perHwThreadPrivateMemorySizeRequested = 0u;
544+
std::unique_ptr<MockImmutableData> mockKernelImmDataForModuleWithoutPrivateMemory = std::make_unique<MockImmutableData>(perHwThreadPrivateMemorySizeRequested);
376545
std::unique_ptr<MockModule> moduleWithoutPrivateMemory = std::make_unique<MockModule>(device,
377546
moduleBuildLog,
378547
ModuleType::User,
379-
perHwThreadPrivateMemorySizeRequested);
548+
perHwThreadPrivateMemorySizeRequested,
549+
mockKernelImmDataForModuleWithoutPrivateMemory.get());
380550
result = moduleWithoutPrivateMemory->initialize(&moduleDesc, device->getNEODevice());
381551
EXPECT_TRUE(result);
382552

0 commit comments

Comments
 (0)