[Mlir-commits] [mlir] [MLIR][Linalg] Improve morphism semantics (PR #222959)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Fri Sep 11 07:43:41 PDT 2026
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff origin/main HEAD --extensions h,cpp -- mlir/include/mlir/Dialect/Linalg/IR/Linalg.h mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.h mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp mlir/lib/Dialect/Linalg/Transforms/MorphOps.cpp mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp --diff_from_common_commit
``````````
:warning:
The reproduction instructions above might return results for more than one PR
in a stack if you are using a stacked PR workflow. You can limit the results by
changing `origin/main` to the base branch/commit you want to compare against.
:warning:
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/mlir/include/mlir/Dialect/Linalg/IR/Linalg.h b/mlir/include/mlir/Dialect/Linalg/IR/Linalg.h
index aaf4a61b1..5a7a5d989 100644
--- a/mlir/include/mlir/Dialect/Linalg/IR/Linalg.h
+++ b/mlir/include/mlir/Dialect/Linalg/IR/Linalg.h
@@ -161,7 +161,6 @@ struct ArityGroupAndKind {
};
ArityGroupAndKind getArityGroupAndKind(ElementwiseKind kind);
-
/// Specialization of `linalg.matmul` op that has a transpose map on A
class MatmulTransposeAOp : public MatmulOp {
/// Create an affine map for a transpose-A matmul. Used only in the builders.
diff --git a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
index 699ffa61a..575b8c20b 100644
--- a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
+++ b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
@@ -920,8 +920,7 @@ FailureOr<GenericOp> interchangeGenericOp(RewriterBase &rewriter,
/// Create a GenericOp or CategoryOp from the given named operation `linalgOp`
/// and replace the given `linalgOp`. Return failure if `linalgOp` is a
/// GenericOp or misses a region builder.
-FailureOr<LinalgOp> generalizeNamedOp(RewriterBase &rewriter,
- LinalgOp linalgOp,
+FailureOr<LinalgOp> generalizeNamedOp(RewriterBase &rewriter, LinalgOp linalgOp,
bool emitCategoryOps = false);
/// Replace the given GenericOp with a namedOp or categoryOp.
@@ -1668,10 +1667,11 @@ FailureOr<LinalgOp> downscaleSizeOneWindowedConvolution(RewriterBase &rewriter,
struct LinalgGeneralizationPattern
: public OpInterfaceRewritePattern<LinalgOp> {
- LinalgGeneralizationPattern(
- MLIRContext *context, bool emitCategoryOps = false,
- PatternBenefit benefit = 1)
- : OpInterfaceRewritePattern<LinalgOp>(context, benefit), emitCategoryOps(emitCategoryOps) {}
+ LinalgGeneralizationPattern(MLIRContext *context,
+ bool emitCategoryOps = false,
+ PatternBenefit benefit = 1)
+ : OpInterfaceRewritePattern<LinalgOp>(context, benefit),
+ emitCategoryOps(emitCategoryOps) {}
/// `matchAndRewrite` implementation that returns the significant
/// transformed pieces of IR.
@@ -1691,10 +1691,11 @@ private:
struct LinalgSpecializationPattern : public OpRewritePattern<GenericOp> {
- LinalgSpecializationPattern(
- MLIRContext *context, bool emitCategoryOps = false,
- PatternBenefit benefit = 1)
- : OpRewritePattern<GenericOp>(context, benefit), emitCategoryOps(emitCategoryOps) {}
+ LinalgSpecializationPattern(MLIRContext *context,
+ bool emitCategoryOps = false,
+ PatternBenefit benefit = 1)
+ : OpRewritePattern<GenericOp>(context, benefit),
+ emitCategoryOps(emitCategoryOps) {}
FailureOr<GenericOp>
returningMatchAndRewrite(GenericOp op, PatternRewriter &rewriter) const {
@@ -1710,10 +1711,10 @@ private:
bool emitCategoryOps;
};
-struct LinalgCategorizationPattern : public OpInterfaceRewritePattern<LinalgOp> {
+struct LinalgCategorizationPattern
+ : public OpInterfaceRewritePattern<LinalgOp> {
- LinalgCategorizationPattern(
- MLIRContext *context, PatternBenefit benefit = 1)
+ LinalgCategorizationPattern(MLIRContext *context, PatternBenefit benefit = 1)
: OpInterfaceRewritePattern<LinalgOp>(context, benefit) {}
FailureOr<LinalgOp>
@@ -1943,8 +1944,8 @@ void populateLinalgNamedOpsGeneralizationPatterns(RewritePatternSet &patterns,
/// e.g. linalg.generic that takes a tensor and computes a polynomial such as:
/// p(x) = an*x^n + ... + a1x + a0
/// There is no equivalent named op to convert to. Many such cases exist.
-void populateLinalgGenericOpsSpecializationPatterns(RewritePatternSet &patterns,
- bool emitCategoryOps = false);
+void populateLinalgGenericOpsSpecializationPatterns(
+ RewritePatternSet &patterns, bool emitCategoryOps = false);
/// Populates `patterns` with patterns that fold operations like
/// `linalg.transform` into elementwise op map.
diff --git a/mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp b/mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp
index e1152b287..a1ad875d0 100644
--- a/mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp
+++ b/mlir/lib/Dialect/Linalg/IR/LinalgInterfaces.cpp
@@ -227,9 +227,8 @@ linalg::isaTransposeOpInterface(GenericOp op) {
//===----------------------------------------------------------------------===//
// Elementwise Single Unary/Binary-OpInterface implementation
//===----------------------------------------------------------------------===//
-static bool
-isaElemwiseSingleUnaryOrBinaryOpInterface(linalg::GenericOp op,
- unsigned arity) {
+static bool isaElemwiseSingleUnaryOrBinaryOpInterface(linalg::GenericOp op,
+ unsigned arity) {
// Check all loops are parallel.
if (!op.isAllParallelLoops() || op.getNumLoops() < 1)
return false;
@@ -301,7 +300,6 @@ bool linalg::isaElemwiseSingleTernaryOpInterface(linalg::GenericOp op) {
!op.payloadUsesValueFromOperand(inputOpOperand2));
}
-
//===----------------------------------------------------------------------===//
// ContractionOpInterface implementation
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp b/mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp
index dd3a89bc2..d9ac5f68a 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp
@@ -68,8 +68,7 @@ static FailureOr<LinalgOp> generalizeToContractOp(RewriterBase &rewriter,
attributes.push_back(rewriter.getNamedAttr("cast", castAttr));
LinalgOp contractOp = rewriter.replaceOpWithNewOp<ContractOp>(
- namedOp,
- ValueRange{namedOp.getDpsInputs()[0], namedOp.getDpsInputs()[1]},
+ namedOp, ValueRange{namedOp.getDpsInputs()[0], namedOp.getDpsInputs()[1]},
ValueRange{namedOp.getDpsInits()[0]}, attributes);
return contractOp;
}
@@ -85,7 +84,8 @@ FailureOr<LinalgOp> mlir::linalg::generalizeNamedOp(RewriterBase &rewriter,
FailureOr<LinalgOp> contractOp = generalizeToContractOp(rewriter, linalgOp);
if (succeeded(contractOp))
return contractOp;
- return rewriter.notifyMatchFailure(linalgOp, "failed to categorize to named op");
+ return rewriter.notifyMatchFailure(linalgOp,
+ "failed to categorize to named op");
}
SmallVector<Value> inputs = linalgOp.getDpsInputs();
@@ -136,5 +136,6 @@ void LinalgGeneralizeNamedOpsPass::runOnOperation() {
void mlir::linalg::populateLinalgNamedOpsGeneralizationPatterns(
RewritePatternSet &patterns, bool emitCategoryOps) {
- patterns.add<LinalgGeneralizationPattern>(patterns.getContext(), emitCategoryOps);
+ patterns.add<LinalgGeneralizationPattern>(patterns.getContext(),
+ emitCategoryOps);
}
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp b/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp
index df11be9b3..cacdf1165 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Specialize.cpp
@@ -200,7 +200,7 @@ static FailureOr<LinalgOp> specializeLinalgElementwise(RewriterBase &rewriter,
op->getOperand(scalarOprIdx));
auto scalarBroadcastMap =
AffineMap::get(genericOp.getNumParallelLoops(), /*symbolCount=*/0,
- rewriter.getContext());
+ rewriter.getContext());
indexingMaps.insert(indexingMaps.begin() + scalarOprIdx,
scalarBroadcastMap);
}
@@ -218,7 +218,7 @@ static FailureOr<LinalgOp> specializeLinalgElementwise(RewriterBase &rewriter,
divOp.getLhs().getDefiningOp()))
if (cast<FloatAttr>(constOp.getValue()).getValue().isExactlyValue(1.0))
return replaceOp(ElementwiseKind::reciprocal,
- /*mayHoistScalarOperand=*/false);
+ /*mayHoistScalarOperand=*/false);
}
// Square
@@ -227,9 +227,9 @@ static FailureOr<LinalgOp> specializeLinalgElementwise(RewriterBase &rewriter,
return replaceOp(ElementwiseKind::square);
// Boolean-typed `add` and `mul`.
- if (isBinary && llvm::all_of(
- op->getOperands(), [](Value v) {
- return v.getType().isInteger(1); })) {
+ if (isBinary && llvm::all_of(op->getOperands(), [](Value v) {
+ return v.getType().isInteger(1);
+ })) {
if (isa<arith::OrIOp>(op))
return replaceOp(ElementwiseKind::add);
if (isa<arith::AndIOp>(op))
@@ -246,8 +246,7 @@ static FailureOr<LinalgOp> specializeLinalgElementwise(RewriterBase &rewriter,
}
return rewriter.notifyMatchFailure(
- genericOp,
- "elementwise operation cannot be specialized to category op");
+ genericOp, "elementwise operation cannot be specialized to category op");
}
//===----------------------------------------------------------------------===//
@@ -594,8 +593,8 @@ static FailureOr<LinalgOp> specializeLinalgContractions(RewriterBase &rewriter,
// No named variant matched; fall back to the generic `linalg.contract` op,
// which supports a wider range of variants.
- return replaceWithMatmulVariant<ContractOp>(
- rewriter, genericOp, castTy, genericOp.getIndexingMapsArray());
+ return replaceWithMatmulVariant<ContractOp>(rewriter, genericOp, castTy,
+ genericOp.getIndexingMapsArray());
}
/// Utility to specialize a `genericOp` with a convolution op of type `ConvOpTy`
@@ -698,9 +697,9 @@ static FailureOr<LinalgOp> specializeLinalgConvolutions(RewriterBase &rewriter,
//===----------------------------------------------------------------------===//
// Categorize linalg generic to named op where possible.
//===----------------------------------------------------------------------===//
-FailureOr<LinalgOp> mlir::linalg::specializeGenericOp(
- RewriterBase &rewriter, GenericOp genericOp,
- bool emitCategoryOps) {
+FailureOr<LinalgOp> mlir::linalg::specializeGenericOp(RewriterBase &rewriter,
+ GenericOp genericOp,
+ bool emitCategoryOps) {
// Elementwise - e.g. exp, add are always category ops
if (isaElemwiseSingleUnaryOpInterface(genericOp) ||
isaElemwiseSingleBinaryOpInterface(genericOp) ||
@@ -710,8 +709,7 @@ FailureOr<LinalgOp> mlir::linalg::specializeGenericOp(
// Contraction - e.g. matmul
if (isaContractionOpInterface(genericOp)) {
- return specializeLinalgContractions(rewriter, genericOp,
- emitCategoryOps);
+ return specializeLinalgContractions(rewriter, genericOp, emitCategoryOps);
}
// Early exit in case of category specialization.
@@ -788,5 +786,6 @@ void LinalgSpecializeGenericOpsPass::runOnOperation() {
void mlir::linalg::populateLinalgGenericOpsSpecializationPatterns(
RewritePatternSet &patterns, bool emitCategoryOps) {
- patterns.add<LinalgSpecializationPattern>(patterns.getContext(), emitCategoryOps);
+ patterns.add<LinalgSpecializationPattern>(patterns.getContext(),
+ emitCategoryOps);
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/222959
More information about the Mlir-commits
mailing list