aa8499863a
Introduces a dataflow analysis for tracking offset, size, and stride
ranges of operations.
Inference of the metadata is accomplished through the implementation of
the interface
`InferStridedMetadataOpInterface`.
To keep the size of the patch small, this patch only implements the
interface for the
`memref.subview` operation. It's future work to add more operations.
Example:
```mlir
func.func @memref_subview(%arg0: memref<8x16x4xf32, strided<[64, 4, 1]>>) {
%c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index
%c2 = arith.constant 2 : index
%0 = test.with_bounds {smax = 13 : index, smin = 11 : index, umax = 13 : index, umin = 11 : index} : index
%1 = test.with_bounds {smax = 7 : index, smin = 5 : index, umax = 7 : index, umin = 5 : index} : index
%subview = memref.subview %arg0[%c0, %c0, %c1] [%1, %0, %c2] [%c1, %c1, %c1] : memref<8x16x4xf32, strided<[64, 4, 1]>> to memref<?x?x?xf32, strided<[?, ?, ?], offset: ?>>
return
}
```
Applying `mlir-opt --test-strided-metadata-range-analysis` prints:
```
Op: %subview = memref.subview %arg0[%c0, %c0, %c1] [%1, %0, %c2] [%c1, %c1, %c1] : memref<8x16x4xf32, strided<[64, 4, 1]>> to memref<?x?x?xf32, strided<[?, ?, ?], offset: ?>>
result[0]: strided_metadata<offset = [{unsigned : [1, 1] signed : [1, 1]}], sizes = [{unsigned : [5, 7] signed : [5, 7]}, {unsigned : [11, 13] signed : [11, 13]}, {unsigned : [2, 2] signed : [2, 2]}], strides = [{unsigned : [64, 64] signed : [64, 64]}, {unsigned : [4, 4] signed : [4, 4]}, {unsigned : [1, 1] signed : [1, 1]}]>
```
---------
Signed-off-by: Fabian Mora <fabian.mora-cordero@amd.com>
87 lines
3.0 KiB
C++
87 lines
3.0 KiB
C++
//===- TestStridedMetadataRangeAnalysis.cpp - Test strided md analysis ----===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h"
|
|
#include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
|
|
#include "mlir/Analysis/DataFlow/IntegerRangeAnalysis.h"
|
|
#include "mlir/Analysis/DataFlow/StridedMetadataRangeAnalysis.h"
|
|
#include "mlir/Analysis/DataFlowFramework.h"
|
|
#include "mlir/IR/BuiltinAttributes.h"
|
|
#include "mlir/IR/Operation.h"
|
|
#include "mlir/Pass/Pass.h"
|
|
#include "mlir/Pass/PassRegistry.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace mlir;
|
|
using namespace mlir::dataflow;
|
|
|
|
static void printAnalysisResults(DataFlowSolver &solver, Operation *op,
|
|
raw_ostream &os) {
|
|
// Collect the strided metadata of the op results.
|
|
SmallVector<std::pair<unsigned, const StridedMetadataRangeLattice *>> results;
|
|
for (OpResult result : op->getResults()) {
|
|
const auto *state = solver.lookupState<StridedMetadataRangeLattice>(result);
|
|
// Skip the result if it's uninitialized.
|
|
if (!state || state->getValue().isUninitialized())
|
|
continue;
|
|
|
|
// Skip the result if the range is empty.
|
|
const mlir::StridedMetadataRange &md = state->getValue();
|
|
if (md.getOffsets().empty() && md.getSizes().empty() &&
|
|
md.getStrides().empty())
|
|
continue;
|
|
results.push_back({result.getResultNumber(), state});
|
|
}
|
|
|
|
// Early exit if there's no metadata to print.
|
|
if (results.empty())
|
|
return;
|
|
|
|
// Print the metadata.
|
|
os << "Op: " << OpWithFlags(op, OpPrintingFlags().skipRegions()) << "\n";
|
|
for (auto [idx, state] : results)
|
|
os << " result[" << idx << "]: " << state->getValue() << "\n";
|
|
os << "\n";
|
|
}
|
|
|
|
namespace {
|
|
struct TestStridedMetadataRangeAnalysisPass
|
|
: public PassWrapper<TestStridedMetadataRangeAnalysisPass,
|
|
OperationPass<>> {
|
|
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
|
|
TestStridedMetadataRangeAnalysisPass)
|
|
|
|
StringRef getArgument() const override {
|
|
return "test-strided-metadata-range-analysis";
|
|
}
|
|
void runOnOperation() override {
|
|
Operation *op = getOperation();
|
|
|
|
DataFlowSolver solver;
|
|
solver.load<DeadCodeAnalysis>();
|
|
solver.load<SparseConstantPropagation>();
|
|
solver.load<IntegerRangeAnalysis>();
|
|
solver.load<StridedMetadataRangeAnalysis>();
|
|
if (failed(solver.initializeAndRun(op)))
|
|
return signalPassFailure();
|
|
|
|
op->walk(
|
|
[&](Operation *op) { printAnalysisResults(solver, op, llvm::errs()); });
|
|
}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
namespace mlir {
|
|
namespace test {
|
|
void registerTestStridedMetadataRangeAnalysisPass() {
|
|
PassRegistration<TestStridedMetadataRangeAnalysisPass>();
|
|
}
|
|
} // end namespace test
|
|
} // end namespace mlir
|