Skip to content

[SYCL] Move devicelib req mask collection into a LLVM pass #3291

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
romanovvlad merged 2 commits into from
Mar 4, 2021
Merged

[SYCL] Move devicelib req mask collection into a LLVM pass #3291

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
1332722
Move devicelib req mask collection into a LLVM pass
jinge90 Mar 3, 2021
c37c594
remove unnecessary include
jinge90 Mar 4, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion llvm/tools/sycl-post-link/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,7 +21,7 @@ add_llvm_tool(sycl-post-link
sycl-post-link.cpp
SPIRKernelParamOptInfo.cpp
SpecConstants.cpp

SYCLDeviceLibReqMask.cpp
ADDITIONAL_HEADER_DIRS
${LLVMGenXIntrinsics_SOURCE_DIR}/GenXIntrinsics/include
${LLVMGenXIntrinsics_BINARY_DIR}/GenXIntrinsics/include
Expand Down
199 changes: 199 additions & 0 deletions llvm/tools/sycl-post-link/SYCLDeviceLibReqMask.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,199 @@
//==----- SYCLDeviceLibReqMask.cpp - get SYCL devicelib required Info ------==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This pass goes through input module's function list to detect all SYCL
// devicelib functions invoked. Each devicelib function invoked is included in
// one 'fallback' SPIR-V library loaded by SYCL runtime. After scanning all
// functions in input module, a mask telling which SPIR-V libraries are needed
// by input module indeed will be returned. This mask will be saved and used by
// SYCL runtime later.
//===----------------------------------------------------------------------===//

#include "SYCLDeviceLibReqMask.h"

static constexpr char DEVICELIB_FUNC_PREFIX[] = "__devicelib_";

char SYCLDeviceLibReqMaskPass::ID = 0;
// Please update SDLMap if any item is added to or removed from
// fallback device libraries in libdevice.
SYCLDeviceLibFuncMap SYCLDeviceLibReqMaskPass::SDLMap = {
{"__devicelib_acosf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_acoshf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_asinf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_asinhf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_atan2f", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_atanf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_atanhf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_cbrtf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_cosf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_coshf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_erfcf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_erff", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_exp2f", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_expf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_expm1f", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_fdimf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_fmaf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_fmodf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_frexpf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_hypotf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_ilogbf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_ldexpf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_lgammaf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_log10f", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_log1pf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_log2f", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_logbf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_logf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_modff", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_nextafterf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_powf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_remainderf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_remquof", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_scalbnf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_sinf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_sinhf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_sqrtf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_tanf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_tanhf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_tgammaf", DeviceLibExt::cl_intel_devicelib_math},
{"__devicelib_acos", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_acosh", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_asin", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_asinh", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_atan", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_atan2", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_atanh", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_cbrt", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_cos", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_cosh", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_erf", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_erfc", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_exp", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_exp2", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_expm1", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_fdim", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_fma", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_fmod", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_frexp", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_hypot", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_ilogb", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_ldexp", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_lgamma", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_log", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_log10", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_log1p", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_log2", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_logb", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_modf", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_nextafter", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_pow", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_remainder", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_remquo", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_scalbn", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_sin", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_sinh", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_sqrt", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_tan", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_tanh", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib_tgamma", DeviceLibExt::cl_intel_devicelib_math_fp64},
{"__devicelib___divsc3", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib___mulsc3", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cabsf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cacosf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cacoshf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cargf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_casinf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_casinhf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_catanf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_catanhf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_ccosf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_ccoshf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cexpf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cimagf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_clogf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cpolarf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cpowf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_cprojf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_crealf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_csinf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_csinhf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_csqrtf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_ctanf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib_ctanhf", DeviceLibExt::cl_intel_devicelib_complex},
{"__devicelib___divdc3", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib___muldc3", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cabs", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cacos", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cacosh", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_carg", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_casin", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_casinh", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_catan", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_catanh", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_ccos", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_ccosh", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cexp", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cimag", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_clog", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cpolar", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cpow", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_cproj", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_creal", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_csin", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_csinh", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_csqrt", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_ctan", DeviceLibExt::cl_intel_devicelib_complex_fp64},
{"__devicelib_ctanh", DeviceLibExt::cl_intel_devicelib_complex_fp64},
};

// Each fallback device library corresponds to one bit in "require mask" which
// is an unsigned int32. getDeviceLibBit checks which fallback device library
// is required for FuncName and returns the corresponding bit. The corresponding
// mask for each fallback device library is:
// fallback-cassert: 0x1
// fallback-cmath: 0x2
// fallback-cmath-fp64: 0x4
// fallback-complex: 0x8
// fallback-complex-fp64: 0x10
uint32_t
SYCLDeviceLibReqMaskPass::getDeviceLibBits(const std::string &FuncName) {
auto DeviceLibFuncIter = SDLMap.find(FuncName);
return ((DeviceLibFuncIter == SDLMap.end())
? 0
: 0x1 << (static_cast<uint32_t>(DeviceLibFuncIter->second) -
static_cast<uint32_t>(
DeviceLibExt::cl_intel_devicelib_assert)));
}

// For each device image module, we go through all functions which meets
// 1. The function name has prefix "__devicelib_"
// 2. The function is declaration which means it doesn't have function body
// And we don't expect non-spirv functions with "__devicelib_" prefix.
uint32_t SYCLDeviceLibReqMaskPass::getModuleDeviceLibReqMask(const Module &M) {
// Device libraries will be enabled only for spir-v module.
if (!llvm::Triple(M.getTargetTriple()).isSPIR())
return 0;
// 0x1 means sycl runtime will link and load libsycl-fallback-assert.spv as
// default. In fact, default link assert spv is not necessary but dramatic
// perf regression is observed if we don't link any device library. The perf
// regression is caused by a clang issue.
uint32_t ReqMask = 0x1;
for (const Function &SF : M) {
if (SF.getName().startswith(DEVICELIB_FUNC_PREFIX) && SF.isDeclaration()) {
assert(SF.getCallingConv() == CallingConv::SPIR_FUNC);
uint32_t DeviceLibBits = getDeviceLibBits(SF.getName().str());
ReqMask |= DeviceLibBits;
}
}
return ReqMask;
}
bool SYCLDeviceLibReqMaskPass::runOnModule(Module &M) {
MReqMask = getModuleDeviceLibReqMask(M);
return false;
}
50 changes: 50 additions & 0 deletions llvm/tools/sycl-post-link/SYCLDeviceLibReqMask.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
//===----- SYCLDeviceLibReqMask.h - get SYCL devicelib required Info -----=-==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This pass goes through input module's function list to detect all SYCL
// devicelib functions invoked. Each devicelib function invoked is included in
// one 'fallback' SPIR-V library loaded by SYCL runtime. After scanning all
// functions in input module, a mask telling which SPIR-V libraries are needed
// by input module indeed will be returned. This mask will be saved and used by
// SYCL runtime later.
//===----------------------------------------------------------------------===//

#pragma onece

#include "llvm/ADT/Triple.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Pass.h"
#include <unordered_map>
using namespace llvm;

// DeviceLibExt is shared between sycl-post-link tool and sycl runtime.
// If any change is made here, need to sync with DeviceLibExt definition
// in sycl/source/detail/program_manager/program_manager.hpp
enum class DeviceLibExt : std::uint32_t {
cl_intel_devicelib_assert,
cl_intel_devicelib_math,
cl_intel_devicelib_math_fp64,
cl_intel_devicelib_complex,
cl_intel_devicelib_complex_fp64
};

using SYCLDeviceLibFuncMap = std::unordered_map<std::string, DeviceLibExt>;
class SYCLDeviceLibReqMaskPass : public ModulePass {
Copy link
Contributor

@AlexeySachkov AlexeySachkov Mar 3, 2021

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Since this pass is designed for a legacy pass manager, could you please rename it to SYCLDeviceLibReqMaskLegacyPass? Or even better, rewrite it to use new pass manager infrastructure

Copy link
Contributor Author

@jinge90 jinge90 Mar 4, 2021

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Hi, @AlexeySachkov
I agree it is better to use new pass manager but it looks like legacy pass manager has already been used in sycl-post-link.cpp in several places, I would like to use legacy pass manager in this patch and draft a new patch to replace all legacy pass manager with new pass manager.
Thanks very much.

public:
static char ID;
SYCLDeviceLibReqMaskPass() : ModulePass(ID) { MReqMask = 0; }
bool runOnModule(Module &M) override;
uint32_t getSYCLDeviceLibReqMask() { return MReqMask; }

private:
uint32_t MReqMask;
static SYCLDeviceLibFuncMap SDLMap;
static uint32_t getDeviceLibBits(const std::string &FuncName);
static uint32_t getModuleDeviceLibReqMask(const Module &M);
};
Loading