This is an archive of the discontinued LLVM Phabricator instance.

Differential D156947

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

Authored by aartbik on Aug 2 2023, 3:45 PM.

Details

Reviewers
awarzynski
mehdi_amini
nicolasvasilache
Commits
rG5a1f87f9fcb4: Revert "[mlir][test] Refactor SparseTensor CPU integration tests"
Summary

This reverts commit e77e891d8953b487f5f06bf69225a61ef537f766.

Diff Detail

Event Timeline

aartbik created this revision.Aug 2 2023, 3:45 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 2 2023, 3:45 PM
Herald added subscribers: K-Wu, bviyer, hanchung and 26 others. · View Herald Transcript
aartbik requested review of this revision.Aug 2 2023, 3:45 PM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptAug 2 2023, 3:45 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
This revision was not accepted when it landed; it landed in state Needs Review.Aug 2 2023, 3:47 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG5a1f87f9fcb4: Revert "[mlir][test] Refactor SparseTensor CPU integration tests" (authored by aartbik). · Explain Why
This revision was automatically updated to reflect the committed changes.
aartbik added a commit: rG5a1f87f9fcb4: Revert "[mlir][test] Refactor SparseTensor CPU integration tests".
Harbormaster completed remote builds in B249897: Diff 546625.Aug 2 2023, 6:24 PM

Revision Contents

PathSize
mlir/
test/
Integration/
Dialect/
SparseTensor/
CPU/
33 lines
33 lines
20 lines
33 lines
36 lines
19 lines
33 lines
33 lines
22 lines
25 lines
33 lines
33 lines
33 lines
31 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
29 lines
33 lines
33 lines
33 lines
31 lines
33 lines
32 lines
33 lines
36 lines
33 lines
36 lines
12 lines
34 lines
33 lines
33 lines
29 lines
29 lines
41 lines
12 lines
33 lines
40 lines
33 lines
33 lines
33 lines
33 lines
25 lines
15 lines
33 lines
33 lines
33 lines
19 lines
19 lines
32 lines
22 lines
22 lines
29 lines
27 lines
29 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
33 lines
39 lines
38 lines
35 lines
38 lines
24 lines
38 lines
35 lines
35 lines
35 lines
35 lines
35 lines
33 lines
35 lines
35 lines

Diff 546626

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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run_option} =
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{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 143 Lines • Show Last 20 Lines

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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{command}
// //
// 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: %{sparse_compiler_opts} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true" // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{command}
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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/lit.local.cfg

Show All 9 Linesif config.mlir_run_arm_sve_tests:
config.substitutions.append(("%ENABLE_VLA", "true")) config.substitutions.append(("%ENABLE_VLA", "true"))
config.substitutions.append( config.substitutions.append(
("%VLA_ARCH_ATTR_OPTIONS", '--march=aarch64 --mattr="+sve"') ("%VLA_ARCH_ATTR_OPTIONS", '--march=aarch64 --mattr="+sve"')
) )
else: else:
config.substitutions.append(("%ENABLE_VLA", "false")) config.substitutions.append(("%ENABLE_VLA", "false"))
config.substitutions.append(("%VLA_ARCH_ATTR_OPTIONS", "")) config.substitutions.append(("%VLA_ARCH_ATTR_OPTIONS", ""))
config.substitutions.append(("%mlir_native_utils_lib_dir", config.mlir_lib_dir)) config.substitutions.append(("%mlir_native_utils_lib_dir", config.mlir_lib_dir))
# CONFIGURATION FOR COMPILATION
# -----------------------------
# Sparse compiler options. (Re)Define this substitution in every test file.
config.substitutions.insert(0, ("%{sparse_compiler_opts}",'' ))
# The following substitution should only be used _after_
# %{sparse_compiler_opts} has been updated to enable vectorization.
config.substitutions.insert(0, ("%{sparse_compiler_opts_sve}",'enable-arm-sve=true %{sparse_compiler_opts}'))
# Runs the sparse compiler.
config.substitutions.insert(0, ("%{compile}", 'mlir-opt %s --sparse-compiler="%{sparse_compiler_opts}"'))
# Runs the sparse compiler with SVE/VLA vectorisation.
config.substitutions.insert(0, ("%{compile_sve}", 'mlir-opt %s --sparse-compiler="%{sparse_compiler_opts_sve}"'))
# CONFIGURATION FOR JIT'ing AND EXECUTION
# ---------------------------------------
# Runtime libraries to use. (Re)Define this substitution in every test file.
config.substitutions.insert(0, ("%{run_libs}", ""))
config.substitutions.insert(0, ("%{run_opts}", "-e entry -entry-point-result=void"))
# JIT and run the compiled test.
config.substitutions.insert(0, ("%{run}", "mlir-cpu-runner %{run_opts} %{run_libs}"))
# JIT and run the compiled test with SVE enabled.
config.substitutions.insert(0, ("%{run_sve}", '%mcr_aarch64_cmd --march=aarch64 --mattr="+sve" %{run_opts} %{run_libs}'))

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

// DEFINE: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = "enable-runtime-library=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=false"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// // DEFINE: -e entry -entry-point-result=void \
// Do the same run, but now with direct IR generation. // DEFINE: -shared-libs=%mlir_c_runner_utils | \
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // DEFINE: FileCheck %s
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with direct IR generation and vectorization. // RUN: %{compile} | %{run}
// 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. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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" ]
}> }>
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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"]
}> }>
module { module {
// //
// Main driver. // Main driver.
Show All 31 Lines

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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{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 // REDEFINE: %{option} = "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} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{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 // REDEFINE: %{option} = "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} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{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 // REDEFINE: %{option} = "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} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-index-reduction=true enable-runtime-library=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{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 // REDEFINE: %{option} = "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} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{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 // REDEFINE: %{option} = "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} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2 // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// // DEFINE: -e entry -entry-point-result=void \
// Do the same run, but now with vectorization. // DEFINE: -shared-libs=%mlir_c_runner_utils | \
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // DEFINE: FileCheck %s
// RUN: %{compile} | %{run} | FileCheck %s //
// // RUN: %{compile} | %{run}
// Do the same run, but now with VLA vectorization. //
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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"
// 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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. // Force this file to use the kDirect method for sparse2sparse.
// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=true s2s-strategy=2"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true s2s-strategy=2 // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2 // REDEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2 vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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" ]
}> }>
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" TENSOR1="" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" TENSOR1="" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // 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" 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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<{ 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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.tns" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.tns" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// Do the same run, but now with direct IR generation and VLA vectorization. // Do the same run, but now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: %{compile} | %{run} | FileCheck %s // 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}
//
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option_vec} =
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{option} = enable-runtime-library=true
// RUN: %{compile} | %{run} | FileCheck %s
// 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option_vec} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// RUN: %{compile} | %{run} | FileCheck %s // REDEFINE: %{option} = "%{option_vec}"
// // RUN: %{compile} | %{run}
// 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 %} // Do the same run, but with VLA vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with vectorization. // RUN: %{compile} | %{run}
// 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 VLA vectorization. // Do the same run, but now with vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with vectorization. // RUN: %{compile} | %{run}
// 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 VLA vectorization. // Do the same run, but now with vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with parallelization strategy. // Do the same run, but now with parallelization strategy.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true parallelization-strategy=any-storage-any-loop // REDEFINE: %{option} = "enable-runtime-library=true parallelization-strategy=any-storage-any-loop"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true parallelization-strategy=any-storage-any-loop // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true parallelization-strategy=any-storage-any-loop"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: %{compile} | %{run} | FileCheck %s // 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}
//
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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 --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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with parallelization strategy. // Do the same run, but now with parallelization strategy.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true parallelization-strategy=any-storage-any-loop // REDEFINE: %{option} = "enable-runtime-library=true parallelization-strategy=any-storage-any-loop"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false parallelization-strategy=any-storage-any-loop // REDEFINE: %{option} = "enable-runtime-library=false parallelization-strategy=any-storage-any-loop"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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.
// 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" \
// 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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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.
// 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/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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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. // 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 // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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.
// 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 | \
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// // DEFINE: -e entry -entry-point-result=void \
// Do the same run, but now with VLA vectorization. // DEFINE: -shared-libs=%mlir_c_runner_utils | \
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 // DEFINE: FileCheck %s
// 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}
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = "enable-runtime-library=false enable-index-reduction=true"
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true enable-index-reduction=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true enable-index-reduction=true // REDEFINE: %{option} = "enable-runtime-library=true enable-buffer-initialization=true enable-index-reduction=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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<{ 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{command}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{command}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{command}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{command}
//
// 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_reshape.mlir

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with vectorization. // RUN: %{compile} | %{run}
// 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 VLA vectorization. // Do the same run, but now with vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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}
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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils,%mlir_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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
// //
// Do the same run, but now with vectorization. // RUN: %{compile} | %{run}
// 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, if available, VLA
// // vectorization.
// Do the same run, but now with VLA vectorization. // REDEFINE: %{option} = "enable-runtime-library=false vl=4 enable-arm-sve=%ENABLE_VLA"
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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}
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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=false
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with vectorization. // RUN: %{compile} | %{run}
// 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 VLA vectorization. // Do the same run, but now with vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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}
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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_runner_utils,%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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.
// 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 | \
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // 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. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// 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: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// 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 now with direct IR generation and, if available, VLA
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // vectorization.
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option} = enable-runtime-library=false
// 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option} = enable-runtime-library=false
// 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}
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// vectorization.
// 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"]}>
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// vectorization.
// 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"]
}> }>
#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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// vectorization.
// 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" ] }>
#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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // DEFINE: %{option} = enable-runtime-library=true
// DEFINE: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{env} %{run} | FileCheck %s
//
// Do the same run, but now with vectorization.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=4 enable-buffer-initialization=true
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // 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
// vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true vl=4 enable-arm-sve=%ENABLE_VLA"
// REDEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// REDEFINE: TENSOR1="%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 | \
// 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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{command}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{command}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{command}
// 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: %{env} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric_complex.mtx" // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{run} = TENSOR0="%mlir_src_dir/test/Integration/data/test_symmetric_complex.mtx" \
// RUN: %{compile} | %{env} %{run} | FileCheck %s // DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{env} %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{env} %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{compile} | %{run}
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// 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 vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // 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
//
// 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} | FileCheck %s // R_U_N: %{compile} | %{run}
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
//
// 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 VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // 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
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option_vec} =
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{option} = enable-runtime-library=true
// RUN: %{compile} | %{run} | FileCheck %s // 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
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option_vec} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true
// 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

// REDEFINE: %{run_libs} = -shared-libs=%mlir_c_runner_utils // DEFINE: %{option} = enable-runtime-library=true
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=true // DEFINE: %{compile} = mlir-opt %s --sparse-compiler=%{option}
// RUN: %{compile} | %{run} | FileCheck %s // DEFINE: %{run} = mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // RUN: %{compile} | %{run}
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true
// RUN: %{compile} | %{run} | FileCheck %s
// //
// Do the same run, but now with vectorization. // Do the same run, but now with direct IR generation.
// REDEFINE: %{sparse_compiler_opts} = enable-runtime-library=false enable-buffer-initialization=true vl=2 reassociate-fp-reductions=true enable-index-optimizations=true // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{compile} | %{run} | FileCheck %s // RUN: %{compile} | %{run}
// //
// Do the same run, but now with VLA vectorization. // Do the same run, but now with direct IR generation and vectorization.
// RUN: %if mlir_arm_sve_tests %{ %{compile_sve} | %{run_sve} | FileCheck %s %} // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true 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
// 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