[mlir:async] Use ODS to define async types

[ezhulenev]

Summary

Depends On D94923

Migrate Async dialect to ODS TypeDef

[rriddle]

mlir/lib/Dialect/Async/IR/Async.cpp

78

Remove commented out code.

[rriddle]

Nice cleanup!

[ezhulenev]

Omit empty ins and outs

[rriddle]

mlir/lib/Dialect/Async/IR/Async.cpp

64

You should be able to generate most of the parser/printer as well if you set the mnemonic on the TypeDef.

[ezhulenev]

Use ODS generated parser and printer

[ftynse]

nice!

mlir/include/mlir/Dialect/Async/IR/Async.h

 //===- Async.h - MLIR Async dialect -----------------------------*- C++ -*-===//
 //
 // 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 defines the async dialect that is used for modeling asynchronous
 // execution.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_ASYNC_IR_ASYNC_H
 #define MLIR_DIALECT_ASYNC_IR_ASYNC_H
 
+#include "mlir/Dialect/Async/IR/AsyncTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace async {
-
-namespace detail {
-struct ValueTypeStorage;
-} // namespace detail
-
 //===----------------------------------------------------------------------===//
-// Async dialect types.
+// Async Dialect
 //===----------------------------------------------------------------------===//
 
-/// The token type to represent asynchronous operation completion.
-class TokenType : public Type::TypeBase<TokenType, Type, TypeStorage> {
-public:
-  using Base::Base;
-};
-
-/// The value type to represent values returned from asynchronous operations.
-class ValueType
-    : public Type::TypeBase<ValueType, Type, detail::ValueTypeStorage> {
-public:
-  using Base::Base;
-
-  /// Get or create an async ValueType with the provided value type.
-  static ValueType get(Type valueType);
-
-  Type getValueType();
-};
-
-/// The group type to represent async tokens or values grouped together.
-class GroupType : public Type::TypeBase<GroupType, Type, TypeStorage> {
-public:
-  using Base::Base;
-};
+#include "mlir/Dialect/Async/IR/AsyncOpsDialect.h.inc"
 
 //===----------------------------------------------------------------------===//
-// LLVM coroutines types.
+// Async Dialect Operations
 //===----------------------------------------------------------------------===//
 
-/// The type identifying a switched-resume coroutine.
-class CoroIdType : public Type::TypeBase<CoroIdType, Type, TypeStorage> {
-public:
-  using Base::Base;
-};
-
-/// The coroutine handle type which is a pointer to the coroutine frame.
-class CoroHandleType
-    : public Type::TypeBase<CoroHandleType, Type, TypeStorage> {
-public:
-  using Base::Base;
-};
-
-/// The coroutine saved state type.
-class CoroStateType : public Type::TypeBase<CoroStateType, Type, TypeStorage> {
-public:
-  using Base::Base;
-};
+#define GET_OP_CLASSES
+#include "mlir/Dialect/Async/IR/AsyncOps.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Helper functions of Async dialect transformations.
 //===----------------------------------------------------------------------===//
 
-/// Returns true if the type is reference counted. All async dialect types are
-/// reference counted at runtime.
+namespace mlir {
+namespace async {
+
+/// Returns true if the type is reference counted at runtime.
 inline bool isRefCounted(Type type) {
   return type.isa<TokenType, ValueType, GroupType>();
 }
 
 } // namespace async
 } // namespace mlir
 
-#define GET_OP_CLASSES
-#include "mlir/Dialect/Async/IR/AsyncOps.h.inc"
-
-#include "mlir/Dialect/Async/IR/AsyncOpsDialect.h.inc"
-
 #endif // MLIR_DIALECT_ASYNC_IR_ASYNC_H

mlir/include/mlir/Dialect/Async/IR/AsyncDialect.td

+//===- AsyncDialect.td -------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Async dialect definition.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ASYNC_DIALECT_TD
+#define ASYNC_DIALECT_TD
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// Async dialect definitions
+//===----------------------------------------------------------------------===//
+
+def AsyncDialect : Dialect {
+  let name = "async";
+
+  let summary = "Types and operations for async dialect";
+  let description = [{
+    This dialect contains operations for modeling asynchronous execution.
+  }];
+
+  let cppNamespace = "::mlir::async";
+}
+
+#endif // ASYNC_DIALECT_TD

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

 //===- AsyncOps.td - Async operations definition -----------*- 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 is the operation definition file for Async dialect operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ASYNC_OPS
 #define ASYNC_OPS
 
-include "mlir/Dialect/Async/IR/AsyncBase.td"
+include "mlir/Dialect/Async/IR/AsyncDialect.td"
+include "mlir/Dialect/Async/IR/AsyncTypes.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // Async op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for the operation in this dialect
`async.execute` operation takes `async.token` dependencies and `async.value`
     token and value argument become ready. Unwrapped value passed to the
     attached body region as an %unwrapped value of f32 type.
   }];
 
   let arguments = (ins Variadic<Async_TokenType>:$dependencies,
                        Variadic<Async_AnyValueOrTokenType>:$operands);
 
   let results = (outs Async_TokenType:$token,
-                      Variadic<Async_AnyValueType>:$results);
+                      Variadic<Async_ValueType>:$results);
   let regions = (region SizedRegion<1>:$body);
 
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let verifier = [{ return ::verify(*this); }];
 
   let skipDefaultBuilders = 1;
   let builders = [
def Async_RuntimeStoreOp : Async_Op<"runtime.store",
                      "$_self.cast<ValueType>().getValueType()">]> {
   let summary = "stores the value into the runtime async.value";
   let description = [{
     The `async.runtime.store` operation stores the value into the runtime
     async.value storage.
   }];
 
   let arguments = (ins AnyType:$value,
-                       Async_AnyValueType:$storage);
+                       Async_ValueType:$storage);
   let results = (outs );
   let assemblyFormat = "$value `,` $storage attr-dict `:` type($storage)";
 }
 
 def Async_RuntimeLoadOp : Async_Op<"runtime.load",
       [TypesMatchWith<"type of 'value' matches element type of 'storage'",
                      "storage", "result",
                      "$_self.cast<ValueType>().getValueType()">]> {
   let summary = "loads the value from the runtime async.value";
   let description = [{
     The `async.runtime.load` operation loads the value from the runtime
     async.value storage.
   }];
 
-  let arguments = (ins Async_AnyValueType:$storage);
+  let arguments = (ins Async_ValueType:$storage);
   let results = (outs AnyType:$result);
   let assemblyFormat = "$storage attr-dict `:` type($storage)";
 }
 
 def Async_RuntimeAddToGroupOp : Async_Op<"runtime.add_to_group", []> {
   let summary = "adds and async token or value to the group";
   let description = [{
     The `async.runtime.add_to_group` adds an async token or value to the async

mlir/include/mlir/Dialect/Async/IR/AsyncTypes.h

+//===- AsyncTypes.h - Async Dialect Types -----------------------*- C++ -*-===//
+//
+// 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 defines the types for the Async dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_ASYNC_IR_ASYNCTYPES_H_
+#define MLIR_DIALECT_ASYNC_IR_ASYNCTYPES_H_
+
+#include "mlir/IR/Types.h"
+
+//===----------------------------------------------------------------------===//
+// Async Dialect Types
+//===----------------------------------------------------------------------===//
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/Async/IR/AsyncOpsTypes.h.inc"
+
+#endif // MLIR_DIALECT_ASYNC_IR_ASYNCTYPES_H_

mlir/include/mlir/Dialect/Async/IR/AsyncTypes.td

-//===- AsyncBase.td ----------------------------------------*- tablegen -*-===//
+//===- AsyncTypes.td - Async dialect types -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-// Base definitions for the `async` dialect.
+// This file declares the Async dialect types.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef ASYNC_BASE_TD
-#define ASYNC_BASE_TD
+#ifndef MLIR_DIALECT_ASYNC_IR_ASYNCTYPES
+#define MLIR_DIALECT_ASYNC_IR_ASYNCTYPES
 
-include "mlir/IR/OpBase.td"
+include "mlir/Dialect/Async/IR/AsyncDialect.td"
 
 //===----------------------------------------------------------------------===//
-// Async dialect definitions
+// Async Types
 //===----------------------------------------------------------------------===//
 
-def AsyncDialect : Dialect {
-  let name = "async";
-
-  let summary = "Types and operations for async dialect";
-  let description = [{
-    This dialect contains operations for modeling asynchronous execution.
-  }];
-
-  let cppNamespace = "::mlir::async";
+class Async_Type<string name, string typeMnemonic> : TypeDef<AsyncDialect,
+                                                             name> {
+  let mnemonic = typeMnemonic;
 }
 
-def Async_TokenType : DialectType<AsyncDialect,
-    CPred<"$_self.isa<::mlir::async::TokenType>()">, "token type">,
-    BuildableType<"$_builder.getType<::mlir::async::TokenType>()"> {
+def Async_TokenType : Async_Type<"Token", "token"> {
+  let summary = "async token type";
   let description = [{
     `async.token` is a type returned by asynchronous operations, and it becomes
-    `ready` when the asynchronous operations that created it is completed.
+    `available` when the asynchronous operations that created it is completed.
   }];
 }
 
-class Async_ValueType<Type type>
-    : DialectType<AsyncDialect,
-        And<[
-          CPred<"$_self.isa<::mlir::async::ValueType>()">,
-          SubstLeaves<"$_self",
-                      "$_self.cast<::mlir::async::ValueType>().getValueType()",
-                      type.predicate>
-       ]>, "async value type with " # type.summary # " underlying type"> {
+def Async_ValueType : Async_Type<"Value", "value"> {
+  let summary = "async value type";
   let description = [{
     `async.value` represents a value returned by asynchronous operations,
     which may or may not be available currently, but will be available at some
     point in the future.
   }];
 
-  Type valueType = type;
+  let parameters = (ins "Type":$valueType);
+  let builders = [
+    TypeBuilderWithInferredContext<(ins "Type":$valueType), [{
+      return Base::get(valueType.getContext(), valueType);
+    }], [{
+      return Base::getChecked($_loc, valueType);
+    }]>
+  ];
+  let skipDefaultBuilders = 1;
 }
 
-def Async_GroupType : DialectType<AsyncDialect,
-    CPred<"$_self.isa<::mlir::async::GroupType>()">, "group type">,
-    BuildableType<"$_builder.getType<::mlir::async::GroupType>()"> {
+def Async_GroupType : Async_Type<"Group", "group"> {
+  let summary = "async group type";
   let description = [{
     `async.group` represent a set of async tokens or values and allows to
     execute async operations on all of them together (e.g. wait for the
     completion of all/any of them).
   }];
 }
 
-def Async_AnyValueType : DialectType<AsyncDialect,
-                           CPred<"$_self.isa<::mlir::async::ValueType>()">,
-                                 "async value type">;
-
-def Async_AnyValueOrTokenType : AnyTypeOf<[Async_AnyValueType,
+def Async_AnyValueOrTokenType : AnyTypeOf<[Async_ValueType,
                                            Async_TokenType]>;
 
-def Async_AnyAsyncType : AnyTypeOf<[Async_AnyValueType,
+def Async_AnyAsyncType : AnyTypeOf<[Async_ValueType,
                                     Async_TokenType,
                                     Async_GroupType]>;
 
 //===----------------------------------------------------------------------===//
 // Types for lowering to LLVM + Async Runtime via the LLVM Coroutines.
 //===----------------------------------------------------------------------===//
 
 // LLVM coroutines intrinsics use `token` and `i8*` types to represent coroutine
 // identifiers and handles. To define type-safe Async Runtime operations and
 // build a properly typed intermediate IR during the Async to LLVM lowering we
 // define a separate types for values that can be produced by LLVM intrinsics.
 
-def Async_CoroIdType : DialectType<AsyncDialect,
-    CPred<"$_self.isa<::mlir::async::CoroIdType>()">, "coro.id type">,
-    BuildableType<"$_builder.getType<::mlir::async::CoroIdType>()"> {
+def Async_CoroIdType : Async_Type<"CoroId", "coro.id"> {
+  let summary = "switched-resume coroutine identifier";
   let description = [{
     `async.coro.id` is a type identifying a switched-resume coroutine.
   }];
 }
 
-def Async_CoroHandleType : DialectType<AsyncDialect,
-    CPred<"$_self.isa<::mlir::async::CoroHandleType>()">, "coro.handle type">,
-    BuildableType<"$_builder.getType<::mlir::async::CoroHandleType>()"> {
+def Async_CoroHandleType : Async_Type<"CoroHandle", "coro.handle"> {
+  let summary = "coroutine handle";
   let description = [{
     `async.coro.handle` is a handle to the coroutine (pointer to the coroutine
     frame) that can be passed around to resume or destroy the coroutine.
   }];
 }
 
-def Async_CoroStateType : DialectType<AsyncDialect,
-    CPred<"$_self.isa<::mlir::async::CoroStateType>()">, "coro.state type">,
-    BuildableType<"$_builder.getType<::mlir::async::CoroStateType>()"> {
+def Async_CoroStateType : Async_Type<"CoroState", "coro.state"> {
+  let summary = "saved coroutine state";
   let description = [{
     `async.coro.state` is a saved coroutine state that should be passed to the
     coroutine suspension operation.
   }];
 }
 
-#endif // ASYNC_BASE_TD
+#endif // MLIR_DIALECT_ASYNC_IR_ASYNCTYPES

mlir/lib/Dialect/Async/IR/Async.cpp

 using namespace mlir;
 using namespace mlir::async;
 
 void AsyncDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Async/IR/AsyncOps.cpp.inc"
       >();
-  addTypes<TokenType, ValueType, GroupType>();           // async types
-  addTypes<CoroIdType, CoroHandleType, CoroStateType>(); // coro types
+  addTypes<
+#define GET_TYPEDEF_LIST
+#include "mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc"
+      >();
 }
 
 /// Parse a type registered to this dialect.
 Type AsyncDialect::parseType(DialectAsmParser &parser) const {
   StringRef keyword;
   if (parser.parseKeyword(&keyword))
     return Type();
 
if (keyword == "coro.state")
     return CoroStateType::get(getContext());
 
   parser.emitError(parser.getNameLoc(), "unknown async type: ") << keyword;
   return Type();
 }
 
 /// Print a type registered to this dialect.
 void AsyncDialect::printType(Type type, DialectAsmPrinter &os) const {
   TypeSwitch<Type>(type)
       .Case<TokenType>([&](TokenType) { os << "token"; })
       .Case<ValueType>([&](ValueType valueTy) {
         os << "value<";
         os.printType(valueTy.getValueType());
         os << '>';
       })
       .Case<GroupType>([&](GroupType) { os << "group"; })
       .Case<CoroIdType>([&](CoroIdType) { os << "coro.id"; })
       .Case<CoroHandleType>([&](CoroHandleType) { os << "coro.handle"; })
       .Case<CoroStateType>([&](CoroStateType) { os << "coro.state"; })
       .Default([](Type) { llvm_unreachable("unexpected 'async' type kind"); });
 }
 
-//===----------------------------------------------------------------------===//
-/// ValueType
-//===----------------------------------------------------------------------===//
-
-namespace mlir {
-namespace async {
-namespace detail {
-
-// Storage for `async.value<T>` type, the only member is the wrapped type.
-struct ValueTypeStorage : public TypeStorage {
-  ValueTypeStorage(Type valueType) : valueType(valueType) {}
-
-  /// The hash key used for uniquing.
-  using KeyTy = Type;
-  bool operator==(const KeyTy &key) const { return key == valueType; }
-
-  /// Construction.
-  static ValueTypeStorage *construct(TypeStorageAllocator &allocator,
-                                     Type valueType) {
-    return new (allocator.allocate<ValueTypeStorage>())
-        ValueTypeStorage(valueType);
-  }
-
-  Type valueType;
-};
-
-} // namespace detail
-} // namespace async
-} // namespace mlir
-
-ValueType ValueType::get(Type valueType) {
-  return Base::get(valueType.getContext(), valueType);
-}
+// //===----------------------------------------------------------------------===//
+// /// ValueType
+// //===----------------------------------------------------------------------===//
+
+// namespace mlir {
+// namespace async {
+// namespace detail {
+
+// // Storage for `async.value<T>` type, the only member is the wrapped type.
+// struct ValueTypeStorage : public TypeStorage {
+//   ValueTypeStorage(Type valueType) : valueType(valueType) {}
+
+//   /// The hash key used for uniquing.
+//   using KeyTy = Type;
+//   bool operator==(const KeyTy &key) const { return key == valueType; }
+
+//   /// Construction.
+//   static ValueTypeStorage *construct(TypeStorageAllocator &allocator,
+//                                      Type valueType) {
+//     return new (allocator.allocate<ValueTypeStorage>())
+//         ValueTypeStorage(valueType);
+//   }
+
+//   Type valueType;
+// };
+
+// } // namespace detail
+// } // namespace async
+// } // namespace mlir
+
+// ValueType ValueType::get(Type valueType) {
+//   return Base::get(valueType.getContext(), valueType);
+// }
 
-Type ValueType::getValueType() { return getImpl()->valueType; }
+// Type ValueType::getValueType() { return getImpl()->valueType; }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(YieldOp op) {
   // Get the underlying value types from async values returned from the
   // parent `async.execute` operation.
if (*op.getResultType() != value.getValueType())
       return op.emitOpError()
              << "result type " << *op.getResultType()
              << " does not match async value type " << value.getValueType();
   }
 
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// TableGen'd op method definitions
+//===----------------------------------------------------------------------===//
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Async/IR/AsyncOps.cpp.inc"
+
+//===----------------------------------------------------------------------===//
+// TableGen'd type method definitions
+//===----------------------------------------------------------------------===//
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc"

mlir/test/Dialect/Async/verify.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s
 
 // FileCheck test must have at least one CHECK statement.
 // CHECK-LABEL: @no_op
 func @no_op(%arg0: !async.token) {
   return
 }
 
 // -----
 
 func @wrong_async_await_arg_type(%arg0: f32) {
-  // expected-error @+1 {{'async.await' op operand #0 must be async value type or token type, but got 'f32'}}
+  // expected-error @+1 {{'async.await' op operand #0 must be async value type or async token type, but got 'f32'}}
   async.await %arg0 : f32
 }
 
 // -----
 
 func @wrong_async_await_result_type(%arg0: !async.value<f32>) {
   // expected-error @+1 {{'async.await' op result type 'f64' does not match async value type 'f32'}}
   %0 = "async.await"(%arg0): (!async.value<f32>) -> f64
 }