intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

Differentiate between users ISA and internal ISA allocation

Browse Source 
Related-To: NEO-5240

Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>
This commit is contained in:
Mateusz Hoppe
2020-11-12 19:53:30 +01:00
committed by Compute-Runtime-Automation
parent 4052525091
commit 0f42ef1ed7
43 changed files with 246 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/api/core/ze_module.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/module/module.h"
#include <level_zero/ze_api.h>

2
level_zero/core/source/builtin/builtin_functions_lib_impl.cpp
View File

@@ -158,7 +158,7 @@ std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> BuiltinFunctionsLibImpl::l
moduleDesc.format = builtInCode.type == BuiltInCodeType::Binary ? ZE_MODULE_FORMAT_NATIVE : ZE_MODULE_FORMAT_IL_SPIRV;
moduleDesc.pInputModule = reinterpret_cast<uint8_t *>(&builtInCode.resource[0]);
moduleDesc.inputSize = builtInCode.resource.size();
res = device->createModule(&moduleDesc, &moduleHandle, nullptr);
res = device->createModule(&moduleDesc, &moduleHandle, nullptr, ModuleType::Builtin);
UNRECOVERABLE_IF(res != ZE_RESULT_SUCCESS);
module.reset(Module::fromHandle(moduleHandle));

2
level_zero/core/source/context/context_imp.cpp
View File

@@ -170,7 +170,7 @@ ze_result_t ContextImp::createModule(ze_device_handle_t hDevice,
const ze_module_desc_t *desc,
ze_module_handle_t *phModule,
ze_module_build_log_handle_t *phBuildLog) {
return L0::Device::fromHandle(hDevice)->createModule(desc, phModule, phBuildLog);
return L0::Device::fromHandle(hDevice)->createModule(desc, phModule, phBuildLog, ModuleType::User);
}
ze_result_t ContextImp::createSampler(ze_device_handle_t hDevice,

5
level_zero/core/source/device/device.h
View File

@@ -16,6 +16,7 @@
#include "level_zero/core/source/debugger/debugger_l0.h"
#include "level_zero/core/source/driver/driver.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include "level_zero/core/source/module/module.h"
#include <level_zero/ze_api.h>
#include <level_zero/zet_api.h>
@@ -36,6 +37,8 @@ struct ExecutionEnvironment;
struct MetricContext;
struct SysmanDevice;
enum class ModuleType;
struct Device : _ze_device_handle_t {
virtual uint32_t getRootDeviceIndex() = 0;
virtual ze_result_t canAccessPeer(ze_device_handle_t hPeerDevice, ze_bool_t *value) = 0;
@@ -51,7 +54,7 @@ struct Device : _ze_device_handle_t {
virtual ze_result_t createImage(const ze_image_desc_t *desc, ze_image_handle_t *phImage) = 0;
virtual ze_result_t createModule(const ze_module_desc_t *desc, ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog) = 0;
ze_module_build_log_handle_t *buildLog, ModuleType type) = 0;
virtual ze_result_t createSampler(const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) = 0;
virtual ze_result_t getComputeProperties(ze_device_compute_properties_t *pComputeProperties) = 0;

4
level_zero/core/source/device/device_imp.cpp
View File

@@ -198,14 +198,14 @@ ze_result_t DeviceImp::createSampler(const ze_sampler_desc_t *desc,
}
ze_result_t DeviceImp::createModule(const ze_module_desc_t *desc, ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog) {
ze_module_build_log_handle_t *buildLog, ModuleType type) {
ModuleBuildLog *moduleBuildLog = nullptr;
if (buildLog) {
moduleBuildLog = ModuleBuildLog::create();
*buildLog = moduleBuildLog->toHandle();
}
auto modulePtr = Module::create(this, desc, moduleBuildLog);
auto modulePtr = Module::create(this, desc, moduleBuildLog, type);
if (modulePtr == nullptr) {
return ZE_RESULT_ERROR_MODULE_BUILD_FAILURE;
}

3
level_zero/core/source/device/device_imp.h
View File

@@ -11,6 +11,7 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/driver/driver_handle.h"
#include "level_zero/core/source/module/module.h"
#include "level_zero/tools/source/metrics/metric.h"
namespace L0 {
@@ -26,7 +27,7 @@ struct DeviceImp : public Device {
ze_command_queue_handle_t *commandQueue) override;
ze_result_t createImage(const ze_image_desc_t *desc, ze_image_handle_t *phImage) override;
ze_result_t createModule(const ze_module_desc_t *desc, ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog) override;
ze_module_build_log_handle_t *buildLog, ModuleType type) override;
ze_result_t createSampler(const ze_sampler_desc_t *pDesc,
ze_sampler_handle_t *phSampler) override;
ze_result_t getComputeProperties(ze_device_compute_properties_t *pComputeProperties) override;

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

@@ -35,7 +35,7 @@ struct KernelImmutableData {
void initialize(NEO::KernelInfo *kernelInfo, NEO::MemoryManager &memoryManager, const NEO::Device *device,
uint32_t computeUnitsUsedForSratch,
NEO::GraphicsAllocation *globalConstBuffer, NEO::GraphicsAllocation *globalVarBuffer);
NEO::GraphicsAllocation *globalConstBuffer, NEO::GraphicsAllocation *globalVarBuffer, bool internalKernel);
const std::vector<NEO::GraphicsAllocation *> &getResidencyContainer() const {
return residencyContainer;

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

@@ -97,14 +97,15 @@ inline void patchWithImplicitSurface(ArrayRef<uint8_t> crossThreadData, ArrayRef
void KernelImmutableData::initialize(NEO::KernelInfo *kernelInfo, NEO::MemoryManager &memoryManager,
const NEO::Device *device, uint32_t computeUnitsUsedForSratch,
NEO::GraphicsAllocation *globalConstBuffer,
NEO::GraphicsAllocation *globalVarBuffer) {
NEO::GraphicsAllocation *globalVarBuffer, bool internalKernel) {
UNRECOVERABLE_IF(kernelInfo == nullptr);
this->kernelDescriptor = &kernelInfo->kernelDescriptor;
auto kernelIsaSize = kernelInfo->heapInfo.KernelHeapSize;
const auto allocType = internalKernel ? NEO::GraphicsAllocation::AllocationType::KERNEL_ISA_INTERNAL : NEO::GraphicsAllocation::AllocationType::KERNEL_ISA;
auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(
{device->getRootDeviceIndex(), kernelIsaSize, NEO::GraphicsAllocation::AllocationType::KERNEL_ISA, device->getDeviceBitfield()});
{device->getRootDeviceIndex(), kernelIsaSize, allocType, device->getDeviceBitfield()});
UNRECOVERABLE_IF(allocation == nullptr);
auto &hwInfo = device->getHardwareInfo();

10
level_zero/core/source/module/module.h
View File

@@ -7,7 +7,6 @@
#pragma once
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/context/context.h"
#include "level_zero/core/source/kernel/kernel.h"
#include "level_zero/core/source/module/module_build_log.h"
@@ -21,9 +20,14 @@ struct _ze_module_handle_t {};
namespace L0 {
struct Device;
enum class ModuleType {
Builtin,
User
};
struct Module : _ze_module_handle_t {
static Module *create(Device *device, const ze_module_desc_t *desc,
ModuleBuildLog *moduleBuildLog);
static Module *create(Device *device, const ze_module_desc_t *desc, ModuleBuildLog *moduleBuildLog, ModuleType type);
virtual ~Module() = default;

11
level_zero/core/source/module/module_imp.cpp
View File

@@ -285,9 +285,9 @@ void ModuleTranslationUnit::processDebugData() {
}
}
ModuleImp::ModuleImp(Device *device, ModuleBuildLog *moduleBuildLog)
ModuleImp::ModuleImp(Device *device, ModuleBuildLog *moduleBuildLog, ModuleType type)
: device(device), translationUnit(std::make_unique<ModuleTranslationUnit>(device)),
moduleBuildLog(moduleBuildLog) {
moduleBuildLog(moduleBuildLog), type(type) {
productFamily = device->getHwInfo().platform.eProductFamily;
}
@@ -340,7 +340,8 @@ bool ModuleImp::initialize(const ze_module_desc_t *desc, NEO::Device *neoDevice)
kernelImmData->initialize(ki, *(device->getNEODevice()->getMemoryManager()),
device->getNEODevice(),
device->getNEODevice()->getDeviceInfo().computeUnitsUsedForScratch,
this->translationUnit->globalConstBuffer, this->translationUnit->globalVarBuffer);
this->translationUnit->globalConstBuffer, this->translationUnit->globalVarBuffer,
this->type == ModuleType::Builtin);
kernelImmDatas.push_back(std::move(kernelImmData));
}
this->maxGroupSize = static_cast<uint32_t>(this->translationUnit->device->getNEODevice()->getDeviceInfo().maxWorkGroupSize);
@@ -522,8 +523,8 @@ ze_result_t ModuleImp::getGlobalPointer(const char *pGlobalName, void **pPtr) {
}
Module *Module::create(Device *device, const ze_module_desc_t *desc,
ModuleBuildLog *moduleBuildLog) {
auto module = new ModuleImp(device, moduleBuildLog);
ModuleBuildLog *moduleBuildLog, ModuleType type) {
auto module = new ModuleImp(device, moduleBuildLog, type);
bool success = module->initialize(desc, device->getNEODevice());
if (success == false) {

3
level_zero/core/source/module/module_imp.h
View File

@@ -66,7 +66,7 @@ struct ModuleTranslationUnit {
struct ModuleImp : public Module {
ModuleImp() = delete;
ModuleImp(Device *device, ModuleBuildLog *moduleBuildLog);
ModuleImp(Device *device, ModuleBuildLog *moduleBuildLog, ModuleType type);
~ModuleImp() override;
@@ -127,6 +127,7 @@ struct ModuleImp : public Module {
NEO::Linker::RelocatedSymbolsMap symbols;
bool debugEnabled = false;
bool isFullyLinked = false;
ModuleType type;
NEO::Linker::UnresolvedExternals unresolvedExternalsInfo{};
std::set<NEO::GraphicsAllocation *> importedSymbolAllocations{};
};

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

@@ -23,7 +23,7 @@ struct ModuleFixture : public DeviceFixture {
createModuleFromBinary();
}
void createModuleFromBinary() {
void createModuleFromBinary(ModuleType type = ModuleType::User) {
std::string testFile;
retrieveBinaryKernelFilename(testFile, binaryFilename + "_", ".bin");
@@ -42,7 +42,7 @@ struct ModuleFixture : public DeviceFixture {
ModuleBuildLog *moduleBuildLog = nullptr;
module.reset(Module::create(device, &moduleDesc, moduleBuildLog));
module.reset(Module::create(device, &moduleDesc, moduleBuildLog, type));
}
void createKernel() {
@@ -91,7 +91,7 @@ struct MultiDeviceModuleFixture : public MultiDeviceFixture {
auto device = driverHandle->devices[rootDeviceIndex];
modules[rootDeviceIndex].reset(Module::create(device,
&moduleDesc,
moduleBuildLog));
moduleBuildLog, ModuleType::User));
}
void TearDown() override {

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

@@ -69,7 +69,8 @@ struct Mock<Device> : public Device {
createModule,
(const ze_module_desc_t *desc,
ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog),
ze_module_build_log_handle_t *buildLog,
ModuleType type),
(override));
MOCK_METHOD(ze_result_t,
createSampler,

2
level_zero/core/test/unit_tests/mocks/mock_module.cpp
View File

@@ -12,7 +12,7 @@ using ::testing::Return;
namespace L0 {
namespace ult {
Mock<Module>::Mock(::L0::Device *device, ModuleBuildLog *moduleBuildLog) : WhiteBox(device, moduleBuildLog) { EXPECT_CALL(*this, getMaxGroupSize).WillRepeatedly(Return(256u)); }
Mock<Module>::Mock(::L0::Device *device, ModuleBuildLog *moduleBuildLog, ModuleType type) : WhiteBox(device, moduleBuildLog, type) { EXPECT_CALL(*this, getMaxGroupSize).WillRepeatedly(Return(256u)); }
} // namespace ult
} // namespace L0

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

@@ -28,6 +28,7 @@ struct WhiteBox<::L0::Module> : public ::L0::ModuleImp {
using BaseClass::kernelImmDatas;
using BaseClass::symbols;
using BaseClass::translationUnit;
using BaseClass::type;
using BaseClass::unresolvedExternalsInfo;
};
@@ -35,7 +36,8 @@ using Module = WhiteBox<::L0::Module>;
template <>
struct Mock<Module> : public Module {
Mock(::L0::Device *device, ModuleBuildLog *moduleBuildLog);
Mock(::L0::Device *device, ModuleBuildLog *moduleBuildLog, ModuleType type);
Mock(::L0::Device *device, ModuleBuildLog *moduleBuildLog) : Mock(device, moduleBuildLog, ModuleType::User){};
MOCK_METHOD(ze_result_t, createKernel, (const ze_kernel_desc_t *desc, ze_kernel_handle_t *phFunction), (override));
MOCK_METHOD(ze_result_t, destroy, (), (override));

34
level_zero/core/test/unit_tests/sources/builtin/builtin_functions_tests.cpp
View File

@@ -90,7 +90,7 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenCompilerInterfaceWhenCreateDeviceThen
HWTEST_F(TestBuiltinFunctionsLibImpl, givenRebuildPrecompiledKernelsDebugFlagWhenInitFuctionsThenIntermediateCodeForBuiltinsIsRequested) {
struct MockDeviceForRebuildBuilins : public Mock<DeviceImp> {
struct MockModuleForRebuildBuiltins : public ModuleImp {
MockModuleForRebuildBuiltins(Device *device) : ModuleImp(device, nullptr) {}
MockModuleForRebuildBuiltins(Device *device) : ModuleImp(device, nullptr, ModuleType::Builtin) {}
ze_result_t createKernel(const ze_kernel_desc_t *desc,
ze_kernel_handle_t *phFunction) override {
@@ -106,7 +106,7 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenRebuildPrecompiledKernelsDebugFlagWhe
ze_result_t createModule(const ze_module_desc_t *desc,
ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog) override {
ze_module_build_log_handle_t *buildLog, ModuleType type) override {
EXPECT_EQ(desc->format, ZE_MODULE_FORMAT_IL_SPIRV);
EXPECT_GT(desc->inputSize, 0u);
EXPECT_NE(desc->pInputModule, nullptr);
@@ -138,13 +138,13 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenNotToRebuildPrecompiledKernelsDebugFl
ze_result_t createModule(const ze_module_desc_t *desc,
ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog) override {
ze_module_build_log_handle_t *buildLog, ModuleType type) override {
EXPECT_EQ(desc->format, ZE_MODULE_FORMAT_NATIVE);
EXPECT_GT(desc->inputSize, 0u);
EXPECT_NE(desc->pInputModule, nullptr);
wasCreatedModuleCalled = true;
return DeviceImp::createModule(desc, module, buildLog);
return DeviceImp::createModule(desc, module, buildLog, type);
}
bool wasCreatedModuleCalled = false;
@@ -159,5 +159,31 @@ HWTEST_F(TestBuiltinFunctionsLibImpl, givenNotToRebuildPrecompiledKernelsDebugFl
EXPECT_TRUE(testDevice.wasCreatedModuleCalled);
}
HWTEST_F(TestBuiltinFunctionsLibImpl, GivenBuiltinsWhenInitializingFunctionsThenModulesWithProperTypeAreCreated) {
struct MockDeviceWithBuilins : public Mock<DeviceImp> {
MockDeviceWithBuilins(L0::Device *device) : Mock(device->getNEODevice(), static_cast<NEO::ExecutionEnvironment *>(device->getExecEnvironment())) {
driverHandle = device->getDriverHandle();
builtins = BuiltinFunctionsLib::create(this, neoDevice->getBuiltIns());
}
ze_result_t createModule(const ze_module_desc_t *desc,
ze_module_handle_t *module,
ze_module_build_log_handle_t *buildLog, ModuleType type) override {
typeCreated = type;
EXPECT_EQ(ModuleType::Builtin, type);
return DeviceImp::createModule(desc, module, buildLog, type);
}
ModuleType typeCreated = ModuleType::User;
};
MockDeviceWithBuilins testDevice(device);
testDevice.getBuiltinFunctionsLib()->initFunctions();
EXPECT_EQ(ModuleType::Builtin, testDevice.typeCreated);
}
} // namespace ult
} // namespace L0

6
level_zero/core/test/unit_tests/sources/debugger/test_module_with_debug.cpp
View File

@@ -33,7 +33,7 @@ TEST_F(DeviceWithDebuggerEnabledTest, givenDebuggingEnabledWhenModuleIsCreatedTh
ModuleBuildLog *moduleBuildLog = nullptr;
auto module = std::unique_ptr<L0::ModuleImp>(new L0::ModuleImp(deviceL0, moduleBuildLog));
auto module = std::unique_ptr<L0::ModuleImp>(new L0::ModuleImp(deviceL0, moduleBuildLog, ModuleType::User));
ASSERT_NE(nullptr, module.get());
module->initialize(&moduleDesc, device);
@@ -54,7 +54,7 @@ TEST_F(DeviceWithDebuggerEnabledTest, GivenDebuggeableKernelWhenModuleIsInitiali
ModuleBuildLog *moduleBuildLog = nullptr;
auto module = std::make_unique<WhiteBox<::L0::Module>>(deviceL0, moduleBuildLog);
auto module = std::make_unique<WhiteBox<::L0::Module>>(deviceL0, moduleBuildLog, ModuleType::User);
ASSERT_NE(nullptr, module.get());
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens;
@@ -86,7 +86,7 @@ TEST_F(DeviceWithDebuggerEnabledTest, GivenNonDebuggeableKernelWhenModuleIsIniti
ModuleBuildLog *moduleBuildLog = nullptr;
auto module = std::make_unique<WhiteBox<::L0::Module>>(deviceL0, moduleBuildLog);
auto module = std::make_unique<WhiteBox<::L0::Module>>(deviceL0, moduleBuildLog, ModuleType::User);
ASSERT_NE(nullptr, module.get());
NEO::PatchTokenBinary::KernelFromPatchtokens kernelTokens;

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

@@ -254,7 +254,7 @@ HWTEST_F(KernelPropertiesTests, whenInitializingThenCalculatesProperPrivateSurfa
kernelAttributes.simdSize = 8;
KernelImmutableData kernelImmutableData(device);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), computeUnitsUsedForSratch, nullptr, nullptr);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), computeUnitsUsedForSratch, nullptr, nullptr, false);
size_t expectedSize = static_cast<size_t>(kernelAttributes.perHwThreadPrivateMemorySize) * computeUnitsUsedForSratch;
EXPECT_GE(expectedSize, kernelImmutableData.getPrivateMemoryGraphicsAllocation()->getUnderlyingBufferSize());
@@ -470,7 +470,7 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithoutAllo
auto bcsCsr = device->getNEODevice()->getEngine(aub_stream::EngineType::ENGINE_BCS, false, false).commandStreamReceiver;
auto initialTaskCount = bcsCsr->peekTaskCount();
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr, false);
if (kernelImmutableData.getIsaGraphicsAllocation()->isAllocatedInLocalMemoryPool()) {
EXPECT_EQ(initialTaskCount + 1, bcsCsr->peekTaskCount());
@@ -496,7 +496,7 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithAllowed
auto bcsCsr = device->getNEODevice()->getEngine(aub_stream::EngineType::ENGINE_BCS, false, false).commandStreamReceiver;
auto initialTaskCount = bcsCsr->peekTaskCount();
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr, false);
EXPECT_EQ(initialTaskCount, bcsCsr->peekTaskCount());
@@ -520,12 +520,36 @@ TEST_F(KernelIsaTests, givenKernelAllocationInLocalMemoryWhenCreatingWithDisallo
auto bcsCsr = device->getNEODevice()->getEngine(aub_stream::EngineType::ENGINE_BCS, false, false).commandStreamReceiver;
auto initialTaskCount = bcsCsr->peekTaskCount();
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr, false);
EXPECT_EQ(initialTaskCount, bcsCsr->peekTaskCount());
device->getNEODevice()->getMemoryManager()->freeGraphicsMemory(kernelInfo.kernelAllocation);
}
TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithInternalIsaThenCorrectAllocationTypeIsUsed) {
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr, true);
EXPECT_EQ(NEO::GraphicsAllocation::AllocationType::KERNEL_ISA_INTERNAL, kernelImmutableData.getIsaGraphicsAllocation()->getAllocationType());
}
TEST_F(KernelIsaTests, givenKernelInfoWhenInitializingImmutableDataWithNonInternalIsaThenCorrectAllocationTypeIsUsed) {
uint32_t kernelHeap = 0;
KernelInfo kernelInfo;
kernelInfo.heapInfo.KernelHeapSize = 1;
kernelInfo.heapInfo.pKernelHeap = &kernelHeap;
KernelImmutableData kernelImmutableData(device);
kernelImmutableData.initialize(&kernelInfo, *device->getNEODevice()->getMemoryManager(), device->getNEODevice(), 0, nullptr, nullptr, false);
EXPECT_EQ(NEO::GraphicsAllocation::AllocationType::KERNEL_ISA, kernelImmutableData.getIsaGraphicsAllocation()->getAllocationType());
}
} // namespace ult
} // namespace L0

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

@@ -70,6 +70,27 @@ HWTEST_F(ModuleTest, givenNonZeroCountWhenGettingKernelNamesThenNamesAreReturned
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
HWTEST_F(ModuleTest, givenUserModuleTypeWhenCreatingModuleThenCorrectTypeIsSet) {
WhiteBox<Module> module(device, nullptr, ModuleType::User);
EXPECT_EQ(ModuleType::User, module.type);
}
HWTEST_F(ModuleTest, givenBuiltinModuleTypeWhenCreatingModuleThenCorrectTypeIsSet) {
WhiteBox<Module> module(device, nullptr, ModuleType::Builtin);
EXPECT_EQ(ModuleType::Builtin, module.type);
}
HWTEST_F(ModuleTest, givenUserModuleWhenCreatedThenCorrectAllocationTypeIsUsedForIsa) {
createKernel();
EXPECT_EQ(NEO::GraphicsAllocation::AllocationType::KERNEL_ISA, kernel->getIsaAllocation()->getAllocationType());
}
HWTEST_F(ModuleTest, givenBuiltinModuleWhenCreatedThenCorrectAllocationTypeIsUsedForIsa) {
createModuleFromBinary(ModuleType::Builtin);
createKernel();
EXPECT_EQ(NEO::GraphicsAllocation::AllocationType::KERNEL_ISA_INTERNAL, kernel->getIsaAllocation()->getAllocationType());
}
using ModuleTestSupport = IsWithinProducts<IGFX_SKYLAKE, IGFX_TIGERLAKE_LP>;
HWTEST2_F(ModuleTest, givenNonPatchedTokenThenSurfaceBaseAddressIsCorrectlySet, ModuleTestSupport) {
@@ -172,7 +193,7 @@ HWTEST_F(ModuleSpecConstantsTests, givenSpecializationConstantsSetInDescriptorTh
specConstants.pConstantValues = specConstantsPointerValues.data();
moduleDesc.pConstants = &specConstants;
auto module = new Module(device, nullptr);
auto module = new Module(device, nullptr, ModuleType::User);
module->translationUnit.reset(mockTranslationUnit);
bool success = module->initialize(&moduleDesc, neoDevice);
@@ -211,7 +232,7 @@ HWTEST_F(ModuleLinkingTest, givenFailureDuringLinkingWhenCreatingModuleThenModul
moduleDesc.pInputModule = &spirvData;
moduleDesc.inputSize = sizeof(spirvData);
Module module(device, nullptr);
Module module(device, nullptr, ModuleType::User);
module.translationUnit.reset(mockTranslationUnit);
bool success = module.initialize(&moduleDesc, neoDevice);
@@ -240,7 +261,7 @@ HWTEST_F(ModuleLinkingTest, givenRemainingUnresolvedSymbolsDuringLinkingWhenCrea
moduleDesc.pInputModule = &spirvData;
moduleDesc.inputSize = sizeof(spirvData);
Module module(device, nullptr);
Module module(device, nullptr, ModuleType::User);
module.translationUnit.reset(mockTranslationUnit);
bool success = module.initialize(&moduleDesc, neoDevice);
@@ -248,7 +269,7 @@ HWTEST_F(ModuleLinkingTest, givenRemainingUnresolvedSymbolsDuringLinkingWhenCrea
EXPECT_FALSE(module.isFullyLinked);
}
HWTEST_F(ModuleLinkingTest, givenNotFullyLinkedModuleWhenCreatingKernelThenErrorIsReturned) {
Module module(device, nullptr);
Module module(device, nullptr, ModuleType::User);
module.isFullyLinked = false;
auto retVal = module.createKernel(nullptr, nullptr);
@@ -258,8 +279,8 @@ HWTEST_F(ModuleLinkingTest, givenNotFullyLinkedModuleWhenCreatingKernelThenError
struct ModuleDynamicLinkTests : public Test<ModuleFixture> {
void SetUp() override {
Test<ModuleFixture>::SetUp();
module0 = std::make_unique<Module>(device, nullptr);
module1 = std::make_unique<Module>(device, nullptr);
module0 = std::make_unique<Module>(device, nullptr, ModuleType::User);
module1 = std::make_unique<Module>(device, nullptr, ModuleType::User);
}
std::unique_ptr<Module> module0;
std::unique_ptr<Module> module1;
@@ -513,7 +534,7 @@ HWTEST_F(ModuleTranslationUnitTest, GivenRebuildPrecompiledKernelsFlagAndFileWit
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;
Module module(device, nullptr);
Module module(device, nullptr, ModuleType::User);
MockModuleTU *tu = new MockModuleTU(device);
module.translationUnit.reset(tu);
@@ -540,7 +561,7 @@ HWTEST_F(ModuleTranslationUnitTest, GivenRebuildPrecompiledKernelsFlagAndFileWit
moduleDesc.pInputModule = reinterpret_cast<const uint8_t *>(src.get());
moduleDesc.inputSize = size;
Module module(device, nullptr);
Module module(device, nullptr, ModuleType::User);
MockModuleTU *tu = new MockModuleTU(device);
module.translationUnit.reset(tu);
@@ -608,7 +629,7 @@ TEST(BuildOptions, givenSrcOptionNameInSrcNamesWhenMovingBuildOptionsThenOptionI
TEST_F(ModuleTest, givenInternalOptionsWhenBindlessEnabledThenBindlesOptionsPassed) {
DebugManagerStateRestore restorer;
DebugManager.flags.UseBindlessMode.set(1);
auto module = std::make_unique<ModuleImp>(device, nullptr);
auto module = std::make_unique<ModuleImp>(device, nullptr, ModuleType::User);
ASSERT_NE(nullptr, module);
std::string buildOptions;
@@ -623,7 +644,7 @@ TEST_F(ModuleTest, givenInternalOptionsWhenBindlessEnabledThenBindlesOptionsPass
TEST_F(ModuleTest, givenInternalOptionsWhenBindlessDisabledThenBindlesOptionsNotPassed) {
DebugManagerStateRestore restorer;
DebugManager.flags.UseBindlessMode.set(0);
auto module = std::make_unique<ModuleImp>(device, nullptr);
auto module = std::make_unique<ModuleImp>(device, nullptr, ModuleType::User);
ASSERT_NE(nullptr, module);
std::string buildOptions;