This is an archive of the discontinued LLVM Phabricator instance.

Differential D138145

[mlir][sparse] Make integration tests run on both library and codegen pathes.
ClosedPublic

Authored by bixia on Nov 16 2022, 10:50 AM.

Details

Reviewers
aartbik
nicolasvasilache
Peiming
Commits
rGb5d74f0e837f: [mlir][sparse] Make integration tests run on both library and codegen pathes.

Diff Detail

Event Timeline

bixia created this revision.Nov 16 2022, 10:50 AM
Herald added a reviewer: aartbik. · View Herald TranscriptNov 16 2022, 10:50 AM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: Moerafaat, anlunx, bzcheeseman and 23 others. · View Herald Transcript
bixia requested review of this revision.Nov 16 2022, 10:50 AM
Herald added a reviewer: nicolasvasilache. · View Herald TranscriptNov 16 2022, 10:50 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
bixia added a reviewer: Peiming.Nov 16 2022, 10:51 AM
aartbik accepted this revision.Nov 16 2022, 10:58 AM

Loving it!

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

indentation?

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_matmul.mlir
18–20

and parallelization

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

and parallelization

This revision is now accepted and ready to land.Nov 16 2022, 10:58 AM
Harbormaster completed remote builds in B198036: Diff 475873.Nov 16 2022, 11:09 AM
bixia updated this revision to Diff 475875.Nov 16 2022, 11:09 AM
bixia marked 3 inline comments as done.

Fix indentation and comments.

Harbormaster completed remote builds in B198038: Diff 475875.Nov 16 2022, 11:25 AM
This revision was landed with ongoing or failed builds.Nov 16 2022, 12:01 PM
Closed by commit rGb5d74f0e837f: [mlir][sparse] Make integration tests run on both library and codegen pathes. (authored by bixia). · Explain Why
This revision was automatically updated to reflect the committed changes.
bixia added a commit: rGb5d74f0e837f: [mlir][sparse] Make integration tests run on both library and codegen pathes..

Revision Contents

PathSize
mlir/
test/
Integration/
Dialect/
SparseTensor/
CPU/
20 lines
23 lines
20 lines
20 lines
36 lines
49 lines
17 lines
25 lines
20 lines
17 lines
23 lines
20 lines
20 lines
23 lines
16 lines
16 lines
16 lines
21 lines
16 lines
19 lines
52 lines
16 lines
30 lines
20 lines
33 lines
19 lines
20 lines
20 lines
19 lines
16 lines
43 lines
16 lines
23 lines
19 lines
16 lines
17 lines
17 lines
33 lines
21 lines
26 lines
19 lines
20 lines
17 lines
17 lines
28 lines
26 lines
35 lines
33 lines
31 lines

Diff 475875

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#MAT_C_C = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #MAT_C_C = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}>
#MAT_D_C = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #MAT_D_C = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}>
#MAT_C_D = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}> #MAT_C_D = #sparse_tensor.encoding<{dimLevelType = ["compressed", "dense"]}>
#MAT_C_C_P = #sparse_tensor.encoding<{ #MAT_C_C_P = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
▲ Show 20 Lines • Show All 434 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \ // RUN: %{command}
// RUN: mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#DenseMatrix = #sparse_tensor.encoding<{ #DenseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ], dimLevelType = [ "dense", "dense" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
// UNSUPPORTED: aarch64 // UNSUPPORTED: aarch64
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{dimLevelType = ["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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{dimLevelType = ["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/sparse_abs.mlir

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "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)
], ],
iterator_types = ["parallel"], iterator_types = ["parallel"],
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines %0 = call @sparse_absf(%sv1) : (tensor<?xf64, #SparseVector>)
-> tensor<?xf64, #SparseVector> -> tensor<?xf64, #SparseVector>
%1 = call @sparse_absi(%sv2) : (tensor<?xi32, #SparseVector>) %1 = call @sparse_absi(%sv2) : (tensor<?xi32, #SparseVector>)
-> tensor<?xi32, #SparseVector> -> tensor<?xi32, #SparseVector>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( 1.5, 1.5, 10.2, 11.3, 1, 1, nan, nan, inf, inf, 0, 0, 99.99 ) // CHECK: 12
// CHECK-NEXT: ( -2147483648, 2147483647, 1000, 1, 0, 1, 1000, 2147483646, 2147483647, 9999, 9999, 9999, 9999 ) // CHECK-NEXT: ( 1.5, 1.5, 10.2, 11.3, 1, 1, nan, nan, inf, inf, 0, 0 )
// CHECK-NEXT: 9
// CHECK-NEXT: ( -2147483648, 2147483647, 1000, 1, 0, 1, 1000, 2147483646, 2147483647 )
// //
%x = sparse_tensor.values %0 : tensor<?xf64, #SparseVector> to memref<?xf64> %x = sparse_tensor.values %0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%y = sparse_tensor.values %1 : tensor<?xi32, #SparseVector> to memref<?xi32> %y = sparse_tensor.values %1 : tensor<?xi32, #SparseVector> to memref<?xi32>
%a = vector.transfer_read %x[%c0], %df: memref<?xf64>, vector<13xf64> %a = vector.transfer_read %x[%c0], %df: memref<?xf64>, vector<12xf64>
%b = vector.transfer_read %y[%c0], %di: memref<?xi32>, vector<13xi32> %b = vector.transfer_read %y[%c0], %di: memref<?xi32>, vector<9xi32>
vector.print %a : vector<13xf64> %na = sparse_tensor.number_of_entries %0 : tensor<?xf64, #SparseVector>
vector.print %b : vector<13xi32> %nb = sparse_tensor.number_of_entries %1 : tensor<?xi32, #SparseVector>
vector.print %na : index
vector.print %a : vector<12xf64>
vector.print %nb : index
vector.print %b : vector<9xi32>
// Release the resources. // Release the resources.
bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
bufferization.dealloc_tensor %sv2 : tensor<?xi32, #SparseVector> bufferization.dealloc_tensor %sv2 : tensor<?xi32, #SparseVector>
bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector>
bufferization.dealloc_tensor %1 : tensor<?xi32, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xi32, #SparseVector>
return return
} }
} }

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec_scale = { #trait_vec_scale = {
▲ Show 20 Lines • Show All 327 Lines • ▼ Show 20 Linesmodule {
// //
// Utility functions to dump the value of a tensor. // Utility functions to dump the value of a tensor.
// //
func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) { func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
vector.print %1 : vector<16xf64> vector.print %1 : vector<16xf64>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64> %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
%3 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64> %3 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64>
vector.print %3 : vector<32xf64> vector.print %3 : vector<32xf64>
return return
} }
func.func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) { func.func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1 : i32 %d0 = arith.constant 0 : i32
%0 = sparse_tensor.values %arg0 : tensor<?xi32, #SparseVector> to memref<?xi32> %0 = sparse_tensor.values %arg0 : tensor<?xi32, #SparseVector> to memref<?xi32>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xi32>, vector<24xi32> %1 = vector.transfer_read %0[%c0], %d0: memref<?xi32>, vector<24xi32>
vector.print %1 : vector<24xi32> vector.print %1 : vector<24xi32>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32> %dv = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32>
%3 = vector.transfer_read %dv[%c0], %d0: tensor<?xi32>, vector<32xi32> %3 = vector.transfer_read %dv[%c0], %d0: tensor<?xi32>, vector<32xi32>
vector.print %3 : vector<32xi32> vector.print %3 : vector<32xi32>
return return
} }
func.func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) { func.func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) {
%d0 = arith.constant 0.0 : f64 %d0 = arith.constant 0.0 : f64
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #DCSR> to tensor<?x?xf64> %dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #DCSR> to tensor<?x?xf64>
%1 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<4x8xf64> %1 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<4x8xf64>
vector.print %1 : vector<4x8xf64> vector.print %1 : vector<4x8xf64>
return return
} }
func.func @dump_mat_4x4(%A: tensor<4x4xf64, #DCSR>) { func.func @dump_mat_4x4(%A: tensor<4x4xf64, #DCSR>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%du = arith.constant -1.0 : f64 %du = arith.constant 0.0 : f64
%c = sparse_tensor.convert %A : tensor<4x4xf64, #DCSR> to tensor<4x4xf64> %c = sparse_tensor.convert %A : tensor<4x4xf64, #DCSR> to tensor<4x4xf64>
%v = vector.transfer_read %c[%c0, %c0], %du: tensor<4x4xf64>, vector<4x4xf64> %v = vector.transfer_read %c[%c0, %c0], %du: tensor<4x4xf64>, vector<4x4xf64>
vector.print %v : vector<4x4xf64> vector.print %v : vector<4x4xf64>
%1 = sparse_tensor.values %A : tensor<4x4xf64, #DCSR> to memref<?xf64> %1 = sparse_tensor.values %A : tensor<4x4xf64, #DCSR> to memref<?xf64>
%2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<16xf64> %2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<16xf64>
vector.print %2 : vector<16xf64> vector.print %2 : vector<16xf64>
return return
} }
func.func @dump_mat_4x4_i8(%A: tensor<4x4xi8, #DCSR>) { func.func @dump_mat_4x4_i8(%A: tensor<4x4xi8, #DCSR>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%du = arith.constant -1 : i8 %du = arith.constant 0 : i8
%c = sparse_tensor.convert %A : tensor<4x4xi8, #DCSR> to tensor<4x4xi8> %c = sparse_tensor.convert %A : tensor<4x4xi8, #DCSR> to tensor<4x4xi8>
%v = vector.transfer_read %c[%c0, %c0], %du: tensor<4x4xi8>, vector<4x4xi8> %v = vector.transfer_read %c[%c0, %c0], %du: tensor<4x4xi8>, vector<4x4xi8>
vector.print %v : vector<4x4xi8> vector.print %v : vector<4x4xi8>
%1 = sparse_tensor.values %A : tensor<4x4xi8, #DCSR> to memref<?xi8> %1 = sparse_tensor.values %A : tensor<4x4xi8, #DCSR> to memref<?xi8>
%2 = vector.transfer_read %1[%c0], %du: memref<?xi8>, vector<16xi8> %2 = vector.transfer_read %1[%c0], %du: memref<?xi8>, vector<16xi8>
vector.print %2 : vector<16xi8> vector.print %2 : vector<16xi8>
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines func.func @entry() {
%10 = call @intersect_equal(%sm3, %sm4) %10 = call @intersect_equal(%sm3, %sm4)
: (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xi8, #DCSR> : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xi8, #DCSR>
%11 = call @only_left_right(%sm3, %sm4) %11 = call @only_left_right(%sm3, %sm4)
: (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR> : (tensor<4x4xf64, #DCSR>, tensor<4x4xf64, #DCSR>) -> tensor<4x4xf64, #DCSR>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1 ) // CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 ) // CHECK-NEXT: ( 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 )
// CHECK-NEXT: ( 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 11, 0, 12, 13, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 15, 0, 16, 0, 0, 17, 0, 0, 0, 0, 0, 0, 18, 19, 0, 20 ) // CHECK-NEXT: ( 0, 11, 0, 12, 13, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 15, 0, 16, 0, 0, 17, 0, 0, 0, 0, 0, 0, 18, 19, 0, 20 )
// CHECK-NEXT: ( 1, 11, 2, 13, 14, 3, 15, 4, 16, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 11, 2, 13, 14, 3, 15, 4, 16, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 11, 0, 2, 13, 0, 0, 0, 0, 0, 14, 3, 0, 0, 0, 0, 15, 4, 16, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 ) // CHECK-NEXT: ( 1, 11, 0, 2, 13, 0, 0, 0, 0, 0, 14, 3, 0, 0, 0, 0, 15, 4, 16, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 )
// CHECK-NEXT: ( 0, 6, 3, 28, 0, 6, 56, 72, 9, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 0, 6, 3, 28, 0, 6, 56, 72, 9, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 28, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 56, 72, 0, 9 ) // CHECK-NEXT: ( 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 28, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 56, 72, 0, 9 )
// CHECK-NEXT: ( 1, 3, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 3, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ) // CHECK-NEXT: ( 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 3, 11, 17, 20, 21, 28, 29, 31, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 0, 3, 11, 17, 20, 21, 28, 29, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 17, 0, 0, 20, 21, 0, 0, 0, 0, 0, 0, 28, 29, 0, 31 ) // CHECK-NEXT: ( 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 17, 0, 0, 20, 21, 0, 0, 0, 0, 0, 0, 28, 29, 0, 31 )
// CHECK-NEXT: ( ( 7, 0, 0, 0, 0, 0, 0, -5 ), ( -4, 0, 0, 0, 0, 0, -3, 0 ), ( 0, -2, 0, 0, 0, 0, 0, 7 ), ( 0, 0, 0, 0, 0, 0, 0, 0 ) ) // CHECK-NEXT: ( ( 7, 0, 0, 0, 0, 0, 0, -5 ), ( -4, 0, 0, 0, 0, 0, -3, 0 ), ( 0, -2, 0, 0, 0, 0, 0, 7 ), ( 0, 0, 0, 0, 0, 0, 0, 0 ) )
// CHECK-NEXT: ( ( 2, 0, 4, 1 ), ( 0, 2.5, 0, 0 ), ( 1, 5, 2, 4 ), ( 5, 4, 0, 0 ) ) // CHECK-NEXT: ( ( 2, 0, 4, 1 ), ( 0, 2.5, 0, 0 ), ( 1, 5, 2, 4 ), ( 5, 4, 0, 0 ) )
// CHECK-NEXT: ( 2, 4, 1, 2.5, 1, 5, 2, 4, 5, 4, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 4, 1, 2.5, 1, 5, 2, 4, 5, 4, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 2, 0, 4, 1 ), ( 0, 2.5, 0, 0 ), ( 1, 5, 2, 4 ), ( 5, 4, 0, 0 ) ) // CHECK-NEXT: ( ( 2, 0, 4, 1 ), ( 0, 2.5, 0, 0 ), ( 1, 5, 2, 4 ), ( 5, 4, 0, 0 ) )
// CHECK-NEXT: ( 2, 4, 1, 2.5, 1, 5, 2, 4, 5, 4, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 4, 1, 2.5, 1, 5, 2, 4, 5, 4, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 2, 0, 4, 1 ), ( 0, 2.5, 0, 0 ), ( -1, -5, 2, 4 ), ( 1, 4, 0, 0 ) ) // CHECK-NEXT: ( ( 2, 0, 4, 1 ), ( 0, 2.5, 0, 0 ), ( -1, -5, 2, 4 ), ( 1, 4, 0, 0 ) )
// CHECK-NEXT: ( 2, 4, 1, 2.5, -1, -5, 2, 4, 1, 4, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 4, 1, 2.5, -1, -5, 2, 4, 1, 4, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 0, 0, 1, -1 ), ( 0, 1, 0, 0 ), ( -1, -2, -2, 2 ), ( 1, 2, 0, 0 ) ) // CHECK-NEXT: ( ( 0, 0, 1, -1 ), ( 0, 1, 0, 0 ), ( -1, -2, -2, 2 ), ( 1, 2, 0, 0 ) )
// CHECK-NEXT: ( 0, 1, -1, 1, -1, -2, -2, 2, 1, 2, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 0, 1, -1, 1, -1, -2, -2, 2, 1, 2, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 1, 0, 0, 0 ), ( 0, 0, 0, 0 ), ( 0, 0, 0, 0 ), ( 0, 0, 0, 0 ) ) // CHECK-NEXT: ( ( 1, 0, 0, 0 ), ( 0, 0, 0, 0 ), ( 0, 0, 0, 0 ), ( 0, 0, 0, 0 ) )
// CHECK-NEXT: ( 1, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 0, 0, 0, -1 ), ( 0, 0, 0, 0 ), ( -1, -5, -2, 4 ), ( 0, 4, 0, 0 ) ) // CHECK-NEXT: ( ( 0, 0, 0, -1 ), ( 0, 0, 0, 0 ), ( -1, -5, -2, 4 ), ( 0, 4, 0, 0 ) )
// CHECK-NEXT: ( -1, -1, -5, -2, 4, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( -1, -1, -5, -2, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// //
call @dump_vec(%sv1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%sv1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec(%sv2) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%sv2) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> () call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> ()
call @dump_vec(%1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec(%2) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%2) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec_i32(%3) : (tensor<?xi32, #SparseVector>) -> () call @dump_vec_i32(%3) : (tensor<?xi32, #SparseVector>) -> ()
call @dump_mat(%5) : (tensor<?x?xf64, #DCSR>) -> () call @dump_mat(%5) : (tensor<?x?xf64, #DCSR>) -> ()
Show All 30 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ dimLevelType = [ "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_codegen_dim.mlir

// Test with/without runtime library, the result should always be identical. // DEFINE: %{option} = enable-runtime-library=true
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // DEFINE: mlir-cpu-runner \
// RUN: mlir-cpu-runner \ // DEFINE: -e entry -entry-point-result=void \
// RUN: -e entry -entry-point-result=void \ // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: FileCheck %s
// RUN: FileCheck %s //
// RUN: %{command}
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ //
// RUN: mlir-cpu-runner \ // Do the same run, but now with direct IR generation.
// RUN: -e entry -entry-point-result=void \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %{command}
// RUN: FileCheck %s
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed"] dimLevelType = [ "compressed", "compressed"]
}> }>
module { module {
// //
// Main driver. // Main driver.
Show All 31 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#Row = #sparse_tensor.encoding<{ #Row = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "dense" ] dimLevelType = [ "compressed", "dense" ]
}> }>
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] dimLevelType = [ "dense", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed"] dimLevelType = [ "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_conversion.mlir

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false enable-buffer-initialization=true"| \ //
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \ //
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with direct IR generation.
// RUN: FileCheck %s // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,j,k)> dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed", "compressed" ],
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false enable-buffer-initialization=true" | \ // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] dimLevelType = [ "compressed", "compressed" ]
}> }>
#DCSC = #sparse_tensor.encoding<{ #DCSC = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false enable-buffer-initialization=true" | \ // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed" ],
pointerBitWidth = 8, pointerBitWidth = 8,
indexBitWidth = 8 indexBitWidth = 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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false"| \ //
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \ //
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with direct IR generation.
// RUN: FileCheck %s // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed", "compressed" ],
dimOrdering = affine_map<(i,j,k) -> (i,j,k)> dimOrdering = affine_map<(i,j,k) -> (i,j,k)>
}> }>
#Tensor2 = #sparse_tensor.encoding<{ #Tensor2 = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed", "compressed" ],
▲ Show 20 Lines • Show All 203 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.
// RUN: mlir-opt %s --sparse-compiler="s2s-strategy=2" | \ // DEFINE: %{option} = "enable-runtime-library=true s2s-strategy=2"
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false s2s-strategy=2"
// RUN: %{command}
#Tensor1 = #sparse_tensor.encoding<{ #Tensor1 = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense", "compressed" ] dimLevelType = [ "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_dot.mlir

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], dimLevelType = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
module { module {
// //
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: TENSOR1="" \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR1="" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!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 181 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/test.tns" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/test.tns" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed", "compressed", dimLevelType = [ "compressed", "compressed", "compressed", "compressed",
"compressed", "compressed", "compressed", "compressed" ], "compressed", "compressed", "compressed", "compressed" ],
// Note that any dimOrdering permutation should give the same results // Note that any dimOrdering 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 80 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] dimLevelType = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] dimLevelType = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines func.func @entry() {
%6 = call @sparse_index_2d_conj(%dm) : (tensor<3x4xi64, #SparseMatrix>) %6 = call @sparse_index_2d_conj(%dm) : (tensor<3x4xi64, #SparseMatrix>)
-> tensor<3x4xi64, #SparseMatrix> -> tensor<3x4xi64, #SparseMatrix>
%7 = call @sparse_index_2d_disj(%dm) : (tensor<3x4xi64, #SparseMatrix>) %7 = call @sparse_index_2d_disj(%dm) : (tensor<3x4xi64, #SparseMatrix>)
-> tensor<3x4xi64, #SparseMatrix> -> tensor<3x4xi64, #SparseMatrix>
// //
// Verify result. // Verify result.
// //
// CHECK: ( 20, 80, -1, -1, -1, -1, -1, -1 ) // CHECK: 2
// CHECK-NEXT: 8
// CHECK-NEXT: 8
// CHECK-NEXT: 8
// CHECK-NEXT: 2
// CHECK-NEXT: 12
// CHECK-NEXT: 12
// CHECK-NEXT: 12
// CHECK-NEXT: ( 20, 80 )
// CHECK-NEXT: ( 0, 1, 12, 3, 24, 5, 6, 7 ) // CHECK-NEXT: ( 0, 1, 12, 3, 24, 5, 6, 7 )
// CHECK-NEXT: ( 0, 2, 8, 24, 64, 160, 384, 896 ) // CHECK-NEXT: ( 0, 2, 8, 24, 64, 160, 384, 896 )
// CHECK-NEXT: ( 1, 3, 6, 11, 20, 37, 70, 135 ) // CHECK-NEXT: ( 1, 3, 6, 11, 20, 37, 70, 135 )
// CHECK-NEXT: ( 10, 120, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 10, 120 )
// CHECK-NEXT: ( 0, 1, 2, 3, 1, 12, 3, 4, 2, 3, 4, 25 ) // CHECK-NEXT: ( 0, 1, 2, 3, 1, 12, 3, 4, 2, 3, 4, 25 )
// CHECK-NEXT: ( 0, 0, 0, 0, 0, 2, 2, 3, 0, 2, 12, 24 ) // CHECK-NEXT: ( 0, 0, 0, 0, 0, 2, 2, 3, 0, 2, 12, 24 )
// CHECK-NEXT: ( 1, 2, 3, 4, 2, 4, 4, 5, 3, 4, 7, 9 ) // CHECK-NEXT: ( 1, 2, 3, 4, 2, 4, 4, 5, 3, 4, 7, 9 )
// //
%n0 = sparse_tensor.number_of_entries %0 : tensor<8xi64, #SparseVector>
aartbikUnsubmitted
Done
ReplyInline Actions

indentation?

aartbik: indentation?
%n1 = sparse_tensor.number_of_entries %1 : tensor<8xi64, #SparseVector>
%n2 = sparse_tensor.number_of_entries %2 : tensor<8xi64, #SparseVector>
%n3 = sparse_tensor.number_of_entries %3 : tensor<8xi64, #SparseVector>
%n4 = sparse_tensor.number_of_entries %4 : tensor<3x4xi64, #SparseMatrix>
%n5 = sparse_tensor.number_of_entries %5 : tensor<3x4xi64, #SparseMatrix>
%n6 = sparse_tensor.number_of_entries %6 : tensor<3x4xi64, #SparseMatrix>
%n7 = sparse_tensor.number_of_entries %7 : tensor<3x4xi64, #SparseMatrix>
%8 = sparse_tensor.values %0 : tensor<8xi64, #SparseVector> to memref<?xi64> %8 = sparse_tensor.values %0 : tensor<8xi64, #SparseVector> to memref<?xi64>
%9 = sparse_tensor.values %1 : tensor<8xi64, #SparseVector> to memref<?xi64> %9 = sparse_tensor.values %1 : tensor<8xi64, #SparseVector> to memref<?xi64>
%10 = sparse_tensor.values %2 : tensor<8xi64, #SparseVector> to memref<?xi64> %10 = sparse_tensor.values %2 : tensor<8xi64, #SparseVector> to memref<?xi64>
%11 = sparse_tensor.values %3 : tensor<8xi64, #SparseVector> to memref<?xi64> %11 = sparse_tensor.values %3 : tensor<8xi64, #SparseVector> to memref<?xi64>
%12 = sparse_tensor.values %4 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64> %12 = sparse_tensor.values %4 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64>
%13 = sparse_tensor.values %5 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64> %13 = sparse_tensor.values %5 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64>
%14 = sparse_tensor.values %6 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64> %14 = sparse_tensor.values %6 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64>
%15 = sparse_tensor.values %7 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64> %15 = sparse_tensor.values %7 : tensor<3x4xi64, #SparseMatrix> to memref<?xi64>
%16 = vector.transfer_read %8[%c0], %du: memref<?xi64>, vector<8xi64> %16 = vector.transfer_read %8[%c0], %du: memref<?xi64>, vector<2xi64>
%17 = vector.transfer_read %9[%c0], %du: memref<?xi64>, vector<8xi64> %17 = vector.transfer_read %9[%c0], %du: memref<?xi64>, vector<8xi64>
%18 = vector.transfer_read %10[%c0], %du: memref<?xi64>, vector<8xi64> %18 = vector.transfer_read %10[%c0], %du: memref<?xi64>, vector<8xi64>
%19 = vector.transfer_read %11[%c0], %du: memref<?xi64>, vector<8xi64> %19 = vector.transfer_read %11[%c0], %du: memref<?xi64>, vector<8xi64>
%20 = vector.transfer_read %12[%c0], %du: memref<?xi64>, vector<12xi64> %20 = vector.transfer_read %12[%c0], %du: memref<?xi64>, vector<2xi64>
%21 = vector.transfer_read %13[%c0], %du: memref<?xi64>, vector<12xi64> %21 = vector.transfer_read %13[%c0], %du: memref<?xi64>, vector<12xi64>
%22 = vector.transfer_read %14[%c0], %du: memref<?xi64>, vector<12xi64> %22 = vector.transfer_read %14[%c0], %du: memref<?xi64>, vector<12xi64>
%23 = vector.transfer_read %15[%c0], %du: memref<?xi64>, vector<12xi64> %23 = vector.transfer_read %15[%c0], %du: memref<?xi64>, vector<12xi64>
vector.print %16 : vector<8xi64> vector.print %n0 : index
vector.print %n1 : index
vector.print %n2 : index
vector.print %n3 : index
vector.print %n4 : index
vector.print %n5 : index
vector.print %n6 : index
vector.print %n7 : index
vector.print %16 : vector<2xi64>
vector.print %17 : vector<8xi64> vector.print %17 : vector<8xi64>
vector.print %18 : vector<8xi64> vector.print %18 : vector<8xi64>
vector.print %19 : vector<8xi64> vector.print %19 : vector<8xi64>
vector.print %20 : vector<12xi64> vector.print %20 : vector<2xi64>
vector.print %21 : vector<12xi64> vector.print %21 : vector<12xi64>
vector.print %22 : vector<12xi64> vector.print %22 : vector<12xi64>
vector.print %23 : vector<12xi64> vector.print %23 : vector<12xi64>
// Release resources. // Release resources.
bufferization.dealloc_tensor %sv : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %sv : tensor<8xi64, #SparseVector>
bufferization.dealloc_tensor %dv : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %dv : tensor<8xi64, #SparseVector>
bufferization.dealloc_tensor %0 : tensor<8xi64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<8xi64, #SparseVector>
Show All 26 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] dimLevelType = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] dimLevelType = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 175 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// Do the same run, but now with parallelization. // DEFINE: FileCheck %s
// //
// RUN: mlir-opt %s --sparse-compiler="parallelization-strategy=any-storage-any-loop" | \ // RUN: %{command}
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
// //
// Do the same run, but now with direct IR generation. // Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
// //
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // Do the same run, but now with parallelization strategy.
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // REDEFINE: %{option} = "enable-runtime-library=true parallelization-strategy=any-storage-any-loop"
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // RUN: %{command}
// RUN: FileCheck %s //
// Do the same run, but now with direct IR generation and parallelization strategy.
// REDEFINE: %{option} = "enable-runtime-library=false parallelization-strategy=any-storage-any-loop"
// RUN: %{command}
aartbikUnsubmitted
Done
ReplyInline Actions

and parallelization

aartbik: and parallelization
#CSR = #sparse_tensor.encoding<{ #CSR = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], dimLevelType = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed" ],
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{dimLevelType = ["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 156 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// // DEFINE: FileCheck %s
// Do the same run, but now with parallelization. //
// // RUN: %{command}
// RUN: mlir-opt %s \ //
// RUN: --sparse-compiler="parallelization-strategy=any-storage-any-loop" | \ // Do the same run, but now with direct IR generation.
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \ //
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with parallelization strategy.
// RUN: FileCheck %s // REDEFINE: %{option} = "enable-runtime-library=true parallelization-strategy=any-storage-any-loop"
// RUN: %{command}
//
// Do the same run, but now with direct IR generation and parallelization strategy.
aartbikUnsubmitted
Done
ReplyInline Actions

and parallelization

aartbik: and parallelization
// REDEFINE: %{option} = "enable-runtime-library=false parallelization-strategy=any-storage-any-loop"
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], dimLevelType = [ "dense", "compressed" ],
pointerBitWidth = 8, pointerBitWidth = 8,
indexBitWidth = 8 indexBitWidth = 8
}> }>
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] dimLevelType = [ "compressed", "compressed", "compressed" ]
}> }>
#mttkrp = { #mttkrp = {
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false enable-buffer-initialization=true"| \ // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] dimLevelType = [ "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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false enable-buffer-initialization=true"| \ // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] dimLevelType = [ "compressed", "compressed" ]
}> }>
#SparseTensor = #sparse_tensor.encoding<{ #SparseTensor = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed", "compressed" ] dimLevelType = [ "compressed", "compressed", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#DCSR = #sparse_tensor.encoding<{ #DCSR = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed" ],
dimOrdering = affine_map<(i,j) -> (i,j)> dimOrdering = affine_map<(i,j) -> (i,j)>
}> }>
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #DCSR = #sparse_tensor.encoding<{ dimLevelType = [ "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_reduce_custom.mlir

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], dimLevelType = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines func.func @min_plus_csrcsc(%arga: tensor<?x?xf64, #CSR>,
} -> tensor<?x?xf64, #CSR> } -> tensor<?x?xf64, #CSR>
return %0 : tensor<?x?xf64, #CSR> return %0 : tensor<?x?xf64, #CSR>
} }
// Dumps a sparse vector of type f64. // Dumps a sparse vector of type f64.
func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) { func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<8xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<8xf64>
vector.print %1 : vector<8xf64> vector.print %1 : vector<8xf64>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64> %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
%2 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<16xf64> %2 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<16xf64>
vector.print %2 : vector<16xf64> vector.print %2 : vector<16xf64>
return return
} }
// Dump a sparse matrix. // Dump a sparse matrix.
func.func @dump_mat(%arg0: tensor<?x?xf64, #CSR>) { func.func @dump_mat(%arg0: tensor<?x?xf64, #CSR>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #CSR> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #CSR> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
vector.print %1 : vector<16xf64> vector.print %1 : vector<16xf64>
%dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #CSR> to tensor<?x?xf64> %dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #CSR> to tensor<?x?xf64>
%2 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<5x5xf64> %2 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<5x5xf64>
vector.print %2 : vector<5x5xf64> vector.print %2 : vector<5x5xf64>
return return
} }
Show All 21 Lines func.func @entry() {
%5 = call @min_plus_csrcsr(%sm1, %sm2r) %5 = call @min_plus_csrcsr(%sm1, %sm2r)
: (tensor<?x?xf64, #CSR>, tensor<?x?xf64, #CSR>) -> tensor<?x?xf64, #CSR> : (tensor<?x?xf64, #CSR>, tensor<?x?xf64, #CSR>) -> tensor<?x?xf64, #CSR>
%6 = call @min_plus_csrcsc(%sm1, %sm2c) %6 = call @min_plus_csrcsc(%sm1, %sm2c)
: (tensor<?x?xf64, #CSR>, tensor<?x?xf64, #CSC>) -> tensor<?x?xf64, #CSR> : (tensor<?x?xf64, #CSR>, tensor<?x?xf64, #CSC>) -> tensor<?x?xf64, #CSR>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1 ) // CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 1, 2, 0, 0, 0 ), ( 3, 0, 0, 0, 0 ), ( 0, 0, 4, 5, 6 ), ( 7, 0, 8, 9, 0 ), ( -1, -1, -1, -1, -1 ) ) // CHECK-NEXT: ( ( 1, 2, 0, 0, 0 ), ( 3, 0, 0, 0, 0 ), ( 0, 0, 4, 5, 6 ), ( 7, 0, 8, 9, 0 ), ( 0, 0, 0, 0, 0 ) )
// CHECK-NEXT: ( 6, 5, 4, 3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 6, 5, 4, 3, 2, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 6, 0, 0, 0, -1 ), ( 0, 0, 0, 5, -1 ), ( 4, 0, 0, 3, -1 ), ( 0, 2, 0, 0, -1 ), ( 0, 11, 0, 0, -1 ) ) // CHECK-NEXT: ( ( 6, 0, 0, 0, 0 ), ( 0, 0, 0, 5, 0 ), ( 4, 0, 0, 3, 0 ), ( 0, 2, 0, 0, 0 ), ( 0, 11, 0, 0, 0 ) )
// CHECK-NEXT: ( 2, 3, 120, 504, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 3, 120, 504, 0, 0, 0, 0 )
// CHECK-NEXT: ( 2, 3, 120, 504, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 3, 120, 504, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 6, 5, 12, 2, 11, -1, -1, -1 ) // CHECK-NEXT: ( 6, 5, 12, 2, 11, 0, 0, 0 )
// CHECK-NEXT: ( 6, 5, 12, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 6, 5, 12, 2, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 7, 7, 9, 8, 7, 7, 12, 11, 11, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 7, 7, 9, 8, 7, 7, 12, 11, 11, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 7, 0, 0, 7, -1 ), ( 9, 0, 0, 0, -1 ), ( 8, 7, 0, 7, -1 ), ( 12, 11, 0, 11, -1 ), ( -1, -1, -1, -1, -1 ) ) // CHECK-NEXT: ( ( 7, 0, 0, 7, 0 ), ( 9, 0, 0, 0, 0 ), ( 8, 7, 0, 7, 0 ), ( 12, 11, 0, 11, 0 ), ( 0, 0, 0, 0, 0 ) )
// TODO: Update once identity values are no longer inserted for non-overlapping dot product // TODO: Update once identity values are no longer inserted for non-overlapping dot product
// CHECK-NEXT: ( 7, inf, inf, 7, 9, inf, inf, inf, 8, 7, inf, 7, 12, 11, inf, 11 ) // CHECK-NEXT: ( 7, inf, inf, 7, 9, inf, inf, inf, 8, 7, inf, 7, 12, 11, inf, 11 )
// CHECK-NEXT: ( ( 7, inf, inf, 7, -1 ), ( 9, inf, inf, inf, -1 ), ( 8, 7, inf, 7, -1 ), ( 12, 11, inf, 11, -1 ), ( -1, -1, -1, -1, -1 ) ) // CHECK-NEXT: ( ( 7, inf, inf, 7, 0 ), ( 9, inf, inf, inf, 0 ), ( 8, 7, inf, 7, 0 ), ( 12, 11, inf, 11, 0 ), ( 0, 0, 0, 0, 0 ) )
// //
call @dump_mat(%sm1) : (tensor<?x?xf64, #CSR>) -> () call @dump_mat(%sm1) : (tensor<?x?xf64, #CSR>) -> ()
call @dump_mat(%sm2r) : (tensor<?x?xf64, #CSR>) -> () call @dump_mat(%sm2r) : (tensor<?x?xf64, #CSR>) -> ()
call @dump_vec(%1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec(%2) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%2) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_mat(%5) : (tensor<?x?xf64, #CSR>) -> () call @dump_mat(%5) : (tensor<?x?xf64, #CSR>) -> ()
call @dump_mat(%6) : (tensor<?x?xf64, #CSR>) -> () call @dump_mat(%6) : (tensor<?x?xf64, #CSR>) -> ()
Show All 11 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }>
#DV = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> #DV = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }>
#trait_reduction = { #trait_reduction = {
indexing_maps = [ indexing_maps = [
affine_map<(i) -> (i)>, // a affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out) affine_map<(i) -> ()> // x (scalar out)
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

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

// RxUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RxUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RxUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RxUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RxUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ //
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \ //
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // Do the same run, but now with direct IR generation.
// RUN: FileCheck %s // REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] dimLevelType = ["compressed"]
}> }>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = ["compressed", "compressed"] dimLevelType = ["compressed", "compressed"]
}> }>
▲ Show 20 Lines • Show All 330 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/test.mtx" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ], dimLevelType = [ "compressed", "compressed" ],
pointerBitWidth = 32, pointerBitWidth = 32,
indexBitWidth = 32 indexBitWidth = 32
}> }>
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner -e entry -entry-point-result=void \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: mlir-cpu-runner \
// RUN: FileCheck %s // DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SM = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed" ] }> #SM = #sparse_tensor.encoding<{ dimLevelType = [ "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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#CSR = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }> #CSR = #sparse_tensor.encoding<{ dimLevelType = [ "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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#map = affine_map<(d0, d1, d2) -> (d0, d1, d2)> #map = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
#SparseMatrix = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }> #SparseMatrix = #sparse_tensor.encoding<{ dimLevelType = [ "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 61 Lines • ▼ Show 20 Lines func.func public @entry() {
call @dump(%sm_f) : (tensor<2x3x4xf64, #SparseMatrix>) -> () call @dump(%sm_f) : (tensor<2x3x4xf64, #SparseMatrix>) -> ()
bufferization.dealloc_tensor %sm : tensor<2x3x4xf64, #SparseMatrix> bufferization.dealloc_tensor %sm : tensor<2x3x4xf64, #SparseMatrix>
bufferization.dealloc_tensor %sm_t : tensor<2x3x4xf64, #SparseMatrix> bufferization.dealloc_tensor %sm_t : tensor<2x3x4xf64, #SparseMatrix>
bufferization.dealloc_tensor %sm_f : tensor<2x3x4xf64, #SparseMatrix> bufferization.dealloc_tensor %sm_f : tensor<2x3x4xf64, #SparseMatrix>
return return
} }
} }
No newline at end of file No newline at end of file

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}> #CSR = #sparse_tensor.encoding<{dimLevelType = ["dense", "compressed"]}>
#CSC = #sparse_tensor.encoding<{ #CSC = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ], dimLevelType = [ "dense", "compressed" ],
dimOrdering = affine_map<(i,j) -> (j,i)> dimOrdering = affine_map<(i,j) -> (j,i)>
}> }>
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines func.func @matUpperTriangle(%arga: tensor<?x?xf64, #CSR>) -> tensor<?x?xf64, #CSR> {
} -> tensor<?x?xf64, #CSR> } -> tensor<?x?xf64, #CSR>
return %0 : tensor<?x?xf64, #CSR> return %0 : tensor<?x?xf64, #CSR>
} }
// Dumps a sparse vector of type f64. // Dumps a sparse vector of type f64.
func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) { func.func @dump_vec(%arg0: tensor<?xf64, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<8xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<8xf64>
vector.print %1 : vector<8xf64> vector.print %1 : vector<8xf64>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64> %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
%2 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<16xf64> %2 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<16xf64>
vector.print %2 : vector<16xf64> vector.print %2 : vector<16xf64>
return return
} }
// Dump a sparse matrix. // Dump a sparse matrix.
func.func @dump_mat(%arg0: tensor<?x?xf64, #CSR>) { func.func @dump_mat(%arg0: tensor<?x?xf64, #CSR>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #CSR> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #CSR> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
vector.print %1 : vector<16xf64> vector.print %1 : vector<16xf64>
%dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #CSR> to tensor<?x?xf64> %dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #CSR> to tensor<?x?xf64>
%2 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<5x5xf64> %2 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<5x5xf64>
vector.print %2 : vector<5x5xf64> vector.print %2 : vector<5x5xf64>
return return
} }
Show All 16 Lines func.func @entry() {
// Call sparse matrix kernels. // Call sparse matrix kernels.
%1 = call @vecSelect(%sv1) : (tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector> %1 = call @vecSelect(%sv1) : (tensor<?xf64, #SparseVector>) -> tensor<?xf64, #SparseVector>
%2 = call @matUpperTriangle(%sm1) : (tensor<?x?xf64, #CSR>) -> tensor<?x?xf64, #CSR> %2 = call @matUpperTriangle(%sm1) : (tensor<?x?xf64, #CSR>) -> tensor<?x?xf64, #CSR>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( 1, 2, -4, 0, 5, -1, -1, -1 ) // CHECK: ( 1, 2, -4, 0, 5, 0, 0, 0 )
// CHECK-NEXT: ( 0, 1, 0, 2, 0, -4, 0, 0, 0, 5, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 0, 1, 0, 2, 0, -4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 0, 0, 0, 1, 0 ), ( 0, 0, 0, 0, 2 ), ( 0, 3, 0, 4, 0 ), ( 0, 0, 0, 5, 6 ), ( 0, 0, 7, 0, 0 ) ) // CHECK-NEXT: ( ( 0, 0, 0, 1, 0 ), ( 0, 0, 0, 0, 2 ), ( 0, 3, 0, 4, 0 ), ( 0, 0, 0, 5, 6 ), ( 0, 0, 7, 0, 0 ) )
// CHECK-NEXT: ( 1, 2, 5, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 2, 5, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 1, 0, 2, 0, 0, 0, 0, 0, 5, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 0, 1, 0, 2, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 2, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 0, 0, 0, 1, 0 ), ( 0, 0, 0, 0, 2 ), ( 0, 0, 0, 4, 0 ), ( 0, 0, 0, 0, 6 ), ( 0, 0, 0, 0, 0 ) ) // CHECK-NEXT: ( ( 0, 0, 0, 1, 0 ), ( 0, 0, 0, 0, 2 ), ( 0, 0, 0, 4, 0 ), ( 0, 0, 0, 0, 6 ), ( 0, 0, 0, 0, 0 ) )
// //
call @dump_vec(%sv1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%sv1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_mat(%sm1) : (tensor<?x?xf64, #CSR>) -> () call @dump_mat(%sm1) : (tensor<?x?xf64, #CSR>) -> ()
call @dump_vec(%1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec(%1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_mat(%2) : (tensor<?x?xf64, #CSR>) -> () call @dump_mat(%2) : (tensor<?x?xf64, #CSR>) -> ()
// Release the resources. // Release the resources.
bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
bufferization.dealloc_tensor %sm1 : tensor<?x?xf64, #CSR> bufferization.dealloc_tensor %sm1 : tensor<?x?xf64, #CSR>
bufferization.dealloc_tensor %1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %1 : tensor<?xf64, #SparseVector>
bufferization.dealloc_tensor %2 : tensor<?x?xf64, #CSR> bufferization.dealloc_tensor %2 : tensor<?x?xf64, #CSR>
return return
} }
} }

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "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 All 36 Lines %0 = linalg.generic #trait_op
linalg.yield %result : f64 linalg.yield %result : f64
} -> tensor<?xf64, #SparseVector> } -> tensor<?xf64, #SparseVector>
return %0 : tensor<?xf64, #SparseVector> return %0 : tensor<?xf64, #SparseVector>
} }
// Driver method to call and verify sign kernel. // Driver method to call and verify sign kernel.
func.func @entry() { func.func @entry() {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%du = arith.constant 99.99 : f64 %du = arith.constant 0.0 : f64
%pnan = arith.constant 0x7FF0000001000000 : f64 %pnan = arith.constant 0x7FF0000001000000 : f64
%nnan = arith.constant 0xFFF0000001000000 : f64 %nnan = arith.constant 0xFFF0000001000000 : f64
%pinf = arith.constant 0x7FF0000000000000 : f64 %pinf = arith.constant 0x7FF0000000000000 : f64
%ninf = arith.constant 0xFFF0000000000000 : f64 %ninf = arith.constant 0xFFF0000000000000 : f64
// Setup sparse vector. // Setup sparse vector.
%v1 = arith.constant sparse< %v1 = arith.constant sparse<
Show All 12 Lines func.func @entry() {
// Call sign kernel. // Call sign kernel.
%0 = call @sparse_sign(%sv1) : (tensor<?xf64, #SparseVector>) %0 = call @sparse_sign(%sv1) : (tensor<?xf64, #SparseVector>)
-> tensor<?xf64, #SparseVector> -> tensor<?xf64, #SparseVector>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( -1, 1, -1, 1, 1, -1, nan, -nan, 1, -1, -0, 0, 99.99 ) // CHECK: ( -1, 1, -1, 1, 1, -1, nan, -nan, 1, -1, -0, 0, 0 )
// //
%1 = sparse_tensor.values %0 : tensor<?xf64, #SparseVector> to memref<?xf64> %1 = sparse_tensor.values %0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<13xf64> %2 = vector.transfer_read %1[%c0], %du: memref<?xf64>, vector<13xf64>
vector.print %2 : vector<13xf64> vector.print %2 : vector<13xf64>
// Release the resources. // Release the resources.
bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %0 : tensor<?xf64, #SparseVector>
return return
} }
} }

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

// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=true" | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler="enable-runtime-library=false enable-buffer-initialization=true" | \ // REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // RUN: %{command}
// RUN: TENSOR1="%mlir_src_dir/test/Integration/data/mttkrp_b.tns" \
// RUN: mlir-cpu-runner \
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SortedCOO = #sparse_tensor.encoding<{ #SortedCOO = #sparse_tensor.encoding<{
dimLevelType = [ "compressed-nu", "singleton" ] dimLevelType = [ "compressed-nu", "singleton" ]
}> }>
#SortedCOOPermuted = #sparse_tensor.encoding<{ #SortedCOOPermuted = #sparse_tensor.encoding<{
▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: mlir-cpu-runner \ // DEFINE: TENSOR0="%mlir_src_dir/test/Integration/data/wide.mtx" \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "compressed" ] dimLevelType = [ "dense", "compressed" ]
}> }>
#spmm = { #spmm = {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=true | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// 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.
// RUN: mlir-opt %s --sparse-compiler=enable-runtime-library=false | \ // REDEFINE: %{option} = enable-runtime-library=false
// RUN: mlir-cpu-runner \ // RUN: %{command}
// RUN: -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s
// //
// Several common sparse storage schemes. // Several common sparse storage schemes.
// //
#Dense = #sparse_tensor.encoding<{ #Dense = #sparse_tensor.encoding<{
dimLevelType = [ "dense", "dense" ] dimLevelType = [ "dense", "dense" ]
}> }>
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
// UNSUPPORTED: aarch64 // UNSUPPORTED: aarch64
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] dimLevelType = [ "compressed", "compressed" ]
}> }>
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
!Filename = !llvm.ptr<i8> !Filename = !llvm.ptr<i8>
#SparseMatrix = #sparse_tensor.encoding<{ #SparseMatrix = #sparse_tensor.encoding<{
dimLevelType = [ "compressed", "compressed" ] dimLevelType = [ "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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> #SparseVector = #sparse_tensor.encoding<{ dimLevelType = [ "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"],
Show All 13 Lines func.func @sparse_tanh(%vec: tensor<?xf64, #SparseVector>)
return %0 : tensor<?xf64, #SparseVector> return %0 : tensor<?xf64, #SparseVector>
} }
// Dumps a sparse vector of type f64. // Dumps a sparse vector of type f64.
func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) { func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant -1.0 : f64
%n = sparse_tensor.number_of_entries %arg0: tensor<?xf64, #SparseVector>
vector.print %n : index
%0 = sparse_tensor.values %arg0 %0 = sparse_tensor.values %arg0
: tensor<?xf64, #SparseVector> to memref<?xf64> : tensor<?xf64, #SparseVector> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<32xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<9xf64>
vector.print %1 : vector<32xf64> vector.print %1 : vector<9xf64>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 %dv = sparse_tensor.convert %arg0
: tensor<?xf64, #SparseVector> to tensor<?xf64> : tensor<?xf64, #SparseVector> to tensor<?xf64>
%3 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64> %3 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64>
vector.print %3 : vector<32xf64> vector.print %3 : vector<32xf64>
return return
} }
Show All 9 Lines func.func @entry() {
// Call sparse vector kernel. // Call sparse vector kernel.
%0 = call @sparse_tanh(%sv1) : (tensor<?xf64, #SparseVector>) %0 = call @sparse_tanh(%sv1) : (tensor<?xf64, #SparseVector>)
-> tensor<?xf64, #SparseVector> -> tensor<?xf64, #SparseVector>
// //
// Verify the results (within some precision). // Verify the results (within some precision).
// //
// CHECK: {{( -0.761[0-9]*, 0.761[0-9]*, 0.96[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 )}} // CHECK: 9
// CHECK-NEXT {{( -0.761[0-9]*, 0, 0, 0.761[0-9]*, 0, 0, 0, 0, 0, 0, 0, 0.96[0-9]*, 0, 0, 0, 0, 0, 0.99[0-9]*, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 0, 0, 0, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 1 )}} // CHECK-NEXT: {{( -0.761[0-9]*, 0.761[0-9]*, 0.96[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 0.99[0-9]*, 1 )}}
// CHECK-NEXT: {{( -0.761[0-9]*, 0, 0, 0.761[0-9]*, 0, 0, 0, 0, 0, 0, 0, 0.96[0-9]*, 0, 0, 0, 0, 0, 0.99[0-9]*, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 0, 0, 0, 0, 0, 0.99[0-9]*, 0.99[0-9]*, 0, 1 )}}
// //
call @dump_vec_f64(%0) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%0) : (tensor<?xf64, #SparseVector>) -> ()
// Release the resources. // Release the resources.
bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector> bufferization.dealloc_tensor %sv1 : tensor<?xf64, #SparseVector>
return return
} }
} }

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#ST = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "compressed"]}> #ST = #sparse_tensor.encoding<{dimLevelType = ["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 60 Lines • ▼ Show 20 Lines func.func @entry() {
// Call sparse tensor multiplication kernel. // Call sparse tensor multiplication kernel.
%0 = call @tensor_mul(%sta, %stb) %0 = call @tensor_mul(%sta, %stb)
: (tensor<?x?x?xf64, #ST>, tensor<?x?x?xf64, #ST>) -> tensor<?x?x?xf64, #ST> : (tensor<?x?x?xf64, #ST>, tensor<?x?x?xf64, #ST>) -> tensor<?x?x?xf64, #ST>
// Verify results // Verify results
// //
// CHECK: ( 2.4, 3.5, 2, 8, -1, -1, -1, -1 ) // CHECK: 4
// CHECK-NEXT: ( 2.4, 3.5, 2, 8 )
// CHECK-NEXT: ( ( ( 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ), ( 2.4, 0, 3.5, 0, 0 ) ), // CHECK-NEXT: ( ( ( 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ), ( 2.4, 0, 3.5, 0, 0 ) ),
// CHECK-SAME: ( ( 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ) ), // CHECK-SAME: ( ( 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ) ),
// CHECK-SAME: ( ( 2, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ), ( 0, 0, 8, 0, 0 ) ) ) // CHECK-SAME: ( ( 2, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0 ), ( 0, 0, 8, 0, 0 ) ) )
// //
%n = sparse_tensor.number_of_entries %0 : tensor<?x?x?xf64, #ST>
vector.print %n : index
%m1 = sparse_tensor.values %0 : tensor<?x?x?xf64, #ST> to memref<?xf64> %m1 = sparse_tensor.values %0 : tensor<?x?x?xf64, #ST> to memref<?xf64>
%v1 = vector.transfer_read %m1[%c0], %default_val: memref<?xf64>, vector<8xf64> %v1 = vector.transfer_read %m1[%c0], %default_val: memref<?xf64>, vector<4xf64>
vector.print %v1 : vector<8xf64> vector.print %v1 : vector<4xf64>
// Print %0 in dense form. // Print %0 in dense form.
%dt = sparse_tensor.convert %0 : tensor<?x?x?xf64, #ST> to tensor<?x?x?xf64> %dt = sparse_tensor.convert %0 : tensor<?x?x?xf64, #ST> to tensor<?x?x?xf64>
%v2 = vector.transfer_read %dt[%c0, %c0, %c0], %default_val: tensor<?x?x?xf64>, vector<3x3x5xf64> %v2 = vector.transfer_read %dt[%c0, %c0, %c0], %default_val: tensor<?x?x?xf64>, vector<3x3x5xf64>
vector.print %v2 : vector<3x3x5xf64> vector.print %v2 : vector<3x3x5xf64>
// Release the resources. // Release the resources.
bufferization.dealloc_tensor %sta : tensor<?x?x?xf64, #ST> bufferization.dealloc_tensor %sta : tensor<?x?x?xf64, #ST>
bufferization.dealloc_tensor %stb : tensor<?x?x?xf64, #ST> bufferization.dealloc_tensor %stb : tensor<?x?x?xf64, #ST>
bufferization.dealloc_tensor %0 : tensor<?x?x?xf64, #ST> bufferization.dealloc_tensor %0 : tensor<?x?x?xf64, #ST>
return return
} }
} }

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
#ST1 = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "compressed"]}> #ST1 = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "compressed"]}>
#ST2 = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "dense"]}> #ST2 = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed", "dense"]}>
// //
// Trait for 3-d tensor operation. // Trait for 3-d tensor operation.
// //
#trait_scale = { #trait_scale = {
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines %t = arith.constant dense<
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ] ]> : tensor<3x4x8xf64> [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ] ]> : tensor<3x4x8xf64>
%st = sparse_tensor.convert %t : tensor<3x4x8xf64> to tensor<?x?x?xf64, #ST1> %st = sparse_tensor.convert %t : tensor<3x4x8xf64> to tensor<?x?x?xf64, #ST1>
// Call sparse vector kernels. // Call sparse vector kernels.
%0 = call @tensor_scale(%st) : (tensor<?x?x?xf64, #ST1>) -> tensor<?x?x?xf64, #ST2> %0 = call @tensor_scale(%st) : (tensor<?x?x?xf64, #ST1>) -> tensor<?x?x?xf64, #ST2>
// Sanity check on stored values. // Sanity check on stored values.
// //
// CHECK: ( 1, 2, 3, 4, 5, -1, -1, -1 ) // CHECK: 5
// CHECK-NEXT: ( 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 6, 8, 0, 0, 0, 0, 10, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 1, 2, 3, 4, 5 )
// CHECK-NEXT: 24
// CHECK-NEXT: ( 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 6, 8, 0, 0, 0, 0, 10 )
%m1 = sparse_tensor.values %st : tensor<?x?x?xf64, #ST1> to memref<?xf64> %m1 = sparse_tensor.values %st : tensor<?x?x?xf64, #ST1> to memref<?xf64>
%m2 = sparse_tensor.values %0 : tensor<?x?x?xf64, #ST2> to memref<?xf64> %m2 = sparse_tensor.values %0 : tensor<?x?x?xf64, #ST2> to memref<?xf64>
%v1 = vector.transfer_read %m1[%c0], %d1: memref<?xf64>, vector<8xf64> %n1 = sparse_tensor.number_of_entries %st : tensor<?x?x?xf64, #ST1>
%v2 = vector.transfer_read %m2[%c0], %d1: memref<?xf64>, vector<32xf64> %n2 = sparse_tensor.number_of_entries %0 : tensor<?x?x?xf64, #ST2>
vector.print %v1 : vector<8xf64> %v1 = vector.transfer_read %m1[%c0], %d1: memref<?xf64>, vector<5xf64>
vector.print %v2 : vector<32xf64> %v2 = vector.transfer_read %m2[%c0], %d1: memref<?xf64>, vector<24xf64>
vector.print %n1 : index
vector.print %v1 : vector<5xf64>
vector.print %n2 : index
vector.print %v2 : vector<24xf64>
// Release the resources. // Release the resources.
bufferization.dealloc_tensor %st : tensor<?x?x?xf64, #ST1> bufferization.dealloc_tensor %st : tensor<?x?x?xf64, #ST1>
bufferization.dealloc_tensor %0 : tensor<?x?x?xf64, #ST2> bufferization.dealloc_tensor %0 : tensor<?x?x?xf64, #ST2>
return return
} }
} }

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}> #DCSR = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}>
// //
// Traits for tensor operations. // Traits for tensor operations.
// //
#trait_vec_scale = { #trait_vec_scale = {
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines func.func @matrix_slice(%argx: tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> {
} -> tensor<?x?xf64, #DCSR> } -> tensor<?x?xf64, #DCSR>
return %0 : tensor<?x?xf64, #DCSR> return %0 : tensor<?x?xf64, #DCSR>
} }
// Dumps a sparse vector of type f64. // Dumps a sparse vector of type f64.
func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) { func.func @dump_vec_f64(%arg0: tensor<?xf64, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<32xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<32xf64>
vector.print %1 : vector<32xf64> vector.print %1 : vector<32xf64>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64> %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
%3 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64> %3 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64>
vector.print %3 : vector<32xf64> vector.print %3 : vector<32xf64>
return return
} }
// Dumps a sparse vector of type i32. // Dumps a sparse vector of type i32.
func.func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) { func.func @dump_vec_i32(%arg0: tensor<?xi32, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1 : i32 %d0 = arith.constant 0 : i32
%0 = sparse_tensor.values %arg0 : tensor<?xi32, #SparseVector> to memref<?xi32> %0 = sparse_tensor.values %arg0 : tensor<?xi32, #SparseVector> to memref<?xi32>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xi32>, vector<24xi32> %1 = vector.transfer_read %0[%c0], %d0: memref<?xi32>, vector<24xi32>
vector.print %1 : vector<24xi32> vector.print %1 : vector<24xi32>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32> %dv = sparse_tensor.convert %arg0 : tensor<?xi32, #SparseVector> to tensor<?xi32>
%3 = vector.transfer_read %dv[%c0], %d0: tensor<?xi32>, vector<32xi32> %3 = vector.transfer_read %dv[%c0], %d0: tensor<?xi32>, vector<32xi32>
vector.print %3 : vector<32xi32> vector.print %3 : vector<32xi32>
return return
} }
// Dump a sparse matrix. // Dump a sparse matrix.
func.func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) { func.func @dump_mat(%arg0: tensor<?x?xf64, #DCSR>) {
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #DCSR> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?x?xf64, #DCSR> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
vector.print %1 : vector<16xf64> vector.print %1 : vector<16xf64>
%dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #DCSR> to tensor<?x?xf64> %dm = sparse_tensor.convert %arg0 : tensor<?x?xf64, #DCSR> to tensor<?x?xf64>
%3 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<4x8xf64> %3 = vector.transfer_read %dm[%c0, %c0], %d0: tensor<?x?xf64>, vector<4x8xf64>
vector.print %3 : vector<4x8xf64> vector.print %3 : vector<4x8xf64>
return return
} }
Show All 28 Lines func.func @entry() {
%3 = call @matrix_clip(%sm1) %3 = call @matrix_clip(%sm1)
: (tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> : (tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR>
%4 = call @matrix_slice(%sm1) %4 = call @matrix_slice(%sm1)
: (tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR> : (tensor<?x?xf64, #DCSR>) -> tensor<?x?xf64, #DCSR>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 ) // CHECK-NEXT: ( 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 )
// CHECK-NEXT: ( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1 ) // CHECK-NEXT: ( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 )
// CHECK-NEXT: ( 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0 ) // CHECK-NEXT: ( 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0 )
// CHECK-NEXT: ( -1, 1, 1, -2, 1, 1, 1, 1, 1, 1, 1, -3, 1, 1, 1, 1, 1, -4, 1, 1, -5, -6, 1, 1, 1, 1, 1, 1, -7, -8, 1, -9 ) // CHECK-NEXT: ( -1, 1, 1, -2, 1, 1, 1, 1, 1, 1, 1, -3, 1, 1, 1, 1, 1, -4, 1, 1, -5, -6, 1, 1, 1, 1, 1, 1, -7, -8, 1, -9 )
// CHECK-NEXT: ( -1, 1, 1, -2, 1, 1, 1, 1, 1, 1, 1, -3, 1, 1, 1, 1, 1, -4, 1, 1, -5, -6, 1, 1, 1, 1, 1, 1, -7, -8, 1, -9 ) // CHECK-NEXT: ( -1, 1, 1, -2, 1, 1, 1, 1, 1, 1, 1, -3, 1, 1, 1, 1, 1, -4, 1, 1, -5, -6, 1, 1, 1, 1, 1, 1, -7, -8, 1, -9 )
// CHECK-NEXT: ( 0, 6, 33, 68, 100, 126, 196, 232, 279, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 0, 6, 33, 68, 100, 126, 196, 232, 279, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 68, 0, 0, 100, 126, 0, 0, 0, 0, 0, 0, 196, 232, 0, 279 ) // CHECK-NEXT: ( 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 68, 0, 0, 100, 126, 0, 0, 0, 0, 0, 0, 196, 232, 0, 279 )
// CHECK-NEXT: ( 3, 3, 3, 4, 5, 6, 7, 7, 7, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 3, 3, 3, 4, 5, 6, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 3, 3, 0, 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0, 0, 0, 3 ), ( 0, 0, 4, 0, 5, 0, 0, 6 ), ( 7, 0, 7, 7, 0, 0, 0, 0 ) ) // CHECK-NEXT: ( ( 3, 3, 0, 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0, 0, 0, 3 ), ( 0, 0, 4, 0, 5, 0, 0, 6 ), ( 7, 0, 7, 7, 0, 0, 0, 0 ) )
// CHECK-NEXT: ( 99, 99, 99, 99, 5, 6, 99, 99, 99, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 99, 99, 99, 99, 5, 6, 99, 99, 99, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( ( 99, 99, 0, 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0, 0, 0, 99 ), ( 0, 0, 99, 0, 5, 0, 0, 6 ), ( 99, 0, 99, 99, 0, 0, 0, 0 ) ) // CHECK-NEXT: ( ( 99, 99, 0, 0, 0, 0, 0, 0 ), ( 0, 0, 0, 0, 0, 0, 0, 99 ), ( 0, 0, 99, 0, 5, 0, 0, 6 ), ( 99, 0, 99, 99, 0, 0, 0, 0 ) )
// //
call @dump_vec_f64(%sv1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%sv1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> () call @dump_vec_i32(%0) : (tensor<?xi32, #SparseVector>) -> ()
call @dump_vec_f64(%1) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_vec_f64(%2) : (tensor<?xf64, #SparseVector>) -> () call @dump_vec_f64(%2) : (tensor<?xf64, #SparseVector>) -> ()
call @dump_mat(%3) : (tensor<?x?xf64, #DCSR>) -> () call @dump_mat(%3) : (tensor<?x?xf64, #DCSR>) -> ()
call @dump_mat(%4) : (tensor<?x?xf64, #DCSR>) -> () call @dump_mat(%4) : (tensor<?x?xf64, #DCSR>) -> ()
Show All 12 Lines

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

// RUN: mlir-opt %s --sparse-compiler | \ // DEFINE: %{option} = enable-runtime-library=true
// RUN: mlir-cpu-runner \ // DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// RUN: -e entry -entry-point-result=void \ // DEFINE: mlir-cpu-runner \
// RUN: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \ // DEFINE: -e entry -entry-point-result=void \
// RUN: FileCheck %s // DEFINE: -shared-libs=%mlir_lib_dir/libmlir_c_runner_utils%shlibext | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = "enable-runtime-library=false enable-buffer-initialization=true"
// RUN: %{command}
#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}> #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
#DenseVector = #sparse_tensor.encoding<{dimLevelType = ["dense"]}> #DenseVector = #sparse_tensor.encoding<{dimLevelType = ["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 121 Lines • ▼ Show 20 Lines func.func @vector_dotprod(%arga: tensor<?xf64, #SparseVector>,
} -> tensor<f64> } -> tensor<f64>
return %0 : tensor<f64> return %0 : tensor<f64>
} }
// Dumps a sparse vector. // Dumps a sparse vector.
func.func @dump(%arg0: tensor<?xf64, #SparseVector>) { func.func @dump(%arg0: tensor<?xf64, #SparseVector>) {
// Dump the values array to verify only sparse contents are stored. // Dump the values array to verify only sparse contents are stored.
%c0 = arith.constant 0 : index %c0 = arith.constant 0 : index
%d0 = arith.constant -1.0 : f64 %d0 = arith.constant 0.0 : f64
%0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64> %0 = sparse_tensor.values %arg0 : tensor<?xf64, #SparseVector> to memref<?xf64>
%1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64> %1 = vector.transfer_read %0[%c0], %d0: memref<?xf64>, vector<16xf64>
vector.print %1 : vector<16xf64> vector.print %1 : vector<16xf64>
// Dump the dense vector to verify structure is correct. // Dump the dense vector to verify structure is correct.
%dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64> %dv = sparse_tensor.convert %arg0 : tensor<?xf64, #SparseVector> to tensor<?xf64>
%2 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64> %2 = vector.transfer_read %dv[%c0], %d0: tensor<?xf64>, vector<32xf64>
vector.print %2 : vector<32xf64> vector.print %2 : vector<32xf64>
return return
Show All 37 Lines %4 = call @vector_mul_d(%1, %sv2)
tensor<?xf64, #SparseVector>) -> tensor<?xf64, #DenseVector> tensor<?xf64, #SparseVector>) -> tensor<?xf64, #DenseVector>
%5 = call @vector_dotprod(%1, %sv2, %x) %5 = call @vector_dotprod(%1, %sv2, %x)
: (tensor<?xf64, #SparseVector>, : (tensor<?xf64, #SparseVector>,
tensor<?xf64, #SparseVector>, tensor<f64>) -> tensor<f64> tensor<?xf64, #SparseVector>, tensor<f64>) -> tensor<f64>
// //
// Verify the results. // Verify the results.
// //
// CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1 ) // CHECK: ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 ) // CHECK-NEXT: ( 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 7, 8, 0, 9 )
// CHECK-NEXT: ( 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 11, 0, 12, 13, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 15, 0, 16, 0, 0, 17, 0, 0, 0, 0, 0, 0, 18, 19, 0, 20 ) // CHECK-NEXT: ( 0, 11, 0, 12, 13, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 15, 0, 16, 0, 0, 17, 0, 0, 0, 0, 0, 0, 18, 19, 0, 20 )
// CHECK-NEXT: ( 2, 4, 6, 8, 10, 12, 14, 16, 18, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 4, 6, 8, 10, 12, 14, 16, 18, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 2, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 8, 0, 0, 10, 12, 0, 0, 0, 0, 0, 0, 14, 16, 0, 18 ) // CHECK-NEXT: ( 2, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 8, 0, 0, 10, 12, 0, 0, 0, 0, 0, 0, 14, 16, 0, 18 )
// CHECK-NEXT: ( 2, 4, 6, 8, 10, 12, 14, 16, 18, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 2, 4, 6, 8, 10, 12, 14, 16, 18, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 2, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 8, 0, 0, 10, 12, 0, 0, 0, 0, 0, 0, 14, 16, 0, 18 ) // CHECK-NEXT: ( 2, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 8, 0, 0, 10, 12, 0, 0, 0, 0, 0, 0, 14, 16, 0, 18 )
// CHECK-NEXT: ( 2, 11, 16, 13, 14, 6, 15, 8, 16, 10, 29, 32, 35, 38, -1, -1 ) // CHECK-NEXT: ( 2, 11, 16, 13, 14, 6, 15, 8, 16, 10, 29, 32, 35, 38, 0, 0 )
// CHECK-NEXT: ( 2, 11, 0, 16, 13, 0, 0, 0, 0, 0, 14, 6, 0, 0, 0, 0, 15, 8, 16, 0, 10, 29, 0, 0, 0, 0, 0, 0, 32, 35, 0, 38 ) // CHECK-NEXT: ( 2, 11, 0, 16, 13, 0, 0, 0, 0, 0, 14, 6, 0, 0, 0, 0, 15, 8, 16, 0, 10, 29, 0, 0, 0, 0, 0, 0, 32, 35, 0, 38 )
// CHECK-NEXT: ( 48, 204, 252, 304, 360, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ) // CHECK-NEXT: ( 48, 204, 252, 304, 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 )
// CHECK-NEXT: ( 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 0, 0, 0, 0, 0, 0, 252, 304, 0, 360 ) // CHECK-NEXT: ( 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 0, 0, 0, 0, 0, 0, 252, 304, 0, 360 )
// CHECK-NEXT: ( 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 0, 0, 0, 0, 0, 0, 252, 304, 0, 360 ) // CHECK-NEXT: ( 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 204, 0, 0, 0, 0, 0, 0, 252, 304, 0, 360 )
// CHECK-NEXT: 1169.1 // CHECK-NEXT: 1169.1
// //
call @dump(%sv1) : (tensor<?xf64, #SparseVector>) -> () call @dump(%sv1) : (tensor<?xf64, #SparseVector>) -> ()
call @dump(%sv2) : (tensor<?xf64, #SparseVector>) -> () call @dump(%sv2) : (tensor<?xf64, #SparseVector>) -> ()
call @dump(%0) : (tensor<?xf64, #SparseVector>) -> () call @dump(%0) : (tensor<?xf64, #SparseVector>) -> ()
Show All 20 Lines