This is an archive of the discontinued LLVM Phabricator instance.

Differential D156625

[mlir][test] Refactor SparseTensor CPU integration tests
ClosedPublic

Authored by awarzynski on Jul 30 2023, 12:40 PM.

Details

Reviewers
Peiming
aartbik
jsetoain
nicolasvasilache
c-rhodes
Commits
rG23e5130ebfe1: [mlir][test] Reland: Refactor SparseTensor CPU integration tests
rGe77e891d8953: [mlir][test] Refactor SparseTensor CPU integration tests
Summary

SUMMARY OF CHANGES

This patch aims to reduce test duplication and to improve code re-use in
SparseTensor integration tests for CPU. This is a direct follow-up of:

  1. https://reviews.llvm.org/D155403 (test duplication), and
  2. https://reviews.llvm.org/D155405 (code re-use),

The key logic for this patch is implemented in:

  • SparseTensor/CPU/lit.local.cfg.

Essentially, the set-up that used to be repeated across all test files
has been extracted into a common LIT configuration file. This makes code
re-use straightforward.

All SVE/VLA tests are now enabled _conditionally_ and refactored to use
mlir-cpu-runner rather than lli. The former helps with test
duplication and the latter with code re-use.

A few additional refactoring changes are included.

  1. The reduce verbosity, long runtime library names like:
%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext

are replaced with:

%mlir_c_runner_utils
  1. In order to keep the code and the comments in sync, and to maintain consistency across the tests, the following:
enable-runtime-library=true

is swapped with (and vice-versa):

enable-runtime-library=false

Note that this change won't affect test coverage. Only few tests
required such update.

  1. A VLS vectorization RUN line is added in tests where there was a VLA/VLS RUN line, but no VLS RUN line (with a few exceptions of tests that only contained one RUN line to begin with).
  1. A few test variables are renamed/added. Most notable example:
    • %{options} --> %{sparse_compiler_opts}

TEST RUNTIME IMPROVEMENT

Tl;Dr This change improves test execution time by ~25%.

At the moment, the following llvm-lit invocation takes ~7.30s on my
AArch64 workstation (with SVE):

llvm-lit  <llvm-project>/mlir/test/Integration/Dialect/SparseTensor/CPU/

This timing doesn't change no matter what the value of the following
CMake variable is (it should enable/disable SVE/VLA tests):

MLIR_RUN_ARM_SVE_TESTS

With this patch, the execution time will indeed depend on the value of
the above CMake variable:

  • with MLIR_RUN_ARM_SVE_TESTS=true the timing remains intact,
  • with MLIR_RUN_ARM_SVE_TESTS=false the timing drops to ~5.40s (~25% improvement).

This is expected:

  • on average there are 4 RUN lines per test,
  • _without this change_ (and with MLIR_RUN_ARM_SVE_TESTS=false) the 4th RUN line would in most cases duplicate the 3rd RUN line,
  • _with this change) (and with MLIR_RUN_ARM_SVE_TESTS=false) the 4th RUN line becomes empty.

PATCH SIZE

While rather large and touching many files, most changes in this patch
are rather mechanical. All test configurations have been preserved and
only in a handful of cases new RUN lines added.

Diff Detail

Event Timeline

awarzynski created this revision.Jul 30 2023, 12:40 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 30 2023, 12:40 PM
Herald added subscribers: K-Wu, bviyer, hanchung and 27 others. · View Herald Transcript
awarzynski requested review of this revision.Jul 30 2023, 12:40 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptJul 30 2023, 12:40 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: wangpc, stephenneuendorffer, nicolasvasilache. · View Herald Transcript
awarzynski edited the summary of this revision. (Show Details)Jul 30 2023, 12:46 PM
Harbormaster completed remote builds in B249073: Diff 545467.Jul 30 2023, 1:04 PM
awarzynski added a reviewer: c-rhodes.Jul 31 2023, 1:48 AM
c-rhodes accepted this revision.Jul 31 2023, 3:35 AM

Thanks Andrzej this is a nice refactor, I haven't reviewed every single test as there's a fair amount of churn but generally LGTM.

This revision is now accepted and ready to land.Jul 31 2023, 3:35 AM
Matt added a subscriber: Matt.Jul 31 2023, 12:11 PM
aartbik accepted this revision.Aug 2 2023, 12:57 PM

Thanks for following up on this!

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_0.mlir
24

so same here, not repeated anymore

Closed by commit rGe77e891d8953: [mlir][test] Refactor SparseTensor CPU integration tests (authored by awarzynski). · Explain WhyAug 2 2023, 1:22 PM
This revision was automatically updated to reflect the committed changes.
awarzynski added a commit: rGe77e891d8953: [mlir][test] Refactor SparseTensor CPU integration tests.
mehdi_amini added a comment.Aug 2 2023, 3:06 PM

this broke the bot apparently: https://lab.llvm.org/buildbot/#/builders/61/builds/47005

aartbik added a comment.Aug 2 2023, 3:35 PM
In D156625#4555616, @mehdi_amini wrote:

this broke the bot apparently: https://lab.llvm.org/buildbot/#/builders/61/builds/47005

let's revert this

aartbik added a reverting change: D156947: Revert "[mlir][test] Refactor SparseTensor CPU integration tests".Aug 2 2023, 3:45 PM
aartbik added a reverting change: rG5a1f87f9fcb4: Revert "[mlir][test] Refactor SparseTensor CPU integration tests".Aug 2 2023, 3:47 PM
awarzynski added a comment.Aug 3 2023, 2:15 AM

Thanks for reverting and apologies for the disruption - that failing test is disabled for AArch64 and I forgot to test on X86 :(

I am also told that this is causing some pain downstream, so please expect a bit of a delay.

@aartbik, this is unrelated to my change, but on X86 I hit this with ToT llvm_unreachable.

awarzynski reopened this revision.Aug 3 2023, 2:15 AM
This revision is now accepted and ready to land.Aug 3 2023, 2:15 AM
awarzynski updated this revision to Diff 546767.Aug 3 2023, 2:26 AM

Remove undefined and unused LIT variable

This will fix the bot failure, but not the downstream issue.

Harbormaster completed remote builds in B249997: Diff 546767.Aug 3 2023, 4:52 AM
aartbik requested changes to this revision.Aug 7 2023, 9:00 AM

This will still get the DEFINE always change, right?

This revision now requires changes to proceed.Aug 7 2023, 9:00 AM
awarzynski updated this revision to Diff 549067.Aug 10 2023, 9:04 AM

Refactor all tests not to rely on lit.local.cfg

Instead of relying on shared logic in lit.local.cfg, the generic test logic is
duplicated across all tests files. This is required as there are downstream
users that do not use lit.local.cfg.

CC @aartbik

awarzynski updated this revision to Diff 549134.Aug 10 2023, 12:22 PM

Add missing set-up in sparse_tanh.mlir

aartbik accepted this revision.Aug 10 2023, 4:33 PM

I double checked this will keep working for "certain downstream users" ;-)
And thanks for your patience doing this refactoring, much appreciated

(and looking forward to the day we can move the shared part out some place!)

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_0.mlir
5

"some downstream users" very diplomatic ;-)
And thanks for that!

This revision is now accepted and ready to land.Aug 10 2023, 4:33 PM
Harbormaster completed remote builds in B251760: Diff 549134.Aug 10 2023, 4:48 PM
Closed by commit rG23e5130ebfe1: [mlir][test] Reland: Refactor SparseTensor CPU integration tests (authored by awarzynski). · Explain WhyAug 11 2023, 1:17 AM
This revision was automatically updated to reflect the committed changes.
awarzynski added a commit: rG23e5130ebfe1: [mlir][test] Reland: Refactor SparseTensor CPU integration tests.
awarzynski added a comment.Aug 11 2023, 1:19 AM

Re-landed :) 🎉

mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_0.mlir
5

I think that a lot of people (like my "future self") might feel the urge to move this to lit.local.cfg. So I wanted to leave a hint not to :) I've polished this sentence a tiny bit before landing.

mehdi_amini added inline comments.Sep 12 2023, 1:06 PM
mlir/test/Integration/Dialect/SparseTensor/CPU/concatenate_dim_0.mlir
5

I have concerns about the precedent here: we should not support "non-compatible lit environment", this does not seem like a reasonable requirement from every downstream to push this on upstream!

Revision Contents

PathSize
mlir/
test/
Integration/
Dialect/
SparseTensor/
CPU/
48 lines
48 lines
35 lines
48 lines
51 lines
34 lines
48 lines
48 lines
39 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
47 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
46 lines
48 lines
48 lines
50 lines
46 lines
48 lines
47 lines
48 lines
51 lines
48 lines
51 lines
27 lines
49 lines
48 lines
48 lines
45 lines
45 lines
56 lines
26 lines
48 lines
57 lines
48 lines
48 lines
48 lines
46 lines
39 lines
31 lines
48 lines
48 lines
48 lines
34 lines
34 lines
47 lines
37 lines
34 lines
37 lines
45 lines
43 lines
46 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
48 lines
54 lines
53 lines
50 lines
53 lines
38 lines
53 lines
50 lines
50 lines
50 lines
50 lines
50 lines
48 lines
50 lines
50 lines

Diff 549284

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
aartbikUnsubmitted
Not Done
ReplyInline Actions

"some downstream users" very diplomatic ;-)
And thanks for that!

aartbik: "some downstream users" very diplomatic ;-) And thanks for that!
awarzynskiAuthorUnsubmitted
Done
ReplyInline Actions

I think that a lot of people (like my "future self") might feel the urge to move this to lit.local.cfg. So I wanted to leave a hint not to :) I've polished this sentence a tiny bit before landing.

awarzynski: I think that a lot of people (like my "future self") might feel the urge to move this to lit.
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

I have concerns about the precedent here: we should not support "non-compatible lit environment", this does not seem like a reasonable requirement from every downstream to push this on upstream!

mehdi_amini: I have concerns about the precedent here: we should not support "non-compatible lit…
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
aartbikUnsubmitted
Not Done
ReplyInline Actions

so same here, not repeated anymore

aartbik: so same here, not repeated anymore
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
lvlTypes = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
lvlTypes = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{run_option} = // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext %{run_option} | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
#MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
lvlTypes = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#MAT_D_D = #sparse_tensor.encoding<{ #MAT_D_D = #sparse_tensor.encoding<{
lvlTypes = ["dense", "dense"], lvlTypes = ["dense", "dense"],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#DenseMatrix = #sparse_tensor.encoding<{ #DenseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "dense" ], lvlTypes = [ "dense", "dense" ],
dimToLvl = affine_map<(i,j) -> (i,j)> dimToLvl = affine_map<(i,j) -> (i,j)>
}> }>
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
// UNSUPPORTED: target=aarch64{{.*}} // UNSUPPORTED: target=aarch64{{.*}}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}>
#trait_vec_op = { #trait_vec_op = {
indexing_maps = [ indexing_maps = [
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}>
#trait_vec_op = { #trait_vec_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-index-reduction=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CDR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}> #CDR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
#COO_2D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], posWidth = 32, crdWidth = 32 }> #COO_2D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>
#COO_3D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }> #COO_3D = #sparse_tensor.encoding<{ lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ], posWidth = 32, crdWidth = 32 }>
module { module {
func.func private @printMemref3dF32(%ptr : tensor<?x?x?xf32>) attributes { llvm.emit_c_interface } func.func private @printMemref3dF32(%ptr : tensor<?x?x?xf32>) attributes { llvm.emit_c_interface }
func.func private @printMemref2dF32(%ptr : tensor<?x?xf32>) attributes { llvm.emit_c_interface } func.func private @printMemref2dF32(%ptr : tensor<?x?xf32>) attributes { llvm.emit_c_interface }
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec_scale = { #trait_vec_scale = {
▲ Show 20 Lines • Show All 546 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_cast = { #trait_cast = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // A (in) affine_map<(i) -> (i)>, // A (in)
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=false" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait = { #trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed"] lvlTypes = [ "compressed", "compressed"]
}> }>
module { module {
// //
// Main driver. // Main driver.
Show All 31 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Row = #sparse_tensor.encoding<{ #Row = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense" ] lvlTypes = [ "compressed", "dense" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
lvlTypes = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
//
// RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run}
// //
// Do the same run, but now with direct IR generation and vectorization. // Set-up that's shared across all tests in this directory. In principle, this
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // config could be moved to lit.local.cfg. However, there are downstream users that
// RUN: %{compile} | %{run} // do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// Do the same run, but now with direct IR generation and, if available, VLA // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// vectorization. // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ //
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with direct IR generation and VLA vectorization.
// REDEFINE: FileCheck %s // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)>, // b (in) affine_map<(i) -> (i)>, // b (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op1 = { #trait_op1 = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed"] lvlTypes = [ "compressed", "compressed"]
}> }>
// //
// Integration tests for conversions from sparse constants to sparse tensors. // Integration tests for conversions from sparse constants to sparse tensors.
// //
Show All 36 Lines

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

// DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA enable-index-reduction=true"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCC = #sparse_tensor.encoding<{ #CCC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ] }> lvlTypes = [ "compressed", "compressed", "compressed" ] }>
#CDC = #sparse_tensor.encoding<{ #CDC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed" ] lvlTypes = [ "compressed", "dense", "compressed" ]
// FIXME: Still inadmissible might need investigation // FIXME: Still inadmissible might need investigation
// dimToLvl = affine_map<(i,j,k) -> (j,k,i)> // dimToLvl = affine_map<(i,j,k) -> (j,k,i)>
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-index-reduction=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CDR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}> #CDR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "dense"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA enable-index-reduction=true"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: we can only support dense output for nchw input because 'c' is a reduction loop // TODO: we can only support dense output for nchw input because 'c' is a reduction loop
#CDCD = #sparse_tensor.encoding<{ #CDCD = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed", "dense" ] lvlTypes = [ "compressed", "dense", "compressed", "dense" ]
}> }>
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA enable-index-reduction=true"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCCC = #sparse_tensor.encoding<{ #CCCC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ]
}> }>
#CDCD = #sparse_tensor.encoding<{ #CDCD = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed", "dense" ] lvlTypes = [ "compressed", "dense", "compressed", "dense" ]
}> }>
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-index-reduction=true enable-runtime-library=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA enable-index-reduction=true"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCC = #sparse_tensor.encoding<{ #CCC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
#CDC = #sparse_tensor.encoding<{ #CDC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed" ] lvlTypes = [ "compressed", "dense", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 253 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA enable-index-reduction=true"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CCCCC = #sparse_tensor.encoding<{ #CCCCC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed", "compressed", "compressed" ]
}> }>
#CDCDC = #sparse_tensor.encoding<{ #CDCDC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed", "dense", "compressed"] lvlTypes = [ "compressed", "dense", "compressed", "dense", "compressed"]
}> }>
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimToLvl = affine_map<(i,j,k) -> (i,j,k)> dimToLvl = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \ //
// DEFINE: -e entry -entry-point-result=void \ // Set-up that's shared across all tests in this directory. In principle, this
// DEFINE: -shared-libs=%mlir_c_runner_utils | \ // config could be moved to lit.local.cfg. However, there are downstream users that
// DEFINE: FileCheck %s // do not use these LIT config files. Hence why this is kept inline.
// //
// RUN: %{compile} | %{run} // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// Do the same run, but now with direct IR generation and vectorization. // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// REDEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// RUN: %{compile} | %{run} // DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// // DEFINE: %{run_opts} = -e entry -entry-point-result=void
// Do the same run, but now with direct IR generation and, if available, VLA // DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// vectorization. // DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // DEFINE: %{env} =
// REDEFINE: --entry-function=entry_lli \ //--------------------------------------------------------------------------------------------------
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} //
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton-nu", "singleton" ]
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed", "dense" ] lvlTypes = [ "dense", "compressed", "dense" ]
}> }>
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
posWidth = 8, posWidth = 8,
crdWidth = 8 crdWidth = 8
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
dimToLvl = affine_map<(i,j,k) -> (i,j,k)> dimToLvl = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed", "compressed" ],
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

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

// Force this file to use the kDirect method for sparse2sparse. //--------------------------------------------------------------------------------------------------
// DEFINE: %{option} = "enable-runtime-library=true s2s-strategy=2" // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true s2s-strategy=2
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "dense", "compressed" ] lvlTypes = [ "dense", "dense", "compressed" ]
}> }>
// NOTE: dense after compressed is not currently supported for the target // NOTE: dense after compressed is not currently supported for the target
// of direct-sparse2sparse conversion. (It's fine for the source though.) // of direct-sparse2sparse conversion. (It's fine for the source though.)
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
lvlTypes = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
module { module {
// //
// Sparse kernel. // Sparse kernel.
// //
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// RUN: %{compile} | %{run} // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
func.func private @printMemrefF64(%ptr : tensor<*xf64>) func.func private @printMemrefF64(%ptr : tensor<*xf64>)
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
lvlTypes = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" TENSOR1="" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" TENSOR1=""
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" TENSOR1="" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
!TensorReader = !llvm.ptr<i8> !TensorReader = !llvm.ptr<i8>
!TensorWriter = !llvm.ptr<i8> !TensorWriter = !llvm.ptr<i8>
module { module {
func.func private @getTensorFilename(index) -> (!Filename) func.func private @getTensorFilename(index) -> (!Filename)
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// An example of a 2D convolution with a sparse filter. // An example of a 2D convolution with a sparse filter.
module { module {
func.func @conv2d(%input: tensor<8x8xi32>, func.func @conv2d(%input: tensor<8x8xi32>,
%filter: tensor<3x3xi32, #DCSR>, %filter: tensor<3x3xi32, #DCSR>,
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.tns" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.tns"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.tns" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed", "compressed", lvlTypes = [ "compressed", "compressed", "compressed", "compressed",
"compressed", "compressed", "compressed", "compressed" ], "compressed", "compressed", "compressed", "compressed" ],
// Note that any dimToLvl permutation should give the same results // Note that any dimToLvl permutation should give the same results
// since, even though it impacts the sparse storage scheme layout, // since, even though it impacts the sparse storage scheme layout,
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s
// TODO: support slices on lib path // TODO: support slices on lib path
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#CSR_SLICE = #sparse_tensor.encoding<{ #CSR_SLICE = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

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

// DEFINE: %{option_vec} = //--------------------------------------------------------------------------------------------------
// DEFINE: %{option} = enable-runtime-library=true // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
//
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // Set-up that's shared across all tests in this directory. In principle, this
// DEFINE: %{run} = mlir-cpu-runner \ // config could be moved to lit.local.cfg. However, there are downstream users that
// DEFINE: -e entry -entry-point-result=void \ // do not use these LIT config files. Hence why this is kept inline.
// DEFINE: -shared-libs=%mlir_c_runner_utils | \ //
// DEFINE: FileCheck %s // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// RUN: %{compile} | %{run} // DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option_vec} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: %{option} = "%{option_vec}" // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | %{run} //
// Do the same run, but now with direct IR generation and VLA vectorization.
// Do the same run, but with VLA vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-arm-sve=true %{option_vec}"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %if mlir_arm_sve_tests %{ %{compile} | mlir-translate -mlir-to-llvmir | %{run} %}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
lvlTypes = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
lvlTypes = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \ //
// DEFINE: -e entry -entry-point-result=void \ // Set-up that's shared across all tests in this directory. In principle, this
// DEFINE: -shared-libs=%mlir_c_runner_utils | \ // config could be moved to lit.local.cfg. However, there are downstream users that
// DEFINE: FileCheck %s // do not use these LIT config files. Hence why this is kept inline.
// //
// RUN: %{compile} | %{run} // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// Do the same run, but now with vectorization. // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// RUN: %{compile} | %{run} // DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// Do the same run, but now with direct IR generation and, if available, VLA // DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// vectorization. // DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // DEFINE: %{env} =
// REDEFINE: --entry-function=entry_lli \ //--------------------------------------------------------------------------------------------------
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ //
// REDEFINE: FileCheck %s // Do the same run, but now with direct IR generation.
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// Insertion example using pure codegen (no sparse runtime support lib). // Insertion example using pure codegen (no sparse runtime support lib).
#SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_mul_s = { #trait_mul_s = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// Do the same run, but now with vectorization. // DEFINE: %{env} =
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" //--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// vectorization. // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // Do the same run, but now with vectorization.
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ //
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now VLA vectorization.
// REDEFINE: FileCheck %s // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
lvlTypes = ["dense", "dense"] lvlTypes = ["dense", "dense"]
}> }>
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
lvlTypes = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// Do the same run, but now with vectorization. // DEFINE: %{env} =
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" //--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// vectorization. // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // Do the same run, but now with vectorization.
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ //
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with VLA vectorization.
// REDEFINE: FileCheck %s // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#TensorCSR = #sparse_tensor.encoding<{ #TensorCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "dense", "compressed" ] lvlTypes = [ "compressed", "dense", "compressed" ]
}> }>
#TensorRow = #sparse_tensor.encoding<{ #TensorRow = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "dense" ] lvlTypes = [ "compressed", "compressed", "dense" ]
}> }>
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with parallelization strategy. // Do the same run, but now with parallelization strategy.
// REDEFINE: %{option} = "enable-runtime-library=true parallelization-strategy=any-storage-any-loop" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true parallelization-strategy=any-storage-any-loop
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and parallelization strategy. // Do the same run, but now with direct IR generation and parallelization strategy.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true parallelization-strategy=any-storage-any-loop" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true parallelization-strategy=any-storage-any-loop
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: Investigate the output generated for SVE, see https://github.com/llvm/llvm-project/issues/60626 // TODO: Investigate the output generated for SVE, see https://github.com/llvm/llvm-project/issues/60626
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimToLvl = affine_map<(i,j) -> (i,j)> dimToLvl = affine_map<(i,j) -> (i,j)>
}> }>
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext,%mlir_lib_dir/libmlir_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s
// TODO: support lib path. // TODO: support lib path.
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#DCSR_SLICE = #sparse_tensor.encoding<{ #DCSR_SLICE = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 260 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// //
// Traits for 2-d tensor (aka matrix) operations. // Traits for 2-d tensor (aka matrix) operations.
// //
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ //
// DEFINE: mlir-cpu-runner \ // Set-up that's shared across all tests in this directory. In principle, this
// DEFINE: -e entry -entry-point-result=void \ // config could be moved to lit.local.cfg. However, there are downstream users that
// DEFINE: -shared-libs=%mlir_c_runner_utils | \ // do not use these LIT config files. Hence why this is kept inline.
// DEFINE: FileCheck %s //
// RUN: %{compile} | %{run} // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with parallelization strategy. // Do the same run, but now with parallelization strategy.
// REDEFINE: %{option} = "enable-runtime-library=true parallelization-strategy=any-storage-any-loop" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true parallelization-strategy=any-storage-any-loop
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and parallelization strategy. // Do the same run, but now with direct IR generation and parallelization strategy.
// REDEFINE: %{option} = "enable-runtime-library=false parallelization-strategy=any-storage-any-loop" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false parallelization-strategy=any-storage-any-loop
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and, if available, VLA
// vectorization. // vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
posWidth = 8, posWidth = 8,
crdWidth = 8 crdWidth = 8
}> }>
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0=%mlir_src_dir/test/Integration/data/mttkrp_b.tns
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and, if available, VLA
// vectorization. // vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext -dlopen=%mlir_runner_utils| \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
#mttkrp = { #mttkrp = {
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_mult_elt = { #trait_mult_elt = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // A affine_map<(i,j) -> (i,j)>, // A
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
//
// RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run}
// //
// Do the same run, but now with direct IR generation and vectorization. // Set-up that's shared across all tests in this directory. In principle, this
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // config could be moved to lit.local.cfg. However, there are downstream users that
// RUN: %{compile} | %{run} // do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and, if available, VLA
// vectorization. // vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimToLvl = affine_map<(i,j) -> (i,j)> dimToLvl = affine_map<(i,j) -> (i,j)>
}> }>
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \ //
// DEFINE: -e entry -entry-point-result=void \ // Set-up that's shared across all tests in this directory. In principle, this
// DEFINE: -shared-libs=%mlir_c_runner_utils | \ // config could be moved to lit.local.cfg. However, there are downstream users that
// DEFINE: FileCheck %s // do not use these LIT config files. Hence why this is kept inline.
// //
// RUN: %{compile} | %{run} // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// Do the same run, but now with direct IR generation and, if available, VLA // DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// vectorization. // DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // DEFINE: %{run_opts} = -e entry -entry-point-result=void
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// REDEFINE: --entry-function=entry_lli \ // DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // DEFINE: %{env} =
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ //--------------------------------------------------------------------------------------------------
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with VLA vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// TODO: Pack only support CodeGen Path // TODO: Pack only support CodeGen Path
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
lvlTypes = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#SortedCOOI32 = #sparse_tensor.encoding<{ #SortedCOOI32 = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true" //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=true enable-buffer-initialization=true enable-index-reduction=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
#CCCC = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ], posWidth = 32, crdWidth = 32 }> #CCCC = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed", "compressed" ], posWidth = 32, crdWidth = 32 }>
func.func @pooling_nhwc_sum_CCCC(%input: tensor<1x4x4x1xf32, #CCCC>, %filter: tensor<2x2xf32>) -> tensor<1x3x3x1xf32, #CCCC> { func.func @pooling_nhwc_sum_CCCC(%input: tensor<1x4x4x1xf32, #CCCC>, %filter: tensor<2x2xf32>) -> tensor<1x3x3x1xf32, #CCCC> {
%init = bufferization.alloc_tensor() : tensor<1x3x3x1xf32, #CCCC> %init = bufferization.alloc_tensor() : tensor<1x3x3x1xf32, #CCCC>
%0 = linalg.pooling_nhwc_sum {dilations = dense<1> : tensor<2xi64>, %0 = linalg.pooling_nhwc_sum {dilations = dense<1> : tensor<2xi64>,
strides = dense<1> : tensor<2xi64>} strides = dense<1> : tensor<2xi64>}
ins (%input, %filter: tensor<1x4x4x1xf32, #CCCC>, tensor<2x2xf32>) ins (%input, %filter: tensor<1x4x4x1xf32, #CCCC>, tensor<2x2xf32>)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
// An example of a quantized sparse matmul. With the zero offset for the // An example of a quantized sparse matmul. With the zero offset for the
// sparse input, the sparse compiler generates very efficient code for the // sparse input, the sparse compiler generates very efficient code for the
// x(i,j) += (ext(a(i,k)) - 2) * ext(b(k,j)) // x(i,j) += (ext(a(i,k)) - 2) * ext(b(k,j))
// operation. // operation.
module { module {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a (in) affine_map<(i) -> (i)>, // a (in)
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// Reduction in this file _are_ supported by the AArch64 SVE backend // Reduction in this file _are_ supported by the AArch64 SVE backend
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// Product reductions - kept in a seperate file as these are not supported by // Product reductions - kept in a seperate file as these are not supported by
// the AArch64 SVE backend (so the set-up is a bit different to // the AArch64 SVE backend (so the set-up is a bit different to
// sparse_reducitons.mlir) // sparse_reducitons.mlir)
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
#SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
], ],
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// Reduction in this file _are_ supported by the AArch64 SVE backend // Reduction in this file _are_ supported by the AArch64 SVE backend
#SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
], ],
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
#SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#DV = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }> #DV = #sparse_tensor.encoding<{ lvlTypes = [ "dense" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
lvlTypes = ["compressed"] lvlTypes = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
// //
// Do the same run, but now with vectorization. // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// RUN: %{compile} | %{run} // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// Do the same run, but now with direct IR generation and, if available, VLA // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// vectorization. // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // Do the same run, but now with vectorization.
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ //
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with VLA vectorization.
// REDEFINE: FileCheck %s // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
module { module {
func.func @entry() { func.func @entry() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%c1 = arith.constant 1 : index %c1 = arith.constant 1 : index
%c10 = arith.constant 10 : index %c10 = arith.constant 10 : index
%d0 = arith.constant 0.0 : f32 %d0 = arith.constant 0.0 : f32
%d1 = arith.constant 1.0 : f32 %d1 = arith.constant 1.0 : f32
Show All 27 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// Do the same run, but now with direct IR generation and, if available, VLA // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// vectorization. // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" //
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // Do the same run, but now with vectorization.
// REDEFINE: --entry-function=entry_lli \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ //
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext --dlopen=%mlir_runner_utils | \ // Do the same run, but now with VLA vectorization.
// REDEFINE: FileCheck %s // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
module { module {
func.func private @printMemref1dI32(%ptr : memref<?xi32>) attributes { llvm.emit_c_interface } func.func private @printMemref1dI32(%ptr : memref<?xi32>) attributes { llvm.emit_c_interface }
// Stores 5 values to the memref buffer. // Stores 5 values to the memref buffer.
func.func @storeValuesTo(%b: memref<?xi32>, %v0: i32, %v1: i32, %v2: i32, func.func @storeValuesTo(%b: memref<?xi32>, %v0: i32, %v1: i32, %v2: i32,
%v3: i32, %v4: i32) -> () { %v3: i32, %v4: i32) -> () {
%i0 = arith.constant 0 : index %i0 = arith.constant 0 : index
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
// //
// Do the same run, but now with vectorization. // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// RUN: %{compile} | %{run} // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// Do the same run, but now with direct IR generation and, if available, VLA // RUN: %{compile} | %{run} | FileCheck %s
// vectorization. //
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // Do the same run, but now with vectorization.
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// REDEFINE: --entry-function=entry_lli \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // Do the same run, but now with VLA vectorization.
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
module { module {
// Stores 5 values to the memref buffer. // Stores 5 values to the memref buffer.
func.func @storeValuesTo(%b: memref<?xi32>, %v0: i32, %v1: i32, %v2: i32, func.func @storeValuesTo(%b: memref<?xi32>, %v0: i32, %v1: i32, %v2: i32,
%v3: i32, %v4: i32) -> () { %v3: i32, %v4: i32) -> () {
%i0 = arith.constant 0 : index %i0 = arith.constant 0 : index
%i1 = arith.constant 1 : index %i1 = arith.constant 1 : index
%i2 = arith.constant 2 : index %i2 = arith.constant 2 : index
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and, if available, VLA
// vectorization. // vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
posWidth = 32, posWidth = 32,
crdWidth = 32 crdWidth = 32
}> }>
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with direct IR generation and VLA vectorization.
// vectorization. // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SM = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }> #SM = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed" ] }>
#trait_sampled_dense_dense = { #trait_sampled_dense_dense = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j,k) -> (i,j)>, // S affine_map<(i,j,k) -> (i,j)>, // S
affine_map<(i,j,k) -> (i,k)>, // A affine_map<(i,j,k) -> (i,k)>, // A
affine_map<(i,j,k) -> (k,j)>, // B affine_map<(i,j,k) -> (k,j)>, // B
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// Do the same run, but now with direct IR generation. // DEFINE: %{env} =
// REDEFINE: %{option} = enable-runtime-library=false //--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA // RUN: %{compile} | %{run} | FileCheck %s
// vectorization. //
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // Do the same run, but now with direct IR generation.
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// REDEFINE: --entry-function=entry_lli \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // Do the same run, but now with vectorization.
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4
// REDEFINE: FileCheck %s // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} //
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ lvlTypes = [ "dense", "compressed" ] }>
#trait_scale = { #trait_scale = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)> // X (out) affine_map<(i,j) -> (i,j)> // X (out)
], ],
iterator_types = ["parallel", "parallel"], iterator_types = ["parallel", "parallel"],
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
// //
// Do the same run, but now with direct IR generation. // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// REDEFINE: %{option} = enable-runtime-library=false // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// RUN: %{compile} | %{run} // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// Do the same run, but now with direct IR generation and, if available, VLA // RUN: %{compile} | %{run} | FileCheck %s
// vectorization. //
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA" // Do the same run, but now with direct IR generation.
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// REDEFINE: --entry-function=entry_lli \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // Do the same run, but now with vectorization.
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4
// REDEFINE: FileCheck %s // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} //
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> #map = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
#SparseMatrix = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }> #SparseMatrix = #sparse_tensor.encoding<{ lvlTypes = [ "compressed", "compressed", "compressed" ] }>
module @func_sparse.2 { module @func_sparse.2 {
// Do elementwise x+1 when true, x-1 when false // Do elementwise x+1 when true, x-1 when false
func.func public @condition(%cond: i1, %arg0: tensor<2x3x4xf64, #SparseMatrix>) -> tensor<2x3x4xf64, #SparseMatrix> { func.func public @condition(%cond: i1, %arg0: tensor<2x3x4xf64, #SparseMatrix>) -> tensor<2x3x4xf64, #SparseMatrix> {
%1 = scf.if %cond -> (tensor<2x3x4xf64, #SparseMatrix>) { %1 = scf.if %cond -> (tensor<2x3x4xf64, #SparseMatrix>) {
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
// //
// Do the same run, but now with direct IR generation. // DEFINE: %{env} =
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" //--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA // RUN: %{compile} | %{run} | FileCheck %s
// vectorization. //
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA" // Do the same run, but now with direct IR generation.
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// REDEFINE: --entry-function=entry_lli \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // Do the same run, but now with vectorization.
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// REDEFINE: FileCheck %s // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} //
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ], lvlTypes = [ "dense", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
// //
// Do the same run, but now with direct IR generation. // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// RUN: %{compile} | %{run} // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// Do the same run, but now with direct IR generation and, if available, VLA // RUN: %{compile} | %{run} | FileCheck %s
// vectorization. //
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA" // Do the same run, but now with direct IR generation.
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// REDEFINE: --entry-function=entry_lli \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // Do the same run, but now with vectorization.
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// REDEFINE: FileCheck %s // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} //
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = ["compressed", "compressed"] lvlTypes = ["compressed", "compressed"]
}> }>
#sel_trait = { #sel_trait = {
indexing_maps = [ indexing_maps = [
affine_map<(i,j) -> (i,j)>, // C (in) affine_map<(i,j) -> (i,j)>, // C (in)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
// //
// Do the same run, but now with direct IR generation. // DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// RUN: %{compile} | %{run} // DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// Do the same run, but now with direct IR generation and, if available, VLA // RUN: %{compile} | %{run} | FileCheck %s
// vectorization. //
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA" // Do the same run, but now with direct IR generation.
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// REDEFINE: --entry-function=entry_lli \ // RUN: %{compile} | %{run} | FileCheck %s
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \ //
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \ // Do the same run, but now with vectorization.
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \ // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// REDEFINE: FileCheck %s // RUN: %{compile} | %{run} | FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run} //
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
#SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> (i)> // x (out) affine_map<(i) -> (i)> // x (out)
], ],
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// DEFINE: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// REDEFINE: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with direct IR generation and, if available, VLA // Do the same run, but now with vectorization.
// vectorization. // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA" // RUN: %{compile} | %{env} %{run} | FileCheck %s
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ //
// REDEFINE: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \ // Do the same run, but now with VLA vectorization.
// REDEFINE: %lli_host_or_aarch64_cmd \ // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
lvlTypes = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
#SortedCOOPermuted = #sparse_tensor.encoding<{ #SortedCOOPermuted = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "compressed" ] lvlTypes = [ "dense", "compressed" ]
}> }>
#spmm = { #spmm = {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// //
// Several common sparse storage schemes. // Several common sparse storage schemes.
// //
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
lvlTypes = [ "dense", "dense" ] lvlTypes = [ "dense", "dense" ]
}> }>
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0=%mlir_src_dir/test/Integration/data/test_symmetric.mtx
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: The test currently only operates on the triangular part of the // TODO: The test currently only operates on the triangular part of the
// symmetric matrix. // symmetric matrix.
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \ // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{command} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{command} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// UNSUPPORTED: target=aarch64{{.*}} // UNSUPPORTED: target=aarch64{{.*}}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric_complex.mtx" \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// REDEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric_complex.mtx"
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric_complex.mtx" \
// REDEFINE: %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
// TODO: The test currently only operates on the triangular part of the // TODO: The test currently only operates on the triangular part of the
// symmetric matrix. // symmetric matrix.
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#trait_sum_reduce = { #trait_sum_reduce = {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with VLA vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// Current fails for SVE, see https://github.com/llvm/llvm-project/issues/60626 // Current fails for SVE, see https://github.com/llvm/llvm-project/issues/60626
// UNSUPPORTED: target=aarch64{{.*}} // UNSUPPORTED: target=aarch64{{.*}}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 reassociate-fp-reductions=true enable-index-optimizations=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_op = { #trait_op = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)> // X (out) affine_map<(i) -> (i)> // X (out)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
doc = "X(i) = OP X(i)" doc = "X(i) = OP X(i)"
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#ST = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "compressed"]}> #ST = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "compressed"]}>
// //
// Trait for 3-d tensor element wise multiplication. // Trait for 3-d tensor element wise multiplication.
// //
#trait_mul = { #trait_mul = {
indexing_maps = [ indexing_maps = [
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#ST1 = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "compressed"]}> #ST1 = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "compressed"]}>
#ST2 = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "dense"]}> #ST2 = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed", "dense"]}>
// //
// Trait for 3-d tensor operation. // Trait for 3-d tensor operation.
// //
#trait_scale = { #trait_scale = {
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ] lvlTypes = [ "compressed", "compressed" ]
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
lvlTypes = [ "compressed", "compressed" ], lvlTypes = [ "compressed", "compressed" ],
dimToLvl = affine_map<(i,j) -> (j,i)> dimToLvl = affine_map<(i,j) -> (j,i)>
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// FIXME: lib path does not support all of COO yet // FIXME: lib path does not support all of COO yet
// R_U_N: %{compile} | %{run} // R_U_N: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
lvlTypes = [ "compressed-nu", "singleton" ] lvlTypes = [ "compressed-nu", "singleton" ]
}> }>
module { module {
// A linalg representation of some higher "transpose" op. // A linalg representation of some higher "transpose" op.
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

// DEFINE: %{option_vec} = //--------------------------------------------------------------------------------------------------
// DEFINE: %{option} = enable-runtime-library=true // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run_option} =
// DEFINE: %{cpu_runner} = mlir-cpu-runner
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// DEFINE: %{run} = %{cpu_runner} \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils %{run_option} | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option_vec} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// REDEFINE: %{option} = "%{option_vec}"
// RUN: %{compile} | %{run}
// Do the same run, but with VLA vectorization.
// REDEFINE: %{option} = "enable-arm-sve=true %{option_vec}"
// REDEFINE: %{cpu_runner} = %mcr_aarch64_cmd
// REDEFINE: %{run_option} = %VLA_ARCH_ATTR_OPTIONS
// RUN: %if mlir_arm_sve_tests %{ %{compile} | %{run} %}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{lvlTypes = ["compressed", "compressed"]}>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec = { #trait_vec = {
▲ Show 20 Lines • Show All 284 Lines • Show Last 20 Lines

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

// DEFINE: %{option} = enable-runtime-library=true //--------------------------------------------------------------------------------------------------
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option} // WHEN CREATING A NEW TEST, PLEASE JUST COPY & PASTE WITHOUT EDITS.
// DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// RUN: %{compile} | %{run} // Set-up that's shared across all tests in this directory. In principle, this
// config could be moved to lit.local.cfg. However, there are downstream users that
// do not use these LIT config files. Hence why this is kept inline.
//
// DEFINE: %{sparse_compiler_opts} = enable-runtime-library=true
// DEFINE: %{sparse_compiler_opts_sve} = enable-arm-sve=true %{sparse_compiler_opts}
// DEFINE: %{compile} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"
// DEFINE: %{compile_sve} = mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"
// DEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils
// DEFINE: %{run_opts} = -e entry -entry-point-result=void
// DEFINE: %{run} = mlir-cpu-runner %{run_opts} %{run_libs}
// DEFINE: %{run_sve} = %mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}
//
// DEFINE: %{env} =
//--------------------------------------------------------------------------------------------------
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true" // REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} // RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // Do the same run, but now with VLA vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %}
// RUN: %{compile} | %{run}
// Do the same run, but now with direct IR generation and, if available, VLA
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = %lli_host_or_aarch64_cmd \
// REDEFINE: --entry-function=entry_lli \
// REDEFINE: --extra-module=%S/Inputs/main_for_lli.ll \
// REDEFINE: %VLA_ARCH_ATTR_OPTIONS \
// REDEFINE: --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
// REDEFINE: FileCheck %s
// RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
#SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{lvlTypes = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{lvlTypes = ["dense"]}>
// //
// Traits for 1-d tensor (aka vector) operations. // Traits for 1-d tensor (aka vector) operations.
// //
#trait_scale = { #trait_scale = {
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines