[SYCL][NVPTX][AMDGCN] Move devicelib cmath to header #18706
Conversation
This patch experiments with moving standard library math built-ins from libdevice into headers. This is based on the way clang handles this for CUDA and HIP. In these languages you can define device functions as overloads. This allows re-defining standard library functions specifically for the device in a header, so that we can provide a device specific implementations of certain built-ins while still using the regular standard library headers. By default SYCL doesn't do overloads for device functions, so this patch introduces a new `sycl_device_only` attribute, this attribute will make a function device only and allow it to overload with existing functions.
|
@bader this is a proof of concept for moving C++ library handling from libdevice code into headers. It allows us to remove the hack blocking LLVM intrinsic generation for standard math built-ins, since we intercept them earlier in the header for device side, which is in-line with what clang cuda does. Only for cmath and for Nvidia and AMD for now. I've currently placed the header into the This still needs a ton of work which is why it's a draft, but let me know if you have any feedback on the approach. It would be good to know if this would be interesting for non-AOT targets as well, there's a lot of logic in the driver to conditionally link libdevice libraries, I suspect in theory most of that could be replaced with this header approach, but I haven't looked into this much so I'm not 100% sure if this is something we'd want. |
There was a problem hiding this comment.
@npmiller, thanks for working on this.
It allows us to remove the hack blocking LLVM intrinsic generation for standard math built-ins, since we intercept them earlier in the header for device side, which is in-line with what clang cuda does.
I discussed this approach with Johannes Doerfert a few years ago. He told me that he doesn't like "what clang cuda does" and plans to change it. I think clang still uses the header solution, but it may be worth to double check with LLVM community is doing any work in that direction.
I've currently placed the header into the stl_wrappers directory, it might be better as a clang header, but at least on CUDA the clang header is always included whereas with the stl wrappers it will only be included when the matching standard library header is included.
Interesting... I thought that clang only adds path to the clang headers at the beginning of the search paths list to make sure that clang wrapper header is included before STL one. I didn't know that CUDA compiler always includes clang wrapper headers.
It would be good to know if this would be interesting for non-AOT targets as well, there's a lot of logic in the driver to conditionally link libdevice libraries, I suspect in theory most of that could be replaced with this header approach, but I haven't looked into this much so I'm not 100% sure if this is something we'd want.
@AlexeySachkov, could you take into SPIR-V part, please?
The change looks to be aligned with the community approach. The only concern I have is compile time, but potential increase should be negligible.
cc @Naghasan just to keep in the loop.
clang/lib/AST/Decl.cpp
Outdated
| if (Context.getLangOpts().isSYCL() && hasAttr<SYCLDeviceOnlyAttr>() && | ||
| !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc)) { |
There was a problem hiding this comment.
If I get it right, we allow printf and malloc for all SYCL targets. I'm open to discuss if requiring printf support is reasonable, but I'm not sure if malloc can be supported by all SYCL targets.
There was a problem hiding this comment.
I think this is a copy/paste from the CUDA code just above, malloc shouldn't be there
clang/lib/AST/Decl.cpp
Outdated
| if (Context.getLangOpts().isSYCL() && hasAttr<SYCLDeviceOnlyAttr>() && | ||
| !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc)) { |
There was a problem hiding this comment.
I think this is a copy/paste from the CUDA code just above, malloc shouldn't be there
clang/lib/Sema/SemaOverload.cpp
Outdated
| @@ -1629,6 +1629,14 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, FunctionDecl *New, | |||
| } | |||
| } | |||
|
|
|||
| // Allow overloads with SYCLDeviceOnlyAttr | |||
| if (SemaRef.getLangOpts().isSYCL()) { | |||
| if (hasExplicitAttr<SYCLDeviceOnlyAttr>(Old) != | |||
There was a problem hiding this comment.
we shouldn't limit to explicit attr
There was a problem hiding this comment.
Updated all the hasExplicitAttr to hasAttr
clang/include/clang/Basic/Attr.td
Outdated
| def SYCLDeviceOnly : InheritableAttr { | ||
| let Spellings = [GNU<"sycl_device_only">]; | ||
| let Subjects = SubjectList<[Function]>; | ||
| let LangOpts = [SYCLIsDevice]; |
There was a problem hiding this comment.
| let LangOpts = [SYCLIsDevice]; | |
| let LangOpts = [SYCLIsHost, SYCLIsDevice]; |
otherwise this would create a warning during host compilation and the filtering is dead code
There was a problem hiding this comment.
Added SilentlyIgnoreSYCLIsHost instead, sycl_device had that and it sounds like it should suppress the warning you mention.
We don't support malloc in SYCL, silence warnings for host compilation with `sycl_device_only`. Fix failing clang test with new attribute.
Yeah in the driver here it does: CC1Args.push_back("-include");
CC1Args.push_back("__clang_cuda_runtime_wrapper.h");And Using our stl wrappers solution should allow us to be a little more conservative about when we include all of this stuff. |
This test was relying on the hack preventing LLVM intrinsics from being emitted so it doesn't work at all with the new approach.
This patch experiments with moving standard library math built-ins from libdevice into headers.
This is based on the way clang handles this for CUDA and HIP. In these languages you can define device functions as overloads. This allows re-defining standard library functions specifically for the device in a header, so that we can provide a device specific implementations of certain built-ins while still using the regular standard library headers.
By default SYCL doesn't do overloads for device functions, so this patch introduces a new
sycl_device_onlyattribute, this attribute will make a function device only and allow it to overload with existing functions.