[Mlir-commits] [mlir] 5c32742 - [mlir][sparse] fix typo "admissable" -> "admissible"

[Aart Bik]

Author: Aart Bik
Date: 2022-10-27T13:52:02-07:00
New Revision: 5c32742214827275ccd09b2cc62e4d7875c5c048

URL: https://github.com/llvm/llvm-project/commit/5c32742214827275ccd09b2cc62e4d7875c5c048
DIFF: https://github.com/llvm/llvm-project/commit/5c32742214827275ccd09b2cc62e4d7875c5c048.diff

LOG: [mlir][sparse] fix typo "admissable" -> "admissible"

Reviewed By: wrengr, Peiming

Differential Revision: https://reviews.llvm.org/D136878

Added: 
    

Modified: 
    mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp

Removed: 
    


################################################################################
diff  --git a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
index 5b6cddf8680bb..6d6a4d115ef3e 100644
--- a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp
@@ -869,7 +869,7 @@ Type Merger::inferType(unsigned e, Value src) {
 }
 
 /// Ensures that sparse compiler can generate code for expression.
-static bool isAdmissableBranchExp(Operation *op, Block *block, Value v) {
+static bool isAdmissibleBranchExp(Operation *op, Block *block, Value v) {
   // Arguments are always admissible.
   if (auto arg = v.dyn_cast<BlockArgument>())
     return true;
@@ -883,19 +883,19 @@ static bool isAdmissableBranchExp(Operation *op, Block *block, Value v) {
   // Operation defined within branch. Anything is accepted,
   // as long as all subexpressions are admissible.
   for (unsigned i = 0, n = def->getNumOperands(); i < n; i++)
-    if (!isAdmissableBranchExp(op, block, def->getOperand(i)))
+    if (!isAdmissibleBranchExp(op, block, def->getOperand(i)))
       return false;
   return true;
 }
 
 /// Ensures that sparse compiler can generate code for branch.
-static bool isAdmissableBranch(Operation *op, Region &region) {
+static bool isAdmissibleBranch(Operation *op, Region &region) {
   if (region.empty())
     return true;
   // Build the semi-ring branch semantics backward from yield.
   Operation *yield = region.front().getTerminator();
   assert(isa<YieldOp>(yield));
-  return isAdmissableBranchExp(op, &region.front(), yield->getOperand(0));
+  return isAdmissibleBranchExp(op, &region.front(), yield->getOperand(0));
 }
 
 Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
@@ -989,12 +989,12 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
       if (isa<arith::BitcastOp>(def))
         return addExp(kBitCast, e, v);
       if (auto unop = dyn_cast<sparse_tensor::UnaryOp>(def)) {
-        if (isAdmissableBranch(unop, unop.getPresentRegion()) &&
-            isAdmissableBranch(unop, unop.getAbsentRegion()))
+        if (isAdmissibleBranch(unop, unop.getPresentRegion()) &&
+            isAdmissibleBranch(unop, unop.getAbsentRegion()))
           return addExp(kUnary, e, Value(), def);
       }
       if (auto selop = dyn_cast<sparse_tensor::SelectOp>(def)) {
-        if (isAdmissableBranch(selop, selop.getRegion()))
+        if (isAdmissibleBranch(selop, selop.getRegion()))
           return addExp(kSelect, e, Value(), def);
       }
     }
@@ -1047,11 +1047,11 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
       if (isa<arith::ShLIOp>(def) && isInvariant(e1))
         return addExp(kShlI, e0, e1);
       if (auto binop = dyn_cast<sparse_tensor::BinaryOp>(def)) {
-        if (isAdmissableBranch(binop, binop.getOverlapRegion()) &&
+        if (isAdmissibleBranch(binop, binop.getOverlapRegion()) &&
             (binop.getLeftIdentity() ||
-             isAdmissableBranch(binop, binop.getLeftRegion())) &&
+             isAdmissibleBranch(binop, binop.getLeftRegion())) &&
             (binop.getRightIdentity() ||
-             isAdmissableBranch(binop, binop.getRightRegion())))
+             isAdmissibleBranch(binop, binop.getRightRegion())))
           return addExp(kBinary, e0, e1, Value(), def);
       }
     }
@@ -1065,7 +1065,7 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) {
       unsigned e0 = x.value();
       unsigned e1 = y.value();
       if (auto redop = dyn_cast<sparse_tensor::ReduceOp>(def)) {
-        if (isAdmissableBranch(redop, redop.getRegion()))
+        if (isAdmissibleBranch(redop, redop.getRegion()))
           return addExp(kReduce, e0, e1, Value(), def);
       }
     }