[llvm-branch-commits] [mlir] [MLIR][OpenMP] Add `OpenMP_Clause` tablegen definitions (PR #92521)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri May 17 04:02:19 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir
Author: Sergio Afonso (skatrak)
<details>
<summary>Changes</summary>
This patch adds a new tablegen file for the OpenMP dialect containing the list of clauses currently supported.
---
Patch is 44.02 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/92521.diff
1 Files Affected:
- (added) mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td (+1183)
``````````diff
diff --git a/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
new file mode 100644
index 0000000000000..8b3a53a5842f3
--- /dev/null
+++ b/mlir/include/mlir/Dialect/OpenMP/OpenMPClauses.td
@@ -0,0 +1,1183 @@
+//=== OpenMPClauses.td - OpenMP dialect clause definitions -*- tablegen -*-===//
+//
+// 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 file contains clause definitions for the OpenMP dialect.
+//
+// For each "Xyz" clause, there is an "OpenMP_XyzClauseSkip" class and an
+// "OpenMP_XyzClause" definition. The latter is an instantiation of the former
+// where all "skip" template parameters are set to `false` and should be the
+// preferred variant to used whenever possible when defining `OpenMP_Op`
+// instances.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPENMP_CLAUSES
+#define OPENMP_CLAUSES
+
+include "mlir/Dialect/OpenMP/OpenMPOpBase.td"
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.11] `aligned` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_AlignedClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Variadic<OpenMP_PointerLikeType>:$aligned_vars,
+ OptionalAttr<I64ArrayAttr>:$alignment_values
+ );
+
+ let assemblyFormat = [{
+ `aligned` `(` custom<AlignedClause>($aligned_vars, type($aligned_vars),
+ $alignment_values) `)`
+ }];
+
+ let description = [{
+ The `alignment_values` attribute additionally specifies alignment of each
+ corresponding aligned operand. Note that `aligned_vars` and
+ `alignment_values` should contain the same number of elements.
+ }];
+}
+
+def OpenMP_AlignedClause : OpenMP_AlignedClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [6.6] `allocate` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_AllocateClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Variadic<AnyType>:$allocate_vars,
+ Variadic<AnyType>:$allocators_vars
+ );
+
+ let assemblyFormat = [{
+ `allocate` `(`
+ custom<AllocateAndAllocator>($allocate_vars, type($allocate_vars),
+ $allocators_vars, type($allocators_vars)) `)`
+ }];
+
+ let description = [{
+ The `allocators_vars` and `allocate_vars` parameters are a variadic list of
+ values that specify the memory allocator to be used to obtain storage for
+ private values.
+ }];
+}
+
+def OpenMP_AllocateClause : OpenMP_AllocateClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [16.1, 16.2] `cancel-directive-name` clause set
+//===----------------------------------------------------------------------===//
+
+class OpenMP_CancelDirectiveNameClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ CancellationConstructTypeAttr:$cancellation_construct_type_val
+ );
+
+ let assemblyFormat = [{
+ `cancellation_construct_type` `(`
+ custom<ClauseAttr>($cancellation_construct_type_val) `)`
+ }];
+
+ // TODO: Add description.
+}
+
+def OpenMP_CancelDirectiveNameClause : OpenMP_CancelDirectiveNameClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [4.4.3] `collapse` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_CollapseClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let traits = [
+ AllTypesMatch<["lowerBound", "upperBound", "step"]>
+ ];
+
+ let arguments = (ins
+ Variadic<IntLikeType>:$lowerBound,
+ Variadic<IntLikeType>:$upperBound,
+ Variadic<IntLikeType>:$step
+ );
+
+ let extraClassDeclaration = [{
+ /// Returns the number of loops in the loop nest.
+ unsigned getNumLoops() { return getLowerBound().size(); }
+ }];
+
+ // Description and formatting integrated in the `omp.loop_nest` operation,
+ // which is the only one currently accepting this clause.
+}
+
+def OpenMP_CollapseClause : OpenMP_CollapseClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.7.2] `copyprivate` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_CopyprivateClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Variadic<OpenMP_PointerLikeType>:$copyprivate_vars,
+ OptionalAttr<SymbolRefArrayAttr>:$copyprivate_funcs
+ );
+
+ let assemblyFormat = [{
+ `copyprivate` `(`
+ custom<CopyPrivateVarList>($copyprivate_vars, type($copyprivate_vars),
+ $copyprivate_funcs) `)`
+ }];
+
+ let description = [{
+ If `copyprivate` variables and functions are specified, then each thread
+ variable is updated with the variable value of the thread that executed
+ the single region, using the specified copy functions.
+ }];
+}
+
+def OpenMP_CopyprivateClause : OpenMP_CopyprivateClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [15.2] `critical` `name` argument
+//===----------------------------------------------------------------------===//
+
+class OpenMP_CriticalNameClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ SymbolNameAttr:$sym_name
+ );
+
+ let assemblyFormat = "$sym_name";
+
+ let description = [{
+ The `sym_name` can be used in `omp.critical` constructs in the dialect.
+ }];
+}
+
+def OpenMP_CriticalNameClause : OpenMP_CriticalNameClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [15.9.5] `depend` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_DependClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ OptionalAttr<TaskDependArrayAttr>:$depends,
+ Variadic<OpenMP_PointerLikeType>:$depend_vars
+ );
+
+ let assemblyFormat = [{
+ `depend` `(`
+ custom<DependVarList>($depend_vars, type($depend_vars), $depends) `)`
+ }];
+
+ let description = [{
+ The `depends` and `depend_vars` arguments are variadic lists of values that
+ specify the dependencies of this particular task in relation to other tasks.
+ }];
+}
+
+def OpenMP_DependClause : OpenMP_DependClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [13.2] `device` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_DeviceClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Optional<AnyInteger>:$device
+ );
+
+ let assemblyFormat = [{
+ `device` `(` $device `:` type($device) `)`
+ }];
+
+ let description = [{
+ The optional `device` parameter specifies the device number for the target
+ region.
+ }];
+}
+
+def OpenMP_DeviceClause : OpenMP_DeviceClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [11.6.1] `dist_schedule` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_DistScheduleClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ UnitAttr:$dist_schedule_static,
+ Optional<IntLikeType>:$chunk_size
+ );
+
+ let assemblyFormat = [{
+ `dist_schedule_static` $dist_schedule_static
+ | `chunk_size` `(` $chunk_size `:` type($chunk_size) `)`
+ }];
+
+ let description = [{
+ The `dist_schedule_static` attribute specifies the schedule for this loop,
+ determining how the loop is distributed across the various teams. The
+ optional `chunk_size` associated with this determines further controls this
+ distribution.
+ }];
+}
+
+def OpenMP_DistScheduleClause : OpenMP_DistScheduleClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [15.9.6] `doacross` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_DoacrossClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/true, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ OptionalAttr<ClauseDependAttr>:$depend_type_val,
+ ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
+ Variadic<AnyType>:$depend_vec_vars
+ );
+
+ let assemblyFormat = [{
+ ( `depend_type` `` $depend_type_val^ )?
+ ( `depend_vec` `(` $depend_vec_vars^ `:` type($depend_vec_vars) `)` )?
+ }];
+
+ let description = [{
+ The `depend_type_val` attribute refers to either the DEPEND(SOURCE) clause
+ or the DEPEND(SINK: vec) clause.
+
+ The `num_loops_val` attribute specifies the number of loops in the doacross
+ nest.
+
+ The `depend_vec_vars` is a variadic list of operands that specifies the
+ index of the loop iterator in the doacross nest for the DEPEND(SOURCE)
+ clause or the index of the element of "vec" for the DEPEND(SINK: vec)
+ clause. It contains the operands in multiple "vec" when multiple
+ DEPEND(SINK: vec) clauses exist in one ORDERED directive.
+ }];
+}
+
+def OpenMP_DoacrossClause : OpenMP_DoacrossClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [12.3] `final` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_FinalClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Optional<I1>:$final_expr
+ );
+
+ let assemblyFormat = [{
+ `final` `(` $final_expr `)`
+ }];
+
+ let description = [{
+ When a `final` clause is present and the `final` clause expression evaluates
+ to `true`, the generated tasks will be final tasks. All task constructs
+ encountered during execution of a final task will generate final and
+ included tasks. The use of a variable in a `final` clause expression causes
+ an implicit reference to the variable in all enclosing constructs.
+ }];
+}
+
+def OpenMP_FinalClause : OpenMP_FinalClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [12.6.1] `grainsize` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_GrainsizeClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Optional<IntLikeType>:$grain_size
+ );
+
+ let assemblyFormat = [{
+ `grain_size` `(` $grain_size `:` type($grain_size) `)`
+ }];
+
+ let description = [{
+ If a `grainsize` clause is present, the number of logical loop iterations
+ assigned to each generated task is greater than or equal to the minimum of
+ the value of the grain-size expression and the number of logical loop
+ iterations, but less than two times the value of the grain-size expression.
+ }];
+}
+
+def OpenMP_GrainsizeClause : OpenMP_GrainsizeClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.4.9] `has_device_addr` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_HasDeviceAddrClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Variadic<OpenMP_PointerLikeType>:$has_device_addr
+ );
+
+ let assemblyFormat = [{
+ `has_device_addr` `(` $has_device_addr `:` type($has_device_addr) `)`
+ }];
+
+ let description = [{
+ The optional `has_device_addr` indicates that list items already have device
+ addresses, so they may be directly accessed from the target device. This
+ includes array sections.
+ }];
+}
+
+def OpenMP_HasDeviceAddrClause : OpenMP_HasDeviceAddrClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [15.1.2] `hint` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_HintClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ DefaultValuedOptionalAttr<I64Attr, "0">:$hint_val
+ );
+
+ let assemblyFormat = [{
+ `hint` `(` custom<SynchronizationHint>($hint_val) `)`
+ }];
+
+ let description = [{
+ `hint` is the value of hint (as specified in the hint clause). It is a
+ compile time constant. As the name suggests, this is just a hint for
+ optimization.
+ }];
+}
+
+def OpenMP_HintClause : OpenMP_HintClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [3.4] `if` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_IfClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Optional<I1>:$if_expr
+ );
+
+ let assemblyFormat = [{
+ `if` `(` $if_expr `)`
+ }];
+
+ // Description varies depending on the operation.
+}
+
+def OpenMP_IfClause : OpenMP_IfClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.5.10] `in_reduction` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_InReductionClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let traits = [
+ ReductionClauseInterface
+ ];
+
+ let arguments = (ins
+ Variadic<OpenMP_PointerLikeType>:$in_reduction_vars,
+ OptionalAttr<SymbolRefArrayAttr>:$in_reductions
+ );
+
+ let assemblyFormat = [{
+ `in_reduction` `(`
+ custom<ReductionVarList>($in_reduction_vars, type($in_reduction_vars),
+ $in_reductions) `)`
+ }];
+
+ let extraClassDeclaration = [{
+ /// Returns the reduction variables.
+ SmallVector<Value> getReductionVars() {
+ return SmallVector<Value>(getInReductionVars().begin(),
+ getInReductionVars().end());
+ }
+ }];
+
+ // Description varies depending on the operation.
+}
+
+def OpenMP_InReductionClause : OpenMP_InReductionClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.4.7] `is_device_ptr` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_IsDevicePtrClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Variadic<OpenMP_PointerLikeType>:$is_device_ptr
+ );
+
+ let assemblyFormat = [{
+ `is_device_ptr` `(` $is_device_ptr `:` type($is_device_ptr) `)`
+ }];
+
+ let description = [{
+ The optional `is_device_ptr` indicates list items are device pointers.
+ }];
+}
+
+def OpenMP_IsDevicePtrClause : OpenMP_IsDevicePtrClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.4.6] `linear` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_LinearClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat = false,
+ bit description = false, bit extraClassDeclaration = false
+ > : OpenMP_Clause</*isRequired=*/false, traits, arguments, assemblyFormat,
+ description, extraClassDeclaration> {
+ let arguments = (ins
+ Variadic<AnyType>:$linear_vars,
+ Variadic<I32>:$linear_step_vars
+ );
+
+ let assemblyFormat = [{
+ `linear` `(`
+ custom<LinearClause>($linear_vars, type($linear_vars),
+ $linear_step_vars) `)`
+ }];
+
+ let description = [{
+ The `linear_step_vars` operand additionally specifies the step for each
+ associated linear operand. Note that the `linear_vars` and
+ `linear_step_vars` variadic lists should contain the same number of
+ elements.
+ }];
+}
+
+def OpenMP_LinearClause : OpenMP_LinearClauseSkip<>;
+
+//===----------------------------------------------------------------------===//
+// V5.2: [5.8.3] `map` clause
+//===----------------------------------------------------------------------===//
+
+class OpenMP_MapClauseSkip<
+ bit traits = false, bit arguments = false, bit assemblyFormat =...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/92521
More information about the llvm-branch-commits
mailing list