This is an archive of the discontinued LLVM Phabricator instance.

Differential D109507

[mlir] Factor type reconciliation out of Standard-to-LLVM conversion
ClosedPublic

Authored by ftynse on Sep 9 2021, 7:06 AM.

Details

Reviewers
nicolasvasilache
aartbik
herhut
Commits
rG8b58ab8ccd81: [mlir] Factor type reconciliation out of Standard-to-LLVM conversion
Summary

Conversion to the LLVM dialect is being refactored to be more progressive and
is now performed as a series of independent passes converting different
dialects. These passes may produce unrealized_conversion_cast operations that
represent pending conversions between built-in and LLVM dialect types.
Historically, a more monolithic Standard-to-LLVM conversion pass did not need
these casts as all operations were converted in one shot. Previous refactorings
have led to the requirement of running the Standard-to-LLVM conversion pass to
clean up unrealized_conversion_casts even though the IR had no standard
operations in it. The pass must have been also run the last among all to-LLVM
passes, in contradiction with the partial conversion logic. Additionally, the
way it was set up could produce invalid operations by removing casts between
LLVM and built-in types even when the consumer did not accept the uncasted
type, or could lead to cryptic conversion errors (recursive application of the
rewrite pattern on unrealized_conversion_cast as a means to indicate failure
to eliminate casts).

In fact, the need to eliminate A->B->A unrealized_conversion_casts is not
specific to to-LLVM conversions and can be factored out into a separate type
reconciliation pass, which is achieved in this commit. While the cast operation
itself has a folder pattern, it is insufficient in most conversion passes as
the folder only applies to the second cast. Without complex legality setup in
the conversion target, the conversion infra will either consider the cast
operations valid and not fold them (a separate canonicalization would be
necessary to trigger the folding), or consider the first cast invalid upon
generation and stop with error. The pattern provided by the reconciliation pass
applies to the first cast operation instead. Furthermore, having a separate
pass makes it clear when unrealized_conversion_casts could not have been
eliminated since it is the only reason why this pass can fail.

Diff Detail

Event Timeline

ftynse created this revision.Sep 9 2021, 7:06 AM
Herald added a reviewer: aartbik. · View Herald TranscriptSep 9 2021, 7:06 AM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added subscribers: wenzhicui, wrengr, Chia-hungDuan and 24 others. · View Herald Transcript
ftynse requested review of this revision.Sep 9 2021, 7:06 AM
Herald added a reviewer: herhut. · View Herald TranscriptSep 9 2021, 7:06 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a subscriber: stephenneuendorffer. · View Herald Transcript
nicolasvasilache accepted this revision.Sep 9 2021, 7:28 AM

Thanks!

IMO this is a welcome improvement to "finalize" getting rid of these pesky conversion casts across pass granularities; seems everyone is hitting those issues these days.

This revision is now accepted and ready to land.Sep 9 2021, 7:28 AM
bondhugula added a subscriber: bondhugula.Sep 9 2021, 7:39 AM
bondhugula added inline comments.
mlir/include/mlir/Conversion/Passes.td
374

If I am understanding this explanation right, why doesn't a folding hook on unrealized_conversion_cast get rid of these when the second pass runs?

Harbormaster completed remote builds in B123214: Diff 371584.Sep 9 2021, 7:41 AM
ftynse updated this revision to Diff 371596.Sep 9 2021, 7:48 AM

Fix a runaway python test

This revision was landed with ongoing or failed builds.Sep 9 2021, 7:51 AM
Closed by commit rG8b58ab8ccd81: [mlir] Factor type reconciliation out of Standard-to-LLVM conversion (authored by ftynse). · Explain Why
This revision was automatically updated to reflect the committed changes.
ftynse added a commit: rG8b58ab8ccd81: [mlir] Factor type reconciliation out of Standard-to-LLVM conversion.
Harbormaster completed remote builds in B123222: Diff 371596.Sep 9 2021, 8:26 AM
ftynse marked an inline comment as done.Sep 9 2021, 9:02 AM
ftynse added inline comments.
mlir/include/mlir/Conversion/Passes.td
374

I envision more complex rules here, e.g., A->B->C->A cast chains, just splitting the refactoring part in a separate diff. Also, there is a bunch of passes that do populateXToYPatterns and won't work with the folder alone, they need a pattern that is exercised by this pass.

rriddle added inline comments.Sep 9 2021, 9:49 AM
mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
56

The name here needs to be updated.

bondhugula added inline comments.Sep 9 2021, 6:56 PM
mlir/include/mlir/Conversion/Passes.td
374

But a method to populate this pattern can just be exposed and added to -convert-std-to-llvm instead of adding a -reconcile-unrealized-casts to virtually every codegen pipeline? Honestly, this would appear like an awkwardly named pass, sort of internal detail, being exposed outside.

bondhugula added inline comments.Sep 9 2021, 7:30 PM
mlir/include/mlir/Conversion/Passes.td
374

But you could always fold A -> B -> C to a A -> C. Wouldn't that suffice? Either this or the explanation here needs an update. You are only looking for cyclic chains? The folder runs every iteration on all ops every iteration of the rewrite driver and on every op on the worklist every iteration until the worklist is empty that iteration, as you already know.

mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
2

Spell fix: Reconcile

38–41

Trivial braces.

44

Both "live" and "unrealized conversion" can be ambiguous to read here; "leftover unrealized conversion cast"?

bondhugula added inline comments.Sep 9 2021, 7:56 PM
mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
24

I think the traversal order isn't important or needed here for soundness: having a pattern like this in any greedy rewrite driver-driven pass will do.

36–50

This looks like it could be handled by a local folding hook. You can just pull the operands of your operands' unique defining op which would be another unrealized-conversion-cast? You wouldn't need to walk any use lists. If this makes sense, you ultimately don't need this rewrite pattern, nor this whole pass itself and the need to add such a pass to any other pass or pass pipeline. Folding + dead code elimination in the greedy rewrite driver will naturally take care of this. In general, it's also more efficient having things in the folding hook since the folding hook is called earlier -- before any canonicalization patterns on the op itself are called.

37

Better to have a code comment here.

mehdi_amini added inline comments.Sep 9 2021, 8:01 PM
mlir/include/mlir/Conversion/Passes.td
374

I'm also wondering what kind of complex cases make it so that we couldn't fold it? It seems best if the "reconciliation" of cast happens eagerly as much as possible in general.

ftynse marked 11 inline comments as done.Sep 10 2021, 5:10 AM

Thanks for additional reviews, changes applied in 61bc6aa5a723438198ba8526b0469ff11b47c489.

mlir/include/mlir/Conversion/Passes.td
374

But a method to populate this pattern can just be exposed and added to -convert-std-to-llvm.

"convert-std-to-llvm" will be removed/refactored along with "std", we shouldn't add new functionality to either of those. Also, you may notice that the new library does _not_ depend on std, so it doesn't incur a spurious dependency on somebody who wants to run it beyond std-to-llvm.

virtually every codegen pipeline

I had to change 3 pass pipelines in this change, 2 of them in testing tools. If you are referring to RUN lines in integration tests, I would be interested to figure out a better way for those than repeating the pass list every time. This is orthogonal to the current change though.

Honestly, this would appear like an awkwardly named pass, sort of internal detail, being exposed outside.

I find having to run "-convert-std-to-llvm" to remove _builtin_ cast operations injected by the dialect conversion (implementation detail of specific passes) converting _builtin_ types to LLVM dialect types in absence of any standard operation, and having to do so after all passes, more awkward than a pass that clearly indicates what it does.

374

But you could always fold A -> B -> C to a A -> C. Wouldn't that suffice? Either this or the explanation here needs an update. You are only looking for cyclic chains?

We could, but we don't. This is also not in scope of this patch, which does the same as folder (A->B->A) but in different order.

The folder runs every iteration on all ops every iteration of the rewrite driver and on every op on the worklist every iteration until the worklist is empty that iteration, as you already know.

As I do actually know since I wrote the first implementation of the dialect conversion infrastructure and reviewed most of the further changes (around the lines we will be looking at 1, 2), the process is slightly more involved and is not entirely worklist-based unlike the greedy driver that is _not_ used by these conversions. The worklist is only computed for the original state of the IR. When a pattern is applied, the infrastructure keeps track of operations created by the pattern and attempts to legalize them _immediately_ after the pattern and _fails_ if they are not legal - https://github.com/llvm/llvm-project/blob/788e7b3b8c285d63a4ef354608240e1376179c79/mlir/lib/Transforms/Utils/DialectConversion.cpp#L1930.

I'm also wondering what kind of complex cases make it so that we couldn't fold it? It seems best if the "reconciliation" of cast happens eagerly as much as possible in general.

The one I have in mind is !pseudo_c_ir.intptr_t -> index -> i64 on one hand and i64 -> !pseudo_c_ir.intptr_t on another hand. Part of the input IR is lowered to a dialect that operates on index and another parent is lowered to the LLVM dialect directly. I haven't had time to work on this case in the pet project of mine, so I cannot say for certain if this will be necessary. My preference would be to reconcile eagerly though!

mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
24

It is important for passes that are not based on the greedy driver. The majority of conversion passes use a different driver.

36–50

As a matter of fact, there is and always has been a folder for the unrealized_conversion_cast. Unfortunately, it is not sufficient as the commit message explains. Conversion passes use the dialect conversion driver rather than the greedy driver. It also calls the folder, but on the _wrong op_. The folder can _only_ be expressed on the second op of the pair because it is not allowed to change other ops than the one being folded. The dialect conversion driver must finalize the first op before proceeding to the second. I haven't benchmarked this but I expect it to be only marginally less efficient because, in most cases, the pattern will either bail out early or find exactly one user that is a backwards cast.

I would allow myself a remark which might come out as snarky or otherwise mean, apologies for that: I would have found the discussion more constructive if we all assumed that folks doing large refactorings, especially in the area where they are de-facto code owners, understand what they are doing sufficiently well and have spent enough effort trying to find the least complex way of changing things.

44

"leftover" doesn't sound right here, this message should explain why the match failed, "leftover" sounds more like final result. Changed to "live unrealized conversion cast". "Live" means used by another operation and already appears in dialect conversion terminology.

56

Good catch, my regexp-fu needs improvement...

jpienaar added a subscriber: jpienaar.Sep 10 2021, 5:35 AM
jpienaar added inline comments.
mlir/include/mlir/Conversion/Passes.td
374

I would be interested to figure out a better way for those than repeating the pass list every time

To avoid repeating pass pipeline, https://mlir.llvm.org/docs/PassManagement/#pass-pipeline-registration and that would have been useful here (that's at textual level/tool level) with a potential matching C++ "addStdToLLVMPasses" or some such (C API side don't know if we have support for this so this would still have caused the breakage it did).

ftynse marked 6 inline comments as done.Sep 10 2021, 5:39 AM
ftynse added inline comments.Sep 10 2021, 5:43 AM
mlir/include/mlir/Conversion/Passes.td
374

To avoid repeating pass pipeline, https://mlir.llvm.org/docs/PassManagement/#pass-pipeline-registration and that would have been useful here (that's at textual level/tool level) with a potential matching C++ "addStdToLLVMPasses" or some such (C API side don't know if we have support for this so this would still have caused the breakage it did).

I thought about this too and there are two questions:

  • Should we put these registrations in mlir-opt or in a separate testing tool?
  • What passes to include? E.g., there are multiple ways to go from Linalg to LLVM and they are exercised by tests, sometimes in the same file.

I also thought about some lit substitutions that live next to the set of files they apply to, so we just have // RUN: mlir-opt %current-pass-pipeline %s in all tests and only need to change current-pass-pipeline once per directory.

bondhugula added inline comments.Sep 10 2021, 8:46 PM
mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
36–50

Folding is always considered a good thing to do as early as possible by design. This is why the greedy rewrite driver has always applied the folding hook for every op in its iteration irrespective of which patterns are in the list or for which ops. If the dialect conversion infra isn't running the folding hook on all ops, that would be inconsistent with the general thinking and one should consider improving that infra and have the folding hook run so that this naturally happens as part of the rewrite driver. I feel this should be explored first instead of making this change to adding an extra cleanup pass for what should have been handled inside of -convert-std-to-llvm.

Post-commit review is completely fine and authors/maintainers thinking so is obviously fine per the LLVM policy. However, I don't think a change like this one without exploring the right direction first is out of line. I would request a revert here.

bondhugula added inline comments.Sep 10 2021, 9:54 PM
mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
36–50

I would have found the discussion more constructive if we all assumed that folks
doing large refactorings, especially in the area where they are de-facto code owners,
understand what they are doing sufficiently well and have spent enough effort trying
to find the least complex way of changing things

This comment and understanding is pretty irrelevant here because it does not and should not prevent other folks from questioning the approach post-review. This is all constructive and purely technical feedback/questions (here and on the discourse from everyone the way I see it) and de-facto code owners should learn to understand and recognize that the questions do not mean "they are not doing sufficiently well or have not spent enough effort trying to find the least complex way of changing things". LLVM's policy already leans in several cases towards post-commit review and revert if needed based on that same understanding as well as in the interest of allowing more rapid development.

ftynse added inline comments.Sep 11 2021, 3:54 AM
mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp
36–50

Folding is always considered a good thing to do as early as possible by design. This is why the greedy rewrite driver has always applied the folding hook for every op in its iteration irrespective of which patterns are in the list or for which ops. If the dialect conversion infra isn't running the folding hook on all ops, that would be inconsistent with the general thinking and one should consider improving that infra and have the folding hook run so that this naturally happens as part of the rewrite driver. I feel this should be explored first instead of making this change to adding an extra cleanup pass for what should have been handled inside of -convert-std-to-llvm.

Well, changes to how the dialect conversion operates is not in scope of this patch, so I fail to see how reverting it would help with anything.

ftynse added a comment.Sep 11 2021, 5:18 AM

There is another way to reason about this change in context of dialect layering if we drop the assumption that unrealized_conversion_cast is special. It is just an op in the "builtin" dialect. All -convert-X-to-llvm passes are, in fact, -convert-X-to-llvm-and-builtin because they produce operations from llvm and builtin dialects. We need to further lower those builtin operations to the LLVM dialect. This is can be done by an appropriate pass, similarly to any other conversion. This pass is just, perhaps misleadingly, called -reconcile-unrealized-casts whereas it should have been called -convert-builtin-to-llvm. Ironically, this was my initial take on this as River noticed.

Therefore, I propose the following:

  • create a -convert-builtin-to-llvm that removes the cast chains specifically between built-in and LLVM dialect types, and leaves the other casts alone if they are present;
  • turn -reconcile-conversion-casts into a test pass for the pattern + folding and use that as testbed to further improve the conversion infrastructure if necessary.

Would that satisfy everyone?

Revision Contents

PathSize
mlir/
include/
mlir/
Conversion/
1 line
25 lines
ReconcileUnrealizedCasts/
27 lines
StandardToLLVM/
1 line
lib/
Conversion/
1 line
GPUCommon/
1 line
ReconcileUnrealizedCasts/
16 lines
78 lines
StandardToLLVM/
5 lines
test/
Conversion/
ComplexToLLVM/
2 lines
ComplexToStandard/
2 lines
StandardToLLVM/
4 lines
Integration/
Dialect/
Async/
CPU/
2 lines
5 lines
3 lines
3 lines
Linalg/
CPU/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
SparseTensor/
CPU/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
Standard/
CPU/
2 lines
2 lines
Vector/
CPU/
AMX/
2 lines
2 lines
2 lines
2 lines
2 lines
X86Vector/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
8 lines
8 lines
4 lines
4 lines
2 lines
2 lines
4 lines
Target/
LLVMIR/
2 lines
mlir-cpu-runner/
1 line
1 line
1 line
1 line
2 lines
2 lines
2 lines
1 line
2 lines
2 lines
2 lines
11 lines
8 lines
python/
dialects/
sparse_tensor/
3 lines
integration/
dialects/
linalg/
3 lines
tools/
mlir-vulkan-runner/
2 lines
unittests/
ExecutionEngine/
2 lines
utils/
bazel/
llvm-project-overlay/
mlir/
16 lines

Diff 371584

mlir/include/mlir/Conversion/Passes.h

Show All 25 Lines
#include "mlir/Conversion/MathToLibm/MathToLibm.h" #include "mlir/Conversion/MathToLibm/MathToLibm.h"
#include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h" #include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h" #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
#include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h" #include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
#include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h" #include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
#include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h" #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
#include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h" #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h" #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
#include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h" #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
#include "mlir/Conversion/SCFToStandard/SCFToStandard.h" #include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
#include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h" #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h"
Show All 18 Lines

mlir/include/mlir/Conversion/Passes.td

Show First 20 Lines • Show All 346 Lines • ▼ Show 20 Lines
def ConvertPDLToPDLInterp : Pass<"convert-pdl-to-pdl-interp", "ModuleOp"> { def ConvertPDLToPDLInterp : Pass<"convert-pdl-to-pdl-interp", "ModuleOp"> {
let summary = "Convert PDL ops to PDL interpreter ops"; let summary = "Convert PDL ops to PDL interpreter ops";
let constructor = "mlir::createPDLToPDLInterpPass()"; let constructor = "mlir::createPDLToPDLInterpPass()";
let dependentDialects = ["pdl_interp::PDLInterpDialect"]; let dependentDialects = ["pdl_interp::PDLInterpDialect"];
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ReconcileUnrealizedCasts
//===----------------------------------------------------------------------===//
def ReconcileUnrealizedCasts : Pass<"reconcile-unrealized-casts"> {
let summary = "Simplify and eliminate unrealized conversion casts";
let description = [{
Eliminate `unrealized_conversion_cast` operations, commonly introduced by
partial dialect conversions, that transitively convert a value to another
value of the same type, that is:
```
%0 = "producer.op"() : () -> !type.A
%1 = unrealized_conversion_cast %0 : !type.A to !type.B
%2 = unrealized_conversion_cast %1 : !type.B to !type.A
"consumer.op"(%2) : (!type.A) -> ()
```
Such situations appear when the consumer operation is converted by one pass
and the producer operation is converted by another pass, each of which
produces an unrealized cast. This pass can be used to clean up the IR.
bondhugulaUnsubmitted
Done
ReplyInline Actions

If I am understanding this explanation right, why doesn't a folding hook on unrealized_conversion_cast get rid of these when the second pass runs?

bondhugula: If I am understanding this explanation right, why doesn't a folding hook on…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

I envision more complex rules here, e.g., A->B->C->A cast chains, just splitting the refactoring part in a separate diff. Also, there is a bunch of passes that do populateXToYPatterns and won't work with the folder alone, they need a pattern that is exercised by this pass.

ftynse: I envision more complex rules here, e.g., A->B->C->A cast chains, just splitting the…
bondhugulaUnsubmitted
Done
ReplyInline Actions

But a method to populate this pattern can just be exposed and added to -convert-std-to-llvm instead of adding a -reconcile-unrealized-casts to virtually every codegen pipeline? Honestly, this would appear like an awkwardly named pass, sort of internal detail, being exposed outside.

bondhugula: But a method to populate this pattern can just be exposed and added to `-convert-std-to-llvm`…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

But a method to populate this pattern can just be exposed and added to -convert-std-to-llvm.

"convert-std-to-llvm" will be removed/refactored along with "std", we shouldn't add new functionality to either of those. Also, you may notice that the new library does _not_ depend on std, so it doesn't incur a spurious dependency on somebody who wants to run it beyond std-to-llvm.

virtually every codegen pipeline

I had to change 3 pass pipelines in this change, 2 of them in testing tools. If you are referring to RUN lines in integration tests, I would be interested to figure out a better way for those than repeating the pass list every time. This is orthogonal to the current change though.

Honestly, this would appear like an awkwardly named pass, sort of internal detail, being exposed outside.

I find having to run "-convert-std-to-llvm" to remove _builtin_ cast operations injected by the dialect conversion (implementation detail of specific passes) converting _builtin_ types to LLVM dialect types in absence of any standard operation, and having to do so after all passes, more awkward than a pass that clearly indicates what it does.

ftynse: > But a method to populate this pattern can just be exposed and added to -convert-std-to-llvm.
jpienaarUnsubmitted
Not Done
ReplyInline Actions

I would be interested to figure out a better way for those than repeating the pass list every time

To avoid repeating pass pipeline, https://mlir.llvm.org/docs/PassManagement/#pass-pipeline-registration and that would have been useful here (that's at textual level/tool level) with a potential matching C++ "addStdToLLVMPasses" or some such (C API side don't know if we have support for this so this would still have caused the breakage it did).

jpienaar: >I would be interested to figure out a better way for those than repeating the pass list every…
ftynseAuthorUnsubmitted
Not Done
ReplyInline Actions

To avoid repeating pass pipeline, https://mlir.llvm.org/docs/PassManagement/#pass-pipeline-registration and that would have been useful here (that's at textual level/tool level) with a potential matching C++ "addStdToLLVMPasses" or some such (C API side don't know if we have support for this so this would still have caused the breakage it did).

I thought about this too and there are two questions:

  • Should we put these registrations in mlir-opt or in a separate testing tool?
  • What passes to include? E.g., there are multiple ways to go from Linalg to LLVM and they are exercised by tests, sometimes in the same file.

I also thought about some lit substitutions that live next to the set of files they apply to, so we just have // RUN: mlir-opt %current-pass-pipeline %s in all tests and only need to change current-pass-pipeline once per directory.

ftynse: > To avoid repeating pass pipeline, https://mlir.llvm.org/docs/PassManagement/#pass-pipeline…
bondhugulaUnsubmitted
Done
ReplyInline Actions

But you could always fold A -> B -> C to a A -> C. Wouldn't that suffice? Either this or the explanation here needs an update. You are only looking for cyclic chains? The folder runs every iteration on all ops every iteration of the rewrite driver and on every op on the worklist every iteration until the worklist is empty that iteration, as you already know.

bondhugula: But you could always fold A -> B -> C to a A -> C. Wouldn't that suffice? Either this or the…
mehdi_aminiUnsubmitted
Done
ReplyInline Actions

I'm also wondering what kind of complex cases make it so that we couldn't fold it? It seems best if the "reconciliation" of cast happens eagerly as much as possible in general.

mehdi_amini: I'm also wondering what kind of complex cases make it so that we couldn't fold it? It seems…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

But you could always fold A -> B -> C to a A -> C. Wouldn't that suffice? Either this or the explanation here needs an update. You are only looking for cyclic chains?

We could, but we don't. This is also not in scope of this patch, which does the same as folder (A->B->A) but in different order.

The folder runs every iteration on all ops every iteration of the rewrite driver and on every op on the worklist every iteration until the worklist is empty that iteration, as you already know.

As I do actually know since I wrote the first implementation of the dialect conversion infrastructure and reviewed most of the further changes (around the lines we will be looking at 1, 2), the process is slightly more involved and is not entirely worklist-based unlike the greedy driver that is _not_ used by these conversions. The worklist is only computed for the original state of the IR. When a pattern is applied, the infrastructure keeps track of operations created by the pattern and attempts to legalize them _immediately_ after the pattern and _fails_ if they are not legal - https://github.com/llvm/llvm-project/blob/788e7b3b8c285d63a4ef354608240e1376179c79/mlir/lib/Transforms/Utils/DialectConversion.cpp#L1930.

I'm also wondering what kind of complex cases make it so that we couldn't fold it? It seems best if the "reconciliation" of cast happens eagerly as much as possible in general.

The one I have in mind is !pseudo_c_ir.intptr_t -> index -> i64 on one hand and i64 -> !pseudo_c_ir.intptr_t on another hand. Part of the input IR is lowered to a dialect that operates on index and another parent is lowered to the LLVM dialect directly. I haven't had time to work on this case in the pet project of mine, so I cannot say for certain if this will be necessary. My preference would be to reconcile eagerly though!

ftynse: > But you could always fold A -> B -> C to a A -> C. Wouldn't that suffice? Either this or the…
}];
let constructor = "mlir::createReconcileUnrealizedCastsPass()";
}
//===----------------------------------------------------------------------===//
// SCFToOpenMP // SCFToOpenMP
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertSCFToOpenMP : FunctionPass<"convert-scf-to-openmp"> { def ConvertSCFToOpenMP : FunctionPass<"convert-scf-to-openmp"> {
let summary = "Convert SCF parallel loop to OpenMP parallel + workshare " let summary = "Convert SCF parallel loop to OpenMP parallel + workshare "
"constructs."; "constructs.";
let constructor = "mlir::createConvertSCFToOpenMPPass()"; let constructor = "mlir::createConvertSCFToOpenMPPass()";
let dependentDialects = ["omp::OpenMPDialect"]; let dependentDialects = ["omp::OpenMPDialect"];
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

mlir/include/mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h

  • This file was added.
//===- ReconcileUnrealizedCasts.h - Pass entrypoint -------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_CONVERSION_RECONCILEUNREALIZEDCASTS_RECONCILEUNREALIZEDCASTS_H_
#define MLIR_CONVERSION_RECONCILEUNREALIZEDCASTS_RECONCILEUNREALIZEDCASTS_H_
#include <memory>
namespace mlir {
class Pass;
class RewritePatternSet;
/// Creates a pass that eliminates noop `unrealized_conversion_cast` operation
/// sequences.
std::unique_ptr<Pass> createReconcileUnrealizedCastsPass();
/// Populates `patterns` with rewrite patterns that eliminate noop
/// `unrealized_conversion_cast` operation sequences.
void populateReconcileUnrealizedCastsPatterns(RewritePatternSet &patterns);
} // namespace mlir
#endif // MLIR_CONVERSION_RECONCILEUNREALIZEDCASTS_RECONCILEUNREALIZEDCASTS_H_

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

Show All 10 Lines
#include <memory> #include <memory>
namespace mlir { namespace mlir {
class LowerToLLVMOptions; class LowerToLLVMOptions;
class ModuleOp; class ModuleOp;
template <typename T> template <typename T>
class OperationPass; class OperationPass;
class Pass;
/// Creates a pass to convert the Standard dialect into the LLVMIR dialect. /// Creates a pass to convert the Standard dialect into the LLVMIR dialect.
/// stdlib malloc/free is used by default for allocating memrefs allocated with /// stdlib malloc/free is used by default for allocating memrefs allocated with
/// memref.alloc, while LLVM's alloca is used for those allocated with /// memref.alloc, while LLVM's alloca is used for those allocated with
/// memref.alloca. /// memref.alloca.
std::unique_ptr<OperationPass<ModuleOp>> createLowerToLLVMPass(); std::unique_ptr<OperationPass<ModuleOp>> createLowerToLLVMPass();
std::unique_ptr<OperationPass<ModuleOp>> std::unique_ptr<OperationPass<ModuleOp>>
createLowerToLLVMPass(const LowerToLLVMOptions &options); createLowerToLLVMPass(const LowerToLLVMOptions &options);
} // namespace mlir } // namespace mlir
#endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_ #endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_

mlir/lib/Conversion/CMakeLists.txt

Show All 15 Lines
add_subdirectory(MathToLLVM) add_subdirectory(MathToLLVM)
add_subdirectory(MathToSPIRV) add_subdirectory(MathToSPIRV)
add_subdirectory(MemRefToLLVM) add_subdirectory(MemRefToLLVM)
add_subdirectory(MemRefToSPIRV) add_subdirectory(MemRefToSPIRV)
add_subdirectory(OpenACCToLLVM) add_subdirectory(OpenACCToLLVM)
add_subdirectory(OpenACCToSCF) add_subdirectory(OpenACCToSCF)
add_subdirectory(OpenMPToLLVM) add_subdirectory(OpenMPToLLVM)
add_subdirectory(PDLToPDLInterp) add_subdirectory(PDLToPDLInterp)
add_subdirectory(ReconcileUnrealizedCasts)
add_subdirectory(SCFToGPU) add_subdirectory(SCFToGPU)
add_subdirectory(SCFToOpenMP) add_subdirectory(SCFToOpenMP)
add_subdirectory(SCFToSPIRV) add_subdirectory(SCFToSPIRV)
add_subdirectory(SCFToStandard) add_subdirectory(SCFToStandard)
add_subdirectory(ShapeToStandard) add_subdirectory(ShapeToStandard)
add_subdirectory(SPIRVToLLVM) add_subdirectory(SPIRVToLLVM)
add_subdirectory(StandardToLLVM) add_subdirectory(StandardToLLVM)
add_subdirectory(StandardToSPIRV) add_subdirectory(StandardToSPIRV)
add_subdirectory(TosaToLinalg) add_subdirectory(TosaToLinalg)
add_subdirectory(TosaToSCF) add_subdirectory(TosaToSCF)
add_subdirectory(TosaToStandard) add_subdirectory(TosaToStandard)
add_subdirectory(VectorToROCDL) add_subdirectory(VectorToROCDL)
add_subdirectory(VectorToLLVM) add_subdirectory(VectorToLLVM)
add_subdirectory(VectorToGPU) add_subdirectory(VectorToGPU)
add_subdirectory(VectorToSCF) add_subdirectory(VectorToSCF)
add_subdirectory(VectorToSPIRV) add_subdirectory(VectorToSPIRV)

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

Show First 20 Lines • Show All 342 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void GpuToLLVMConversionPass::runOnOperation() { void GpuToLLVMConversionPass::runOnOperation() {
LLVMTypeConverter converter(&getContext()); LLVMTypeConverter converter(&getContext());
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addIllegalDialect<gpu::GPUDialect>(); target.addIllegalDialect<gpu::GPUDialect>();
target.addIllegalOp<UnrealizedConversionCastOp>();
populateVectorToLLVMConversionPatterns(converter, patterns); populateVectorToLLVMConversionPatterns(converter, patterns);
populateMemRefToLLVMConversionPatterns(converter, patterns); populateMemRefToLLVMConversionPatterns(converter, patterns);
populateStdToLLVMConversionPatterns(converter, patterns); populateStdToLLVMConversionPatterns(converter, patterns);
populateAsyncStructuralTypeConversionsAndLegality(converter, patterns, populateAsyncStructuralTypeConversionsAndLegality(converter, patterns,
target); target);
populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation); populateGpuToLLVMConversionPatterns(converter, patterns, gpuBinaryAnnotation);
▲ Show 20 Lines • Show All 513 Lines • Show Last 20 Lines

mlir/lib/Conversion/ReconcileUnrealizedCasts/CMakeLists.txt

  • This file was added.
add_mlir_conversion_library(MLIRReconcileUnrealizedCasts
ReconcileUnrealizedCasts.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ReconcileUnrealizedCasts
DEPENDS
MLIRConversionPassIncGen
LINK_COMPONENTS
Core
LINK_LIBS PUBLIC
MLIRIR
MLIRTransforms
)

mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp

  • This file was added.
//===- ReoncileUnrealizedCasts.cpp - Eliminate noop unrealized casts ------===//
//
bondhugulaUnsubmitted
Done
ReplyInline Actions

Spell fix: Reconcile

bondhugula: Spell fix: Reconcile
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "../PassDetail.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h"
using namespace mlir;
namespace {
/// Removes `unrealized_conversion_cast`s whose results are only used by other
/// `unrealized_conversion_cast`s converting back to the original type. This
/// pattern is complementary to the folder and can be used to process operations
/// starting from the first, i.e. the usual traversal order in dialect
/// conversion. The folder, on the other hand, can only apply to the last
bondhugulaUnsubmitted
Done
ReplyInline Actions

I think the traversal order isn't important or needed here for soundness: having a pattern like this in any greedy rewrite driver-driven pass will do.

bondhugula: I think the traversal order isn't important or needed here for soundness: having a pattern like…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

It is important for passes that are not based on the greedy driver. The majority of conversion passes use a different driver.

ftynse: It is important for passes that are not based on the greedy driver. The majority of conversion…
/// operation in a chain of conversions because it is not expected to walk
/// use-def chains. One would need to declare cast ops as dynamically illegal
/// with a complex condition in order to eliminate them using the folder alone
/// in the dialect conversion infra.
struct UnrealizedConversionCastPassthrough
: public OpRewritePattern<UnrealizedConversionCastOp> {
using OpRewritePattern<UnrealizedConversionCastOp>::OpRewritePattern;
LogicalResult matchAndRewrite(UnrealizedConversionCastOp op,
PatternRewriter &rewriter) const override {
auto users = op->getUsers();
if (!llvm::all_of(users, [&](Operation *user) {
if (auto other = dyn_cast<UnrealizedConversionCastOp>(user)) {
bondhugulaUnsubmitted
Done
ReplyInline Actions

Better to have a code comment here.

bondhugula: Better to have a code comment here.
return other.getResultTypes() == op.inputs().getTypes() &&
other.inputs() == op.outputs();
}
return false;
bondhugulaUnsubmitted
Done
ReplyInline Actions

Trivial braces.

bondhugula: Trivial braces.
})) {
return rewriter.notifyMatchFailure(op, "live unrealized conversion");
}
bondhugulaUnsubmitted
Done
ReplyInline Actions

Both "live" and "unrealized conversion" can be ambiguous to read here; "leftover unrealized conversion cast"?

bondhugula: Both "live" and "unrealized conversion" can be ambiguous to read here; "leftover unrealized…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

"leftover" doesn't sound right here, this message should explain why the match failed, "leftover" sounds more like final result. Changed to "live unrealized conversion cast". "Live" means used by another operation and already appears in dialect conversion terminology.

ftynse: "leftover" doesn't sound right here, this message should explain why the match failed…
for (Operation *user : users)
rewriter.replaceOp(user, op.inputs());
rewriter.eraseOp(op);
return success();
bondhugulaUnsubmitted
Done
ReplyInline Actions

This looks like it could be handled by a local folding hook. You can just pull the operands of your operands' unique defining op which would be another unrealized-conversion-cast? You wouldn't need to walk any use lists. If this makes sense, you ultimately don't need this rewrite pattern, nor this whole pass itself and the need to add such a pass to any other pass or pass pipeline. Folding + dead code elimination in the greedy rewrite driver will naturally take care of this. In general, it's also more efficient having things in the folding hook since the folding hook is called earlier -- before any canonicalization patterns on the op itself are called.

bondhugula: This looks like it could be handled by a local folding hook. You can just pull the operands of…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

As a matter of fact, there is and always has been a folder for the unrealized_conversion_cast. Unfortunately, it is not sufficient as the commit message explains. Conversion passes use the dialect conversion driver rather than the greedy driver. It also calls the folder, but on the _wrong op_. The folder can _only_ be expressed on the second op of the pair because it is not allowed to change other ops than the one being folded. The dialect conversion driver must finalize the first op before proceeding to the second. I haven't benchmarked this but I expect it to be only marginally less efficient because, in most cases, the pattern will either bail out early or find exactly one user that is a backwards cast.

I would allow myself a remark which might come out as snarky or otherwise mean, apologies for that: I would have found the discussion more constructive if we all assumed that folks doing large refactorings, especially in the area where they are de-facto code owners, understand what they are doing sufficiently well and have spent enough effort trying to find the least complex way of changing things.

ftynse: As a matter of fact, there is and [[ https://github.com/llvm/llvm…
bondhugulaUnsubmitted
Not Done
ReplyInline Actions

Folding is always considered a good thing to do as early as possible by design. This is why the greedy rewrite driver has always applied the folding hook for every op in its iteration irrespective of which patterns are in the list or for which ops. If the dialect conversion infra isn't running the folding hook on all ops, that would be inconsistent with the general thinking and one should consider improving that infra and have the folding hook run so that this naturally happens as part of the rewrite driver. I feel this should be explored first instead of making this change to adding an extra cleanup pass for what should have been handled inside of -convert-std-to-llvm.

Post-commit review is completely fine and authors/maintainers thinking so is obviously fine per the LLVM policy. However, I don't think a change like this one without exploring the right direction first is out of line. I would request a revert here.

bondhugula: Folding is always considered a good thing to do as early as possible by design. This is why the…
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

Folding is always considered a good thing to do as early as possible by design. This is why the greedy rewrite driver has always applied the folding hook for every op in its iteration irrespective of which patterns are in the list or for which ops. If the dialect conversion infra isn't running the folding hook on all ops, that would be inconsistent with the general thinking and one should consider improving that infra and have the folding hook run so that this naturally happens as part of the rewrite driver. I feel this should be explored first instead of making this change to adding an extra cleanup pass for what should have been handled inside of -convert-std-to-llvm.

Well, changes to how the dialect conversion operates is not in scope of this patch, so I fail to see how reverting it would help with anything.

ftynse: > Folding is always considered a good thing to do as early as possible by design. This is why…
bondhugulaUnsubmitted
Done
ReplyInline Actions

I would have found the discussion more constructive if we all assumed that folks
doing large refactorings, especially in the area where they are de-facto code owners,
understand what they are doing sufficiently well and have spent enough effort trying
to find the least complex way of changing things

This comment and understanding is pretty irrelevant here because it does not and should not prevent other folks from questioning the approach post-review. This is all constructive and purely technical feedback/questions (here and on the discourse from everyone the way I see it) and de-facto code owners should learn to understand and recognize that the questions do not mean "they are not doing sufficiently well or have not spent enough effort trying to find the least complex way of changing things". LLVM's policy already leans in several cases towards post-commit review and revert if needed based on that same understanding as well as in the interest of allowing more rapid development.

bondhugula: >I would have found the discussion more constructive if we all assumed that folks >doing large…
}
};
/// Pass to simplify and eliminate unrealized conversion casts.
struct FinalizeToLLVM : public ReconcileUnrealizedCastsBase<FinalizeToLLVM> {
FinalizeToLLVM() = default;
rriddleUnsubmitted
Done
ReplyInline Actions

The name here needs to be updated.

rriddle: The name here needs to be updated.
ftynseAuthorUnsubmitted
Done
ReplyInline Actions

Good catch, my regexp-fu needs improvement...

ftynse: Good catch, my regexp-fu needs improvement...
void runOnOperation() override {
RewritePatternSet patterns(&getContext());
populateReconcileUnrealizedCastsPatterns(patterns);
ConversionTarget target(getContext());
target.addIllegalOp<UnrealizedConversionCastOp>();
if (failed(applyPartialConversion(getOperation(), target,
std::move(patterns))))
signalPassFailure();
}
};
} // namespace
void mlir::populateReconcileUnrealizedCastsPatterns(
RewritePatternSet &patterns) {
patterns.add<UnrealizedConversionCastPassthrough>(patterns.getContext());
}
std::unique_ptr<Pass> mlir::createReconcileUnrealizedCastsPass() {
return std::make_unique<FinalizeToLLVM>();
}

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

Show First 20 Lines • Show All 364 Lines • ▼ Show 20 Lines for (auto it : llvm::zip(blockArgs, oldArgTypes)) {
// Replace barePtr with a placeholder (undef), promote barePtr to a ranked // Replace barePtr with a placeholder (undef), promote barePtr to a ranked
// or unranked memref descriptor and replace placeholder with the last // or unranked memref descriptor and replace placeholder with the last
// instruction of the memref descriptor. // instruction of the memref descriptor.
// TODO: The placeholder is needed to avoid replacing barePtr uses in the // TODO: The placeholder is needed to avoid replacing barePtr uses in the
// MemRef descriptor instructions. We may want to have a utility in the // MemRef descriptor instructions. We may want to have a utility in the
// rewriter to properly handle this use case. // rewriter to properly handle this use case.
Location loc = funcOp.getLoc(); Location loc = funcOp.getLoc();
auto placeholder = rewriter.create<LLVM::UndefOp>(loc, memrefTy); auto placeholder = rewriter.create<LLVM::UndefOp>(
loc, getTypeConverter()->convertType(memrefTy));
rewriter.replaceUsesOfBlockArgument(arg, placeholder); rewriter.replaceUsesOfBlockArgument(arg, placeholder);
Value desc = MemRefDescriptor::fromStaticShape( Value desc = MemRefDescriptor::fromStaticShape(
rewriter, loc, *getTypeConverter(), memrefTy, arg); rewriter, loc, *getTypeConverter(), memrefTy, arg);
rewriter.replaceOp(placeholder, {desc}); rewriter.replaceOp(placeholder, {desc});
} }
rewriter.eraseOp(funcOp); rewriter.eraseOp(funcOp);
▲ Show 20 Lines • Show All 801 Lines • ▼ Show 20 Lines patterns.add<
SubIOpLowering, SubIOpLowering,
SwitchOpLowering, SwitchOpLowering,
TruncateIOpLowering, TruncateIOpLowering,
UIToFPOpLowering, UIToFPOpLowering,
UnsignedDivIOpLowering, UnsignedDivIOpLowering,
UnsignedRemIOpLowering, UnsignedRemIOpLowering,
UnsignedShiftRightOpLowering, UnsignedShiftRightOpLowering,
XOrOpLowering, XOrOpLowering,
UnrealizedConversionCastOpLowering,
ZeroExtendIOpLowering>(converter); ZeroExtendIOpLowering>(converter);
// clang-format on // clang-format on
} }
namespace { namespace {
/// A pass converting MLIR operations into the LLVM IR dialect. /// A pass converting MLIR operations into the LLVM IR dialect.
struct LLVMLoweringPass : public ConvertStandardToLLVMBase<LLVMLoweringPass> { struct LLVMLoweringPass : public ConvertStandardToLLVMBase<LLVMLoweringPass> {
LLVMLoweringPass() = default; LLVMLoweringPass() = default;
Show All 36 Lines void runOnOperation() override {
LLVMTypeConverter typeConverter(&getContext(), options, LLVMTypeConverter typeConverter(&getContext(), options,
&dataLayoutAnalysis); &dataLayoutAnalysis);
RewritePatternSet patterns(&getContext()); RewritePatternSet patterns(&getContext());
populateStdToLLVMConversionPatterns(typeConverter, patterns); populateStdToLLVMConversionPatterns(typeConverter, patterns);
LLVMConversionTarget target(getContext()); LLVMConversionTarget target(getContext());
target.addIllegalOp<UnrealizedConversionCastOp>();
if (failed(applyPartialConversion(m, target, std::move(patterns)))) if (failed(applyPartialConversion(m, target, std::move(patterns))))
signalPassFailure(); signalPassFailure();
m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(), m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(),
StringAttr::get(m.getContext(), this->dataLayout)); StringAttr::get(m.getContext(), this->dataLayout));
} }
}; };
} // end namespace } // end namespace
Show All 18 Lines

mlir/test/Conversion/ComplexToLLVM/full-conversion.mlir

// RUN: mlir-opt %s -convert-complex-to-llvm -convert-std-to-llvm | FileCheck %s // RUN: mlir-opt %s -convert-complex-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | FileCheck %s
// CHECK-LABEL: llvm.func @complex_div // CHECK-LABEL: llvm.func @complex_div
// CHECK-SAME: %[[LHS:.*]]: ![[C_TY:.*>]], %[[RHS:.*]]: ![[C_TY]]) -> ![[C_TY]] // CHECK-SAME: %[[LHS:.*]]: ![[C_TY:.*>]], %[[RHS:.*]]: ![[C_TY]]) -> ![[C_TY]]
func @complex_div(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> { func @complex_div(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
%div = complex.div %lhs, %rhs : complex<f32> %div = complex.div %lhs, %rhs : complex<f32>
return %div : complex<f32> return %div : complex<f32>
} }
// CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[LHS]][0] : ![[C_TY]] // CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[LHS]][0] : ![[C_TY]]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

mlir/test/Conversion/ComplexToStandard/full-conversion.mlir

// RUN: mlir-opt %s -convert-complex-to-standard -convert-complex-to-llvm -convert-math-to-llvm -convert-std-to-llvm | FileCheck %s // RUN: mlir-opt %s -convert-complex-to-standard -convert-complex-to-llvm -convert-math-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | FileCheck %s
// CHECK-LABEL: llvm.func @complex_abs // CHECK-LABEL: llvm.func @complex_abs
// CHECK-SAME: %[[ARG:.*]]: ![[C_TY:.*]]) // CHECK-SAME: %[[ARG:.*]]: ![[C_TY:.*]])
func @complex_abs(%arg: complex<f32>) -> f32 { func @complex_abs(%arg: complex<f32>) -> f32 {
%abs = complex.abs %arg: complex<f32> %abs = complex.abs %arg: complex<f32>
return %abs : f32 return %abs : f32
} }
// CHECK: %[[REAL:.*]] = llvm.extractvalue %[[ARG]][0] : ![[C_TY]] // CHECK: %[[REAL:.*]] = llvm.extractvalue %[[ARG]][0] : ![[C_TY]]
Show All 36 Lines

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

// RUN: mlir-opt -convert-memref-to-llvm -convert-std-to-llvm='emit-c-wrappers=1' %s | FileCheck %s // RUN: mlir-opt -convert-memref-to-llvm -convert-std-to-llvm='emit-c-wrappers=1' -reconcile-unrealized-casts %s | FileCheck %s
// RUN: mlir-opt -convert-memref-to-llvm -convert-std-to-llvm %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE // RUN: mlir-opt -convert-memref-to-llvm -convert-std-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 241 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-std \ // RUN: -convert-scf-to-std \
// RUN: -std-expand \ // RUN: -std-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
#map0 = affine_map<(d0, d1) -> (d0, d1)> #map0 = affine_map<(d0, d1) -> (d0, d1)>
▲ Show 20 Lines • Show All 98 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-std \ // RUN: -convert-scf-to-std \
// RUN: -std-expand \ // RUN: -std-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm -print-ir-after-all \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_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-std \ // RUN: -convert-scf-to-std \
// RUN: -std-expand \ // RUN: -std-expand \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext\
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
#map0 = affine_map<(d0, d1) -> (d0, d1)> #map0 = affine_map<(d0, d1) -> (d0, d1)>
▲ Show 20 Lines • Show All 99 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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -std-expand \ // RUN: -std-expand \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -std-expand \ // RUN: -std-expand \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_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: target-block-size=1" \ // RUN: target-block-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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -std-expand \ // RUN: -std-expand \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
// Suppress constant folding by introducing "dynamic" zero value at runtime. // Suppress constant folding by introducing "dynamic" zero value at runtime.
func private @zero() -> index { func private @zero() -> index {
▲ Show 20 Lines • Show All 69 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: -convert-async-to-llvm \ // RUN: -convert-async-to-llvm \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_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: target-block-size=1" \ // RUN: target-block-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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// 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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_async_runtime%shlibext\
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
func @entry() { func @entry() {
%c0 = constant 0.0 : f32 %c0 = constant 0.0 : f32
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul.mlir

// RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \ // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
// RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \ // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul register-tile-sizes=12,32,16 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.copy register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-op=linalg.copy register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \ // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
// RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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 \
// Activate to dump assembly // Activate to dump assembly
// R_UN: -dump-object-file -object-filename=/tmp/a.o \ // R_UN: -dump-object-file -object-filename=/tmp/a.o \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// Use tee to both print to stderr and FileCheck // Use tee to both print to stderr and FileCheck
// RUN: tee -a /dev/stderr | FileCheck %s // RUN: tee -a /dev/stderr | FileCheck %s
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul_i8_i8_i32.mlir

// RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \ // RUN: export M=24 && export K=64 && export N=192 && export ITERS=10 && \
// RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \ // RUN: cat %s | sed 's@${M}@'"$M"'@g'| sed 's@${K}@'"$K"'@g' | sed 's@${N}@'"$N"'@g'| sed 's@${ITERS}@'"$ITERS"'@g'| \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul_i8_i8_i32 register-tile-sizes=12,32,16 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.matmul_i8_i8_i32 register-tile-sizes=12,32,16 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.fill register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.copy register-tile-sizes=4,32 vectorize" | \ // RUN: mlir-opt -test-linalg-codegen-strategy="anchor-func=matmul anchor-op=linalg.copy register-tile-sizes=4,32 vectorize" | \
// RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \ // RUN: mlir-opt -canonicalize -convert-vector-to-scf -lower-affine -convert-linalg-to-loops | \
// RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -mlir-disable-threading | \ // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts -mlir-disable-threading | \
// RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \ // RUN: mlir-cpu-runner -O3 -e main -entry-point-result=void \
// Activate to dump assembly // Activate to dump assembly
// R_UN: -dump-object-file -object-filename=/tmp/a.o \ // R_UN: -dump-object-file -object-filename=/tmp/a.o \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// Use tee to both print to stderr and FileCheck // Use tee to both print to stderr and FileCheck
// RUN: tee -a /dev/stderr | FileCheck %s // RUN: tee -a /dev/stderr | FileCheck %s
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) { func @matmul(%A: memref<?x?xf32>, %B: memref<?x?xf32>) -> (memref<?x?xf32>) {
%c0 = constant 0 : index %c0 = constant 0 : index
▲ Show 20 Lines • Show All 65 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-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
func @main() { func @main() {
%c0 = constant 0 : index %c0 = constant 0 : index
Show All 29 Lines

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

// RUN: mlir-opt %s -linalg-bufferize -std-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -std-bufferize \
// RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \ // RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -convert-linalg-to-llvm \ // RUN: -finalizing-bufferize -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = 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 = 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-comprehensive-bufferize.mlir

// RUN: mlir-opt %s -canonicalize -cse -linalg-comprehensive-module-bufferize |\ // RUN: mlir-opt %s -canonicalize -cse -linalg-comprehensive-module-bufferize |\
// RUN: mlir-opt -convert-vector-to-scf -lower-affine -convert-linalg-to-loops |\ // RUN: mlir-opt -convert-vector-to-scf -lower-affine -convert-linalg-to-loops |\
// RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt -canonicalize -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext |\ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_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-conv-1d-call.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=4" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=4" -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=4" \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=4" \
// RUN: -test-conv-vectorization="tile-sizes=1,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -test-conv-vectorization="tile-sizes=1,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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 @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> { func @alloc_1d_filled_f32(%s1 : index, %f : f32) -> memref<?xf32> {
Show All 36 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,4" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,4" -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,4" \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,4" \
// RUN: -test-conv-vectorization="tile-sizes=1,1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -test-conv-vectorization="tile-sizes=1,1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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 @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> { func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2" -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2" \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2" \
// RUN: -test-conv-vectorization="tile-sizes=1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -test-conv-vectorization="tile-sizes=1,1,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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 @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> { func @alloc_2d_filled_f32(%s1 : index, %s2 : index, %f : f32) -> memref<?x?xf32> {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,3,2" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,3,2" -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,3,2" \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,3,3,2" \
// RUN: -test-conv-vectorization="tile-sizes=1,1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -test-conv-vectorization="tile-sizes=1,1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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 @alloc_4d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %f : f32) -> memref<?x?x?x?xf32> { 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 103 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2,2" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2,2" -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2,2" \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=2,2,2" \
// RUN: -test-conv-vectorization="tile-sizes=1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -test-conv-vectorization="tile-sizes=1,1,1,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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 @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> { func @alloc_3d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %f : f32) -> memref<?x?x?xf32> {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=0,5,5,5" -convert-linalg-to-loops -convert-scf-to-std \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=0,5,5,5" -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,1,1,3,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,1,1,1,1,3,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=0,5,5,5" \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=0,5,5,5" \
// RUN: -test-conv-vectorization="tile-sizes=1,1,1,1,1,3,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -test-conv-vectorization="tile-sizes=1,1,1,1,1,3,3,3,3" -convert-linalg-to-llvm -lower-affine -convert-scf-to-std -convert-vector-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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 @alloc_5d_filled_f32(%s1 : index, %s2 : index, %s3 : index, %s4 : index, %s5 : index, %f : f32) -> memref<?x?x?x?x?xf32> { 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 166 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-elementwise-to-linalg -std-bufferize -tensor-constant-bufferize -linalg-bufferize -tensor-bufferize -func-bufferize -convert-linalg-to-loops -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-elementwise-to-linalg -std-bufferize -tensor-constant-bufferize -linalg-bufferize -tensor-bufferize -func-bufferize -convert-linalg-to-loops -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%a = constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32> %a = constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32>
%b = constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32> %b = constant dense<[10.0, 20.0, 30.0]> : tensor<3xf32>
Show All 10 Lines

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

// RUN: mlir-opt %s -linalg-bufferize -std-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -std-bufferize \
// RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \ // RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize -convert-linalg-to-llvm \ // RUN: -finalizing-bufferize -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = 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 = 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-padtensor.mlir

// RUN: mlir-opt %s -linalg-bufferize -std-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -std-bufferize \
// RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \ // RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize \ // RUN: -finalizing-bufferize \
// RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = constant dense<[[[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]]]> : tensor<1x2x3xf32> %const = 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 -std-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -std-bufferize \
// RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \ // RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize \ // RUN: -finalizing-bufferize \
// RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = constant dense<10.0> : tensor<2xf32> %const = constant dense<10.0> : tensor<2xf32>
%insert_val = constant dense<20.0> : tensor<1xf32> %insert_val = 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 -std-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -std-bufferize \
// RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \ // RUN: -tensor-constant-bufferize -tensor-bufferize -func-bufferize \
// RUN: -finalizing-bufferize \ // RUN: -finalizing-bufferize \
// RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%const = constant dense<10.0> : tensor<2xf32> %const = constant dense<10.0> : tensor<2xf32>
%insert_val = constant dense<20.0> : tensor<1xf32> %insert_val = 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 -tensor-constant-bufferize -std-bufferize -linalg-bufferize \ // RUN: mlir-opt %s -tensor-constant-bufferize -std-bufferize -linalg-bufferize \
// RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -convert-linalg-to-loops \ // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -convert-linalg-to-loops \
// RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @foo() -> tensor<4xf32> { func @foo() -> tensor<4xf32> {
%0 = constant dense<[1.0, 2.0, 3.0, 4.0]> : tensor<4xf32> %0 = 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

// RUN: mlir-opt %s -linalg-bufferize -std-bufferize -tensor-constant-bufferize \ // RUN: mlir-opt %s -linalg-bufferize -std-bufferize -tensor-constant-bufferize \
// RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-std \ // RUN: -tensor-bufferize -func-bufferize -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=1,2,3" -linalg-bufferize \ // RUN: mlir-opt %s -linalg-tile="linalg-tile-sizes=1,2,3" -linalg-bufferize \
// RUN: -scf-bufferize -std-bufferize -tensor-constant-bufferize -tensor-bufferize \ // RUN: -scf-bufferize -std-bufferize -tensor-constant-bufferize -tensor-bufferize \
// RUN: -func-bufferize \ // RUN: -func-bufferize \
// RUN: -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-std -convert-scf-to-std \ // RUN: -finalizing-bufferize -convert-linalg-to-loops -convert-scf-to-std -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -convert-linalg-to-llvm -lower-affine -convert-scf-to-std --convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
%A = constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> %A = constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
%B = constant dense<[[1.0, 2.0, 3.0, 4.0], %B = 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 18 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
// RUN: TENSOR1="%mlir_integration_test_dir/data/zero.mtx" \ // RUN: TENSOR1="%mlir_integration_test_dir/data/zero.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_conversion.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,j,k)> dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_flatten.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/test.tns" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/test.tns" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_matvec.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// //
// Do the same run, but now with SIMDization as well. This should not change the outcome. // Do the same run, but now with SIMDization as well. This should not change the outcome.
// //
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification="vectorization-strategy=2 vl=16 enable-simd-index32" --sparse-tensor-conversion \ // RUN: --sparsification="vectorization-strategy=2 vl=16 enable-simd-index32" --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize --lower-affine \ // RUN: --std-bufferize --finalizing-bufferize --lower-affine \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_mttkrp.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/mttkrp_b.tns" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/mttkrp_b.tns" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_out_simple.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sampled_matmul.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// //
// Do the same run, but now with SIMDization as well. This should not change the outcome. // Do the same run, but now with SIMDization as well. This should not change the outcome.
// //
// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification="vectorization-strategy=2 vl=4 enable-simd-index32" --sparse-tensor-conversion \ // RUN: --sparsification="vectorization-strategy=2 vl=4 enable-simd-index32" --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize --lower-affine \ // RUN: --std-bufferize --finalizing-bufferize --lower-affine \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// //
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_scale.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>
#trait_scale = { #trait_scale = {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_spmm.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_storage.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// //
// Several common sparse storage schemes. // Several common sparse storage schemes.
// //
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sum.mlir

// RUN: mlir-opt %s \ // RUN: mlir-opt %s \
// RUN: --sparsification --sparse-tensor-conversion \ // RUN: --sparsification --sparse-tensor-conversion \
// RUN: --convert-vector-to-scf --convert-scf-to-std \ // RUN: --convert-vector-to-scf --convert-scf-to-std \
// RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \ // RUN: --func-bufferize --tensor-constant-bufferize --tensor-bufferize \
// RUN: --std-bufferize --finalizing-bufferize \ // RUN: --std-bufferize --finalizing-bufferize \
// RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm | \ // RUN: --convert-vector-to-llvm --convert-memref-to-llvm --convert-std-to-llvm --reconcile-unrealized-casts | \
// RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \ // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
// 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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!Filename = type !llvm.ptr<i8> !Filename = type !llvm.ptr<i8>
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -std-expand -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -std-expand -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_read_2d(%A : memref<40xi32>, %base1: index) { func @transfer_read_2d(%A : memref<40xi32>, %base1: index) {
%i42 = constant -42: i32 %i42 = 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 73 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_integration_test_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.mlir

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_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 @kernel1(%arg0: memref<2x4xbf16>, 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-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_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 @print(%arg0: memref<16x4xi32>) { func @print(%arg0: memref<16x4xi32>) {
%iu = constant -1: i32 %iu = constant -1: i32
▲ Show 20 Lines • Show All 189 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-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_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 @kernel1(%arg0: memref<2x8xi8>, 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-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_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 @print(%arg0: memref<4x32xf32>) { func @print(%arg0: memref<4x32xf32>) {
%fu = constant -1.0: f32 %fu = 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-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm="enable-amx" -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="+amx-tile,+amx-int8,+amx-bf16" --dlopen=%mlir_integration_test_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 @tilezero(%arg0: memref<?x?xi32>, %i: index, %j: index) { 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/X86Vector/test-dot.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() -> i32 { func @entry() -> i32 {
%i0 = constant 0 : i32 %i0 = constant 0 : i32
%i4 = constant 4 : i32 %i4 = constant 4 : i32
Show All 15 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx512bw" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() -> i32 { func @entry() -> i32 {
%i0 = constant 0 : i32 %i0 = constant 0 : i32
%a = std.constant dense<[1., 0., 0., 2., 4., 3., 5., 7., 8., 1., 5., 5., 3., 1., 0., 7.]> : vector<16xf32> %a = std.constant dense<[1., 0., 0., 2., 4., 3., 5., 7., 8., 1., 5., 5., 3., 1., 0., 7.]> : vector<16xf32>
Show All 18 Lines

mlir/test/Integration/Dialect/Vector/CPU/X86Vector/test-rsqrt.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm -reconcile-unrealized-casts | \
// RUN: mlir-translate --mlir-to-llvmir | \ // RUN: mlir-translate --mlir-to-llvmir | \
// RUN: %lli --entry-function=entry --mattr="avx512bw" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() -> i32 { func @entry() -> i32 {
%i0 = constant 0 : i32 %i0 = constant 0 : i32
%v = std.constant dense<[0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0]> : vector<8xf32> %v = std.constant dense<[0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0]> : vector<8xf32>
%r = x86vector.avx.rsqrt %v : vector<8xf32> %r = x86vector.avx.rsqrt %v : vector<8xf32>
// CHECK: ( 2.82764, 1.99951, 1.41382, 0.999756, 0.706909, 0.499878, 0.353455, 0.249939 ) // CHECK: ( 2.82764, 1.99951, 1.41382, 0.999756, 0.706909, 0.499878, 0.353455, 0.249939 )
vector.print %r : vector<8xf32> vector.print %r : vector<8xf32>
return %i0 : i32 return %i0 : i32
} }

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_integration_test_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/X86Vector/test-vp2intersect-i32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm="enable-x86vector" -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %lli --entry-function=entry --mattr="avx512bw,avx512vp2intersect" --dlopen=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// Note: To run this test, your CPU must support AVX512 vp2intersect. // Note: To run this test, your CPU must support AVX512 vp2intersect.
func @entry() -> i32 { func @entry() -> i32 {
%i0 = constant 0 : i32 %i0 = constant 0 : i32
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%i = constant 2147483647: i32 %i = constant 2147483647: i32
%l = constant 9223372036854775807 : i64 %l = constant 9223372036854775807 : i64
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @compress16(%base: memref<?xf32>, func @compress16(%base: memref<?xf32>,
%mask: vector<16xi1>, %value: vector<16xf32>) { %mask: vector<16xi1>, %value: vector<16xf32>) {
%c0 = constant 0: index %c0 = constant 0: index
vector.compressstore %base[%c0], %mask, %value vector.compressstore %base[%c0], %mask, %value
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-constant-mask.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%0 = vector.constant_mask [4] : vector<8xi1> %0 = vector.constant_mask [4] : vector<8xi1>
vector.print %0 : vector<8xi1> vector.print %0 : vector<8xi1>
// CHECK: ( 1, 1, 1, 1, 0, 0, 0, 0 ) // CHECK: ( 1, 1, 1, 1, 0, 0, 0, 0 )
Show All 40 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
#dotp_accesses = [ #dotp_accesses = [
affine_map<(i) -> (i)>, affine_map<(i) -> (i)>,
affine_map<(i) -> (i)>, affine_map<(i) -> (i)>,
affine_map<(i) -> ()> affine_map<(i) -> ()>
▲ Show 20 Lines • Show All 374 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-create-mask-v4i1.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// NOTE: This is similar to test-create-mask.mlir, but with a different length, // NOTE: This is similar to test-create-mask.mlir, but with a different length,
// because the v4i1 vector specifically exposed bugs in the LLVM backend. // because the v4i1 vector specifically exposed bugs in the LLVM backend.
func @entry() { func @entry() {
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-create-mask.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%c0 = constant 0 : index %c0 = constant 0 : index
%c1 = constant 1 : index %c1 = constant 1 : index
%c2 = constant 2 : index %c2 = constant 2 : index
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @expand16(%base: memref<?xf32>, func @expand16(%base: memref<?xf32>,
%mask: vector<16xi1>, %mask: vector<16xi1>,
%pass_thru: vector<16xf32>) -> vector<16xf32> { %pass_thru: vector<16xf32>) -> vector<16xf32> {
%c0 = constant 0: index %c0 = constant 0: index
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-extract-strided-slice.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = constant 0.0: f32 %f0 = constant 0.0: f32
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
Show All 23 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-flat-transpose-col.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = constant 0.0: f64 %f0 = constant 0.0: f64
%f1 = constant 1.0: f64 %f1 = constant 1.0: f64
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-flat-transpose-row.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = constant 0.0: f64 %f0 = constant 0.0: f64
%f1 = constant 1.0: f64 %f1 = constant 1.0: f64
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f3 = constant 3.0: f32 %f3 = constant 3.0: f32
%f7 = constant 7.0: f32 %f7 = constant 7.0: f32
Show All 19 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @gather8(%base: memref<?xf32>, %indices: vector<8xi32>, 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 = constant 0: index %c0 = 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 81 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-index-vectors.mlir

// RUN: mlir-opt %s -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%c0 = constant dense<[0, 1, 2, 3]>: vector<4xindex> %c0 = constant dense<[0, 1, 2, 3]>: vector<4xindex>
%c1 = constant dense<[0, 1]>: vector<2xindex> %c1 = constant dense<[0, 1]>: vector<2xindex>
%c2 = constant 2 : index %c2 = constant 2 : index
Show All 23 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-insert-strided-slice.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
%f3 = constant 3.0: f32 %f3 = constant 3.0: f32
Show All 27 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @maskedload16(%base: memref<?xf32>, %mask: vector<16xi1>, func @maskedload16(%base: memref<?xf32>, %mask: vector<16xi1>,
%pass_thru: vector<16xf32>) -> vector<16xf32> { %pass_thru: vector<16xf32>) -> vector<16xf32> {
%c0 = constant 0: index %c0 = constant 0: index
%ld = vector.maskedload %base[%c0], %mask, %pass_thru %ld = vector.maskedload %base[%c0], %mask, %pass_thru
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @maskedstore16(%base: memref<?xf32>, func @maskedstore16(%base: memref<?xf32>,
%mask: vector<16xi1>, %value: vector<16xf32>) { %mask: vector<16xi1>, %value: vector<16xf32>) {
%c0 = constant 0: index %c0 = constant 0: index
vector.maskedstore %base[%c0], %mask, %value vector.maskedstore %base[%c0], %mask, %value
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-matrix-multiply-col.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=column-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = constant 0.0: f64 %f0 = constant 0.0: f64
%f1 = constant 1.0: f64 %f1 = constant 1.0: f64
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-matrix-multiply-row.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \ // RUN: -lower-matrix-intrinsics -matrix-allow-contract -matrix-default-layout=row-major \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = constant 0.0: f64 %f0 = constant 0.0: f64
%f1 = constant 1.0: f64 %f1 = constant 1.0: f64
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-outerproduct-f32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!vector_type_A = type vector<8xf32> !vector_type_A = type vector<8xf32>
!vector_type_B = type vector<8xf32> !vector_type_B = type vector<8xf32>
!vector_type_C = type vector<8x8xf32> !vector_type_C = type vector<8x8xf32>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-outerproduct-i64.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
!vector_type_A = type vector<8xi64> !vector_type_A = type vector<8xi64>
!vector_type_B = type vector<8xi64> !vector_type_B = type vector<8xi64>
!vector_type_C = type vector<8x8xi64> !vector_type_C = type vector<8x8xi64>
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-print-int.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// //
// Test various signless, signed, unsigned integer types. // Test various signless, signed, unsigned integer types.
// //
func @entry() { func @entry() {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f32-reassoc.mlir

// RUN: mlir-opt %s -convert-scf-to-std \ // RUN: mlir-opt %s -convert-scf-to-std \
// RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \ // RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \
// RUN: -convert-std-to-llvm | \ // RUN: -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector, numerically very stable. // Construct test vector, numerically very stable.
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
Show All 27 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%f1 = constant 1.5: f32 %f1 = constant 1.5: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f64-reassoc.mlir

// RUN: mlir-opt %s -convert-scf-to-std \ // RUN: mlir-opt %s -convert-scf-to-std \
// RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \ // RUN: -convert-vector-to-llvm='reassociate-fp-reductions' \
// RUN: -convert-std-to-llvm | \ // RUN: -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector, numerically very stable. // Construct test vector, numerically very stable.
%f1 = constant 1.0: f64 %f1 = constant 1.0: f64
%f2 = constant 2.0: f64 %f2 = constant 2.0: f64
Show All 27 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-f64.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%f1 = constant 1.5: f64 %f1 = constant 1.5: f64
%f2 = constant 2.0: f64 %f2 = constant 2.0: f64
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-i32.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%i1 = constant 1: i32 %i1 = constant 1: i32
%i2 = constant 2: i32 %i2 = constant 2: i32
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-i4.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%v = std.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<24xi4> %v = std.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<24xi4>
vector.print %v : vector<24xi4> vector.print %v : vector<24xi4>
// //
Show All 35 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-i64.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
// Construct test vector. // Construct test vector.
%i1 = constant 1: i64 %i1 = constant 1: i64
%i2 = constant 2: i64 %i2 = constant 2: i64
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-si4.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%v = std.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]> : vector<16xsi4> %v = std.constant dense<[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]> : vector<16xsi4>
vector.print %v : vector<16xsi4> vector.print %v : vector<16xsi4>
// //
Show All 34 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-reductions-ui4.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%v = std.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<16xui4> %v = std.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : vector<16xui4>
vector.print %v : vector<16xui4> vector.print %v : vector<16xui4>
// //
Show All 34 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @scatter8(%base: memref<?xf32>, func @scatter8(%base: memref<?xf32>,
%indices: vector<8xi32>, %indices: vector<8xi32>,
%mask: vector<8xi1>, %value: vector<8xf32>) { %mask: vector<8xi1>, %value: vector<8xf32>) {
%c0 = constant 0: index %c0 = constant 0: index
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-shape-cast.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
%f3 = constant 3.0: f32 %f3 = constant 3.0: f32
Show All 35 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
%v1 = vector.broadcast %f1 : f32 to vector<2x4xf32> %v1 = vector.broadcast %f1 : f32 to vector<2x4xf32>
Show All 15 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_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-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_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 -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_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 204 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_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 172 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf='full-unroll=true lower-permutation-maps=true' -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_read_3d(%A : memref<?x?x?x?xf32>, 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 = constant -42.0: f32 %fm42 = 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 124 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_read_1d(%A : memref<?xf32>, %base: index) { func @transfer_read_1d(%A : memref<?xf32>, %base: index) {
%fm42 = constant -42.0: f32 %fm42 = 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 78 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext,%mlir_integration_test_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 private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(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-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @transfer_write16_inbounds_1d(%A : memref<?xf32>, %base: index) { func @transfer_write16_inbounds_1d(%A : memref<?xf32>, %base: index) {
%f = constant 16.0 : f32 %f = constant 16.0 : f32
%v = splat %f : vector<16xf32> %v = splat %f : vector<16xf32>
vector.transfer_write %v, %A[%base] vector.transfer_write %v, %A[%base]
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \ // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-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_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
func @entry() { func @entry() {
%f0 = constant 0.0: f32 %f0 = constant 0.0: f32
%f1 = constant 1.0: f32 %f1 = constant 1.0: f32
%f2 = constant 2.0: f32 %f2 = constant 2.0: f32
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

mlir/test/Integration/Dialect/Vector/CPU/test-vector-distribute.mlir

// RUN: mlir-opt %s -test-vector-to-forloop -convert-vector-to-scf \ // RUN: mlir-opt %s -test-vector-to-forloop -convert-vector-to-scf \
// RUN: -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | \ // RUN: -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-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_integration_test_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -convert-vector-to-scf -lower-affine \ // RUN: mlir-opt %s -convert-vector-to-scf -lower-affine \
// RUN: -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e main \ // RUN: -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e main \
// RUN: -entry-point-result=void \ // RUN: -entry-point-result=void \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// RUN: mlir-opt %s -test-vector-to-forloop | FileCheck %s -check-prefix=TRANSFORM // RUN: mlir-opt %s -test-vector-to-forloop | FileCheck %s -check-prefix=TRANSFORM
func private @print_memref_f32(memref<*xf32>) func private @print_memref_f32(memref<*xf32>)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

mlir/test/Target/LLVMIR/vector-to-llvm-ir.mlir

// RUN: mlir-opt %s -convert-vector-to-llvm -convert-std-to-llvm | mlir-translate -mlir-to-llvmir | FileCheck %s // RUN: mlir-opt %s -convert-vector-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-translate -mlir-to-llvmir | FileCheck %s
func @genbool_1d() -> vector<8xi1> { func @genbool_1d() -> vector<8xi1> {
%0 = vector.constant_mask [4] : vector<8xi1> %0 = vector.constant_mask [4] : vector<8xi1>
return %0 : vector<8xi1> return %0 : vector<8xi1>
} }
// CHECK-LABEL: @genbool_1d() // CHECK-LABEL: @genbool_1d()
// CHECK-NEXT: ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false> // CHECK-NEXT: ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false>
Show All 22 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
func @main() { func @main() {
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -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-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
Show All 33 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -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-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s --dump-input=always // RUN: | FileCheck %s --dump-input=always
func @main() { func @main() {
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -async-to-async-runtime \ // RUN: mlir-opt %s -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-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func @main() { func @main() {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/bare_ptr_call_conv.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' | mlir-cpu-runner -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext -entry-point-result=void | FileCheck %s // RUN: mlir-opt %s -convert-scf-to-std -convert-memref-to-llvm -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -reconcile-unrealized-casts | mlir-cpu-runner -shared-libs=%linalg_test_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 @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) { func @simple_add1_add2_test(%arg0: memref<2xf32>, %arg1: memref<2xf32>) {
%c2 = constant 2 : index %c2 = 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 -convert-scf-to-std -convert-memref-to-llvm -convert-std-to-llvm \ // RUN: mlir-opt %s -convert-scf-to-std -convert-memref-to-llvm -convert-std-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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func @main() -> () { func @main() -> () {
%c0 = constant 0 : index %c0 = constant 0 : index
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/global_memref.mlir

// RUN: mlir-opt %s -convert-memref-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt %s -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func private @print_memref_i32(memref<*xi32>) attributes { llvm.emit_c_interface } func private @print_memref_i32(memref<*xi32>) attributes { llvm.emit_c_interface }
func private @printNewline() -> () 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 @test1DMemref() { 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/math_polynomial_approx.mlir

// RUN: mlir-opt %s -test-math-polynomial-approximation \ // RUN: mlir-opt %s -test-math-polynomial-approximation \
// RUN: -convert-vector-to-llvm \ // RUN: -convert-vector-to-llvm \
// RUN: -convert-std-to-llvm \ // RUN: -convert-std-to-llvm \
// RUN: -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=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \ // RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
// -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- //
// Tanh. // Tanh.
▲ Show 20 Lines • Show All 299 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/memref_reinterpret_cast.mlir

// RUN: mlir-opt %s -convert-scf-to-std -convert-memref-to-llvm -convert-std-to-llvm \ // RUN: mlir-opt %s -convert-scf-to-std -convert-memref-to-llvm -convert-std-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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func @main() -> () { func @main() -> () {
%c0 = constant 0 : index %c0 = constant 0 : index
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/memref_reshape.mlir

// RUN: mlir-opt %s -convert-scf-to-std -std-expand -convert-memref-to-llvm -convert-std-to-llvm \ // RUN: mlir-opt %s -convert-scf-to-std -std-expand -convert-memref-to-llvm -convert-std-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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \ // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext \
// RUN: | FileCheck %s // RUN: | FileCheck %s
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface } func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }
func @main() -> () { func @main() -> () {
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/sgemm_naive_codegen.mlir

// RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: mlir-opt -convert-linalg-to-loops -lower-affine -convert-scf-to-std -convert-vector-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts %s | mlir-cpu-runner -O3 -e main -entry-point-result=void -shared-libs=%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s
func @main() { 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 = constant 1.00000e+00 : f32 %cf1 = constant 1.00000e+00 : f32
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

mlir/test/mlir-cpu-runner/unranked_memref.mlir

// RUN: mlir-opt %s -convert-linalg-to-loops \ // RUN: mlir-opt %s -convert-linalg-to-loops \
// RUN: -convert-scf-to-std \ // RUN: -convert-scf-to-std \
// RUN: -convert-linalg-to-llvm \ // RUN: -convert-linalg-to-llvm \
// RUN: -convert-memref-to-llvm \ // RUN: -convert-memref-to-llvm \
// RUN: -convert-std-to-llvm | \ // RUN: -convert-std-to-llvm \
// 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_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_dir/libmlir_c_runner_utils%shlibext | FileCheck %s // RUN: -shared-libs=%mlir_runner_utils_dir/libmlir_runner_utils%shlibext,%mlir_runner_utils_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 118 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_0d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-0D
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_1d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-1D
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e print_3d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-3D
// RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D // RUN: mlir-opt %s -convert-linalg-to-loops -convert-scf-to-std -convert-linalg-to-llvm -convert-memref-to-llvm -convert-std-to-llvm -reconcile-unrealized-casts | mlir-cpu-runner -e vector_splat_2d -entry-point-result=void -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext | FileCheck %s --check-prefix=PRINT-VECTOR-SPLAT-2D
func @print_0d() { func @print_0d() {
%f = constant 2.00000e+00 : f32 %f = 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 @print_memref_f32(%U): (memref<*xf32>) -> () call @print_memref_f32(%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/python/dialects/sparse_tensor/test_SpMM.py

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines pipeline = (
f'sparse-tensor-conversion,' f'sparse-tensor-conversion,'
f'builtin.func(convert-linalg-to-loops,convert-vector-to-scf),' f'builtin.func(convert-linalg-to-loops,convert-vector-to-scf),'
f'convert-scf-to-std,' f'convert-scf-to-std,'
f'func-bufferize,' f'func-bufferize,'
f'tensor-constant-bufferize,' f'tensor-constant-bufferize,'
f'builtin.func(tensor-bufferize,std-bufferize,finalizing-bufferize),' f'builtin.func(tensor-bufferize,std-bufferize,finalizing-bufferize),'
f'convert-vector-to-llvm{{reassociate-fp-reductions=1 enable-index-optimizations=1}},' f'convert-vector-to-llvm{{reassociate-fp-reductions=1 enable-index-optimizations=1}},'
f'convert-memref-to-llvm,' f'convert-memref-to-llvm,'
f'convert-std-to-llvm') f'convert-std-to-llvm,'
f'reconcile-unrealized-casts')
self.pipeline = pipeline self.pipeline = pipeline
def __call__(self, module: ir.Module): def __call__(self, module: ir.Module):
passmanager.PassManager.parse(self.pipeline).run(module) passmanager.PassManager.parse(self.pipeline).run(module)
# CHECK-LABEL: TEST: testSpMM # CHECK-LABEL: TEST: testSpMM
# CHECK: Passed 72 tests # CHECK: Passed 72 tests
Show All 38 Lines

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

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Linesdef transform(module, boilerplate):
# TODO: Allow cloning functions from one module to another. # TODO: Allow cloning functions from one module to another.
# Atm we have to resort to string concatenation. # Atm we have to resort to string concatenation.
mod = Module.parse( mod = Module.parse(
str(module.operation.regions[0].blocks[0].operations[0].operation) + str(module.operation.regions[0].blocks[0].operations[0].operation) +
boilerplate) boilerplate)
pm = PassManager.parse( pm = PassManager.parse(
"builtin.func(convert-linalg-to-loops, lower-affine, " + "builtin.func(convert-linalg-to-loops, lower-affine, " +
"convert-scf-to-std), convert-vector-to-llvm," + "convert-scf-to-std), convert-vector-to-llvm," +
"convert-memref-to-llvm,convert-std-to-llvm") "convert-memref-to-llvm,convert-std-to-llvm," +
"reconcile-unrealized-casts")
pm.run(mod) pm.run(mod)
return mod return mod
def test_matmul_builtin(): def test_matmul_builtin():
with Context() as ctx, Location.unknown(): with Context() as ctx, Location.unknown():
module = Module.create() module = Module.create()
f32 = F32Type.get() f32 = F32Type.get()
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

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

Show All 10 Lines
// JIT-compiling and executing the latter. // JIT-compiling and executing the latter.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Conversion/LLVMCommon/LoweringOptions.h" #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/StandardToSPIRVPass.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/Dialect/MemRef/IR/MemRef.h"
#include "mlir/Dialect/MemRef/Transforms/Passes.h" #include "mlir/Dialect/MemRef/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
Show All 21 Linesstatic LogicalResult runMLIRPasses(ModuleOp module) {
OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>(); OpPassManager &modulePM = passManager.nest<spirv::ModuleOp>();
modulePM.addPass(spirv::createLowerABIAttributesPass()); modulePM.addPass(spirv::createLowerABIAttributesPass());
modulePM.addPass(spirv::createUpdateVersionCapabilityExtensionPass()); modulePM.addPass(spirv::createUpdateVersionCapabilityExtensionPass());
passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass()); passManager.addPass(createConvertGpuLaunchFuncToVulkanLaunchFuncPass());
LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module)); LowerToLLVMOptions llvmOptions(module.getContext(), DataLayout(module));
llvmOptions.emitCWrappers = true; llvmOptions.emitCWrappers = true;
passManager.addPass(createMemRefToLLVMPass()); passManager.addPass(createMemRefToLLVMPass());
passManager.addPass(createLowerToLLVMPass(llvmOptions)); passManager.addPass(createLowerToLLVMPass(llvmOptions));
passManager.addPass(createReconcileUnrealizedCastsPass());
passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass()); passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass());
return passManager.run(module); return passManager.run(module);
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
llvm::llvm_shutdown_obj x; llvm::llvm_shutdown_obj x;
registerPassManagerCLOptions(); registerPassManagerCLOptions();
Show All 16 Lines

mlir/unittests/ExecutionEngine/Invoke.cpp

//===- Invoke.cpp ------------------------------------*- C++ -*-===// //===- Invoke.cpp ------------------------------------*- C++ -*-===//
// //
// This file is licensed under the Apache License v2.0 with LLVM Exceptions. // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h" #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
#include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h" #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
#include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h" #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
#include "mlir/Conversion/VectorToSCF/VectorToSCF.h" #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/ExecutionEngine/CRunnerUtils.h" #include "mlir/ExecutionEngine/CRunnerUtils.h"
#include "mlir/ExecutionEngine/ExecutionEngine.h" #include "mlir/ExecutionEngine/ExecutionEngine.h"
#include "mlir/ExecutionEngine/MemRefUtils.h" #include "mlir/ExecutionEngine/MemRefUtils.h"
#include "mlir/ExecutionEngine/RunnerUtils.h" #include "mlir/ExecutionEngine/RunnerUtils.h"
Show All 18 Lines
} 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.getContext()); PassManager pm(module.getContext());
pm.addPass(mlir::createMemRefToLLVMPass()); pm.addPass(mlir::createMemRefToLLVMPass());
pm.addPass(mlir::createLowerToLLVMPass()); pm.addPass(mlir::createLowerToLLVMPass());
pm.addPass(mlir::createReconcileUnrealizedCastsPass());
return pm.run(module); return pm.run(module);
} }
// The JIT isn't supported on Windows at that time // The JIT isn't supported on Windows at that time
#ifndef _WIN32 #ifndef _WIN32
TEST(MLIRExecutionEngine, AddInteger) { TEST(MLIRExecutionEngine, AddInteger) {
std::string moduleStr = R"mlir( std::string moduleStr = R"mlir(
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

Show First 20 Lines • Show All 1,975 Lines • ▼ Show 20 Lines deps = [
":MathToLibm", ":MathToLibm",
":MathToSPIRV", ":MathToSPIRV",
":MemRefToLLVM", ":MemRefToLLVM",
":MemRefToSPIRV", ":MemRefToSPIRV",
":OpenACCToLLVM", ":OpenACCToLLVM",
":OpenACCToSCF", ":OpenACCToSCF",
":OpenMPToLLVM", ":OpenMPToLLVM",
":PDLToPDLInterp", ":PDLToPDLInterp",
":ReconcileUnrealizedCasts",
":SCFToGPUPass", ":SCFToGPUPass",
":SCFToOpenMP", ":SCFToOpenMP",
":SCFToSPIRV", ":SCFToSPIRV",
":SCFToStandard", ":SCFToStandard",
":SPIRVToLLVM", ":SPIRVToLLVM",
":ShapeToStandard", ":ShapeToStandard",
":StandardToLLVM", ":StandardToLLVM",
":StandardToSPIRV", ":StandardToSPIRV",
▲ Show 20 Lines • Show All 2,370 Lines • ▼ Show 20 Lines deps = [
":LLVMDialect", ":LLVMDialect",
":Support", ":Support",
":Transforms", ":Transforms",
"//llvm:Core", "//llvm:Core",
], ],
) )
cc_library( cc_library(
name = "ReconcileUnrealizedCasts",
srcs = ["lib/Conversion/PassDetail.h"] + glob(["lib/Conversion/ReconcileUnrealizedCasts/*.cpp"]),
hdrs = glob(["include/mlir/Conversion/ReconcileUnrealizedCasts/*.h"]),
includes = ["include"],
deps = [
":ConversionPassIncGen",
":IR",
":Pass",
":TransformUtils",
],
)
cc_library(
name = "StandardToLLVM", name = "StandardToLLVM",
srcs = [ srcs = [
"lib/Conversion/PassDetail.h", "lib/Conversion/PassDetail.h",
"lib/Conversion/StandardToLLVM/StandardToLLVM.cpp", "lib/Conversion/StandardToLLVM/StandardToLLVM.cpp",
], ],
hdrs = [ hdrs = [
"include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h", "include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h",
"include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h", "include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h",
▲ Show 20 Lines • Show All 716 Lines • ▼ Show 20 Lines deps = [
":OpenMPDialect", ":OpenMPDialect",
":OpenMPToLLVM", ":OpenMPToLLVM",
":PDLDialect", ":PDLDialect",
":PDLInterpDialect", ":PDLInterpDialect",
":PDLToPDLInterp", ":PDLToPDLInterp",
":QuantOps", ":QuantOps",
":QuantPassIncGen", ":QuantPassIncGen",
":ROCDLDialect", ":ROCDLDialect",
":ReconcileUnrealizedCasts",
":SCFDialect", ":SCFDialect",
":SCFPassIncGen", ":SCFPassIncGen",
":SCFToGPUPass", ":SCFToGPUPass",
":SCFToStandard", ":SCFToStandard",
":SCFTransforms", ":SCFTransforms",
":SDBM", ":SDBM",
":SPIRVDialect", ":SPIRVDialect",
":SPIRVPassIncGen", ":SPIRVPassIncGen",
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines deps = [
":LLVMCommonConversion", ":LLVMCommonConversion",
":LLVMDialect", ":LLVMDialect",
":LLVMToLLVMIRTranslation", ":LLVMToLLVMIRTranslation",
":MemRefDialect", ":MemRefDialect",
":MemRefToLLVM", ":MemRefToLLVM",
":MemRefTransforms", ":MemRefTransforms",
":MlirJitRunner", ":MlirJitRunner",
":Pass", ":Pass",
":ReconcileUnrealizedCasts",
":SPIRVDialect", ":SPIRVDialect",
":SPIRVTransforms", ":SPIRVTransforms",
":StandardOps", ":StandardOps",
":StandardToLLVM", ":StandardToLLVM",
":StandardToSPIRV", ":StandardToSPIRV",
":ToLLVMIRTranslation", ":ToLLVMIRTranslation",
"//llvm:Support", "//llvm:Support",
], ],
▲ Show 20 Lines • Show All 1,678 Lines • Show Last 20 Lines