[cfe-dev] [OpenCL] Representing kernel attributes by LLVM target-dependent attribute-value pairs instead of metadata
Liu, Yaxun (Sam) via cfe-dev
cfe-dev at lists.llvm.org
Thu Jun 2 14:24:20 PDT 2016
How about following Tom's suggestion and representing reqd_work_group_size, work_group_size_hint and vector_type_hint as target-dependent function attributes, whereas representing kernel argument metadata as function metadata.
Since the former affects optimization of the code whereas the latter is mostly for reflection.
Thanks.
Sam
-----Original Message-----
From: Liu, Yaxun (Sam)
Sent: Wednesday, June 1, 2016 5:53 PM
To: 'Anastasia Stulova' <Anastasia.Stulova at arm.com>; 'Tom Stellard' <tom at stellard.net>
Cc: 'cfe-dev (cfe-dev at lists.llvm.org)' <cfe-dev at lists.llvm.org>; 'Pan, Xiuli' <xiuli.pan at intel.com>; 'Bader, Alexey (alexey.bader at intel.com)' <alexey.bader at intel.com>; Mekhanoshin, Stanislav <Stanislav.Mekhanoshin at amd.com>; Stellard, Thomas <Tom.Stellard at amd.com>; Sumner, Brian <Brian.Sumner at amd.com>; 'nd' <nd at arm.com>
Subject: RE: [cfe-dev] [OpenCL] Representing kernel attributes by LLVM target-dependent attribute-value pairs instead of metadata
I did a comparison between target-dependent function attributes and function metadata.
Here is an example of setting or adding a target-dependent function attribute,
std::string S;
llvm::raw_string_ostream SS(S);
SS << x << " " << y << " " << z;
F.setAttributes(F.getAttributes().addAttribute(Ctx, AttributeSet::FunctionIndex, "work_group_size_hint", SS.str());
To set or add a function metadata,
llvm::Metadata *MDs[] = {
llvm::ConstantAsMetadata::get(Builder.getInt32(x)),
llvm::ConstantAsMetadata::get(Builder.getInt32(y)),
llvm::ConstantAsMetadata::get(Builder.getInt32(z))};
F.setMetadata("work_group_size_hint", llvm::MDNode::get(Context, MDs));
Sometimes a kernel function is modified to insert a new argument, then the kernel argument metadata needs to be updated. For kernel attribute, the following needs to be done:
* insert info for the new argument into the string
* update the function attribute
For function metadata, since we cannot add insert a new operand into an existing MDNode, the following needs to be done
* the operands of the old MDNode need to be put into a vector of Metadata
* create a new Metadata for the new argument and insert it into the vector
* create a new MDNode with the vector
* set the new MDNode to the function
For readability of LLVM assembly, function attribute is easier to read since the name and the value stay together, e.g.
void f(int, int) #1
#1 = {"work_group_size_hint"="1 1 1", "kernel_arg_type"="int int", ...}
Whereas the operands of function metadata are scattered, e.g
void f(int, int) !work_group_size_hint !1 !kernel_arg_type !2 !1= {!1 !1 !1} !2={!"int" !"int"}
However this may be less important.
Sam
-----Original Message-----
From: Liu, Yaxun (Sam)
Sent: Monday, May 30, 2016 2:03 PM
To: Anastasia Stulova <Anastasia.Stulova at arm.com>; Tom Stellard <tom at stellard.net>
Cc: cfe-dev (cfe-dev at lists.llvm.org) <cfe-dev at lists.llvm.org>; Pan, Xiuli <xiuli.pan at intel.com>; Bader, Alexey (alexey.bader at intel.com) <alexey.bader at intel.com>; Mekhanoshin, Stanislav <Stanislav.Mekhanoshin at amd.com>; Stellard, Thomas <Tom.Stellard at amd.com>; Sumner, Brian <Brian.Sumner at amd.com>; nd <nd at arm.com>
Subject: RE: [cfe-dev] [OpenCL] Representing kernel attributes by LLVM target-dependent attribute-value pairs instead of metadata
>> If the kernel_arg_type is optional, we will not be able to know that a sampler type kernel argument is a sampler type, since it becomes int type in LLVM. Is that OK for the backend and runtime?
> Would representing as metadata help here?
It is OK as long as it is not dropped by some passes before consumed by the backend.
Sam
-----Original Message-----
From: Anastasia Stulova [mailto:Anastasia.Stulova at arm.com]
Sent: Wednesday, May 25, 2016 12:04 PM
To: Liu, Yaxun (Sam) <Yaxun.Liu at amd.com>; Tom Stellard <tom at stellard.net>
Cc: cfe-dev (cfe-dev at lists.llvm.org) <cfe-dev at lists.llvm.org>; Pan, Xiuli <xiuli.pan at intel.com>; Bader, Alexey (alexey.bader at intel.com) <alexey.bader at intel.com>; Mekhanoshin, Stanislav <Stanislav.Mekhanoshin at amd.com>; Stellard, Thomas <Tom.Stellard at amd.com>; Sumner, Brian <Brian.Sumner at amd.com>; nd <nd at arm.com>
Subject: RE: [cfe-dev] [OpenCL] Representing kernel attributes by LLVM target-dependent attribute-value pairs instead of metadata
I agree with Tom that the function metadata seems to be more appropriate for this purpose.
> If the kernel_arg_type is optional, we will not be able to know that a sampler type kernel argument is a sampler type, since it becomes int type in LLVM. Is that OK for the backend and runtime?
Would representing as metadata help here?
-----Original Message-----
From: Liu, Yaxun (Sam) [mailto:Yaxun.Liu at amd.com]
Sent: 13 May 2016 15:18
To: Tom Stellard
Cc: cfe-dev (cfe-dev at lists.llvm.org); Anastasia Stulova; Pan, Xiuli; Bader, Alexey (alexey.bader at intel.com); Mekhanoshin, Stanislav; Stellard, Thomas; Sumner, Brian
Subject: RE: [cfe-dev] [OpenCL] Representing kernel attributes by LLVM target-dependent attribute-value pairs instead of metadata
If the kernel_arg_type is optional, we will not be able to know that a sampler type kernel argument is a sampler type, since it becomes int type in LLVM. Is that OK for the backend and runtime?
Thanks.
Sam
-----Original Message-----
From: Tom Stellard [mailto:tom at stellard.net]
Sent: Thursday, May 12, 2016 11:55 AM
To: Liu, Yaxun (Sam) <Yaxun.Liu at amd.com>
Cc: cfe-dev (cfe-dev at lists.llvm.org) <cfe-dev at lists.llvm.org>; 'anastasia.stulova at arm.com' <anastasia.stulova at arm.com>; Pan, Xiuli <xiuli.pan at intel.com>; Bader, Alexey (alexey.bader at intel.com) <alexey.bader at intel.com>; Mekhanoshin, Stanislav <Stanislav.Mekhanoshin at amd.com>; Stellard, Thomas <Tom.Stellard at amd.com>; Sumner, Brian <Brian.Sumner at amd.com>
Subject: Re: [cfe-dev] [OpenCL] Representing kernel attributes by LLVM target-dependent attribute-value pairs instead of metadata
On Mon, May 09, 2016 at 08:05:11PM +0000, Liu, Yaxun (Sam) via cfe-dev wrote:
> Hi,
>
> When SPIR 1.2/2.0 spec was developed, there was no target-dependent attribute-value pair in LLVM. As such, kernel attributes were represented as metadata.
>
> This caused lots of inconvenience since these metadata are difficult to manipulate/change when kernel functions went through transformations in backends.
>
> Now LLVM supports target-dependent attribute-value pair, I am wondering whether it is time to use that to represent kernel attributes.
>
> e.g. something like (just to give an idea, not exact llvm IR)
>
> kernel void foo(global int*a, sampler_t s); #1
> #1 = {
> reqd_work_group_size="1 1 1",
> kernel_arg_type="int *, sampler_t",
> ...
> }
I don't really think the argument type information should be included in the target attributes. It's optional information that the backend doesn't need. It seems like metadata is more appropriate.
-Tom
>
> basically we keep the info conveyed by the original metadata but attach them to the kernel function as attribute/value pair. This will make these attributes much easier to manipulate/change.
>
> Any feedbacks? Thanks.
>
> Sam
> _______________________________________________
> cfe-dev mailing list
> cfe-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-dev
More information about the cfe-dev
mailing list