[mlir][polynomial] split attributes into its own tablegen #92613
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
@llvm/pr-subscribers-mlir Author: Jeremy Kun (j2kun) ChangesOut of tree we have other dialects that use the ring attribute, but we get compilation errors when generating ops while pulling in all the Polynomial tablegen ops (there's no This PR simply moves the attributes into its own file, so it can be included separately, and this also requires moving the dialect declaration into its own file. Full diff: https://github.com/llvm/llvm-project/pull/92613.diff 5 Files Affected:
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt b/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
index e8f48f13be2b8..ecdea158ddefb 100644
--- a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
@@ -1,7 +1,7 @@
add_mlir_dialect(Polynomial polynomial)
add_mlir_doc(Polynomial PolynomialDialect Dialects/ -gen-dialect-doc -dialect=polynomial)
-set(LLVM_TARGET_DEFINITIONS Polynomial.td)
+set(LLVM_TARGET_DEFINITIONS PolynomialAttributes.td)
mlir_tablegen(PolynomialAttributes.cpp.inc -gen-attrdef-defs -attrdefs-dialect=polynomial)
mlir_tablegen(PolynomialAttributes.h.inc -gen-attrdef-decls -attrdefs-dialect=polynomial)
add_public_tablegen_target(MLIRPolynomialAttributesIncGen)
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td b/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
index 537be4832e8f8..294f58ae084bf 100644
--- a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
@@ -13,157 +13,8 @@ include "mlir/IR/BuiltinAttributes.td"
include "mlir/IR/OpBase.td"
include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td"
-
-def Polynomial_Dialect : Dialect {
- let name = "polynomial";
- let cppNamespace = "::mlir::polynomial";
- let description = [{
- The Polynomial dialect defines single-variable polynomial types and
- operations.
-
- The simplest use of `polynomial` is to represent mathematical operations in
- a polynomial ring `R[x]`, where `R` is another MLIR type like `i32`.
-
- More generally, this dialect supports representing polynomial operations in a
- quotient ring `R[X]/(f(x))` for some statically fixed polynomial `f(x)`.
- Two polyomials `p(x), q(x)` are considered equal in this ring if they have the
- same remainder when dividing by `f(x)`. When a modulus is given, ring operations
- are performed with reductions modulo `f(x)` and relative to the coefficient ring
- `R`.
-
- Examples:
-
- ```mlir
- // A constant polynomial in a ring with i32 coefficients and no polynomial modulus
- #ring = #polynomial.ring<coefficientType=i32>
- %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
-
- // A constant polynomial in a ring with i32 coefficients, modulo (x^1024 + 1)
- #modulus = #polynomial.int_polynomial<1 + x**1024>
- #ring = #polynomial.ring<coefficientType=i32, polynomialModulus=#modulus>
- %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
-
- // A constant polynomial in a ring with i32 coefficients, with a polynomial
- // modulus of (x^1024 + 1) and a coefficient modulus of 17.
- #modulus = #polynomial.int_polynomial<1 + x**1024>
- #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=17:i32, polynomialModulus=#modulus>
- %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
- ```
- }];
-
- let useDefaultTypePrinterParser = 1;
- let useDefaultAttributePrinterParser = 1;
-}
-
-class Polynomial_Attr<string name, string attrMnemonic, list<Trait> traits = []>
- : AttrDef<Polynomial_Dialect, name, traits> {
- let mnemonic = attrMnemonic;
-}
-
-def Polynomial_IntPolynomialAttr : Polynomial_Attr<"IntPolynomial", "int_polynomial"> {
- let summary = "An attribute containing a single-variable polynomial with integer coefficients.";
- let description = [{
- A polynomial attribute represents a single-variable polynomial with integer
- coefficients, which is used to define the modulus of a `RingAttr`, as well
- as to define constants and perform constant folding for `polynomial` ops.
-
- The polynomial must be expressed as a list of monomial terms, with addition
- or subtraction between them. The choice of variable name is arbitrary, but
- must be consistent across all the monomials used to define a single
- attribute. The order of monomial terms is arbitrary, each monomial degree
- must occur at most once.
-
- Example:
-
- ```mlir
- #poly = #polynomial.int_polynomial<x**1024 + 1>
- ```
- }];
- let parameters = (ins "::mlir::polynomial::IntPolynomial":$polynomial);
- let hasCustomAssemblyFormat = 1;
-}
-
-def Polynomial_FloatPolynomialAttr : Polynomial_Attr<"FloatPolynomial", "float_polynomial"> {
- let summary = "An attribute containing a single-variable polynomial with double precision floating point coefficients.";
- let description = [{
- A polynomial attribute represents a single-variable polynomial with double
- precision floating point coefficients.
-
- The polynomial must be expressed as a list of monomial terms, with addition
- or subtraction between them. The choice of variable name is arbitrary, but
- must be consistent across all the monomials used to define a single
- attribute. The order of monomial terms is arbitrary, each monomial degree
- must occur at most once.
-
- Example:
-
- ```mlir
- #poly = #polynomial.float_polynomial<0.5 x**7 + 1.5>
- ```
- }];
- let parameters = (ins "FloatPolynomial":$polynomial);
- let hasCustomAssemblyFormat = 1;
-}
-
-def Polynomial_RingAttr : Polynomial_Attr<"Ring", "ring"> {
- let summary = "An attribute specifying a polynomial ring.";
- let description = [{
- A ring describes the domain in which polynomial arithmetic occurs. The ring
- attribute in `polynomial` represents the more specific case of polynomials
- with a single indeterminate; whose coefficients can be represented by
- another MLIR type (`coefficientType`); and, if the coefficient type is
- integral, whose coefficients are taken modulo some statically known modulus
- (`coefficientModulus`).
-
- Additionally, a polynomial ring can specify a _polynomialModulus_, which converts
- polynomial arithmetic to the analogue of modular integer arithmetic, where
- each polynomial is represented as its remainder when dividing by the
- modulus. For single-variable polynomials, an "polynomialModulus" is always specificed
- via a single polynomial, which we call `polynomialModulus`.
-
- An expressive example is polynomials with i32 coefficients, whose
- coefficients are taken modulo `2**32 - 5`, with a polynomial modulus of
- `x**1024 - 1`.
-
- ```mlir
- #poly_mod = #polynomial.int_polynomial<-1 + x**1024>
- #ring = #polynomial.ring<coefficientType=i32,
- coefficientModulus=4294967291:i32,
- polynomialModulus=#poly_mod>
-
- %0 = ... : polynomial.polynomial<#ring>
- ```
-
- In this case, the value of a polynomial is always "converted" to a
- canonical form by applying repeated reductions by setting `x**1024 = 1`
- and simplifying.
-
- The coefficient and polynomial modulus parameters are optional, and the
- coefficient modulus is only allowed if the coefficient type is integral.
- }];
-
- let parameters = (ins
- "Type": $coefficientType,
- OptionalParameter<"::mlir::IntegerAttr">: $coefficientModulus,
- OptionalParameter<"::mlir::polynomial::IntPolynomialAttr">: $polynomialModulus,
- OptionalParameter<"::mlir::IntegerAttr">: $primitiveRoot
- );
- let assemblyFormat = "`<` struct(params) `>`";
- let builders = [
- AttrBuilderWithInferredContext<
- (ins "::mlir::Type":$coefficientTy,
- CArg<"::mlir::IntegerAttr", "nullptr"> :$coefficientModulusAttr,
- CArg<"::mlir::polynomial::IntPolynomialAttr", "nullptr"> :$polynomialModulusAttr,
- CArg<"::mlir::IntegerAttr", "nullptr"> :$primitiveRootAttr), [{
- return $_get(
- coefficientTy.getContext(),
- coefficientTy,
- coefficientModulusAttr,
- polynomialModulusAttr,
- primitiveRootAttr);
- }]>,
- ];
-}
+include "mlir/Dialect/Polynomial/IR/PolynomialDialect.td"
+include "mlir/Dialect/Polynomial/IR/PolynomialAttributes.td"
class Polynomial_Type<string name, string typeMnemonic>
: TypeDef<Polynomial_Dialect, name> {
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td
new file mode 100644
index 0000000000000..e5dbfa7fa21ee
--- /dev/null
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td
@@ -0,0 +1,125 @@
+//===- PolynomialOps.td - Polynomial dialect ---------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef POLYNOMIAL_ATTRIBUTES
+#define POLYNOMIAL_ATTRIBUTES
+
+include "mlir/IR/BuiltinAttributes.td"
+include "mlir/Dialect/Polynomial/IR/PolynomialDialect.td"
+
+class Polynomial_Attr<string name, string attrMnemonic, list<Trait> traits = []>
+ : AttrDef<Polynomial_Dialect, name, traits> {
+ let mnemonic = attrMnemonic;
+}
+
+def Polynomial_IntPolynomialAttr : Polynomial_Attr<"IntPolynomial", "int_polynomial"> {
+ let summary = "An attribute containing a single-variable polynomial with integer coefficients.";
+ let description = [{
+ A polynomial attribute represents a single-variable polynomial with integer
+ coefficients, which is used to define the modulus of a `RingAttr`, as well
+ as to define constants and perform constant folding for `polynomial` ops.
+
+ The polynomial must be expressed as a list of monomial terms, with addition
+ or subtraction between them. The choice of variable name is arbitrary, but
+ must be consistent across all the monomials used to define a single
+ attribute. The order of monomial terms is arbitrary, each monomial degree
+ must occur at most once.
+
+ Example:
+
+ ```mlir
+ #poly = #polynomial.int_polynomial<x**1024 + 1>
+ ```
+ }];
+ let parameters = (ins "::mlir::polynomial::IntPolynomial":$polynomial);
+ let hasCustomAssemblyFormat = 1;
+}
+
+def Polynomial_FloatPolynomialAttr : Polynomial_Attr<"FloatPolynomial", "float_polynomial"> {
+ let summary = "An attribute containing a single-variable polynomial with double precision floating point coefficients.";
+ let description = [{
+ A polynomial attribute represents a single-variable polynomial with double
+ precision floating point coefficients.
+
+ The polynomial must be expressed as a list of monomial terms, with addition
+ or subtraction between them. The choice of variable name is arbitrary, but
+ must be consistent across all the monomials used to define a single
+ attribute. The order of monomial terms is arbitrary, each monomial degree
+ must occur at most once.
+
+ Example:
+
+ ```mlir
+ #poly = #polynomial.float_polynomial<0.5 x**7 + 1.5>
+ ```
+ }];
+ let parameters = (ins "FloatPolynomial":$polynomial);
+ let hasCustomAssemblyFormat = 1;
+}
+
+def Polynomial_RingAttr : Polynomial_Attr<"Ring", "ring"> {
+ let summary = "An attribute specifying a polynomial ring.";
+ let description = [{
+ A ring describes the domain in which polynomial arithmetic occurs. The ring
+ attribute in `polynomial` represents the more specific case of polynomials
+ with a single indeterminate; whose coefficients can be represented by
+ another MLIR type (`coefficientType`); and, if the coefficient type is
+ integral, whose coefficients are taken modulo some statically known modulus
+ (`coefficientModulus`).
+
+ Additionally, a polynomial ring can specify a _polynomialModulus_, which converts
+ polynomial arithmetic to the analogue of modular integer arithmetic, where
+ each polynomial is represented as its remainder when dividing by the
+ modulus. For single-variable polynomials, an "polynomialModulus" is always specificed
+ via a single polynomial, which we call `polynomialModulus`.
+
+ An expressive example is polynomials with i32 coefficients, whose
+ coefficients are taken modulo `2**32 - 5`, with a polynomial modulus of
+ `x**1024 - 1`.
+
+ ```mlir
+ #poly_mod = #polynomial.int_polynomial<-1 + x**1024>
+ #ring = #polynomial.ring<coefficientType=i32,
+ coefficientModulus=4294967291:i32,
+ polynomialModulus=#poly_mod>
+
+ %0 = ... : polynomial.polynomial<#ring>
+ ```
+
+ In this case, the value of a polynomial is always "converted" to a
+ canonical form by applying repeated reductions by setting `x**1024 = 1`
+ and simplifying.
+
+ The coefficient and polynomial modulus parameters are optional, and the
+ coefficient modulus is only allowed if the coefficient type is integral.
+ }];
+
+ let parameters = (ins
+ "Type": $coefficientType,
+ OptionalParameter<"::mlir::IntegerAttr">: $coefficientModulus,
+ OptionalParameter<"::mlir::polynomial::IntPolynomialAttr">: $polynomialModulus,
+ OptionalParameter<"::mlir::IntegerAttr">: $primitiveRoot
+ );
+ let assemblyFormat = "`<` struct(params) `>`";
+ let builders = [
+ AttrBuilderWithInferredContext<
+ (ins "::mlir::Type":$coefficientTy,
+ CArg<"::mlir::IntegerAttr", "nullptr"> :$coefficientModulusAttr,
+ CArg<"::mlir::polynomial::IntPolynomialAttr", "nullptr"> :$polynomialModulusAttr,
+ CArg<"::mlir::IntegerAttr", "nullptr"> :$primitiveRootAttr), [{
+ return $_get(
+ coefficientTy.getContext(),
+ coefficientTy,
+ coefficientModulusAttr,
+ polynomialModulusAttr,
+ primitiveRootAttr);
+ }]>,
+ ];
+}
+
+#endif // POLYNOMIAL_ATTRIBUTES
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td
new file mode 100644
index 0000000000000..b0573b3715f78
--- /dev/null
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td
@@ -0,0 +1,55 @@
+//===- PolynomialDialect.td - Polynomial dialect base ------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef POLYNOMIAL_DIALECT
+#define POLYNOMIAL_DIALECT
+
+include "mlir/IR/OpBase.td"
+
+def Polynomial_Dialect : Dialect {
+ let name = "polynomial";
+ let cppNamespace = "::mlir::polynomial";
+ let description = [{
+ The Polynomial dialect defines single-variable polynomial types and
+ operations.
+
+ The simplest use of `polynomial` is to represent mathematical operations in
+ a polynomial ring `R[x]`, where `R` is another MLIR type like `i32`.
+
+ More generally, this dialect supports representing polynomial operations in a
+ quotient ring `R[X]/(f(x))` for some statically fixed polynomial `f(x)`.
+ Two polyomials `p(x), q(x)` are considered equal in this ring if they have the
+ same remainder when dividing by `f(x)`. When a modulus is given, ring operations
+ are performed with reductions modulo `f(x)` and relative to the coefficient ring
+ `R`.
+
+ Examples:
+
+ ```mlir
+ // A constant polynomial in a ring with i32 coefficients and no polynomial modulus
+ #ring = #polynomial.ring<coefficientType=i32>
+ %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
+
+ // A constant polynomial in a ring with i32 coefficients, modulo (x^1024 + 1)
+ #modulus = #polynomial.int_polynomial<1 + x**1024>
+ #ring = #polynomial.ring<coefficientType=i32, polynomialModulus=#modulus>
+ %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
+
+ // A constant polynomial in a ring with i32 coefficients, with a polynomial
+ // modulus of (x^1024 + 1) and a coefficient modulus of 17.
+ #modulus = #polynomial.int_polynomial<1 + x**1024>
+ #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=17:i32, polynomialModulus=#modulus>
+ %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
+ ```
+ }];
+
+ let useDefaultTypePrinterParser = 1;
+ let useDefaultAttributePrinterParser = 1;
+}
+
+#endif // POLYNOMIAL_OPS
diff --git a/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel b/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel
index dac759cfd1002..71fca298e9b9a 100644
--- a/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel
+++ b/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel
@@ -6737,7 +6737,7 @@ cc_library(
td_library(
name = "PolynomialTdFiles",
- srcs = ["include/mlir/Dialect/Polynomial/IR/Polynomial.td"],
+ srcs = glob(["include/mlir/Dialect/Polynomial/IR/*.td"]),
includes = ["include"],
deps = [
":BuiltinDialectTdFiles",
|
joker-eph
approved these changes
May 17, 2024
j2kun
added a commit
that referenced
this pull request
May 20, 2024
Similar to #92613, but for types. Co-authored-by: Jeremy Kun <j2kun@users.noreply.github.com>
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Out of tree we have other dialects that use the ring attribute, but we get compilation errors when generating ops while pulling in all the Polynomial tablegen ops (there's no
-dialectflag inmlir-tblgenfor op generation like there is for attributes and types).This PR simply moves the attributes into its own file, so it can be included separately, and this also requires moving the dialect declaration into its own file.