This is an archive of the discontinued LLVM Phabricator instance.

Differential D87060

[mlir][Toy] Update the tutorial to use tablegen for dialect declarations
ClosedPublic

Authored by rriddle on Sep 2 2020, 3:27 PM.

Details

Reviewers
mehdi_amini
jpienaar
bollu
Commits
rGee7486059786: [mlir][Toy] Update the tutorial to use tablegen for dialect declarations
Summary

This was missed when the feature was originally added.

Diff Detail

Event Timeline

rriddle created this revision.Sep 2 2020, 3:27 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 2 2020, 3:27 PM
Herald added subscribers: msifontes, jurahul, Kayjukh and 10 others. · View Herald Transcript
rriddle requested review of this revision.Sep 2 2020, 3:27 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald TranscriptSep 2 2020, 3:27 PM
Harbormaster completed remote builds in B70474: Diff 289588.Sep 2 2020, 4:33 PM
mehdi_amini accepted this revision.Sep 4 2020, 11:41 PM

Thanks!

mlir/docs/Tutorials/Toy/Ch-2.md
213

context.loadDialect?

216–217

This sentence is outdated

mlir/docs/Tutorials/Toy/Ch-7.md
194

I think you should remove expose here?

This revision is now accepted and ready to land.Sep 4 2020, 11:41 PM
jpienaar accepted this revision.Sep 5 2020, 9:21 AM
jpienaar added inline comments.
mlir/examples/toy/Ch2/mlir/Dialect.cpp
28

Instead of custom, dialect. This is where dialect types and operations are registered.

Closed by commit rGee7486059786: [mlir][Toy] Update the tutorial to use tablegen for dialect declarations (authored by rriddle). · Explain WhyMar 17 2021, 5:42 PM
This revision was automatically updated to reflect the committed changes.
rriddle marked 4 inline comments as done.
rriddle added a commit: rGee7486059786: [mlir][Toy] Update the tutorial to use tablegen for dialect declarations.
Herald added a reviewer: bollu. · View Herald TranscriptMar 17 2021, 5:42 PM
Herald added subscribers: dcaballe, cota, teijeong and 2 others. · View Herald Transcript

Revision Contents

PathSize
mlir/
docs/
Tutorials/
Toy/
65 lines
43 lines
examples/
toy/
Ch2/
include/
toy/
1 line
15 lines
mlir/
7 lines
Ch3/
include/
toy/
1 line
15 lines
mlir/
7 lines
Ch4/
include/
toy/
1 line
15 lines
mlir/
7 lines
Ch5/
include/
toy/
1 line
15 lines
mlir/
7 lines
Ch6/
include/
toy/
1 line
15 lines
mlir/
7 lines
Ch7/
include/
toy/
1 line
26 lines
10 lines
mlir/
7 lines

Diff 289588

mlir/docs/Tutorials/Toy/Ch-2.md

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
provide an easy avenue for high-level analysis and transformation. provide an easy avenue for high-level analysis and transformation.
```c++ ```c++
/// This is the definition of the Toy dialect. A dialect inherits from /// This is the definition of the Toy dialect. A dialect inherits from
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// mlir::Dialect and registers custom attributes, operations, and types (in its
/// constructor). It can also override virtual methods to change some general /// constructor). It can also override virtual methods to change some general
/// behavior, which will be demonstrated in later chapters of the tutorial. /// behavior, which will be demonstrated in later chapters of the tutorial.
class ToyDialect : public mlir::Dialect { class ToyDialect : public mlir::Dialect {
public: public:
explicit ToyDialect(mlir::MLIRContext *ctx); explicit ToyDialect(mlir::MLIRContext *ctx);
/// Provide a utility accessor to the dialect namespace. This is used by /// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities. /// several utilities.
static llvm::StringRef getDialectNamespace() { return "toy"; } static llvm::StringRef getDialectNamespace() { return "toy"; }
/// An initializer called from the constructor of ToyDialect that is used to
/// register operations, types, and more within the Toy dialect.
void initialize();
}; };
``` ```
The dialect can now be registered in the global registry: This is the C++ definition of a dialect, but MLIR also supports defining
dialects declaratively via tablegen. Using the declarative specification is much
cleaner as it removes the need for a large portion of the boilerplate when
defining a new dialect. In the declarative format, the toy dialect would be
specified as:
```tablegen
// Provide a definition of the 'toy' dialect in the ODS framework so that we
// can define our operations.
def Toy_Dialect : Dialect {
// The namespace of our dialect, this corresponds 1-1 with the string we
// provided in `ToyDialect::getDialectNamespace`.
let name = "toy";
// The C++ namespace that the dialect class definition resides in.
let cppNamespace = "toy";
}
```
To see what this generates, we can run the `mlir-tblgen` command with the
`gen-dialect-decls` action like so:
```shell
${build_root}/bin/mlir-tblgen -gen-dialect-decls ${mlir_src_root}/examples/toy/Ch2/include/toy/Ops.td -I ${mlir_src_root}/include/
```
The dialect can now be loaded into an MLIRContext:
```c++ ```c++
mlir::registerDialect<ToyDialect>(); context.getOrLoadDialect<ToyDialect>();
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

context.loadDialect?

mehdi_amini: `context.loadDialect`?
``` ```
Any new `MLIRContext` created from now on will contain an instance of the Toy Any new `MLIRContext` created from now on will contain an instance of the Toy
dialect and invoke specific hooks for things like parsing attributes and types. dialect and invoke specific hooks for things like parsing attributes and types.
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

This sentence is outdated

mehdi_amini: This sentence is outdated
## Defining Toy Operations ## Defining Toy Operations
Now that we have a `Toy` dialect, we can start registering operations. This will Now that we have a `Toy` dialect, we can start registering operations. This will
allow for providing semantic information that the rest of the system can hook allow for providing semantic information that the rest of the system can hook
into. Let's walk through the creation of the `toy.constant` operation: into. Let's walk through the creation of the `toy.constant` operation:
```mlir ```mlir
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines public:
static void build(mlir::OpBuilder &builder, mlir::OperationState &state, static void build(mlir::OpBuilder &builder, mlir::OperationState &state,
mlir::DenseElementsAttr value); mlir::DenseElementsAttr value);
/// Build a constant by broadcasting the given 'value'. /// Build a constant by broadcasting the given 'value'.
static void build(mlir::OpBuilder &builder, mlir::OperationState &state, static void build(mlir::OpBuilder &builder, mlir::OperationState &state,
double value); double value);
}; };
``` ```
and we register this operation in the `ToyDialect` constructor: and we register this operation in the `ToyDialect` initializer:
```c++ ```c++
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx) {
addOperations<ConstantOp>(); addOperations<ConstantOp>();
} }
``` ```
### Op vs Operation: Using MLIR Operations ### Op vs Operation: Using MLIR Operations
Now that we have defined an operation, we will want to access and Now that we have defined an operation, we will want to access and
transform it. In MLIR, there are two main classes related to transform it. In MLIR, there are two main classes related to
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
regarding an operation are specified concisely into a TableGen record, which regarding an operation are specified concisely into a TableGen record, which
will be expanded into an equivalent `mlir::Op` C++ template specialization at will be expanded into an equivalent `mlir::Op` C++ template specialization at
compile time. Using the ODS framework is the desired way for defining operations compile time. Using the ODS framework is the desired way for defining operations
in MLIR given the simplicity, conciseness, and general stability in the face of in MLIR given the simplicity, conciseness, and general stability in the face of
C++ API changes. C++ API changes.
Lets see how to define the ODS equivalent of our ConstantOp: Lets see how to define the ODS equivalent of our ConstantOp:
The first thing to do is to define a link to the Toy dialect that we defined in Operations in ODS are defined by inheriting from the `Op` class. To simplify our
C++. This is used to link all of the operations that we will define to our operation definitions, we will define a base class for operations in the Toy
dialect: dialect.
```tablegen
// Provide a definition of the 'toy' dialect in the ODS framework so that we
// can define our operations.
def Toy_Dialect : Dialect {
// The namespace of our dialect, this corresponds 1-1 with the string we
// provided in `ToyDialect::getDialectNamespace`.
let name = "toy";
// The C++ namespace that the dialect class definition resides in.
let cppNamespace = "toy";
}
```
Now that we have defined a link to the Toy dialect, we can start defining
operations. Operations in ODS are defined by inheriting from the `Op` class. To
simplify our operation definitions, we will define a base class for operations
in the Toy dialect.
```tablegen ```tablegen
// Base class for toy dialect operations. This operation inherits from the base // Base class for toy dialect operations. This operation inherits from the base
// `Op` class in OpBase.td, and provides: // `Op` class in OpBase.td, and provides:
// * The parent dialect of the operation. // * The parent dialect of the operation.
// * The mnemonic for the operation, or the name without the dialect prefix. // * The mnemonic for the operation, or the name without the dialect prefix.
// * A list of traits for the operation. // * A list of traits for the operation.
class Toy_Op<string mnemonic, list<OpTrait> traits = []> : class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

mlir/docs/Tutorials/Toy/Ch-7.md

Show First 20 Lines • Show All 171 Lines • ▼ Show 20 Lines llvm::ArrayRef<mlir::Type> getElementTypes() {
return getImpl()->elementTypes; return getImpl()->elementTypes;
} }
/// Returns the number of element type held by this struct. /// Returns the number of element type held by this struct.
size_t getNumElementTypes() { return getElementTypes().size(); } size_t getNumElementTypes() { return getElementTypes().size(); }
}; };
``` ```
We register this type in the `ToyDialect` constructor in a similar way to how we We register this type in the `ToyDialect` initializer in a similar way to how we
did with operations: did with operations:
```c++ ```c++
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx) {
addTypes<StructType>(); addTypes<StructType>();
} }
``` ```
With this we can now use our `StructType` when generating MLIR from Toy. See With this we can now use our `StructType` when generating MLIR from Toy. See
examples/toy/Ch7/mlir/MLIRGen.cpp for more details. examples/toy/Ch7/mlir/MLIRGen.cpp for more details.
### Exposing to ODS
After defining a new type, we should expose make the ODS framework aware of our
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

I think you should remove expose here?

mehdi_amini: I think you should remove `expose` here?
Type so that we can use it in the operation definitions and auto-generate
utilities within the Dialect. A simple example is shown below:
```tablegen
// Provide a definition for the Toy StructType for use in ODS. This allows for
// using StructType in a similar way to Tensor or MemRef. We use `DialectType`
// to demarcate the StructType as belonging to the Toy dialect.
def Toy_StructType :
DialectType<Toy_Dialect, CPred<"$_self.isa<StructType>()">,
"Toy struct type">;
// Provide a definition of the types that are used within the Toy dialect.
def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>;
```
### Parsing and Printing ### Parsing and Printing
At this point we can use our `StructType` during MLIR generation and At this point we can use our `StructType` during MLIR generation and
transformation, but we can't output or parse `.mlir`. For this we need to add transformation, but we can't output or parse `.mlir`. For this we need to add
support for parsing and printing instances of the `StructType`. This can be done support for parsing and printing instances of the `StructType`. This can be done
by overriding the `parseType` and `printType` methods on the `ToyDialect`. by overriding the `parseType` and `printType` methods on the `ToyDialect`.
Declarations for these methods are automatically provided when the type is
exposed to ODS as detailed in the previous section.
```c++ ```c++
class ToyDialect : public mlir::Dialect { class ToyDialect : public mlir::Dialect {
public: public:
/// Parse an instance of a type registered to the toy dialect. /// Parse an instance of a type registered to the toy dialect.
mlir::Type parseType(mlir::DialectAsmParser &parser) const override; mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
/// Print an instance of a type registered to the toy dialect. /// Print an instance of a type registered to the toy dialect.
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
### Operating on `StructType` ### Operating on `StructType`
Now that the `struct` type has been defined, and we can round-trip it through Now that the `struct` type has been defined, and we can round-trip it through
the IR. The next step is to add support for using it within our operations. the IR. The next step is to add support for using it within our operations.
#### Updating Existing Operations #### Updating Existing Operations
A few of our existing operations will need to be updated to handle `StructType`. A few of our existing operations, e.g. `ReturnOp`, will need to be updated to
The first step is to make the ODS framework aware of our Type so that we can use handle `Toy_StructType`.
it in the operation definitions. A simple example is shown below:
```tablegen
// Provide a definition for the Toy StructType for use in ODS. This allows for
// using StructType in a similar way to Tensor or MemRef.
def Toy_StructType :
Type<CPred<"$_self.isa<StructType>()">, "Toy struct type">;
// Provide a definition of the types that are used within the Toy dialect.
def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>;
```
We can then update our operations, e.g. `ReturnOp`, to also accept the
`Toy_StructType`:
```tablegen ```tablegen
def ReturnOp : Toy_Op<"return", [Terminator, HasParent<"FuncOp">]> { def ReturnOp : Toy_Op<"return", [Terminator, HasParent<"FuncOp">]> {
... ...
let arguments = (ins Variadic<Toy_Type>:$input); let arguments = (ins Variadic<Toy_Type>:$input);
... ...
} }
``` ```
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

mlir/examples/toy/Ch2/include/toy/CMakeLists.txt

set(LLVM_TARGET_DEFINITIONS Ops.td) set(LLVM_TARGET_DEFINITIONS Ops.td)
mlir_tablegen(Ops.h.inc -gen-op-decls) mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs) mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
add_public_tablegen_target(ToyCh2OpsIncGen) add_public_tablegen_target(ToyCh2OpsIncGen)

mlir/examples/toy/Ch2/include/toy/Dialect.h

Show All 15 Lines
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/Function.h" #include "mlir/IR/Function.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
namespace mlir { namespace mlir {
namespace toy { namespace toy {
/// This is the definition of the Toy dialect. A dialect inherits from /// Include the auto-generated header file containing the declaration of the toy
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// dialect.
/// constructor). It can also override some general behavior exposed via virtual #include "toy/Dialect.h.inc"
/// methods.
class ToyDialect : public mlir::Dialect {
public:
explicit ToyDialect(mlir::MLIRContext *ctx);
/// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities for casting between dialects.
static llvm::StringRef getDialectNamespace() { return "toy"; }
};
/// Include the auto-generated header file containing the declarations of the /// Include the auto-generated header file containing the declarations of the
/// toy operations. /// toy operations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "toy/Ops.h.inc" #include "toy/Ops.h.inc"
} // end namespace toy } // end namespace toy
} // end namespace mlir } // end namespace mlir
#endif // MLIR_TUTORIAL_TOY_DIALECT_H_ #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch2/mlir/Dialect.cpp

Show All 18 Lines
using namespace mlir; using namespace mlir;
using namespace mlir::toy; using namespace mlir::toy;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyDialect // ToyDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Dialect creation, the instance will be owned by the context. This is the /// Dialect initialization, the instance will be owned by the context. This is
/// point of registration of custom types and operations for the dialect. /// the point of registration of custom types and operations for the dialect.
jpienaarUnsubmitted
Done
ReplyInline Actions

Instead of custom, dialect. This is where dialect types and operations are registered.

jpienaar: Instead of custom, dialect. This is where dialect types and operations are registered.
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "toy/Ops.cpp.inc" #include "toy/Ops.cpp.inc"
>(); >();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Toy Operations // Toy Operations
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

mlir/examples/toy/Ch3/include/toy/CMakeLists.txt

set(LLVM_TARGET_DEFINITIONS Ops.td) set(LLVM_TARGET_DEFINITIONS Ops.td)
mlir_tablegen(Ops.h.inc -gen-op-decls) mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs) mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
add_public_tablegen_target(ToyCh3OpsIncGen) add_public_tablegen_target(ToyCh3OpsIncGen)

mlir/examples/toy/Ch3/include/toy/Dialect.h

Show All 15 Lines
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/IR/Function.h" #include "mlir/IR/Function.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
namespace mlir { namespace mlir {
namespace toy { namespace toy {
/// This is the definition of the Toy dialect. A dialect inherits from /// Include the auto-generated header file containing the declaration of the toy
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// dialect.
/// constructor). It can also override some general behavior exposed via virtual #include "toy/Dialect.h.inc"
/// methods.
class ToyDialect : public mlir::Dialect {
public:
explicit ToyDialect(mlir::MLIRContext *ctx);
/// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities for casting between dialects.
static llvm::StringRef getDialectNamespace() { return "toy"; }
};
/// Include the auto-generated header file containing the declarations of the /// Include the auto-generated header file containing the declarations of the
/// toy operations. /// toy operations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "toy/Ops.h.inc" #include "toy/Ops.h.inc"
} // end namespace toy } // end namespace toy
} // end namespace mlir } // end namespace mlir
#endif // MLIR_TUTORIAL_TOY_DIALECT_H_ #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch3/mlir/Dialect.cpp

Show All 18 Lines
using namespace mlir; using namespace mlir;
using namespace mlir::toy; using namespace mlir::toy;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyDialect // ToyDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Dialect creation, the instance will be owned by the context. This is the /// Dialect initialization, the instance will be owned by the context. This is
/// point of registration of custom types and operations for the dialect. /// the point of registration of custom types and operations for the dialect.
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "toy/Ops.cpp.inc" #include "toy/Ops.cpp.inc"
>(); >();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Toy Operations // Toy Operations
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

mlir/examples/toy/Ch4/include/toy/CMakeLists.txt

# Most dialects should use add_mlir_dialect(). See examples/standalone. # Most dialects should use add_mlir_dialect(). See examples/standalone.
set(LLVM_TARGET_DEFINITIONS Ops.td) set(LLVM_TARGET_DEFINITIONS Ops.td)
mlir_tablegen(Ops.h.inc -gen-op-decls) mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs) mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
add_public_tablegen_target(ToyCh4OpsIncGen) add_public_tablegen_target(ToyCh4OpsIncGen)
# Most dialects should use add_mlir_interfaces(). # Most dialects should use add_mlir_interfaces().
set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td) set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls) mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs) mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
add_public_tablegen_target(ToyCh4ShapeInferenceInterfaceIncGen) add_public_tablegen_target(ToyCh4ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch4/include/toy/Dialect.h

Show All 17 Lines
#include "mlir/IR/Function.h" #include "mlir/IR/Function.h"
#include "mlir/IR/StandardTypes.h" #include "mlir/IR/StandardTypes.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "toy/ShapeInferenceInterface.h" #include "toy/ShapeInferenceInterface.h"
namespace mlir { namespace mlir {
namespace toy { namespace toy {
/// This is the definition of the Toy dialect. A dialect inherits from /// Include the auto-generated header file containing the declaration of the toy
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// dialect.
/// constructor). It can also override some general behavior exposed via virtual #include "toy/Dialect.h.inc"
/// methods.
class ToyDialect : public mlir::Dialect {
public:
explicit ToyDialect(mlir::MLIRContext *ctx);
/// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities for casting between dialects.
static llvm::StringRef getDialectNamespace() { return "toy"; }
};
/// Include the auto-generated header file containing the declarations of the /// Include the auto-generated header file containing the declarations of the
/// toy operations. /// toy operations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "toy/Ops.h.inc" #include "toy/Ops.h.inc"
} // end namespace toy } // end namespace toy
} // end namespace mlir } // end namespace mlir
#endif // MLIR_TUTORIAL_TOY_DIALECT_H_ #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch4/mlir/Dialect.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines Operation *materializeCallConversion(OpBuilder &builder, Value input,
return builder.create<CastOp>(conversionLoc, resultType, input); return builder.create<CastOp>(conversionLoc, resultType, input);
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyDialect // ToyDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Dialect creation, the instance will be owned by the context. This is the /// Dialect initialization, the instance will be owned by the context. This is
/// point of registration of custom types and operations for the dialect. /// the point of registration of custom types and operations for the dialect.
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "toy/Ops.cpp.inc" #include "toy/Ops.cpp.inc"
>(); >();
addInterfaces<ToyInlinerInterface>(); addInterfaces<ToyInlinerInterface>();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

mlir/examples/toy/Ch5/include/toy/CMakeLists.txt

# Most dialects should use add_mlir_dialect(). See examples/standalone. # Most dialects should use add_mlir_dialect(). See examples/standalone.
set(LLVM_TARGET_DEFINITIONS Ops.td) set(LLVM_TARGET_DEFINITIONS Ops.td)
mlir_tablegen(Ops.h.inc -gen-op-decls) mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs) mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
add_public_tablegen_target(ToyCh5OpsIncGen) add_public_tablegen_target(ToyCh5OpsIncGen)
# Most dialects should use add_mlir_interfaces(). # Most dialects should use add_mlir_interfaces().
set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td) set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls) mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs) mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
add_public_tablegen_target(ToyCh5ShapeInferenceInterfaceIncGen) add_public_tablegen_target(ToyCh5ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch5/include/toy/Dialect.h

Show All 17 Lines
#include "mlir/IR/Function.h" #include "mlir/IR/Function.h"
#include "mlir/IR/StandardTypes.h" #include "mlir/IR/StandardTypes.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "toy/ShapeInferenceInterface.h" #include "toy/ShapeInferenceInterface.h"
namespace mlir { namespace mlir {
namespace toy { namespace toy {
/// This is the definition of the Toy dialect. A dialect inherits from /// Include the auto-generated header file containing the declaration of the toy
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// dialect.
/// constructor). It can also override some general behavior exposed via virtual #include "toy/Dialect.h.inc"
/// methods.
class ToyDialect : public mlir::Dialect {
public:
explicit ToyDialect(mlir::MLIRContext *ctx);
/// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities for casting between dialects.
static llvm::StringRef getDialectNamespace() { return "toy"; }
};
/// Include the auto-generated header file containing the declarations of the /// Include the auto-generated header file containing the declarations of the
/// toy operations. /// toy operations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "toy/Ops.h.inc" #include "toy/Ops.h.inc"
} // end namespace toy } // end namespace toy
} // end namespace mlir } // end namespace mlir
#endif // MLIR_TUTORIAL_TOY_DIALECT_H_ #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch5/mlir/Dialect.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines Operation *materializeCallConversion(OpBuilder &builder, Value input,
return builder.create<CastOp>(conversionLoc, resultType, input); return builder.create<CastOp>(conversionLoc, resultType, input);
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyDialect // ToyDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Dialect creation, the instance will be owned by the context. This is the /// Dialect initialization, the instance will be owned by the context. This is
/// point of registration of custom types and operations for the dialect. /// the point of registration of custom types and operations for the dialect.
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "toy/Ops.cpp.inc" #include "toy/Ops.cpp.inc"
>(); >();
addInterfaces<ToyInlinerInterface>(); addInterfaces<ToyInlinerInterface>();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/include/toy/CMakeLists.txt

# Most dialects should use add_mlir_dialect(). See examples/standalone. # Most dialects should use add_mlir_dialect(). See examples/standalone.
set(LLVM_TARGET_DEFINITIONS Ops.td) set(LLVM_TARGET_DEFINITIONS Ops.td)
mlir_tablegen(Ops.h.inc -gen-op-decls) mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs) mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
add_public_tablegen_target(ToyCh6OpsIncGen) add_public_tablegen_target(ToyCh6OpsIncGen)
# Most dialects should use add_mlir_interfaces(). # Most dialects should use add_mlir_interfaces().
set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td) set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls) mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs) mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
add_public_tablegen_target(ToyCh6ShapeInferenceInterfaceIncGen) add_public_tablegen_target(ToyCh6ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch6/include/toy/Dialect.h

Show All 17 Lines
#include "mlir/IR/Function.h" #include "mlir/IR/Function.h"
#include "mlir/IR/StandardTypes.h" #include "mlir/IR/StandardTypes.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "toy/ShapeInferenceInterface.h" #include "toy/ShapeInferenceInterface.h"
namespace mlir { namespace mlir {
namespace toy { namespace toy {
/// This is the definition of the Toy dialect. A dialect inherits from /// Include the auto-generated header file containing the declaration of the toy
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// dialect.
/// constructor). It can also override some general behavior exposed via virtual #include "toy/Dialect.h.inc"
/// methods.
class ToyDialect : public mlir::Dialect {
public:
explicit ToyDialect(mlir::MLIRContext *ctx);
/// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities for casting between dialects.
static llvm::StringRef getDialectNamespace() { return "toy"; }
};
/// Include the auto-generated header file containing the declarations of the /// Include the auto-generated header file containing the declarations of the
/// toy operations. /// toy operations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "toy/Ops.h.inc" #include "toy/Ops.h.inc"
} // end namespace toy } // end namespace toy
} // end namespace mlir } // end namespace mlir
#endif // MLIR_TUTORIAL_TOY_DIALECT_H_ #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch6/mlir/Dialect.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines Operation *materializeCallConversion(OpBuilder &builder, Value input,
return builder.create<CastOp>(conversionLoc, resultType, input); return builder.create<CastOp>(conversionLoc, resultType, input);
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyDialect // ToyDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Dialect creation, the instance will be owned by the context. This is the /// Dialect initialization, the instance will be owned by the context. This is
/// point of registration of custom types and operations for the dialect. /// the point of registration of custom types and operations for the dialect.
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "toy/Ops.cpp.inc" #include "toy/Ops.cpp.inc"
>(); >();
addInterfaces<ToyInlinerInterface>(); addInterfaces<ToyInlinerInterface>();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/include/toy/CMakeLists.txt

# Most dialects should use add_mlir_dialect(). See examples/standalone. # Most dialects should use add_mlir_dialect(). See examples/standalone.
set(LLVM_TARGET_DEFINITIONS Ops.td) set(LLVM_TARGET_DEFINITIONS Ops.td)
mlir_tablegen(Ops.h.inc -gen-op-decls) mlir_tablegen(Ops.h.inc -gen-op-decls)
mlir_tablegen(Ops.cpp.inc -gen-op-defs) mlir_tablegen(Ops.cpp.inc -gen-op-defs)
mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
add_public_tablegen_target(ToyCh7OpsIncGen) add_public_tablegen_target(ToyCh7OpsIncGen)
# Most dialects should use add_mlir_interfaces(). # Most dialects should use add_mlir_interfaces().
set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td) set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls) mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs) mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
add_public_tablegen_target(ToyCh7ShapeInferenceInterfaceIncGen) add_public_tablegen_target(ToyCh7ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch7/include/toy/Dialect.h

Show All 20 Lines
#include "toy/ShapeInferenceInterface.h" #include "toy/ShapeInferenceInterface.h"
namespace mlir { namespace mlir {
namespace toy { namespace toy {
namespace detail { namespace detail {
struct StructTypeStorage; struct StructTypeStorage;
} // end namespace detail } // end namespace detail
/// This is the definition of the Toy dialect. A dialect inherits from /// Include the auto-generated header file containing the declaration of the toy
/// mlir::Dialect and registers custom attributes, operations, and types (in its /// dialect.
/// constructor). It can also override some general behavior exposed via virtual #include "toy/Dialect.h.inc"
/// methods.
class ToyDialect : public mlir::Dialect {
public:
explicit ToyDialect(mlir::MLIRContext *ctx);
/// A hook used to materialize constant values with the given type.
Operation *materializeConstant(OpBuilder &builder, Attribute value, Type type,
Location loc) override;
/// Parse an instance of a type registered to the toy dialect.
mlir::Type parseType(mlir::DialectAsmParser &parser) const override;
/// Print an instance of a type registered to the toy dialect.
void printType(mlir::Type type,
mlir::DialectAsmPrinter &printer) const override;
/// Provide a utility accessor to the dialect namespace. This is used by
/// several utilities for casting between dialects.
static llvm::StringRef getDialectNamespace() { return "toy"; }
};
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Toy Operations // Toy Operations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Include the auto-generated header file containing the declarations of the /// Include the auto-generated header file containing the declarations of the
/// toy operations. /// toy operations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
Show All 31 Lines

mlir/examples/toy/Ch7/include/toy/Ops.td

Show All 16 Lines
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
include "toy/ShapeInferenceInterface.td" include "toy/ShapeInferenceInterface.td"
// Provide a definition of the 'toy' dialect in the ODS framework so that we // Provide a definition of the 'toy' dialect in the ODS framework so that we
// can define our operations. // can define our operations.
def Toy_Dialect : Dialect { def Toy_Dialect : Dialect {
let name = "toy"; let name = "toy";
let cppNamespace = "toy"; let cppNamespace = "toy";
// We set this bit to generate a declaration of the `materializeConstant`
// method so that we can materialize constants for our toy operations.
let hasConstantMaterializer = 1;
} }
// Base class for toy dialect operations. This operation inherits from the base // Base class for toy dialect operations. This operation inherits from the base
// `Op` class in OpBase.td, and provides: // `Op` class in OpBase.td, and provides:
// * The parent dialect of the operation. // * The parent dialect of the operation.
// * The mnemonic for the operation, or the name without the dialect prefix. // * The mnemonic for the operation, or the name without the dialect prefix.
// * A list of traits for the operation. // * A list of traits for the operation.
class Toy_Op<string mnemonic, list<OpTrait> traits = []> : class Toy_Op<string mnemonic, list<OpTrait> traits = []> :
Op<Toy_Dialect, mnemonic, traits>; Op<Toy_Dialect, mnemonic, traits>;
// Provide a definition for the Toy StructType for use in ODS. This allows for // Provide a definition for the Toy StructType for use in ODS. This allows for
// using StructType in a similar way to Tensor or MemRef. // using StructType in a similar way to Tensor or MemRef. We use `DialectType`
// to demarcate the StructType as belonging to the Toy dialect.
def Toy_StructType : def Toy_StructType :
Type<CPred<"$_self.isa<StructType>()">, "Toy struct type">; DialectType<Toy_Dialect, CPred<"$_self.isa<StructType>()">,
"Toy struct type">;
// Provide a definition of the types that are used within the Toy dialect. // Provide a definition of the types that are used within the Toy dialect.
def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>; def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Toy Operations // Toy Operations
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 299 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/mlir/Dialect.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines Operation *materializeCallConversion(OpBuilder &builder, Value input,
return builder.create<CastOp>(conversionLoc, resultType, input); return builder.create<CastOp>(conversionLoc, resultType, input);
} }
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyDialect // ToyDialect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Dialect creation, the instance will be owned by the context. This is the /// Dialect initialization, the instance will be owned by the context. This is
/// point of registration of custom types and operations for the dialect. /// the point of registration of custom types and operations for the dialect.
ToyDialect::ToyDialect(mlir::MLIRContext *ctx) void ToyDialect::initialize() {
: mlir::Dialect(getDialectNamespace(), ctx, TypeID::get<ToyDialect>()) {
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "toy/Ops.cpp.inc" #include "toy/Ops.cpp.inc"
>(); >();
addInterfaces<ToyInlinerInterface>(); addInterfaces<ToyInlinerInterface>();
addTypes<StructType>(); addTypes<StructType>();
} }
▲ Show 20 Lines • Show All 459 Lines • Show Last 20 Lines