[mlir][memref] Extract isStaticShapeAndContiguousRowMajor as a util function.

[ftynse]

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

19

MLIR/LLVM prefers to forward-declare classes that only appear as function arguments instead of transitively including (large) headers.

24–25

Nit: top-level entities use /// in MLIR.

[olegshyshkov]

Fixes from comments.

[olegshyshkov]

Thank you!

[olegshyshkov]

fix cmake

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

 // either by passes, optimization sequences, or in turn by other transformation
 // utilities.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H
 #define MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H
 
+namespace mlir {
+
+class MemRefType;
+
+namespace memref {
+
+/// Returns true, if the memref type has static shapes and represents a
+/// contiguous chunk of memory.
+bool isStaticShapeAndContiguousRowMajor(MemRefType type);
+
+} // namespace memref
+} // namespace mlir
+
 #endif // MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H

mlir/lib/Conversion/MemRefToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRMemRefToLLVM
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIRAnalysis
   MLIRDataLayoutInterfaces
   MLIRLLVMCommonConversion
   MLIRMemRefDialect
+  MLIRMemRefUtils
   MLIRLLVMDialect
   MLIRTransforms
   )

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/MemRefToLLVM/AllocLikeConversion.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include <optional>
 
 namespace mlir {
struct MemRefCopyOpLowering : public ConvertOpToLLVMPattern<memref::CopyOp> {
   }
 
   LogicalResult
   matchAndRewrite(memref::CopyOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = cast<BaseMemRefType>(op.getSource().getType());
     auto targetType = cast<BaseMemRefType>(op.getTarget().getType());
 
-    auto isStaticShapeAndContiguousRowMajor = [](MemRefType type) {
-      if (!type.hasStaticShape())
-        return false;
-
-      SmallVector<int64_t> strides;
-      int64_t offset;
-      if (failed(getStridesAndOffset(type, strides, offset)))
-        return false;
-
-      // MemRef is contiguous if outer dimensions are size-1 and inner
-      // dimensions have unit strides.
-      int64_t runningStride = 1;
-      int64_t curDim = strides.size() - 1;
-      // Finds all inner dimensions with unit strides.
-      while (curDim >= 0 && strides[curDim] == runningStride) {
-        runningStride *= type.getDimSize(curDim);
-        --curDim;
-      }
-
-      // Check if other dimensions are size-1.
-      while (curDim >= 0 && type.getDimSize(curDim) == 1) {
-        --curDim;
-      }
-
-      // All dims are unit-strided or size-1.
-      return curDim < 0;
-    };
-
     auto isContiguousMemrefType = [&](BaseMemRefType type) {
       auto memrefType = dyn_cast<mlir::MemRefType>(type);
       // We can use memcpy for memrefs if they have an identity layout or are
       // contiguous with an arbitrary offset. Ignore empty memrefs, which is a
       // special case handled by memrefCopy.
       return memrefType &&
              (memrefType.getLayout().isIdentity() ||
               (memrefType.hasStaticShape() && memrefType.getNumElements() > 0 &&
-               isStaticShapeAndContiguousRowMajor(memrefType)));
+               memref::isStaticShapeAndContiguousRowMajor(memrefType)));
     };
 
     if (isContiguousMemrefType(srcType) && isContiguousMemrefType(targetType))
       return lowerToMemCopyIntrinsic(op, adaptor, rewriter);
 
     return lowerToMemCopyFunctionCall(op, adaptor, rewriter);
   }
 };

mlir/lib/Dialect/MemRef/CMakeLists.txt

 add_subdirectory(IR)
 add_subdirectory(TransformOps)
 add_subdirectory(Transforms)
+add_subdirectory(Utils)

mlir/lib/Dialect/MemRef/Utils/CMakeLists.txt

+add_mlir_dialect_library(MLIRMemRefUtils
+  MemRefUtils.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${PROJECT_SOURCE_DIR}/inlude/mlir/Dialect/MemRef/Utils
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+)

mlir/lib/Dialect/MemRef/Utils/MemRefUtils.cpp

+//===- MemRefUtils.cpp - Utilities to support the MemRef dialect ----------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements utilities for the MemRef dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/MemRef/Utils/MemRefUtils.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
+
+namespace mlir {
+namespace memref {
+
+bool isStaticShapeAndContiguousRowMajor(MemRefType type) {
+  if (!type.hasStaticShape())
+    return false;
+
+  SmallVector<int64_t> strides;
+  int64_t offset;
+  if (failed(getStridesAndOffset(type, strides, offset)))
+    return false;
+
+  // MemRef is contiguous if outer dimensions are size-1 and inner
+  // dimensions have unit strides.
+  int64_t runningStride = 1;
+  int64_t curDim = strides.size() - 1;
+  // Finds all inner dimensions with unit strides.
+  while (curDim >= 0 && strides[curDim] == runningStride) {
+    runningStride *= type.getDimSize(curDim);
+    --curDim;
+  }
+
+  // Check if other dimensions are size-1.
+  while (curDim >= 0 && type.getDimSize(curDim) == 1) {
+    --curDim;
+  }
+
+  // All dims are unit-strided or size-1.
+  return curDim < 0;
+};
+
+} // namespace memref
+} // namespace mlir