229 lines
8.7 KiB
C++
229 lines
8.7 KiB
C++
/*
|
|
* Copyright (C) 2018-2025 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#include "shared/source/built_ins/built_ins.h"
|
|
#include "shared/source/debug_settings/debug_settings_manager.h"
|
|
#include "shared/source/device/device.h"
|
|
#include "shared/source/execution_environment/root_device_environment.h"
|
|
#include "shared/source/helpers/api_specific_config.h"
|
|
#include "shared/source/helpers/gfx_core_helper.h"
|
|
#include "shared/source/helpers/hw_info.h"
|
|
#include "shared/source/helpers/path.h"
|
|
|
|
#include "os_inc.h"
|
|
|
|
#include <cstdint>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
|
|
namespace NEO {
|
|
|
|
const char *getBuiltinAsString(EBuiltInOps::Type builtin) {
|
|
switch (builtin) {
|
|
default:
|
|
return "unknown";
|
|
case EBuiltInOps::auxTranslation:
|
|
return "aux_translation.builtin_kernel";
|
|
case EBuiltInOps::copyBufferToBuffer:
|
|
return "copy_buffer_to_buffer.builtin_kernel";
|
|
case EBuiltInOps::copyBufferToBufferStateless:
|
|
case EBuiltInOps::copyBufferToBufferStatelessHeapless:
|
|
return "copy_buffer_to_buffer_stateless.builtin_kernel";
|
|
case EBuiltInOps::copyBufferRect:
|
|
return "copy_buffer_rect.builtin_kernel";
|
|
case EBuiltInOps::copyBufferRectStateless:
|
|
case EBuiltInOps::copyBufferRectStatelessHeapless:
|
|
return "copy_buffer_rect_stateless.builtin_kernel";
|
|
case EBuiltInOps::fillBuffer:
|
|
return "fill_buffer.builtin_kernel";
|
|
case EBuiltInOps::fillBufferStateless:
|
|
case EBuiltInOps::fillBufferStatelessHeapless:
|
|
return "fill_buffer_stateless.builtin_kernel";
|
|
case EBuiltInOps::copyBufferToImage3d:
|
|
return "copy_buffer_to_image3d.builtin_kernel";
|
|
case EBuiltInOps::copyBufferToImage3dStateless:
|
|
case EBuiltInOps::copyBufferToImage3dHeapless:
|
|
return "copy_buffer_to_image3d_stateless.builtin_kernel";
|
|
case EBuiltInOps::copyImage3dToBuffer:
|
|
return "copy_image3d_to_buffer.builtin_kernel";
|
|
case EBuiltInOps::copyImage3dToBufferStateless:
|
|
case EBuiltInOps::copyImage3dToBufferHeapless:
|
|
return "copy_image3d_to_buffer_stateless.builtin_kernel";
|
|
case EBuiltInOps::copyImageToImage1d:
|
|
case EBuiltInOps::copyImageToImage1dHeapless:
|
|
return "copy_image_to_image1d.builtin_kernel";
|
|
case EBuiltInOps::copyImageToImage2d:
|
|
case EBuiltInOps::copyImageToImage2dHeapless:
|
|
return "copy_image_to_image2d.builtin_kernel";
|
|
case EBuiltInOps::copyImageToImage3d:
|
|
case EBuiltInOps::copyImageToImage3dHeapless:
|
|
return "copy_image_to_image3d.builtin_kernel";
|
|
case EBuiltInOps::fillImage1d:
|
|
case EBuiltInOps::fillImage1dHeapless:
|
|
return "fill_image1d.builtin_kernel";
|
|
case EBuiltInOps::fillImage2d:
|
|
case EBuiltInOps::fillImage2dHeapless:
|
|
return "fill_image2d.builtin_kernel";
|
|
case EBuiltInOps::fillImage3d:
|
|
case EBuiltInOps::fillImage3dHeapless:
|
|
return "fill_image3d.builtin_kernel";
|
|
case EBuiltInOps::queryKernelTimestamps:
|
|
return "copy_kernel_timestamps.builtin_kernel";
|
|
};
|
|
}
|
|
|
|
BuiltinResourceT createBuiltinResource(const char *ptr, size_t size) {
|
|
return BuiltinResourceT(ptr, ptr + size);
|
|
}
|
|
|
|
BuiltinResourceT createBuiltinResource(const BuiltinResourceT &r) {
|
|
return BuiltinResourceT(r);
|
|
}
|
|
|
|
std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::string &extension) {
|
|
return getBuiltinAsString(builtin) + extension;
|
|
}
|
|
|
|
StackVec<std::string, 3> getBuiltinResourceNames(EBuiltInOps::Type builtin, BuiltinCode::ECodeType type, const Device &device) {
|
|
auto &hwInfo = device.getHardwareInfo();
|
|
auto &productHelper = device.getRootDeviceEnvironment().getHelper<ProductHelper>();
|
|
|
|
auto createDeviceIdFilenameComponent = [](const NEO::HardwareIpVersion &hwIpVersion) {
|
|
std::ostringstream deviceId;
|
|
deviceId << hwIpVersion.architecture << "_" << hwIpVersion.release << "_" << hwIpVersion.revision;
|
|
return deviceId.str();
|
|
};
|
|
const auto deviceIp = createDeviceIdFilenameComponent(hwInfo.ipVersion);
|
|
const auto builtinFilename = getBuiltinAsString(builtin);
|
|
const auto extension = BuiltinCode::getExtension(type);
|
|
|
|
std::string_view addressingModePrefix = "";
|
|
if (type == BuiltinCode::ECodeType::binary) {
|
|
const bool heaplessEnabled = EBuiltInOps::isHeapless(builtin);
|
|
const bool requiresStatelessAddressing = (false == productHelper.isStatefulAddressingModeSupported());
|
|
const bool builtInUsesStatelessAddressing = EBuiltInOps::isStateless(builtin);
|
|
if (heaplessEnabled) {
|
|
addressingModePrefix = "heapless_";
|
|
} else if (builtInUsesStatelessAddressing || requiresStatelessAddressing) {
|
|
addressingModePrefix = "stateless_";
|
|
} else if (ApiSpecificConfig::getBindlessMode(device)) {
|
|
addressingModePrefix = "bindless_";
|
|
} else {
|
|
addressingModePrefix = "bindful_";
|
|
}
|
|
}
|
|
|
|
auto createBuiltinResourceName = [](ConstStringRef deviceIpPath, std::string_view addressingModePrefix, std::string_view builtinFilename, std::string_view extension) {
|
|
std::ostringstream outResourceName;
|
|
if (false == deviceIpPath.empty()) {
|
|
outResourceName << deviceIpPath.str() << "_";
|
|
}
|
|
outResourceName << addressingModePrefix << builtinFilename << extension;
|
|
return outResourceName.str();
|
|
};
|
|
StackVec<std::string, 3> resourcesToLookup = {};
|
|
resourcesToLookup.push_back(createBuiltinResourceName(deviceIp, addressingModePrefix, builtinFilename, extension));
|
|
|
|
if (BuiltinCode::ECodeType::binary != type) {
|
|
resourcesToLookup.push_back(createBuiltinResourceName("", addressingModePrefix, builtinFilename, extension));
|
|
}
|
|
return resourcesToLookup;
|
|
}
|
|
|
|
std::string getDriverInstallationPath() {
|
|
return "";
|
|
}
|
|
|
|
BuiltinResourceT Storage::load(const std::string &resourceName) {
|
|
return loadImpl(joinPath(rootPath, resourceName));
|
|
}
|
|
|
|
BuiltinResourceT FileStorage::loadImpl(const std::string &fullResourceName) {
|
|
BuiltinResourceT ret;
|
|
|
|
std::ifstream f{fullResourceName, std::ios::in | std::ios::binary | std::ios::ate};
|
|
auto end = f.tellg();
|
|
f.seekg(0, std::ios::beg);
|
|
auto beg = f.tellg();
|
|
auto s = end - beg;
|
|
ret.resize(static_cast<size_t>(s));
|
|
f.read(ret.data(), s);
|
|
return ret;
|
|
}
|
|
|
|
const BuiltinResourceT *EmbeddedStorageRegistry::get(const std::string &name) const {
|
|
auto it = resources.find(name);
|
|
if (resources.end() == it) {
|
|
return nullptr;
|
|
}
|
|
|
|
return &it->second;
|
|
}
|
|
|
|
BuiltinResourceT EmbeddedStorage::loadImpl(const std::string &fullResourceName) {
|
|
auto *constResource = EmbeddedStorageRegistry::getInstance().get(fullResourceName);
|
|
if (constResource == nullptr) {
|
|
BuiltinResourceT ret;
|
|
return ret;
|
|
}
|
|
|
|
return createBuiltinResource(*constResource);
|
|
}
|
|
|
|
BuiltinsLib::BuiltinsLib() {
|
|
allStorages.push_back(std::unique_ptr<Storage>(new EmbeddedStorage("")));
|
|
allStorages.push_back(std::unique_ptr<Storage>(new FileStorage(getDriverInstallationPath())));
|
|
}
|
|
|
|
BuiltinCode BuiltinsLib::getBuiltinCode(EBuiltInOps::Type builtin, BuiltinCode::ECodeType requestedCodeType, Device &device) {
|
|
std::lock_guard<std::mutex> lockRaii{mutex};
|
|
|
|
BuiltinResourceT bc;
|
|
BuiltinCode::ECodeType usedCodetType = BuiltinCode::ECodeType::invalid;
|
|
|
|
if (requestedCodeType == BuiltinCode::ECodeType::any) {
|
|
uint32_t codeType = static_cast<uint32_t>(BuiltinCode::ECodeType::binary);
|
|
if (debugManager.flags.RebuildPrecompiledKernels.get()) {
|
|
codeType = static_cast<uint32_t>(BuiltinCode::ECodeType::source);
|
|
}
|
|
for (uint32_t e = static_cast<uint32_t>(BuiltinCode::ECodeType::count);
|
|
codeType != e; ++codeType) {
|
|
bc = getBuiltinResource(builtin, static_cast<BuiltinCode::ECodeType>(codeType), device);
|
|
if (bc.size() > 0) {
|
|
usedCodetType = static_cast<BuiltinCode::ECodeType>(codeType);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
bc = getBuiltinResource(builtin, requestedCodeType, device);
|
|
usedCodetType = requestedCodeType;
|
|
}
|
|
|
|
BuiltinCode ret;
|
|
std::swap(ret.resource, bc);
|
|
ret.type = usedCodetType;
|
|
ret.targetDevice = &device;
|
|
|
|
return ret;
|
|
}
|
|
|
|
BuiltinResourceT BuiltinsLib::getBuiltinResource(EBuiltInOps::Type builtin, BuiltinCode::ECodeType requestedCodeType, Device &device) {
|
|
BuiltinResourceT builtinResource;
|
|
auto resourcesToLookup = getBuiltinResourceNames(builtin, requestedCodeType, device);
|
|
for (auto &resourceName : resourcesToLookup) {
|
|
for (auto &storage : allStorages) {
|
|
builtinResource = storage->load(resourceName);
|
|
if (builtinResource.size() != 0) {
|
|
return builtinResource;
|
|
}
|
|
}
|
|
}
|
|
return builtinResource;
|
|
}
|
|
|
|
} // namespace NEO
|