This is an archive of the discontinued LLVM Phabricator instance.

Differential D142463

[mlir][Conversion] Rename the MemRefToLLVM pass
ClosedPublic

Authored by qcolombet on Jan 24 2023, 5:50 AM.

Details

Reviewers
mehdi_amini
nicolasvasilache
ftynse
antiagainst
aartbik
ThomasRaoux
herhut
dcaballe
Commits
rGcb4ccd38fa04: [mlir][Conversion] Rename the MemRefToLLVM pass
Summary

TL;DR Pretty boring patch; Rename memref-to-llvm into finalize-memref-to-llvm

Since the recent MemRef refactoring that centralizes the lowering of
complex MemRef operations outside of the conversion framework, the
MemRefToLLVM pass doesn't directly convert these complex operations.

Instead, to fully convert the whole MemRef dialect space, MemRefToLLVM
needs to run after expand-strided-metadata.

Make this more obvious by changing the name of the pass and the option
associated with it from convert-memref-to-llvm to
finalize-memref-to-llvm.
The word "finalize" conveys that this pass needs to run after something
else and that something else is documented in its tablegen description.

This is a follow-up patch related to the conversation at:
https://discourse.llvm.org/t/psa-you-need-to-run-expand-strided-metadata-before-memref-to-llvm-now/66956/14

Diff Detail

Event Timeline

qcolombet created this revision.Jan 24 2023, 5:50 AM
Herald added a reviewer: antiagainst. · View Herald TranscriptJan 24 2023, 5:50 AM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: ThomasRaoux. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: hanchung, jsetoain, Moerafaat and 28 others. · View Herald Transcript
qcolombet requested review of this revision.Jan 24 2023, 5:50 AM
Herald added a reviewer: herhut. · View Herald TranscriptJan 24 2023, 5:50 AM
Herald added a reviewer: dcaballe. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, jholewinski. · View Herald Transcript
Harbormaster completed remote builds in B209623: Diff 491736.Jan 24 2023, 6:46 AM
mehdi_amini accepted this revision.Jan 24 2023, 10:18 AM
This revision is now accepted and ready to land.Jan 24 2023, 10:18 AM
Closed by commit rGcb4ccd38fa04: [mlir][Conversion] Rename the MemRefToLLVM pass (authored by qcolombet). · Explain WhyJan 27 2023, 1:37 AM
This revision was automatically updated to reflect the committed changes.
qcolombet added a commit: rGcb4ccd38fa04: [mlir][Conversion] Rename the MemRefToLLVM pass.
Herald added a subscriber: thopre. · View Herald TranscriptJan 27 2023, 1:37 AM

Revision Contents

PathSize
mlir/
docs/
2 lines
examples/
toy/
Ch6/
mlir/
2 lines
Ch7/
mlir/
2 lines
include/
mlir/
Conversion/
MemRefToLLVM/
6 lines
10 lines
lib/
Conversion/
GPUCommon/
2 lines
GPUToNVVM/
2 lines
GPUToROCDL/
2 lines
LinalgToLLVM/
2 lines
MemRefToLLVM/
16 lines
OpenMPToLLVM/
2 lines
SPIRVToLLVM/
2 lines
Dialect/
SparseTensor/
Pipelines/
2 lines
test/
Conversion/
FuncToLLVM/
4 lines
MemRefToLLVM/
2 lines
6 lines
2 lines
4 lines
4 lines
4 lines
Integration/
Dialect/
Async/
CPU/
4 lines
6 lines
6 lines
6 lines
Complex/
CPU/
2 lines
LLVMIR/
CPU/
2 lines
2 lines
Linalg/
CPU/
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Memref/
2 lines
2 lines
Standard/
CPU/
2 lines
2 lines
Vector/
CPU/
AMX/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ArmSVE/
2 lines
X86Vector/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
lib/
Dialect/
LLVM/
2 lines
mlir-cpu-runner/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
mlir-opt/
2 lines
python/
2 lines
integration/
dialects/
linalg/
2 lines
tools/
mlir-vulkan-runner/
2 lines
unittests/
ExecutionEngine/
2 lines

Diff 492666

mlir/docs/TargetLLVMIR.md

Show All 29 Lines
[TOC] [TOC]
## Conversion to the LLVM Dialect ## Conversion to the LLVM Dialect
Conversion to the LLVM dialect from other dialects is the first step to produce Conversion to the LLVM dialect from other dialects is the first step to produce
LLVM IR. All non-trivial IR modifications are expected to happen at this stage LLVM IR. All non-trivial IR modifications are expected to happen at this stage
or before. The conversion is *progressive*: most passes convert one dialect to or before. The conversion is *progressive*: most passes convert one dialect to
the LLVM dialect and keep operations from other dialects intact. For example, the LLVM dialect and keep operations from other dialects intact. For example,
the `-convert-memref-to-llvm` pass will only convert operations from the the `-finalize-memref-to-llvm` pass will only convert operations from the
`memref` dialect but will not convert operations from other dialects even if `memref` dialect but will not convert operations from other dialects even if
they use or produce `memref`-typed values. they use or produce `memref`-typed values.
The process relies on the [Dialect Conversion](DialectConversion.md) The process relies on the [Dialect Conversion](DialectConversion.md)
infrastructure and, in particular, on the infrastructure and, in particular, on the
[materialization](DialectConversion.md#type-conversion) hooks of `TypeConverter` [materialization](DialectConversion.md#type-conversion) hooks of `TypeConverter`
to support progressive lowering by injecting `unrealized_conversion_cast` to support progressive lowering by injecting `unrealized_conversion_cast`
operations between converted and unconverted operations. After multiple partial operations between converted and unconverted operations. After multiple partial
▲ Show 20 Lines • Show All 884 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// dialects. These patterns lowering in multiple stages, relying on transitive // dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a // patterns must be applied to fully transform an illegal operation into a
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns); mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This // We want to completely lower to LLVM, so we use a `FullConversion`. This
Show All 11 Lines

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Linesvoid ToyToLLVMLoweringPass::runOnOperation() {
// dialects. These patterns lowering in multiple stages, relying on transitive // dialects. These patterns lowering in multiple stages, relying on transitive
// lowerings. Transitive lowering, or A->B->C lowering, is when multiple // lowerings. Transitive lowering, or A->B->C lowering, is when multiple
// patterns must be applied to fully transform an illegal operation into a // patterns must be applied to fully transform an illegal operation into a
// set of legal ones. // set of legal ones.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateAffineToStdConversionPatterns(patterns); populateAffineToStdConversionPatterns(patterns);
populateSCFToControlFlowConversionPatterns(patterns); populateSCFToControlFlowConversionPatterns(patterns);
mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns); mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(typeConverter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns); cf::populateControlFlowToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
// The only remaining operation to lower from the `toy` dialect, is the // The only remaining operation to lower from the `toy` dialect, is the
// PrintOp. // PrintOp.
patterns.add<PrintOpLowering>(&getContext()); patterns.add<PrintOpLowering>(&getContext());
// We want to completely lower to LLVM, so we use a `FullConversion`. This // We want to completely lower to LLVM, so we use a `FullConversion`. This
Show All 11 Lines

mlir/include/mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h

Show All 10 Lines
#include <memory> #include <memory>
namespace mlir { namespace mlir {
class Pass; class Pass;
class LLVMTypeConverter; class LLVMTypeConverter;
class RewritePatternSet; class RewritePatternSet;
#define GEN_PASS_DECL_MEMREFTOLLVMCONVERSIONPASS #define GEN_PASS_DECL_FINALIZEMEMREFTOLLVMCONVERSIONPASS
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
/// Collect a set of patterns to convert memory-related operations from the /// Collect a set of patterns to convert memory-related operations from the
/// MemRef dialect to the LLVM dialect. /// MemRef dialect to the LLVM dialect.
void populateMemRefToLLVMConversionPatterns(LLVMTypeConverter &converter, void populateFinalizeMemRefToLLVMConversionPatterns(
RewritePatternSet &patterns); LLVMTypeConverter &converter, RewritePatternSet &patterns);
} // namespace mlir } // namespace mlir
#endif // MLIR_CONVERSION_MEMREFTOLLVM_MEMREFTOLLVM_H #endif // MLIR_CONVERSION_MEMREFTOLLVM_MEMREFTOLLVM_H

mlir/include/mlir/Conversion/Passes.td

Show First 20 Lines • Show All 558 Lines • ▼ Show 20 Lines Option<"minWidthOfFPowIExponent", "min-width-of-fpowi-exponent", "unsigned",
"is greater than or equal to this value"> "is greater than or equal to this value">
]; ];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MemRefToLLVM // MemRefToLLVM
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def MemRefToLLVMConversionPass : Pass<"convert-memref-to-llvm", "ModuleOp"> { def FinalizeMemRefToLLVMConversionPass :
let summary = "Convert operations from the MemRef dialect to the LLVM " Pass<"finalize-memref-to-llvm", "ModuleOp"> {
"dialect"; let summary = "Finalize the conversion of the operations from the MemRef "
"dialect to the LLVM dialect."
"This conversion will not convert some complex MemRef "
"operations. Make sure to run `expand-strided-metadata` "
"beforehand for these.";
let dependentDialects = ["LLVM::LLVMDialect"]; let dependentDialects = ["LLVM::LLVMDialect"];
let options = [ let options = [
Option<"useAlignedAlloc", "use-aligned-alloc", "bool", /*default=*/"false", Option<"useAlignedAlloc", "use-aligned-alloc", "bool", /*default=*/"false",
"Use aligned_alloc in place of malloc for heap allocations">, "Use aligned_alloc in place of malloc for heap allocations">,
Option<"indexBitwidth", "index-bitwidth", "unsigned", Option<"indexBitwidth", "index-bitwidth", "unsigned",
/*default=kDeriveIndexBitwidthFromDataLayout*/"0", /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
"Bitwidth of the index type, 0 to use size of machine word">, "Bitwidth of the index type, 0 to use size of machine word">,
Option<"useGenericFunctions", "use-generic-functions", Option<"useGenericFunctions", "use-generic-functions",
▲ Show 20 Lines • Show All 437 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

Show First 20 Lines • Show All 386 Lines • ▼ Show 20 Linesvoid GpuToLLVMConversionPass::runOnOperation() {
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addIllegalDialect<gpu::GPUDialect>(); target.addIllegalDialect<gpu::GPUDialect>();
mlir::arith::populateArithToLLVMConversionPatterns(converter, patterns); mlir::arith::populateArithToLLVMConversionPatterns(converter, patterns);
mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns); mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateVectorToLLVMConversionPatterns(converter, patterns); populateVectorToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(converter, patterns);
populateFuncToLLVMConversionPatterns(converter, patterns); populateFuncToLLVMConversionPatterns(converter, patterns);
populateAsyncStructuralTypeConversionsAndLegality(converter, patterns, populateAsyncStructuralTypeConversionsAndLegality(converter, patterns,
target); target);
populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation, populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation,
kernelBarePtrCallConv); kernelBarePtrCallConv);
if (failed( if (failed(
applyPartialConversion(getOperation(), target, std::move(patterns)))) applyPartialConversion(getOperation(), target, std::move(patterns))))
▲ Show 20 Lines • Show All 530 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

Show First 20 Lines • Show All 275 Lines • ▼ Show 20 Lines void runOnOperation() override {
converter.addConversion([&](gpu::MMAMatrixType type) -> Type { converter.addConversion([&](gpu::MMAMatrixType type) -> Type {
return convertMMAToLLVMType(type); return convertMMAToLLVMType(type);
}); });
RewritePatternSet llvmPatterns(m.getContext()); RewritePatternSet llvmPatterns(m.getContext());
arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns); arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateFuncToLLVMConversionPatterns(converter, llvmPatterns); populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateFinalizeMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToNVVMConversionPatterns(converter, llvmPatterns); populateGpuToNVVMConversionPatterns(converter, llvmPatterns);
populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns); populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns);
if (this->hasRedux) if (this->hasRedux)
populateGpuSubgroupReduceOpLoweringPattern(converter, llvmPatterns); populateGpuSubgroupReduceOpLoweringPattern(converter, llvmPatterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
configureGpuToNVVMConversionLegality(target); configureGpuToNVVMConversionLegality(target);
if (failed(applyPartialConversion(m, target, std::move(llvmPatterns)))) if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
signalPassFailure(); signalPassFailure();
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

Show First 20 Lines • Show All 161 Lines • ▼ Show 20 Lines void runOnOperation() override {
RewritePatternSet llvmPatterns(ctx); RewritePatternSet llvmPatterns(ctx);
mlir::arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns); mlir::arith::populateArithToLLVMConversionPatterns(converter, llvmPatterns);
populateAMDGPUToROCDLConversionPatterns(converter, llvmPatterns, populateAMDGPUToROCDLConversionPatterns(converter, llvmPatterns,
*maybeChipset); *maybeChipset);
populateVectorToLLVMConversionPatterns(converter, llvmPatterns); populateVectorToLLVMConversionPatterns(converter, llvmPatterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns); cf::populateControlFlowToLLVMConversionPatterns(converter, llvmPatterns);
populateFuncToLLVMConversionPatterns(converter, llvmPatterns); populateFuncToLLVMConversionPatterns(converter, llvmPatterns);
populateMemRefToLLVMConversionPatterns(converter, llvmPatterns); populateFinalizeMemRefToLLVMConversionPatterns(converter, llvmPatterns);
populateGpuToROCDLConversionPatterns(converter, llvmPatterns, runtime); populateGpuToROCDLConversionPatterns(converter, llvmPatterns, runtime);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
configureGpuToROCDLConversionLegality(target); configureGpuToROCDLConversionLegality(target);
if (failed(applyPartialConversion(m, target, std::move(llvmPatterns)))) if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
signalPassFailure(); signalPassFailure();
// Manually rewrite known block size attributes so the LLVMIR translation // Manually rewrite known block size attributes so the LLVMIR translation
// infrastructure can pick them up. // infrastructure can pick them up.
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
void ConvertLinalgToLLVMPass::runOnOperation() { void ConvertLinalgToLLVMPass::runOnOperation() {
auto module = getOperation(); auto module = getOperation();
// Convert to the LLVM IR dialect using the converter defined above. // Convert to the LLVM IR dialect using the converter defined above.
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
populateLinalgToLLVMConversionPatterns(converter, patterns); populateLinalgToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(converter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addLegalOp<ModuleOp>(); target.addLegalOp<ModuleOp>();
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertLinalgToLLVMPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertLinalgToLLVMPass() {
return std::make_unique<ConvertLinalgToLLVMPass>(); return std::make_unique<ConvertLinalgToLLVMPass>();
} }

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

Show All 19 Lines
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/IR/IRMapping.h" #include "mlir/IR/IRMapping.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallBitVector.h"
#include <optional> #include <optional>
namespace mlir { namespace mlir {
#define GEN_PASS_DEF_MEMREFTOLLVMCONVERSIONPASS #define GEN_PASS_DEF_FINALIZEMEMREFTOLLVMCONVERSIONPASS
#include "mlir/Conversion/Passes.h.inc" #include "mlir/Conversion/Passes.h.inc"
} // namespace mlir } // namespace mlir
using namespace mlir; using namespace mlir;
namespace { namespace {
bool isStaticStrideOrOffset(int64_t strideOrOffset) { bool isStaticStrideOrOffset(int64_t strideOrOffset) {
▲ Show 20 Lines • Show All 1,661 Lines • ▼ Show 20 Lines matchAndRewrite(memref::ExtractStridedMetadataOp extractStridedMetadataOp,
rewriter.replaceOp(extractStridedMetadataOp, results); rewriter.replaceOp(extractStridedMetadataOp, results);
return success(); return success();
} }
}; };
} // namespace } // namespace
void mlir::populateMemRefToLLVMConversionPatterns(LLVMTypeConverter &converter, void mlir::populateFinalizeMemRefToLLVMConversionPatterns(
RewritePatternSet &patterns) { LLVMTypeConverter &converter, RewritePatternSet &patterns) {
// clang-format off // clang-format off
patterns.add< patterns.add<
AllocaOpLowering, AllocaOpLowering,
AllocaScopeOpLowering, AllocaScopeOpLowering,
AtomicRMWOpLowering, AtomicRMWOpLowering,
AssumeAlignmentOpLowering, AssumeAlignmentOpLowering,
ConvertExtractAlignedPointerAsIndex, ConvertExtractAlignedPointerAsIndex,
DimOpLowering, DimOpLowering,
Show All 20 Lines if (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc)
patterns.add<AlignedAllocOpLowering, AlignedReallocOpLowering, patterns.add<AlignedAllocOpLowering, AlignedReallocOpLowering,
DeallocOpLowering>(converter); DeallocOpLowering>(converter);
else if (allocLowering == LowerToLLVMOptions::AllocLowering::Malloc) else if (allocLowering == LowerToLLVMOptions::AllocLowering::Malloc)
patterns.add<AllocOpLowering, ReallocOpLowering, DeallocOpLowering>( patterns.add<AllocOpLowering, ReallocOpLowering, DeallocOpLowering>(
converter); converter);
} }
namespace { namespace {
struct MemRefToLLVMConversionPass struct FinalizeMemRefToLLVMConversionPass
: public impl::MemRefToLLVMConversionPassBase<MemRefToLLVMConversionPass> { : public impl::FinalizeMemRefToLLVMConversionPassBase<
using MemRefToLLVMConversionPassBase::MemRefToLLVMConversionPassBase; FinalizeMemRefToLLVMConversionPass> {
using FinalizeMemRefToLLVMConversionPassBase::
FinalizeMemRefToLLVMConversionPassBase;
void runOnOperation() override { void runOnOperation() override {
Operation *op = getOperation(); Operation *op = getOperation();
const auto &dataLayoutAnalysis = getAnalysis<DataLayoutAnalysis>(); const auto &dataLayoutAnalysis = getAnalysis<DataLayoutAnalysis>();
LowerToLLVMOptions options(&getContext(), LowerToLLVMOptions options(&getContext(),
dataLayoutAnalysis.getAtOrAbove(op)); dataLayoutAnalysis.getAtOrAbove(op));
options.allocLowering = options.allocLowering =
(useAlignedAlloc ? LowerToLLVMOptions::AllocLowering::AlignedAlloc (useAlignedAlloc ? LowerToLLVMOptions::AllocLowering::AlignedAlloc
: LowerToLLVMOptions::AllocLowering::Malloc); : LowerToLLVMOptions::AllocLowering::Malloc);
options.useGenericFunctions = useGenericFunctions; options.useGenericFunctions = useGenericFunctions;
if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout) if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
options.overrideIndexBitwidth(indexBitwidth); options.overrideIndexBitwidth(indexBitwidth);
LLVMTypeConverter typeConverter(&getContext(), options, LLVMTypeConverter typeConverter(&getContext(), options,
&dataLayoutAnalysis); &dataLayoutAnalysis);
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(typeConverter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addLegalOp<func::FuncOp>(); target.addLegalOp<func::FuncOp>();
if (failed(applyPartialConversion(op, target, std::move(patterns)))) if (failed(applyPartialConversion(op, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
}; };
} // namespace } // namespace

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Lines
void ConvertOpenMPToLLVMPass::runOnOperation() { void ConvertOpenMPToLLVMPass::runOnOperation() {
auto module = getOperation(); auto module = getOperation();
// Convert to OpenMP operations with LLVM IR dialect // Convert to OpenMP operations with LLVM IR dialect
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
arith::populateArithToLLVMConversionPatterns(converter, patterns); arith::populateArithToLLVMConversionPatterns(converter, patterns);
cf::populateControlFlowToLLVMConversionPatterns(converter, patterns); cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(converter, patterns);
populateFuncToLLVMConversionPatterns(converter, patterns); populateFuncToLLVMConversionPatterns(converter, patterns);
populateOpenMPToLLVMConversionPatterns(converter, patterns); populateOpenMPToLLVMConversionPatterns(converter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp, target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp,
omp::BarrierOp, omp::TaskwaitOp>(); omp::BarrierOp, omp::TaskwaitOp>();
configureOpenMPToLLVMConversionLegality(target, converter); configureOpenMPToLLVMConversionLegality(target, converter);
if (failed(applyPartialConversion(module, target, std::move(patterns)))) if (failed(applyPartialConversion(module, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
} }
std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() { std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() {
return std::make_unique<ConvertOpenMPToLLVMPass>(); return std::make_unique<ConvertOpenMPToLLVMPass>();
} }

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines void runOnOperation() override {
} }
// Specify options to lower to LLVM and pull in the conversion patterns. // Specify options to lower to LLVM and pull in the conversion patterns.
LowerToLLVMOptions options(module.getContext()); LowerToLLVMOptions options(module.getContext());
auto *context = module.getContext(); auto *context = module.getContext();
RewritePatternSet patterns(context); RewritePatternSet patterns(context);
LLVMTypeConverter typeConverter(context, options); LLVMTypeConverter typeConverter(context, options);
mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns); mlir::arith::populateArithToLLVMConversionPatterns(typeConverter, patterns);
populateMemRefToLLVMConversionPatterns(typeConverter, patterns); populateFinalizeMemRefToLLVMConversionPatterns(typeConverter, patterns);
populateFuncToLLVMConversionPatterns(typeConverter, patterns); populateFuncToLLVMConversionPatterns(typeConverter, patterns);
patterns.add<GPULaunchLowering>(typeConverter); patterns.add<GPULaunchLowering>(typeConverter);
// Pull in SPIR-V type conversion patterns to convert SPIR-V global // Pull in SPIR-V type conversion patterns to convert SPIR-V global
// variable's type to LLVM dialect type. // variable's type to LLVM dialect type.
populateSPIRVToLLVMTypeConversion(typeConverter); populateSPIRVToLLVMTypeConversion(typeConverter);
ConversionTarget target(*context); ConversionTarget target(*context);
Show All 20 Lines

mlir/lib/Dialect/SparseTensor/Pipelines/SparseTensorPipelines.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesvoid mlir::sparse_tensor::buildSparseCompiler(
// TODO(springerm): Add sparse support to the BufferDeallocation pass and add // TODO(springerm): Add sparse support to the BufferDeallocation pass and add
// it to this pipeline. // it to this pipeline.
pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass()); pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass()); pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass()); pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());
pm.addPass(memref::createExpandStridedMetadataPass()); pm.addPass(memref::createExpandStridedMetadataPass());
pm.addPass(createLowerAffinePass()); pm.addPass(createLowerAffinePass());
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions())); pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
pm.addPass(createMemRefToLLVMConversionPass()); pm.addPass(createFinalizeMemRefToLLVMConversionPass());
pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass()); pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
pm.addNestedPass<mlir::func::FuncOp>(mlir::arith::createArithExpandOpsPass()); pm.addNestedPass<mlir::func::FuncOp>(mlir::arith::createArithExpandOpsPass());
pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass()); pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
pm.addPass(createConvertMathToLibmPass()); pm.addPass(createConvertMathToLibmPass());
pm.addPass(createConvertComplexToLibmPass()); pm.addPass(createConvertComplexToLibmPass());
// Repeat convert-vector-to-llvm. // Repeat convert-vector-to-llvm.
pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions())); pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
pm.addPass(createConvertComplexToLLVMPass()); pm.addPass(createConvertComplexToLLVMPass());
Show All 17 Lines

mlir/test/Conversion/FuncToLLVM/calling-convention.mlir

// RUN: mlir-opt -convert-memref-to-llvm -llvm-request-c-wrappers -convert-func-to-llvm -reconcile-unrealized-casts %s | FileCheck %s // RUN: mlir-opt -finalize-memref-to-llvm -llvm-request-c-wrappers -convert-func-to-llvm -reconcile-unrealized-casts %s | FileCheck %s
// RUN: mlir-opt -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE // RUN: mlir-opt -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE
// This tests the default memref calling convention and the emission of C // This tests the default memref calling convention and the emission of C
// wrappers. We don't need to separate runs because the wrapper-emission // wrappers. We don't need to separate runs because the wrapper-emission
// version subsumes the calling convention and only adds new functions, that we // version subsumes the calling convention and only adds new functions, that we
// can also file-check in the same run. // can also file-check in the same run.
// An external function is transformed into the glue around calling an interface function. // An external function is transformed into the glue around calling an interface function.
// CHECK-LABEL: @external // CHECK-LABEL: @external
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

mlir/test/Conversion/MemRefToLLVM/convert-alloca-scope.mlir

// RUN: mlir-opt -convert-memref-to-llvm %s | FileCheck %s // RUN: mlir-opt -finalize-memref-to-llvm %s | FileCheck %s
// CHECK-LABEL: @empty // CHECK-LABEL: @empty
func.func @empty() { func.func @empty() {
// CHECK: llvm.intr.stacksave // CHECK: llvm.intr.stacksave
// CHECK: llvm.br // CHECK: llvm.br
memref.alloca_scope { memref.alloca_scope {
memref.alloca_scope.return memref.alloca_scope.return
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/test/Conversion/MemRefToLLVM/convert-dynamic-memref-ops.mlir

// RUN: mlir-opt -split-input-file -convert-memref-to-llvm %s | FileCheck %s // RUN: mlir-opt -split-input-file -finalize-memref-to-llvm %s | FileCheck %s
// RUN: mlir-opt -split-input-file -convert-memref-to-llvm='use-aligned-alloc=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC // RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='use-aligned-alloc=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC
// RUN: mlir-opt -split-input-file -convert-memref-to-llvm='index-bitwidth=32' %s | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt -split-input-file -finalize-memref-to-llvm='index-bitwidth=32' %s | FileCheck --check-prefix=CHECK32 %s
// CHECK-LABEL: func @mixed_alloc( // CHECK-LABEL: func @mixed_alloc(
// CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index) // CHECK: %[[Marg:.*]]: index, %[[Narg:.*]]: index)
func.func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> { func.func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> {
// CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]] // CHECK-DAG: %[[M:.*]] = builtin.unrealized_conversion_cast %[[Marg]]
// CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]] // CHECK-DAG: %[[N:.*]] = builtin.unrealized_conversion_cast %[[Narg]]
// CHECK: %[[c42:.*]] = llvm.mlir.constant(42 : index) : i64 // CHECK: %[[c42:.*]] = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64 // CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
▲ Show 20 Lines • Show All 742 Lines • Show Last 20 Lines

mlir/test/Conversion/MemRefToLLVM/convert-static-memref-ops.mlir

// RUN: mlir-opt -convert-memref-to-llvm -split-input-file %s | FileCheck %s // RUN: mlir-opt -finalize-memref-to-llvm -split-input-file %s | FileCheck %s
// CHECK-LABEL: func @zero_d_alloc() // CHECK-LABEL: func @zero_d_alloc()
func.func @zero_d_alloc() -> memref<f32> { func.func @zero_d_alloc() -> memref<f32> {
// CHECK: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64 // CHECK: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32> // CHECK: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<f32>
// CHECK: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32> // CHECK: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
// CHECK: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64 // CHECK: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
// CHECK: llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8> // CHECK: llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

mlir/test/Conversion/MemRefToLLVM/expand-then-convert-to-llvm.mlir

// RUN: mlir-opt -expand-strided-metadata -convert-memref-to-llvm -lower-affine -convert-arith-to-llvm -cse %s -split-input-file | FileCheck %s // RUN: mlir-opt -expand-strided-metadata -finalize-memref-to-llvm -lower-affine -convert-arith-to-llvm -cse %s -split-input-file | FileCheck %s
// //
// This test demonstrates a full "memref to llvm" pipeline where // This test demonstrates a full "memref to llvm" pipeline where
// we first expand some of the memref operations (using affine, // we first expand some of the memref operations (using affine,
// arith, and memref operations) and convert each individual // arith, and memref operations) and convert each individual
// dialect to llvm. // dialect to llvm.
// //
// Note: We run CSE in that test to get rid of duplicated // Note: We run CSE in that test to get rid of duplicated
// unrealized_conversion_cast that are inserted with // unrealized_conversion_cast that are inserted with
// convert-memref-to-llvm and then convert-arith-to-llvm. // finalize-memref-to-llvm and then convert-arith-to-llvm.
// The final code is still not perfect, because we have // The final code is still not perfect, because we have
// noop unrealized_conversion_cast from i64 to index // noop unrealized_conversion_cast from i64 to index
// and back. // and back.
// ----- // -----
// Final offset = baseOffset + subOffset0 * baseStride0 + subOffset1 * baseStride1 // Final offset = baseOffset + subOffset0 * baseStride0 + subOffset1 * baseStride1
// = 0 + %arg0 * 4 + %arg1 * 1 // = 0 + %arg0 * 4 + %arg1 * 1
▲ Show 20 Lines • Show All 652 Lines • Show Last 20 Lines

mlir/test/Conversion/MemRefToLLVM/generic-functions.mlir

// RUN: mlir-opt -pass-pipeline="builtin.module(convert-memref-to-llvm{use-generic-functions=1})" -split-input-file %s \ // RUN: mlir-opt -pass-pipeline="builtin.module(finalize-memref-to-llvm{use-generic-functions=1})" -split-input-file %s \
// RUN: | FileCheck %s --check-prefix="CHECK-NOTALIGNED" // RUN: | FileCheck %s --check-prefix="CHECK-NOTALIGNED"
// RUN: mlir-opt -pass-pipeline="builtin.module(convert-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1})" -split-input-file %s \ // RUN: mlir-opt -pass-pipeline="builtin.module(finalize-memref-to-llvm{use-generic-functions=1 use-aligned-alloc=1})" -split-input-file %s \
// RUN: | FileCheck %s --check-prefix="CHECK-ALIGNED" // RUN: | FileCheck %s --check-prefix="CHECK-ALIGNED"
// CHECK-LABEL: func @alloc() // CHECK-LABEL: func @alloc()
func.func @zero_d_alloc() -> memref<f32> { func.func @zero_d_alloc() -> memref<f32> {
// CHECK-NOTALIGNED: llvm.call @_mlir_memref_to_llvm_alloc(%{{.*}}) : (i64) -> !llvm.ptr<i8> // CHECK-NOTALIGNED: llvm.call @_mlir_memref_to_llvm_alloc(%{{.*}}) : (i64) -> !llvm.ptr<i8>
// CHECK-ALIGNED: llvm.call @_mlir_memref_to_llvm_aligned_alloc(%{{.*}}, %{{.*}}) : (i64, i64) -> !llvm.ptr<i8> // CHECK-ALIGNED: llvm.call @_mlir_memref_to_llvm_aligned_alloc(%{{.*}}, %{{.*}}) : (i64, i64) -> !llvm.ptr<i8>
%0 = memref.alloc() : memref<f32> %0 = memref.alloc() : memref<f32>
return %0 : memref<f32> return %0 : memref<f32>
Show All 11 Lines

mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir

// RUN: mlir-opt -convert-memref-to-llvm %s -split-input-file | FileCheck %s // RUN: mlir-opt -finalize-memref-to-llvm %s -split-input-file | FileCheck %s
// RUN: mlir-opt -convert-memref-to-llvm='index-bitwidth=32' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt -finalize-memref-to-llvm='index-bitwidth=32' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
// CHECK-LABEL: func @view( // CHECK-LABEL: func @view(
// CHECK: %[[ARG0F:.*]]: index, %[[ARG1F:.*]]: index, %[[ARG2F:.*]]: index // CHECK: %[[ARG0F:.*]]: index, %[[ARG1F:.*]]: index, %[[ARG2F:.*]]: index
func.func @view(%arg0 : index, %arg1 : index, %arg2 : index) { func.func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]] // CHECK: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F:.*]]
// CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[ARG0F:.*]] // CHECK: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[ARG0F:.*]]
// CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1F:.*]] // CHECK: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1F:.*]]
// CHECK: llvm.mlir.constant(2048 : index) : i64 // CHECK: llvm.mlir.constant(2048 : index) : i64
▲ Show 20 Lines • Show All 529 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Async/CPU/microbench-linalg-async-parallel-for.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-linalg-to-parallel-loops \ // RUN: -convert-linalg-to-parallel-loops \
// RUN: -async-parallel-for \ // RUN: -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Async/CPU/microbench-scf-async-parallel-for.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -async-parallel-for \ // RUN: -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -async-parallel-for=async-dispatch=false \ // RUN: -async-parallel-for=async-dispatch=false \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -convert-linalg-to-loops \ // RUN: -convert-linalg-to-loops \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O3 \ // RUN: -e entry -entry-point-result=void -O3 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-1d.mlir

// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-policy-based-ref-counting \ // RUN: -async-runtime-policy-based-ref-counting \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \ // RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \
// RUN: num-workers=20 \ // RUN: num-workers=20 \
// RUN: min-task-size=1" \ // RUN: min-task-size=1" \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -memref-expand \ // RUN: -memref-expand \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Async/CPU/test-async-parallel-for-2d.mlir

// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for \ // RUN: mlir-opt %s -async-parallel-for \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-policy-based-ref-counting \ // RUN: -async-runtime-policy-based-ref-counting \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \ // RUN: mlir-opt %s -async-parallel-for="async-dispatch=false \
// RUN: num-workers=20 \ // RUN: num-workers=20 \
// RUN: min-task-size=1" \ // RUN: min-task-size=1" \
// RUN: -async-to-async-runtime \ // RUN: -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \ // RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \ // RUN: -async-runtime-ref-counting-opt \
// RUN: -arith-expand \ // RUN: -arith-expand \
// RUN: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-cf \ // RUN: -convert-scf-to-cf \
// RUN: -convert-memref-to-llvm \ // RUN: -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm \ // RUN: -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts \ // RUN: -reconcile-unrealized-casts \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void -O0 \ // RUN: -e entry -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Complex/CPU/correctness.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: -func-bufferize -tensor-bufferize -arith-bufferize --canonicalize \ // RUN: -func-bufferize -tensor-bufferize -arith-bufferize --canonicalize \
// RUN: -convert-scf-to-cf --convert-complex-to-standard \ // RUN: -convert-scf-to-cf --convert-complex-to-standard \
// RUN: -convert-memref-to-llvm -convert-math-to-llvm -convert-math-to-libm \ // RUN: -finalize-memref-to-llvm -convert-math-to-llvm -convert-math-to-libm \
// RUN: -convert-vector-to-llvm -convert-complex-to-llvm \ // RUN: -convert-vector-to-llvm -convert-complex-to-llvm \
// RUN: -convert-func-to-llvm -reconcile-unrealized-casts |\ // RUN: -convert-func-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner \ // RUN: mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void \ // RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\
// RUN: FileCheck %s // RUN: FileCheck %s
// XFAIL: target=aarch64{{.*}} // XFAIL: target=aarch64{{.*}}
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/LLVMIR/CPU/test-complex-sparse-constant.mlir

// RUN: mlir-opt %s --convert-memref-to-llvm | \ // RUN: mlir-opt %s --finalize-memref-to-llvm | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void // RUN: mlir-cpu-runner -e entry -entry-point-result=void
// //
// Code should not crash on the complex32 sparse constant. // Code should not crash on the complex32 sparse constant.
// //
module attributes {llvm.data_layout = ""} { module attributes {llvm.data_layout = ""} {
memref.global "private" constant @"__constant_32xcomplex<f32>_0" : memref<32xcomplex<f32>> = memref.global "private" constant @"__constant_32xcomplex<f32>_0" : memref<32xcomplex<f32>> =
sparse<[[1], [28], [31]], sparse<[[1], [28], [31]],
[(1.000000e+00,0.000000e+00), (2.000000e+00,0.000000e+00), (3.000000e+00,0.000000e+00)] [(1.000000e+00,0.000000e+00), (2.000000e+00,0.000000e+00), (3.000000e+00,0.000000e+00)]
> {alignment = 128 : i64} > {alignment = 128 : i64}
llvm.func @entry() { llvm.func @entry() {
%0 = memref.get_global @"__constant_32xcomplex<f32>_0" : memref<32xcomplex<f32>> %0 = memref.get_global @"__constant_32xcomplex<f32>_0" : memref<32xcomplex<f32>>
llvm.return llvm.return
} }
} }

mlir/test/Integration/Dialect/LLVMIR/CPU/test-vp-intrinsic.mlir

// RUN: mlir-opt %s -convert-vector-to-llvm -convert-memref-to-llvm \ // RUN: mlir-opt %s -convert-vector-to-llvm -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry \ // RUN: %lli --entry-function=entry \
// RUN: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
memref.global "private" @gv_i32 : memref<20xi32> = memref.global "private" @gv_i32 : memref<20xi32> =
dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
Show All 23 Lines

mlir/test/Integration/Dialect/Linalg/CPU/matmul-vs-matvec.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
func.func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) { func.func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/rank-reducing-subview.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
func.func @main() { func.func @main() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
Show All 30 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-collapse-tensor.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \ // RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \
// RUN: -expand-strided-metadata -lower-affine \ // RUN: -expand-strided-metadata -lower-affine \
// RUN: -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%const = arith.constant dense<[[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997]],[[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]]],[[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966]],[[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]]> : tensor<2x2x3x2xf32> %const = arith.constant dense<[[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997]],[[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]]],[[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966]],[[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]]> : tensor<2x2x3x2xf32>
%dynamic = tensor.cast %const: tensor<2x2x3x2xf32> to tensor<2x?x?x?xf32> %dynamic = tensor.cast %const: tensor<2x2x3x2xf32> to tensor<2x?x?x?xf32>
Show All 26 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-call.mlir

// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
// Creates and returns a 1-D buffer of size %s1 filled with the value %f // Creates and returns a 1-D buffer of size %s1 filled with the value %f
func.func @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> { func.func @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-1d-nwc-wcf-call.mlir

// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
// Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> { func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-call.mlir

// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
// Creates and returns a 2-D buffer of size (%s1, %s2) filled with the value %f // Creates and returns a 2-D buffer of size (%s1, %s2) filled with the value %f
func.func @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> { func.func @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-2d-nhwc-hwcf-call.mlir

// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
// Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f // Creates and returns 4-D buffer of size (%s1, %s2, %s3, %s4) filled with the value %f
func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> memref<?x?x?x?xf32> { func.func @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> memref<?x?x?x?xf32> {
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-call.mlir

// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
// Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f // Creates and returns 3-D buffer of size (%s1, %s2, %s3) filled with the value %f
func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> { func.func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-conv-3d-ndhwc-dhwcf-call.mlir

// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
// Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f // Creates and returns 5-D buffer of size (%s1, %s2, %s3, %s4, %s5) filled with the value %f
func.func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> memref<?x?x?x?x?xf32> { func.func @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> memref<?x?x?x?x?xf32> {
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-elementwise.mlir

// RUN: mlir-opt %s -convert-elementwise-to-linalg \ // RUN: mlir-opt %s -convert-elementwise-to-linalg \
// RUN: -arith-bufferize -linalg-bufferize -tensor-bufferize \ // RUN: -arith-bufferize -linalg-bufferize -tensor-bufferize \
// RUN: -func-bufferize -buffer-deallocation -convert-linalg-to-loops \ // RUN: -func-bufferize -buffer-deallocation -convert-linalg-to-loops \
// RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-func-to-llvm \ // RUN: -convert-linalg-to-llvm --finalize-memref-to-llvm -convert-func-to-llvm \
// RUN: -reconcile-unrealized-casts | \ // RUN: -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%a = arith.constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32> %a = arith.constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32>
%b = arith.constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32> %b = arith.constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32>
Show All 11 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-expand-tensor.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \ // RUN: -finalizing-bufferize -buffer-deallocation -convert-linalg-to-llvm \
// RUN: -expand-strided-metadata -lower-affine \ // RUN: -expand-strided-metadata -lower-affine \
// RUN: -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%const = arith.constant dense<[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997],[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]],[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966],[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]> : tensor<2x6x2xf32> %const = arith.constant dense<[[[-3.9058,0.9072],[-2.9470,-2.2055],[18.3946,8.2997],[3.4700,5.9006],[-17.2267,4.9777],[1.0450,-0.8201]],[[17.6996,-11.1763],[26.7775,-3.8823],[-4.2492,-5.8966],[2.1259,13.1794],[-10.7136,0.8428],[16.4233,9.4589]]]> : tensor<2x6x2xf32>
%dynamic = tensor.cast %const: tensor<2x6x2xf32> to tensor<2x?x?xf32> %dynamic = tensor.cast %const: tensor<2x6x2xf32> to tensor<2x?x?xf32>
Show All 27 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-one-shot-bufferize.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(canonicalize,cse),one-shot-bufferize{bufferize-function-boundaries})" |\ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(canonicalize,cse),one-shot-bufferize{bufferize-function-boundaries})" |\
// RUN: mlir-opt -pass-pipeline="builtin.module(func.func(buffer-deallocation,convert-vector-to-scf,lower-affine,convert-linalg-to-loops))" |\ // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(buffer-deallocation,convert-vector-to-scf,lower-affine,convert-linalg-to-loops))" |\
// RUN: mlir-opt -pass-pipeline="builtin.module(func.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,expand-strided-metadata,lower-affine,convert-arith-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(canonicalize,convert-scf-to-cf),convert-vector-to-llvm,expand-strided-metadata,lower-affine,convert-arith-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\
// RUN: FileCheck %s // RUN: FileCheck %s
#map0 = affine_map<(d0, d1)[s0] -> ((d1 - d0) ceildiv s0)> #map0 = affine_map<(d0, d1)[s0] -> ((d1 - d0) ceildiv s0)>
#map1 = affine_map<(d0, d1)[s0] -> ((d0 - d1) ceildiv s0)> #map1 = affine_map<(d0, d1)[s0] -> ((d0 - d1) ceildiv s0)>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-padtensor.mlir

// RUN: mlir-opt %s -test-linalg-transform-patterns=test-linalg-to-vector-patterns \ // RUN: mlir-opt %s -test-linalg-transform-patterns=test-linalg-to-vector-patterns \
// RUN: -empty-tensor-to-alloc-tensor -linalg-bufferize -arith-bufferize \ // RUN: -empty-tensor-to-alloc-tensor -linalg-bufferize -arith-bufferize \
// RUN: -bufferization-bufferize -tensor-bufferize -func-bufferize \ // RUN: -bufferization-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation \ // RUN: -finalizing-bufferize -buffer-deallocation \
// RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%const = arith.constant dense<[[[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]]]> : tensor<1x2x3xf32> %const = arith.constant dense<[[[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]]]> : tensor<1x2x3xf32>
%dynamic = tensor.cast %const: tensor<1x2x3xf32> to tensor<1x?x3xf32> %dynamic = tensor.cast %const: tensor<1x2x3xf32> to tensor<1x?x3xf32>
Show All 21 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-subtensor-insert-multiple-uses.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation \ // RUN: -finalizing-bufferize -buffer-deallocation \
// RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%const = arith.constant dense<10.0> : tensor<2xf32> %const = arith.constant dense<10.0> : tensor<2xf32>
%insert_val = arith.constant dense<20.0> : tensor<1xf32> %insert_val = arith.constant dense<20.0> : tensor<1xf32>
Show All 25 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-subtensor-insert.mlir

// RUN: mlir-opt %s -linalg-bufferize \ // RUN: mlir-opt %s -linalg-bufferize \
// RUN: -arith-bufferize -tensor-bufferize -func-bufferize \ // RUN: -arith-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -buffer-deallocation \ // RUN: -finalizing-bufferize -buffer-deallocation \
// RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-loops -convert-scf-to-cf -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%const = arith.constant dense<10.0> : tensor<2xf32> %const = arith.constant dense<10.0> : tensor<2xf32>
%insert_val = arith.constant dense<20.0> : tensor<1xf32> %insert_val = arith.constant dense<20.0> : tensor<1xf32>
%inserted = tensor.insert_slice %insert_val into %const[0][1][1] : tensor<1xf32> into tensor<2xf32> %inserted = tensor.insert_slice %insert_val into %const[0][1][1] : tensor<1xf32> into tensor<2xf32>
Show All 12 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-e2e.mlir

// RUN: mlir-opt %s -arith-bufferize -linalg-bufferize \ // RUN: mlir-opt %s -arith-bufferize -linalg-bufferize \
// RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops \ // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops \
// RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @foo() -> tensor<4xf32> { func.func @foo() -> tensor<4xf32> {
%0 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : tensor<4xf32> %0 = arith.constant dense<[1.0, 2.0, 3.0, 4.0]> : tensor<4xf32>
return %0 : tensor<4xf32> return %0 : tensor<4xf32>
} }
Show All 25 Lines

mlir/test/Integration/Dialect/Linalg/CPU/test-tensor-matmul.mlir

// UNSUPPORTED: asan // UNSUPPORTED: asan
// RUN: mlir-opt %s -test-transform-dialect-erase-schedule -linalg-bufferize -arith-bufferize \ // RUN: mlir-opt %s -test-transform-dialect-erase-schedule -linalg-bufferize -arith-bufferize \
// RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops -convert-scf-to-cf \ // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -buffer-deallocation -convert-linalg-to-loops -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -linalg-bufferize \ // RUN: mlir-opt %s -test-transform-dialect-interpreter -test-transform-dialect-erase-schedule -linalg-bufferize \
// RUN: -scf-bufferize -arith-bufferize -tensor-bufferize \ // RUN: -scf-bufferize -arith-bufferize -tensor-bufferize \
// RUN: -func-bufferize \ // RUN: -func-bufferize \
// RUN: -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-cf -convert-scf-to-cf \ // RUN: -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-cf -convert-scf-to-cf \
// RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-linalg-to-llvm -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-scf-to-cf --finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func @main() { func.func @main() {
%A = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> %A = arith.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
%B = arith.constant dense<[[1.0, 2.0, 3.0, 4.0], %B = arith.constant dense<[[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0], [5.0, 6.0, 7.0, 8.0],
Show All 24 Lines

mlir/test/Integration/Dialect/Memref/cast-runtime-verification.mlir

// RUN: mlir-opt %s -generate-runtime-verification -convert-memref-to-llvm \ // RUN: mlir-opt %s -generate-runtime-verification -finalize-memref-to-llvm \
// RUN: -test-cf-assert \ // RUN: -test-cf-assert \
// RUN: -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext 2>&1 | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext 2>&1 | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @cast_to_static_dim(%m: memref<?xf32>) -> memref<10xf32> { func.func @cast_to_static_dim(%m: memref<?xf32>) -> memref<10xf32> {
%0 = memref.cast %m : memref<?xf32> to memref<10xf32> %0 = memref.cast %m : memref<?xf32> to memref<10xf32>
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Memref/memref_abi.c

// Split the MLIR string: this will produce %t/input.mlir // Split the MLIR string: this will produce %t/input.mlir
// RUN: split-file %s %t // RUN: split-file %s %t
// Compile the MLIR file to LLVM: // Compile the MLIR file to LLVM:
// RUN: mlir-opt %t/input.mlir \ // RUN: mlir-opt %t/input.mlir \
// RUN: -lower-affine -convert-scf-to-cf -convert-memref-to-llvm \ // RUN: -lower-affine -convert-scf-to-cf -finalize-memref-to-llvm \
// RUN: -convert-func-to-llvm -reconcile-unrealized-casts \ // RUN: -convert-func-to-llvm -reconcile-unrealized-casts \
// RUN: | mlir-translate --mlir-to-llvmir -o %t.ll // RUN: | mlir-translate --mlir-to-llvmir -o %t.ll
// Generate an object file for the MLIR code // Generate an object file for the MLIR code
// RUN: llc %t.ll -o %t.o -filetype=obj // RUN: llc %t.ll -o %t.o -filetype=obj
// Compile the current C file and link it to the MLIR code: // Compile the current C file and link it to the MLIR code:
// RUN: %host_cc %s %t.o -o %t.exe // RUN: %host_cc %s %t.o -o %t.exe
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Standard/CPU/test-ceil-floor-pos-neg.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf,memref-expand,arith-expand),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf,memref-expand,arith-expand),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_read_2d(%A : memref<40xi32>, %base1: index) { func.func @transfer_read_2d(%A : memref<40xi32>, %base1: index) {
%i42 = arith.constant -42: i32 %i42 = arith.constant -42: i32
%f = vector.transfer_read %A[%base1], %i42 %f = vector.transfer_read %A[%base1], %i42
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Standard/CPU/test_subview.mlir

// RUN: mlir-opt %s -expand-strided-metadata -lower-affine -convert-arith-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -expand-strided-metadata -lower-affine -convert-arith-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s
memref.global "private" constant @__constant_5x3xf32 : memref<5x3xf32> = memref.global "private" constant @__constant_5x3xf32 : memref<5x3xf32> =
dense<[[0.0, 1.0, 2.0], dense<[[0.0, 1.0, 2.0],
[3.0, 4.0, 5.0], [3.0, 4.0, 5.0],
[6.0, 7.0, 8.0], [6.0, 7.0, 8.0],
[9.0, 10.0, 11.0], [9.0, 10.0, 11.0],
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-mulf-full.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \
// RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \ // RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \
// RUN: -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \
// RUN: --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
// Multiply full size tiles into zero destination. // Multiply full size tiles into zero destination.
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-mulf.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
// Multiply into zeroed destination. // Multiply into zeroed destination.
func.func @kernel1(%arg0: memref<2x4xbf16>, func.func @kernel1(%arg0: memref<2x4xbf16>,
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-muli-ext.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
func.func @print(%arg0: memref<16x4xi32>) { func.func @print(%arg0: memref<16x4xi32>) {
%iu = arith.constant -1: i32 %iu = arith.constant -1: i32
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-muli-full.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf \
// RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \ // RUN: -arith-bufferize -convert-vector-to-llvm="enable-amx" \
// RUN: -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" \
// RUN: --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
// Multiply full size tiles into zero destination. // Multiply full size tiles into zero destination.
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-muli.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
// Multiply into zeroed destination. // Multiply into zeroed destination.
func.func @kernel1(%arg0: memref<2x8xi8>, func.func @kernel1(%arg0: memref<2x8xi8>,
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-tilezero-block.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
func.func @print(%arg0: memref<4x32xf32>) { func.func @print(%arg0: memref<4x32xf32>) {
%fu = arith.constant -1.0: f32 %fu = arith.constant -1.0: f32
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/AMX/test-tilezero.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-amx" -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AMX. // Note: To run this test, your CPU must support AMX.
func.func @tilezero(%arg0: memref<?x?xi32>, %i: index, %j: index) { func.func @tilezero(%arg0: memref<?x?xi32>, %i: index, %j: index) {
%1 = amx.tile_zero : vector<16x16xi32> %1 = amx.tile_zero : vector<16x16xi32>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/ArmSVE/test-sve.mlir

// RUN: mlir-opt %s -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-arm-sve" -convert-memref-to-llvm -convert-func-to-llvm -convert-arith-to-llvm -canonicalize | \ // RUN: mlir-opt %s -lower-affine -convert-scf-to-cf -convert-vector-to-llvm="enable-arm-sve" -finalize-memref-to-llvm -convert-func-to-llvm -convert-arith-to-llvm -canonicalize | \
// RUN: mlir-translate -mlir-to-llvmir | \ // RUN: mlir-translate -mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --march=aarch64 --mattr="+sve" --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --march=aarch64 --mattr="+sve" --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support SVE // Note: To run this test, your CPU must support SVE
// VLA memcopy // VLA memcopy
func.func @kernel_copy(%src : memref<?xi64>, %dst : memref<?xi64>, %size : index) { func.func @kernel_copy(%src : memref<?xi64>, %dst : memref<?xi64>, %size : index) {
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-inline-asm-vector-avx512.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1' -convert-arith-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1' -convert-arith-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-translate --mlir-to-llvmir |\ // RUN: mlir-translate --mlir-to-llvmir |\
// RUN: %lli --entry-function=entry --mattr="avx512f" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\ // RUN: %lli --entry-function=entry --mattr="avx512f" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext |\
// RUN: FileCheck %s // RUN: FileCheck %s
module { module {
// an array of 16 i32 of values [0..15] // an array of 16 i32 of values [0..15]
llvm.mlir.global private @const16( llvm.mlir.global private @const16(
Show All 32 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-sparse-dot-product.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm="enable-x86vector" -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm="enable-x86vector" -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// This test shows how to implement a sparse vector-vector dot product with // This test shows how to implement a sparse vector-vector dot product with
// AVX512. It uses vp2intersect, mask.compress and vector.contract to compute // AVX512. It uses vp2intersect, mask.compress and vector.contract to compute
// the dot product of two sparse HW vectors of 8 float64 elements ("segment"). // the dot product of two sparse HW vectors of 8 float64 elements ("segment").
// Each sparse vector is represented by an index memref (A or C) and by a data // Each sparse vector is represented by an index memref (A or C) and by a data
▲ Show 20 Lines • Show All 468 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-0-d-vectors.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @extract_element_0d(%a: vector<f32>) { func.func @extract_element_0d(%a: vector<f32>) {
%1 = vector.extractelement %a[] : vector<f32> %1 = vector.extractelement %a[] : vector<f32>
// CHECK: 42 // CHECK: 42
vector.print %1: f32 vector.print %1: f32
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-compress.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @compress16(%base: memref<?xf32>, func.func @compress16(%base: memref<?xf32>,
%mask: vector<16xi1>, %value: vector<16xf32>) { %mask: vector<16xi1>, %value: vector<16xf32>) {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
vector.compressstore %base[%c0], %mask, %value vector.compressstore %base[%c0], %mask, %value
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-expand.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @expand16(%base: memref<?xf32>, func.func @expand16(%base: memref<?xf32>,
%mask: vector<16xi1>, %mask: vector<16xi1>,
%pass_thru: vector<16xf32>) -> vector<16xf32> { %pass_thru: vector<16xf32>) -> vector<16xf32> {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-gather.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @gather8(%base: memref<?xf32>, %indices: vector<8xi32>, func.func @gather8(%base: memref<?xf32>, %indices: vector<8xi32>,
%mask: vector<8xi1>, %pass_thru: vector<8xf32>) -> vector<8xf32> { %mask: vector<8xi1>, %pass_thru: vector<8xf32>) -> vector<8xf32> {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
%g = vector.gather %base[%c0][%indices], %mask, %pass_thru %g = vector.gather %base[%c0][%indices], %mask, %pass_thru
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-maskedload.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @maskedload16(%base: memref<?xf32>, %mask: vector<16xi1>, func.func @maskedload16(%base: memref<?xf32>, %mask: vector<16xi1>,
%pass_thru: vector<16xf32>) -> vector<16xf32> { %pass_thru: vector<16xf32>) -> vector<16xf32> {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
%ld = vector.maskedload %base[%c0], %mask, %pass_thru %ld = vector.maskedload %base[%c0], %mask, %pass_thru
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-maskedstore.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @maskedstore16(%base: memref<?xf32>, func.func @maskedstore16(%base: memref<?xf32>,
%mask: vector<16xi1>, %value: vector<16xf32>) { %mask: vector<16xi1>, %value: vector<16xf32>) {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
vector.maskedstore %base[%c0], %mask, %value vector.maskedstore %base[%c0], %mask, %value
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-realloc.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts |\ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext
// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm='use-aligned-alloc=1' -convert-func-to-llvm -arith-expand -reconcile-unrealized-casts |\ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm='use-aligned-alloc=1' -convert-func-to-llvm -arith-expand -reconcile-unrealized-casts |\
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func.func @entry() { func.func @entry() {
// Set up memory. // Set up memory.
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
%c1 = arith.constant 1: index %c1 = arith.constant 1: index
%c8 = arith.constant 8: index %c8 = arith.constant 8: index
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-scatter.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @scatter8(%base: memref<?xf32>, func.func @scatter8(%base: memref<?xf32>,
%indices: vector<8xi32>, %indices: vector<8xi32>,
%mask: vector<8xi1>, %value: vector<8xf32>) { %mask: vector<8xi1>, %value: vector<8xf32>) {
%c0 = arith.constant 0: index %c0 = arith.constant 0: index
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-sparse-dot-matvec.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations // Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations
// of the vector dialect (and some std/scf). Essentially, this example performs // of the vector dialect (and some std/scf). Essentially, this example performs
// the following multiplication: // the following multiplication:
// //
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-sparse-saxpy-jagged-matvec.mlir

// RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations // Illustrates an 8x8 Sparse Matrix x Vector implemented with only operations
// of the vector dialect (and some std/scf). Essentially, this example performs // of the vector dialect (and some std/scf). Essentially, this example performs
// the following multiplication: // the following multiplication:
// //
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-1d.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,expand-strided-metadata,lower-affine,convert-arith-to-llvm,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,expand-strided-metadata,lower-affine,convert-arith-to-llvm,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},expand-strided-metadata,lower-affine,convert-arith-to-llvm,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},expand-strided-metadata,lower-affine,convert-arith-to-llvm,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Test for special cases of 1D vector transfer ops. // Test for special cases of 1D vector transfer ops.
memref.global "private" @gv : memref<5x6xf32> = memref.global "private" @gv : memref<5x6xf32> =
dense<[[0. , 1. , 2. , 3. , 4. , 5. ], dense<[[0. , 1. , 2. , 3. , 4. , 5. ],
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-2d.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
memref.global "private" @gv : memref<3x4xf32> = dense<[[0. , 1. , 2. , 3. ], memref.global "private" @gv : memref<3x4xf32> = dense<[[0. , 1. , 2. , 3. ],
[10., 11., 12., 13.], [10., 11., 12., 13.],
[20., 21., 22., 23.]]> [20., 21., 22., 23.]]>
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read-3d.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_read_3d(%A : memref<?x?x?x?xf32>, func.func @transfer_read_3d(%A : memref<?x?x?x?xf32>,
%o: index, %a: index, %b: index, %c: index) { %o: index, %a: index, %b: index, %c: index) {
%fm42 = arith.constant -42.0: f32 %fm42 = arith.constant -42.0: f32
%f = vector.transfer_read %A[%o, %a, %b, %c], %fm42 %f = vector.transfer_read %A[%o, %a, %b, %c], %fm42
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-read.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_read_1d(%A : memref<?xf32>, %base: index) { func.func @transfer_read_1d(%A : memref<?xf32>, %base: index) {
%fm42 = arith.constant -42.0: f32 %fm42 = arith.constant -42.0: f32
%f = vector.transfer_read %A[%base], %fm42 %f = vector.transfer_read %A[%base], %fm42
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-to-loops.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf,lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-vector-to-scf{full-unroll=true},lower-affine,convert-scf-to-cf),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
#map0 = affine_map<(d0, d1) -> (d1, d0)> #map0 = affine_map<(d0, d1) -> (d1, d0)>
#map1 = affine_map<(d0, d1) -> (d1)> #map1 = affine_map<(d0, d1) -> (d1)>
func.func private @printMemrefF32(memref<*xf32>) func.func private @printMemrefF32(memref<*xf32>)
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-transfer-write.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -convert-scf-to-cf -convert-vector-to-llvm -convert-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \ // RUN: mlir-opt %s -convert-vector-to-scf -convert-scf-to-cf -convert-vector-to-llvm -finalize-memref-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func.func @transfer_write16_inbounds_1d(%A : memref<?xf32>, %base: index) { func.func @transfer_write16_inbounds_1d(%A : memref<?xf32>, %base: index) {
%f = arith.constant 16.0 : f32 %f = arith.constant 16.0 : f32
%v = vector.splat %f : vector<16xf32> %v = vector.splat %f : vector<16xf32>
vector.transfer_write %v, %A[%base] vector.transfer_write %v, %A[%base]
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/LLVM/TestLowerToLLVM.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines pm.addPass(createConvertVectorToLLVMPass(
options.reassociateFPReductions))); options.reassociateFPReductions)));
// Convert Math to LLVM (always needed). // Convert Math to LLVM (always needed).
pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass()); pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
// Expand complicated MemRef operations before lowering them. // Expand complicated MemRef operations before lowering them.
pm.addPass(memref::createExpandStridedMetadataPass()); pm.addPass(memref::createExpandStridedMetadataPass());
// The expansion may create affine expressions. Get rid of them. // The expansion may create affine expressions. Get rid of them.
pm.addPass(createLowerAffinePass()); pm.addPass(createLowerAffinePass());
// Convert MemRef to LLVM (always needed). // Convert MemRef to LLVM (always needed).
pm.addPass(createMemRefToLLVMConversionPass()); pm.addPass(createFinalizeMemRefToLLVMConversionPass());
// Convert Func to LLVM (always needed). // Convert Func to LLVM (always needed).
pm.addPass(createConvertFuncToLLVMPass()); pm.addPass(createConvertFuncToLLVMPass());
// Convert Index to LLVM (always needed). // Convert Index to LLVM (always needed).
pm.addPass(createConvertIndexToLLVMPass()); pm.addPass(createConvertIndexToLLVMPass());
// Convert remaining unrealized_casts (always needed). // Convert remaining unrealized_casts (always needed).
pm.addPass(createReconcileUnrealizedCastsPass()); pm.addPass(createReconcileUnrealizedCastsPass());
} }
} // namespace } // namespace
Show All 12 Lines

mlir/test/mlir-cpu-runner/async-value.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-arith-to-llvm),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// FIXME: https://github.com/llvm/llvm-project/issues/57231 // FIXME: https://github.com/llvm/llvm-project/issues/57231
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/async.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,finalize-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner \ // RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \ // RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// FIXME: https://github.com/llvm/llvm-project/issues/57231 // FIXME: https://github.com/llvm/llvm-project/issues/57231
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/bare-ptr-call-conv.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1},reconcile-unrealized-casts)" | mlir-cpu-runner -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,convert-arith-to-llvm),finalize-memref-to-llvm,convert-func-to-llvm{use-bare-ptr-memref-call-conv=1},reconcile-unrealized-casts)" | mlir-cpu-runner -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s
// Verify bare pointer memref calling convention. `simple_add1_add2_test` // Verify bare pointer memref calling convention. `simple_add1_add2_test`
// gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second // gets two 2xf32 memrefs, adds 1.0f to the first one and 2.0f to the second
// one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2} // one. 'main' calls 'simple_add1_add2_test' with {1, 1} and {2, 2} so {2, 2}
// and {4, 4} are the expected outputs. // and {4, 4} are the expected outputs.
func.func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) { func.func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) {
%c2 = arith.constant 2 : index %c2 = arith.constant 2 : index
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/copy.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,convert-arith-to-llvm),finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func @main() -> () { func.func @main() -> () {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/global-memref.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-arith-to-llvm),finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func private @printMemrefI32(memref<*xi32>) attributes { llvm.emit_c_interface } func.func private @printMemrefI32(memref<*xi32>) attributes { llvm.emit_c_interface }
func.func private @printNewline() -> () func.func private @printNewline() -> ()
memref.global "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]> memref.global "private" @gv0 : memref<4xf32> = dense<[0.0, 1.0, 2.0, 3.0]>
func.func @test1DMemref() { func.func @test1DMemref() {
%0 = memref.get_global @gv0 : memref<4xf32> %0 = memref.get_global @gv0 : memref<4xf32>
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/memref-reinterpret-cast.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf),convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf),finalize-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func @main() -> () { func.func @main() -> () {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/memref-reshape.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,memref-expand,convert-arith-to-llvm),convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-scf-to-cf,memref-expand,convert-arith-to-llvm),finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | mlir-cpu-runner -e main -entry-point-result=void \ // RUN: | mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface } func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
func.func @main() -> () { func.func @main() -> () {
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/sgemm-naive-codegen.mlir

// RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,lower-affine,convert-scf-to-cf,convert-arith-to-llvm),convert-vector-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,lower-affine,convert-scf-to-cf,convert-arith-to-llvm),convert-vector-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func.func @main() { func.func @main() {
%A = memref.alloc() : memref<16x16xf32> %A = memref.alloc() : memref<16x16xf32>
%B = memref.alloc() : memref<16x16xf32> %B = memref.alloc() : memref<16x16xf32>
%C = memref.alloc() : memref<16x16xf32> %C = memref.alloc() : memref<16x16xf32>
%cf1 = arith.constant 1.00000e+00 : f32 %cf1 = arith.constant 1.00000e+00 : f32
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/unranked-memref.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | \
// RUN: mlir-cpu-runner -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -e main -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext,%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
// CHECK: rank = 2 // CHECK: rank = 2
// CHECK-SAME: sizes = [10, 3] // CHECK-SAME: sizes = [10, 3]
// CHECK-SAME: strides = [3, 1] // CHECK-SAME: strides = [3, 1]
// CHECK-COUNT-10: [10, 10, 10] // CHECK-COUNT-10: [10, 10, 10]
// //
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/utils.mlir

// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D
// RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D // RUN: mlir-opt %s -pass-pipeline="builtin.module(func.func(convert-linalg-to-loops,convert-scf-to-cf,convert-arith-to-llvm),convert-linalg-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)" | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%mlir_lib_dir/libmlir_runner_utils%shlibext -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D
func.func @print_0d() { func.func @print_0d() {
%f = arith.constant 2.00000e+00 : f32 %f = arith.constant 2.00000e+00 : f32
%A = memref.alloc() : memref<f32> %A = memref.alloc() : memref<f32>
memref.store %f, %A[]: memref<f32> memref.store %f, %A[]: memref<f32>
%U = memref.cast %A : memref<f32> to memref<*xf32> %U = memref.cast %A : memref<f32> to memref<*xf32>
call @printMemrefF32(%U): (memref<*xf32>) -> () call @printMemrefF32(%U): (memref<*xf32>) -> ()
memref.dealloc %A : memref<f32> memref.dealloc %A : memref<f32>
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

mlir/test/mlir-opt/async.mlir

// Check if mlir marks the corresponding function with required coroutine attribute. // Check if mlir marks the corresponding function with required coroutine attribute.
// //
// RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,convert-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \ // RUN: mlir-opt %s -pass-pipeline="builtin.module(async-to-async-runtime,func.func(async-runtime-ref-counting,async-runtime-ref-counting-opt),convert-async-to-llvm,func.func(convert-linalg-to-loops,convert-scf-to-cf),convert-linalg-to-llvm,finalize-memref-to-llvm,func.func(convert-arith-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}presplitcoroutine // CHECK: llvm.func @async_execute_fn{{.*}}attributes{{.*}}presplitcoroutine
// CHECK: llvm.func @async_execute_fn_0{{.*}}attributes{{.*}}presplitcoroutine // CHECK: llvm.func @async_execute_fn_0{{.*}}attributes{{.*}}presplitcoroutine
// CHECK: llvm.func @async_execute_fn_1{{.*}}attributes{{.*}}presplitcoroutine // CHECK: llvm.func @async_execute_fn_1{{.*}}attributes{{.*}}presplitcoroutine
func.func @main() { func.func @main() {
%i0 = arith.constant 0 : index %i0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

mlir/test/python/execution_engine.py

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines except RuntimeError as e:
log("Got RuntimeError: ", e) log("Got RuntimeError: ", e)
run(testInvalidModule) run(testInvalidModule)
def lowerToLLVM(module): def lowerToLLVM(module):
pm = PassManager.parse( pm = PassManager.parse(
"builtin.module(convert-complex-to-llvm,convert-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)") "builtin.module(convert-complex-to-llvm,finalize-memref-to-llvm,convert-func-to-llvm,reconcile-unrealized-casts)")
pm.run(module) pm.run(module)
return module return module
# Test simple ExecutionEngine execution # Test simple ExecutionEngine execution
# CHECK-LABEL: TEST: testInvokeVoid # CHECK-LABEL: TEST: testInvokeVoid
def testInvokeVoid(): def testInvokeVoid():
with Context(): with Context():
▲ Show 20 Lines • Show All 518 Lines • Show Last 20 Lines

mlir/test/python/integration/dialects/linalg/opsrun.py

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Linesdef transform(module, boilerplate):
pm = PassManager('builtin.module') pm = PassManager('builtin.module')
pm.add("func.func(convert-linalg-to-loops)") pm.add("func.func(convert-linalg-to-loops)")
pm.add("func.func(lower-affine)") pm.add("func.func(lower-affine)")
pm.add("func.func(convert-math-to-llvm)") pm.add("func.func(convert-math-to-llvm)")
pm.add("func.func(convert-scf-to-cf)") pm.add("func.func(convert-scf-to-cf)")
pm.add("func.func(arith-expand)") pm.add("func.func(arith-expand)")
pm.add("func.func(memref-expand)") pm.add("func.func(memref-expand)")
pm.add("convert-vector-to-llvm") pm.add("convert-vector-to-llvm")
pm.add("convert-memref-to-llvm") pm.add("finalize-memref-to-llvm")
pm.add("convert-func-to-llvm") pm.add("convert-func-to-llvm")
pm.add("reconcile-unrealized-casts") pm.add("reconcile-unrealized-casts")
pm.run(mod) pm.run(mod)
return mod return mod
def test_elemwise_builtin(): def test_elemwise_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
▲ Show 20 Lines • Show All 403 Lines • Show Last 20 Lines

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Linesstatic LogicalResult runMLIRPasses(Operation *op,
OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>(); OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>();
modulePM.addPass(spirv::createSPIRVLowerABIAttributesPass()); modulePM.addPass(spirv::createSPIRVLowerABIAttributesPass());
modulePM.addPass(spirv::createSPIRVUpdateVCEPass()); modulePM.addPass(spirv::createSPIRVUpdateVCEPass());
if (options.spirvWebGPUPrepare) if (options.spirvWebGPUPrepare)
modulePM.addPass(spirv::createSPIRVWebGPUPreparePass()); modulePM.addPass(spirv::createSPIRVWebGPUPreparePass());
passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass()); passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass());
LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module)); LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module));
passManager.addPass(createMemRefToLLVMConversionPass()); passManager.addPass(createFinalizeMemRefToLLVMConversionPass());
passManager.addPass(createConvertVectorToLLVMPass()); passManager.addPass(createConvertVectorToLLVMPass());
passManager.nest<func::FuncOp>().addPass(LLVM::createRequestCWrappersPass()); passManager.nest<func::FuncOp>().addPass(LLVM::createRequestCWrappersPass());
passManager.addPass(createConvertFuncToLLVMPass(llvmOptions)); passManager.addPass(createConvertFuncToLLVMPass(llvmOptions));
passManager.addPass(createReconcileUnrealizedCastsPass()); passManager.addPass(createReconcileUnrealizedCastsPass());
passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass()); passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass());
return passManager.run(module); return passManager.run(module);
} }
Show All 28 Lines

mlir/unittests/ExecutionEngine/Invoke.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines LLVMInitializer() {
llvm::InitializeNativeTargetAsmPrinter(); llvm::InitializeNativeTargetAsmPrinter();
} }
} initializer; } initializer;
/// Simple conversion pipeline for the purpose of testing sources written in /// Simple conversion pipeline for the purpose of testing sources written in
/// dialects lowering to LLVM Dialect. /// dialects lowering to LLVM Dialect.
static LogicalResult lowerToLLVMDialect(ModuleOp module) { static LogicalResult lowerToLLVMDialect(ModuleOp module) {
PassManager pm(module->getName()); PassManager pm(module->getName());
pm.addPass(mlir::createMemRefToLLVMConversionPass()); pm.addPass(mlir::createFinalizeMemRefToLLVMConversionPass());
pm.addNestedPass<func::FuncOp>(mlir::createArithToLLVMConversionPass()); pm.addNestedPass<func::FuncOp>(mlir::createArithToLLVMConversionPass());
pm.addPass(mlir::createConvertFuncToLLVMPass()); pm.addPass(mlir::createConvertFuncToLLVMPass());
pm.addPass(mlir::createReconcileUnrealizedCastsPass()); pm.addPass(mlir::createReconcileUnrealizedCastsPass());
return pm.run(module); return pm.run(module);
} }
TEST(MLIRExecutionEngine, SKIP_WITHOUT_JIT(AddInteger)) { TEST(MLIRExecutionEngine, SKIP_WITHOUT_JIT(AddInteger)) {
std::string moduleStr = R"mlir( std::string moduleStr = R"mlir(
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines