diff options
author | Jeremy Kun <jkun@google.com> | 2024-05-17 16:03:44 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2024-05-17 16:03:44 -0700 |
commit | b80e0fbcfb71b24d762d8b48069153b9e16679be (patch) | |
tree | a01c66cb794fc3afd4d89f48a1b03f0eb344f706 | |
parent | ab7930bd9f088c4fcdfd438b5207a4052c9669b8 (diff) | |
download | llvm-b80e0fbcfb71b24d762d8b48069153b9e16679be.zip llvm-b80e0fbcfb71b24d762d8b48069153b9e16679be.tar.gz llvm-b80e0fbcfb71b24d762d8b48069153b9e16679be.tar.bz2 |
[mlir][polynomial] split attributes into its own tablegen (#92613)
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 `-dialect` flag in `mlir-tblgen` for
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.
5 files changed, 184 insertions, 153 deletions
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt b/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt index e8f48f1..ecdea15 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 537be48..294f58a 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 0000000..e5dbfa7 --- /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 0000000..b0573b3 --- /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 dac759c..71fca29 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", |