intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-11 16:45:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove builtins duplication

Browse Source 
Resolves: NEO-7064

Signed-off-by: Krystian Chmielewski <krystian.chmielewski@intel.com>
This commit is contained in:
Krystian Chmielewski
2022-08-22 14:53:48 +00:00
committed by Compute-Runtime-Automation
parent a5b4a13452
commit 835174c076
31 changed files with 362 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
shared/source/built_ins/built_in_ops_base.h
View File

@@ -1,11 +1,13 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <algorithm>
#include <array>
#include <cstdint>
namespace NEO {
@@ -32,6 +34,16 @@ constexpr Type FillImage2d{15};
constexpr Type FillImage3d{16};
constexpr Type QueryKernelTimestamps{17};
constexpr bool isStateless(Type type) {
constexpr std::array<Type, 5> statelessBuiltins{{CopyBufferToBufferStateless, CopyBufferRectStateless, FillBufferStateless, CopyBufferToImage3dStateless, CopyImage3dToBufferStateless}};
for (auto &builtinType : statelessBuiltins) {
if (type == builtinType) {
return true;
}
}
return false;
}
constexpr Type MaxBaseValue{17};
constexpr Type COUNT{64};
} // namespace EBuiltInOps

60
shared/source/built_ins/built_ins.h
View File

@@ -36,10 +36,38 @@ static constexpr ConstStringRef mediaKernelsBuildOptionsList[] = {
static constexpr CompilerOptions::ConstConcatenation<> mediaKernelsBuildOptions{mediaKernelsBuildOptionsList};
struct BuiltinCode {
enum class ECodeType {
Any = 0, // for requesting "any" code available - priorities as below
Binary = 1, // ISA - highest priority
Intermediate = 2, // SPIR/LLVM - medium prioroty
Source = 3, // OCL C - lowest priority
COUNT,
INVALID
};
static const char *getExtension(BuiltinCode::ECodeType ct) {
switch (ct) {
default:
return "";
case BuiltinCode::ECodeType::Binary:
return ".bin";
case BuiltinCode::ECodeType::Intermediate:
return ".bc";
case BuiltinCode::ECodeType::Source:
return ".cl";
}
}
BuiltinCode::ECodeType type;
BuiltinResourceT resource;
Device *targetDevice;
};
BuiltinResourceT createBuiltinResource(const char *ptr, size_t size);
BuiltinResourceT createBuiltinResource(const BuiltinResourceT &r);
std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::string &extension,
const std::string &platformName = "", uint32_t deviceRevId = 0);
std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::string &extension);
StackVec<std::string, 3> getBuiltinResourceNames(EBuiltInOps::Type builtin, BuiltinCode::ECodeType type, const Device &device);
std::string joinPath(const std::string &lhs, const std::string &rhs);
const char *getBuiltinAsString(EBuiltInOps::Type builtin);
const char *getAdditionalBuiltinAsString(EBuiltInOps::Type builtin);
@@ -97,34 +125,6 @@ class EmbeddedStorage : public Storage {
BuiltinResourceT loadImpl(const std::string &fullResourceName) override;
};
struct BuiltinCode {
enum class ECodeType {
Any = 0, // for requesting "any" code available - priorities as below
Binary = 1, // ISA - highest priority
Intermediate = 2, // SPIR/LLVM - medium prioroty
Source = 3, // OCL C - lowest priority
COUNT,
INVALID
};
static const char *getExtension(ECodeType ct) {
switch (ct) {
default:
return "";
case ECodeType::Binary:
return ".bin";
case ECodeType::Intermediate:
return ".bc";
case ECodeType::Source:
return ".cl";
}
}
ECodeType type;
BuiltinResourceT resource;
Device *targetDevice;
};
class BuiltinsLib {
public:
BuiltinsLib();

93
shared/source/built_ins/built_ins_storage.cpp
View File

@@ -14,6 +14,7 @@
#include "os_inc.h"
#include <cstdint>
#include <sstream>
namespace NEO {
@@ -72,24 +73,52 @@ BuiltinResourceT createBuiltinResource(const BuiltinResourceT &r) {
return BuiltinResourceT(r);
}
std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::string &extension,
const std::string &platformName, uint32_t deviceRevId) {
std::string ret;
if (platformName.size() > 0) {
ret = platformName;
ret += "_" + std::to_string(deviceRevId);
ret += "_";
}
if (extension == ".bin") {
ret += ApiSpecificConfig::getBindlessConfiguration() ? "bindless_" : "bindful_";
}
ret += getBuiltinAsString(builtin);
std::string createBuiltinResourceName(EBuiltInOps::Type builtin, const std::string &extension) {
return getBuiltinAsString(builtin) + extension;
}
if (extension.size() > 0) {
ret += extension;
}
StackVec<std::string, 3> getBuiltinResourceNames(EBuiltInOps::Type builtin, BuiltinCode::ECodeType type, const Device &device) {
auto &hwInfo = device.getHardwareInfo();
auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
return ret;
const auto platformName = getFamilyNameWithType(hwInfo);
const auto revisionId = std::to_string(hwInfo.platform.usRevId);
const auto builtinName = getBuiltinAsString(builtin);
const auto extension = BuiltinCode::getExtension(type);
auto getAddressingMode = [type, &hwInfo, builtin]() {
if (type == BuiltinCode::ECodeType::Binary) {
const bool requiresStatelessAddressing = (false == HwInfoConfig::get(hwInfo.platform.eProductFamily)->isStatefulAddressingModeSupported());
const bool builtInUsesStatelessAddressing = EBuiltInOps::isStateless(builtin);
if (builtInUsesStatelessAddressing || requiresStatelessAddressing) {
return "stateless_";
} else if (ApiSpecificConfig::getBindlessConfiguration()) {
return "bindless_";
} else {
return "bindful_";
}
}
return "";
};
const auto addressingMode = getAddressingMode();
auto createBuiltinResourceName = [](ConstStringRef platformName, ConstStringRef revisionId, ConstStringRef addressingMode, ConstStringRef builtinName, ConstStringRef extension) {
std::ostringstream outResourceName;
if (false == platformName.empty()) {
outResourceName << platformName.str() << "_" << revisionId.str() << "_";
}
outResourceName << addressingMode.str() << builtinName.str() << extension.str();
return outResourceName.str();
};
StackVec<std::string, 3> resourcesToLookup = {};
resourcesToLookup.push_back(createBuiltinResourceName(platformName, revisionId, addressingMode, builtinName, extension));
const bool requiresSpecificResource = (BuiltinCode::ECodeType::Binary == type && hwHelper.isRevisionSpecificBinaryBuiltinRequired());
if (false == requiresSpecificResource) {
const auto defaultRevisionId = std::to_string(hwHelper.getDefaultRevisionId(hwInfo));
resourcesToLookup.push_back(createBuiltinResourceName(platformName, defaultRevisionId, addressingMode, builtinName, extension));
resourcesToLookup.push_back(createBuiltinResourceName("", "", addressingMode, builtinName, extension));
}
return resourcesToLookup;
}
std::string joinPath(const std::string &lhs, const std::string &rhs) {
@@ -186,33 +215,17 @@ BuiltinCode BuiltinsLib::getBuiltinCode(EBuiltInOps::Type builtin, BuiltinCode::
}
BuiltinResourceT BuiltinsLib::getBuiltinResource(EBuiltInOps::Type builtin, BuiltinCode::ECodeType requestedCodeType, Device &device) {
BuiltinResourceT bc;
auto &hwInfo = device.getHardwareInfo();
auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
std::string resourceNameGeneric = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType));
std::string resourceNameForPlatformType = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType),
getFamilyNameWithType(hwInfo),
hwHelper.getDefaultRevisionId(hwInfo));
std::string resourceNameForPlatformTypeAndStepping = createBuiltinResourceName(builtin, BuiltinCode::getExtension(requestedCodeType),
getFamilyNameWithType(hwInfo),
hwInfo.platform.usRevId);
StackVec<const std::string *, 3> resourcesToLookup;
resourcesToLookup.push_back(&resourceNameForPlatformTypeAndStepping);
if (BuiltinCode::ECodeType::Binary != requestedCodeType || !hwHelper.isRevisionSpecificBinaryBuiltinRequired()) {
resourcesToLookup.push_back(&resourceNameForPlatformType);
resourcesToLookup.push_back(&resourceNameGeneric);
}
for (auto &rn : resourcesToLookup) { // first look for dedicated version, only fallback to generic one
for (auto &s : allStorages) {
UNRECOVERABLE_IF(!rn);
bc = s->load(*rn);
if (bc.size() != 0) {
return bc;
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 bc;
return builtinResource;
}
} // namespace NEO

26
shared/source/built_ins/builtins_binary.cmake
View File

@@ -4,15 +4,18 @@
# SPDX-License-Identifier: MIT
#
add_library(${BUILTINS_BINARIES_STATELESS_LIB_NAME} OBJECT EXCLUDE_FROM_ALL builtins_binary.cmake)
add_library(${BUILTINS_BINARIES_BINDFUL_LIB_NAME} OBJECT EXCLUDE_FROM_ALL builtins_binary.cmake)
add_library(${BUILTINS_BINARIES_BINDLESS_LIB_NAME} OBJECT EXCLUDE_FROM_ALL builtins_binary.cmake)
target_compile_definitions(${BUILTINS_BINARIES_STATELESS_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
target_compile_definitions(${BUILTINS_BINARIES_BINDFUL_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
target_compile_definitions(${BUILTINS_BINARIES_BINDLESS_LIB_NAME} PUBLIC MOCKABLE_VIRTUAL=)
# Add builtins sources
add_subdirectory(registry)
list(APPEND BIND_MODES
list(APPEND ADDRESSING_MODES
"stateless"
"bindful"
"bindless"
)
@@ -55,7 +58,7 @@ if(COMPILE_BUILT_INS)
add_subdirectory(kernels)
endif()
foreach(MODE ${BIND_MODES})
foreach(MODE ${ADDRESSING_MODES})
get_property(GENERATED_BUILTINS_CPPS_${MODE} GLOBAL PROPERTY GENERATED_BUILTINS_CPPS_${MODE})
source_group("generated files\\${CORE_TYPE_LOWER}" FILES GENERATED_BUILTINS_CPPS_${MODE})
endforeach()
@@ -95,3 +98,22 @@ target_include_directories(${BUILTINS_BINARIES_BINDLESS_LIB_NAME} PRIVATE
${NEO__IGC_INCLUDE_DIR}
${THIRD_PARTY_DIR}
)
if(COMPILE_BUILT_INS)
target_sources(${BUILTINS_BINARIES_STATELESS_LIB_NAME} PUBLIC ${GENERATED_BUILTINS_CPPS_stateless})
set_source_files_properties(${GENERATED_BUILTINS_CPPS_stateless} PROPERTIES GENERATED TRUE)
endif()
set_target_properties(${BUILTINS_BINARIES_STATELESS_LIB_NAME} PROPERTIES LINKER_LANGUAGE CXX)
set_target_properties(${BUILTINS_BINARIES_STATELESS_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
set_target_properties(${BUILTINS_BINARIES_STATELESS_LIB_NAME} PROPERTIES FOLDER "${SHARED_SOURCE_PROJECTS_FOLDER}/${SHARED_BUILTINS_PROJECTS_FOLDER}")
target_include_directories(${BUILTINS_BINARIES_STATELESS_LIB_NAME} PRIVATE
${ENGINE_NODE_DIR}
${KHRONOS_HEADERS_DIR}
${KHRONOS_GL_HEADERS_DIR}
${NEO__GMM_INCLUDE_DIR}
${NEO__IGC_INCLUDE_DIR}
${THIRD_PARTY_DIR}
)

56
shared/source/built_ins/kernels/CMakeLists.txt
View File

@@ -7,6 +7,7 @@
add_custom_target(builtins)
set_target_properties(builtins PROPERTIES FOLDER "${SHARED_SOURCE_PROJECTS_FOLDER}/${SHARED_BUILTINS_PROJECTS_FOLDER}")
set(BUILTINS_OUTDIR_WITH_ARCH "${TargetDir}/built_ins/${NEO_ARCH}")
add_dependencies(${BUILTINS_BINARIES_STATELESS_LIB_NAME} builtins)
add_dependencies(${BUILTINS_BINARIES_BINDFUL_LIB_NAME} builtins)
add_dependencies(${BUILTINS_BINARIES_BINDLESS_LIB_NAME} builtins)
add_subdirectories()
@@ -174,32 +175,57 @@ macro(macro_for_each_core_type)
add_custom_target(${target_name})
add_dependencies(builtins ${target_name})
set_target_properties(${target_name} PROPERTIES FOLDER "${SHARED_SOURCE_PROJECTS_FOLDER}/${SHARED_BUILTINS_PROJECTS_FOLDER}/${family_name_with_type}")
foreach(MODE ${BIND_MODES})
foreach(MODE ${ADDRESSING_MODES})
unset(BUILTINS_COMMANDS)
if((${MODE} STREQUAL "bindless") AND (NOT BUILD_WITH_L0 OR("${CORE_TYPE}" STREQUAL "GEN8")))
continue()
endif()
foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
foreach(GENERATED_BUILTIN_STATELESS ${GENERATED_BUILTINS_STATELESS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN_STATELESS}.builtin_kernel ${BITS} "${BUILTIN_OPTIONS_STATELESS}" ${MODE})
endforeach()
if(${IMAGE_SUPPORT})
foreach(GENERATED_BUILTINS_IMAGES ${GENERATED_BUILTINS_IMAGES})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTINS_IMAGES}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
foreach(GENERATED_BUILTIN_IMAGES_STATELESS ${GENERATED_BUILTINS_IMAGES_STATELESS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN_IMAGES_STATELESS}.builtin_kernel ${BITS} "${BUILTIN_OPTIONS_STATELESS}" ${MODE})
endforeach()
endif()
if(${AUX_TRANSLATION_SUPPORT})
foreach(GENERATED_BUILTIN_AUX_TRANSLATION ${GENERATED_BUILTINS_AUX_TRANSLATION})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN_AUX_TRANSLATION}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
endif()
if(${MODE} STREQUAL "stateless")
foreach(GENERATED_BUILTIN_STATELESS ${GENERATED_BUILTINS_STATELESS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN_STATELESS}.builtin_kernel ${BITS} "${BUILTIN_OPTIONS_STATELESS}" ${MODE})
endforeach()
if(${IMAGE_SUPPORT})
foreach(GENERATED_BUILTIN_IMAGES_STATELESS ${GENERATED_BUILTINS_IMAGES_STATELESS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN_IMAGES_STATELESS}.builtin_kernel ${BITS} "${BUILTIN_OPTIONS_STATELESS}" ${MODE})
endforeach()
endif()
if("${CORE_TYPE}" STREQUAL "XE_HPC_CORE")
# Compile stateful versions as stateless
foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
if(${IMAGE_SUPPORT})
foreach(GENERATED_BUILTINS_IMAGES ${GENERATED_BUILTINS_IMAGES})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTINS_IMAGES}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
endif()
endif()
else()
if("${CORE_TYPE}" STREQUAL "XE_HPC_CORE")
continue()
endif()
foreach(GENERATED_BUILTIN ${GENERATED_BUILTINS})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTIN}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
if(${IMAGE_SUPPORT})
foreach(GENERATED_BUILTINS_IMAGES ${GENERATED_BUILTINS_IMAGES})
compile_builtin(${CORE_TYPE} ${PLATFORM_TYPE} ${GENERATED_BUILTINS_IMAGES}.builtin_kernel ${NEO_BITS} "${BUILTIN_OPTIONS}" ${MODE})
endforeach()
endif()
endif()
get_property(GENERATED_BUILTINS_CPPS_${MODE} GLOBAL PROPERTY GENERATED_BUILTINS_CPPS_${MODE})
foreach(BUILTIN ${BUILTINS_COMMANDS})
list(APPEND GENERATED_BUILTINS_CPPS_${MODE} ${BUILTIN})

2
shared/source/os_interface/hw_info_config.h
View File

@@ -135,6 +135,7 @@ class HwInfoConfig {
virtual bool isEvictionIfNecessaryFlagSupported() const = 0;
virtual void adjustNumberOfCcs(HardwareInfo &hwInfo) const = 0;
virtual bool isPrefetcherDisablingInDirectSubmissionRequired() const = 0;
virtual bool isStatefulAddressingModeSupported() const = 0;
MOCKABLE_VIRTUAL ~HwInfoConfig() = default;
@@ -240,6 +241,7 @@ class HwInfoConfigHw : public HwInfoConfig {
bool isEvictionIfNecessaryFlagSupported() const override;
void adjustNumberOfCcs(HardwareInfo &hwInfo) const override;
bool isPrefetcherDisablingInDirectSubmissionRequired() const override;
bool isStatefulAddressingModeSupported() const override;
protected:
HwInfoConfigHw() = default;

5
shared/source/os_interface/hw_info_config.inl
View File

@@ -492,4 +492,9 @@ template <PRODUCT_FAMILY gfxProduct>
bool HwInfoConfigHw<gfxProduct>::isPrefetcherDisablingInDirectSubmissionRequired() const {
return true;
}
template <PRODUCT_FAMILY gfxProduct>
bool HwInfoConfigHw<gfxProduct>::isStatefulAddressingModeSupported() const {
return true;
}
} // namespace NEO

5
shared/source/xe_hpc_core/pvc/os_agnostic_hw_info_config_pvc.inl
View File

@@ -198,4 +198,9 @@ bool HwInfoConfigHw<gfxProduct>::isIpSamplingSupported(const HardwareInfo &hwInf
template <>
void HwInfoConfigHw<gfxProduct>::adjustNumberOfCcs(HardwareInfo &hwInfo) const {
hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 1;
}
template <>
bool HwInfoConfigHw<gfxProduct>::isStatefulAddressingModeSupported() const {
return false;
}