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

Reuse builtin module and init selected builtin on device init

Browse Source 
-start async thread at device initialization which initializes selected
builtins and exits
-share module across builtins using same binary

Resolves: NEO-7644

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk
2023-02-08 12:06:17 +00:00
committed by Compute-Runtime-Automation
parent 72f33b898d
commit e6181d7933
15 changed files with 139 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/core/source/builtin/builtin_functions_lib.h
View File

@@ -67,6 +67,7 @@ struct BuiltinFunctionsLib {
virtual Kernel *getImageFunction(ImageBuiltin func) = 0;
virtual void initBuiltinKernel(Builtin builtId) = 0;
virtual void initBuiltinImageKernel(ImageBuiltin func) = 0;
virtual void ensureInitCompletion() = 0;
[[nodiscard]] MOCKABLE_VIRTUAL std::unique_lock<MutexType> obtainUniqueOwnership();
protected:

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

@@ -9,10 +9,10 @@
#include "shared/source/built_ins/built_ins.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/os_interface.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/kernel/kernel.h"
#include "level_zero/core/source/module/module.h"
namespace NEO {
const char *getAdditionalBuiltinAsString(EBuiltInOps::Type builtin) {
@@ -24,13 +24,9 @@ namespace L0 {
BuiltinFunctionsLibImpl::BuiltinData::~BuiltinData() {
func.reset();
module.reset();
}
BuiltinFunctionsLibImpl::BuiltinData::BuiltinData() = default;
BuiltinFunctionsLibImpl::BuiltinData::BuiltinData(std::unique_ptr<L0::Module> &&mod, std::unique_ptr<L0::Kernel> &&ker) {
module = std::move(mod);
func = std::move(ker);
}
BuiltinFunctionsLibImpl::BuiltinData::BuiltinData(Module *module, std::unique_ptr<L0::Kernel> &&ker) : module(module), func(std::move(ker)) {}
std::unique_lock<BuiltinFunctionsLib::MutexType> BuiltinFunctionsLib::obtainUniqueOwnership() {
return std::unique_lock<BuiltinFunctionsLib::MutexType>(this->ownershipMutex);
}
@@ -185,9 +181,17 @@ void BuiltinFunctionsLibImpl::initBuiltinImageKernel(ImageBuiltin func) {
imageBuiltins[builtId] = loadBuiltIn(builtin, builtinName);
}
BuiltinFunctionsLibImpl::BuiltinFunctionsLibImpl(Device *device, NEO::BuiltIns *builtInsLib) : device(device), builtInsLib(builtInsLib) {
if (initBuiltinsAsyncEnabled(device)) {
this->initAsyncComplete = false;
this->initAsync = std::async(std::launch::async, &BuiltinFunctionsLibImpl::initBuiltinKernel, this, Builtin::FillBufferImmediate);
}
}
Kernel *BuiltinFunctionsLibImpl::getFunction(Builtin func) {
auto builtId = static_cast<uint32_t>(func);
this->ensureInitCompletion();
if (builtins[builtId].get() == nullptr) {
initBuiltinKernel(func);
}
@@ -198,6 +202,7 @@ Kernel *BuiltinFunctionsLibImpl::getFunction(Builtin func) {
Kernel *BuiltinFunctionsLibImpl::getImageFunction(ImageBuiltin func) {
auto builtId = static_cast<uint32_t>(func);
this->ensureInitCompletion();
if (imageBuiltins[builtId].get() == nullptr) {
initBuiltinImageKernel(func);
}
@@ -227,27 +232,46 @@ std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> BuiltinFunctionsLibImpl::l
}
}
[[maybe_unused]] ze_result_t res;
std::unique_ptr<Module> module;
ze_module_handle_t moduleHandle;
ze_module_desc_t moduleDesc = {};
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, ModuleType::Builtin);
UNRECOVERABLE_IF(res != ZE_RESULT_SUCCESS);
if (builtinCode.resource.empty() || !NEO::EmbeddedStorageRegistry::exists) {
return nullptr;
}
module.reset(Module::fromHandle(moduleHandle));
[[maybe_unused]] ze_result_t res;
if (this->modules.size() <= builtin) {
this->modules.resize(builtin + 1u);
}
if (this->modules[builtin].get() == nullptr) {
std::unique_ptr<Module> module;
ze_module_handle_t moduleHandle;
ze_module_desc_t moduleDesc = {};
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, ModuleType::Builtin);
UNRECOVERABLE_IF(res != ZE_RESULT_SUCCESS);
module.reset(Module::fromHandle(moduleHandle));
this->modules[builtin] = std::move(module);
}
std::unique_ptr<Kernel> kernel;
ze_kernel_handle_t kernelHandle;
ze_kernel_desc_t kernelDesc = {};
kernelDesc.pKernelName = builtInName;
res = module->createKernel(&kernelDesc, &kernelHandle);
res = this->modules[builtin]->createKernel(&kernelDesc, &kernelHandle);
DEBUG_BREAK_IF(res != ZE_RESULT_SUCCESS);
kernel.reset(Kernel::fromHandle(kernelHandle));
return std::unique_ptr<BuiltinData>(new BuiltinData{std::move(module), std::move(kernel)});
return std::unique_ptr<BuiltinData>(new BuiltinData{modules[builtin].get(), std::move(kernel)});
}
void BuiltinFunctionsLibImpl::ensureInitCompletion() {
if (!this->initAsyncComplete) {
this->initAsync.wait();
this->initAsyncComplete = true;
}
}
} // namespace L0

22
level_zero/core/source/builtin/builtin_functions_lib_impl.h
View File

@@ -7,7 +7,13 @@
#pragma once
#include "shared/source/os_interface/os_thread.h"
#include "level_zero/core/source/builtin/builtin_functions_lib.h"
#include "level_zero/core/source/module/module.h"
#include <future>
#include <vector>
namespace NEO {
namespace EBuiltInOps {
@@ -17,15 +23,12 @@ class BuiltIns;
} // namespace NEO
namespace L0 {
struct Module;
struct Kernel;
struct Device;
struct BuiltinFunctionsLibImpl : BuiltinFunctionsLib {
struct BuiltinData;
BuiltinFunctionsLibImpl(Device *device, NEO::BuiltIns *builtInsLib)
: device(device), builtInsLib(builtInsLib) {
}
BuiltinFunctionsLibImpl(Device *device, NEO::BuiltIns *builtInsLib);
~BuiltinFunctionsLibImpl() override {
builtins->reset();
imageBuiltins->reset();
@@ -35,20 +38,27 @@ struct BuiltinFunctionsLibImpl : BuiltinFunctionsLib {
Kernel *getImageFunction(ImageBuiltin func) override;
void initBuiltinKernel(Builtin builtId) override;
void initBuiltinImageKernel(ImageBuiltin func) override;
void ensureInitCompletion() override;
MOCKABLE_VIRTUAL std::unique_ptr<BuiltinFunctionsLibImpl::BuiltinData> loadBuiltIn(NEO::EBuiltInOps::Type builtin, const char *builtInName);
static bool initBuiltinsAsyncEnabled(Device *device);
protected:
std::vector<std::unique_ptr<Module>> modules = {};
std::unique_ptr<BuiltinData> builtins[static_cast<uint32_t>(Builtin::COUNT)];
std::unique_ptr<BuiltinData> imageBuiltins[static_cast<uint32_t>(ImageBuiltin::COUNT)];
Device *device;
NEO::BuiltIns *builtInsLib;
std::future<void> initAsync = {};
bool initAsyncComplete = true;
};
struct BuiltinFunctionsLibImpl::BuiltinData {
MOCKABLE_VIRTUAL ~BuiltinData();
BuiltinData();
BuiltinData(std::unique_ptr<L0::Module> &&mod, std::unique_ptr<L0::Kernel> &&ker);
BuiltinData(Module *module, std::unique_ptr<L0::Kernel> &&ker);
std::unique_ptr<Module> module;
Module *module = nullptr;
std::unique_ptr<Kernel> func;
};
} // namespace L0