5545b0f672
All checks were successful
Validate Operations / validate-operations (push) Successful in 22m31s
95 lines
3.7 KiB
C++
95 lines
3.7 KiB
C++
#pragma once
|
|
|
|
#include "mlir/Dialect/Func/IR/FuncOps.h"
|
|
#include "mlir/Dialect/MemRef/IR/MemRef.h"
|
|
#include "mlir/IR/Operation.h"
|
|
#include "mlir/IR/PatternMatch.h"
|
|
#include "mlir/IR/Value.h"
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/STLFunctionalExtras.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
#include "src/Compiler/CompilerOptions.hpp"
|
|
|
|
inline constexpr llvm::StringRef PimWeightAlwaysAttrName = "weightAlways";
|
|
|
|
namespace onnx_mlir {
|
|
|
|
struct ResolvedContiguousAddress {
|
|
mlir::Value base;
|
|
int64_t byteOffset = 0;
|
|
};
|
|
|
|
struct StaticValueKnowledge {
|
|
llvm::DenseMap<mlir::Value, int64_t> indexValues;
|
|
llvm::DenseMap<mlir::Value, mlir::Value> aliases;
|
|
|
|
StaticValueKnowledge() {}
|
|
};
|
|
|
|
std::string getOutputDir();
|
|
|
|
void createDirectory(const std::string& directory);
|
|
|
|
void dumpModule(mlir::ModuleOp moduleOp, const std::string& name);
|
|
|
|
llvm::FailureOr<mlir::func::FuncOp> getPimEntryFunc(mlir::ModuleOp moduleOp);
|
|
|
|
bool hasWeightAlways(mlir::Operation* op);
|
|
|
|
void markWeightAlways(mlir::Operation* op);
|
|
|
|
bool isSpatialMvmVmmWeightUse(mlir::OpOperand& use);
|
|
bool hasOnlySpatialMvmVmmWeightUses(mlir::Value value);
|
|
|
|
void walkPimMvmVmmWeightUses(mlir::Operation* root, llvm::function_ref<void(mlir::OpOperand&)> callback);
|
|
|
|
mlir::memref::GlobalOp lookupGlobalForGetGlobal(mlir::ModuleOp moduleOp, mlir::memref::GetGlobalOp getGlobalOp);
|
|
|
|
llvm::FailureOr<mlir::Operation*>
|
|
getOtherEndOfChannel(mlir::Operation* op, bool opIsReceive, mlir::RewriterBase& rewriter);
|
|
|
|
llvm::SmallVector<int64_t> computeRowMajorStrides(llvm::ArrayRef<int64_t> shape);
|
|
|
|
llvm::SmallVector<int64_t>
|
|
delinearizeIndex(int64_t linearIndex, llvm::ArrayRef<int64_t> shape, llvm::ArrayRef<int64_t> strides);
|
|
|
|
int64_t linearizeIndex(llvm::ArrayRef<int64_t> indices, llvm::ArrayRef<int64_t> strides);
|
|
|
|
int64_t getNumElements(llvm::ArrayRef<int64_t> shape);
|
|
|
|
bool isMemoryContiguous(llvm::ArrayRef<int64_t> srcShape,
|
|
llvm::ArrayRef<int64_t> offsets,
|
|
llvm::ArrayRef<int64_t> sizes,
|
|
llvm::ArrayRef<int64_t> strides);
|
|
|
|
llvm::FailureOr<ResolvedContiguousAddress> resolveContiguousAddress(mlir::Value value);
|
|
llvm::FailureOr<ResolvedContiguousAddress> resolveContiguousAddress(mlir::Value value,
|
|
const StaticValueKnowledge& knowledge);
|
|
|
|
llvm::FailureOr<int64_t> resolveIndexValue(mlir::Value value);
|
|
llvm::FailureOr<int64_t> resolveIndexValue(mlir::Value value, const StaticValueKnowledge& knowledge);
|
|
|
|
/// Follows alias and view/DPS chains using `knowledge` to find the value an scf.for
|
|
/// iter-arg is ultimately backed by. Used when interpreting scf.for loop carries.
|
|
mlir::Value resolveLoopCarriedAlias(mlir::Value value, const StaticValueKnowledge& knowledge);
|
|
|
|
/// Returns true for ops inside a pim.core body that do not emit any PIM instruction and
|
|
/// only contribute to static addressing or index computations (arith integer math,
|
|
/// memref view ops, memref.alloc, arith.constant).
|
|
bool isCoreStaticAddressOp(mlir::Operation* op);
|
|
|
|
/// Walks `block` (the body of a pim.core region or an scf.for nested in it), statically
|
|
/// unrolling any scf.for with resolvable bounds using `knowledge`. For each remaining op
|
|
/// that is not skipped (pim.halt, scf.yield, or isCoreStaticAddressOp), `callback` is
|
|
/// invoked with the op and the in-scope knowledge. The walker keeps going after a callback
|
|
/// failure so callers can collect multiple diagnostics, but propagates the overall result.
|
|
mlir::LogicalResult
|
|
walkPimCoreBlock(mlir::Block& block,
|
|
const StaticValueKnowledge& knowledge,
|
|
llvm::function_ref<mlir::LogicalResult(mlir::Operation&, const StaticValueKnowledge&)> callback);
|
|
|
|
} // namespace onnx_mlir
|