1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// DEFINE: %{option} = enable-runtime-library=true
// DEFINE: %{command} = mlir-opt %s --sparse-compiler=%{option} | \
// DEFINE: mlir-cpu-runner \
// DEFINE: -e entry -entry-point-result=void \
// DEFINE: -shared-libs=%mlir_c_runner_utils | \
// DEFINE: FileCheck %s
//
// RUN: %{command}
//
// Do the same run, but now with direct IR generation.
// REDEFINE: %{option} = enable-runtime-library=false
// RUN: %{command}
//
// Do the same run, but now with direct IR generation and vectorization.
// REDEFINE: %{option} = "enable-runtime-library=false vl=2 reassociate-fp-reductions=true enable-index-optimizations=true"
// RUN: %{command}
#SV = #sparse_tensor.encoding<{ lvlTypes = [ "compressed" ] }>
#trait_reduction = {
indexing_maps = [
affine_map<(i) -> (i)>, // a
affine_map<(i) -> ()> // x (scalar out)
],
iterator_types = ["reduction"],
doc = "x += MIN_i a(i)"
}
// Examples of sparse vector MIN reductions.
module {
// Custom MIN reduction: stored i32 elements only.
func.func @min1(%arga: tensor<32xi32, #SV>, %argx: tensor<i32>) -> tensor<i32> {
%c = tensor.extract %argx[] : tensor<i32>
%0 = linalg.generic #trait_reduction
ins(%arga: tensor<32xi32, #SV>)
outs(%argx: tensor<i32>) {
^bb(%a: i32, %b: i32):
%1 = sparse_tensor.reduce %a, %b, %c : i32 {
^bb0(%x: i32, %y: i32):
%m = arith.minsi %x, %y : i32
sparse_tensor.yield %m : i32
}
linalg.yield %1 : i32
} -> tensor<i32>
return %0 : tensor<i32>
}
// Regular MIN reduction: stored i32 elements AND implicit zeros.
// Note that dealing with the implicit zeros is taken care of
// by the sparse compiler to preserve semantics of the "original".
func.func @min2(%arga: tensor<32xi32, #SV>, %argx: tensor<i32>) -> tensor<i32> {
%c = tensor.extract %argx[] : tensor<i32>
%0 = linalg.generic #trait_reduction
ins(%arga: tensor<32xi32, #SV>)
outs(%argx: tensor<i32>) {
^bb(%a: i32, %b: i32):
%m = arith.minsi %a, %b : i32
linalg.yield %m : i32
} -> tensor<i32>
return %0 : tensor<i32>
}
func.func @dump_i32(%arg0 : tensor<i32>) {
%v = tensor.extract %arg0[] : tensor<i32>
vector.print %v : i32
return
}
func.func @entry() {
%ri = arith.constant dense<999> : tensor<i32>
// Vectors with a few zeros.
%c_0_i32 = arith.constant dense<[
2, 2, 7, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 3, 0, 9, 2, 2, 2, 2, 0, 5, 1, 7, 3
]> : tensor<32xi32>
// Vectors with no zeros.
%c_1_i32 = arith.constant dense<[
2, 2, 7, 2, 2, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2,
2, 2, 2, 2, 3, 2, 7, 2, 2, 2, 2, 2, 2, 1, 7, 3
]> : tensor<32xi32>
// Convert constants to annotated tensors. Note that this
// particular conversion only stores nonzero elements,
// so we will have no explicit zeros, only implicit zeros.
%sv0 = sparse_tensor.convert %c_0_i32
: tensor<32xi32> to tensor<32xi32, #SV>
%sv1 = sparse_tensor.convert %c_1_i32
: tensor<32xi32> to tensor<32xi32, #SV>
// Special case, construct a sparse vector with an explicit zero.
%v = arith.constant sparse< [ [1], [7] ], [ 0, 22 ] > : tensor<32xi32>
%sv2 = sparse_tensor.convert %v: tensor<32xi32> to tensor<32xi32, #SV>
// Call the kernels.
%0 = call @min1(%sv0, %ri) : (tensor<32xi32, #SV>, tensor<i32>) -> tensor<i32>
%1 = call @min1(%sv1, %ri) : (tensor<32xi32, #SV>, tensor<i32>) -> tensor<i32>
%2 = call @min1(%sv2, %ri) : (tensor<32xi32, #SV>, tensor<i32>) -> tensor<i32>
%3 = call @min2(%sv0, %ri) : (tensor<32xi32, #SV>, tensor<i32>) -> tensor<i32>
%4 = call @min2(%sv1, %ri) : (tensor<32xi32, #SV>, tensor<i32>) -> tensor<i32>
%5 = call @min2(%sv2, %ri) : (tensor<32xi32, #SV>, tensor<i32>) -> tensor<i32>
// Verify results.
//
// CHECK: 1
// CHECK: 1
// CHECK: 0
// CHECK: 0
// CHECK: 1
// CHECK: 0
//
call @dump_i32(%0) : (tensor<i32>) -> ()
call @dump_i32(%1) : (tensor<i32>) -> ()
call @dump_i32(%2) : (tensor<i32>) -> ()
call @dump_i32(%3) : (tensor<i32>) -> ()
call @dump_i32(%4) : (tensor<i32>) -> ()
call @dump_i32(%5) : (tensor<i32>) -> ()
// Release the resources.
bufferization.dealloc_tensor %sv0 : tensor<32xi32, #SV>
bufferization.dealloc_tensor %sv1 : tensor<32xi32, #SV>
bufferization.dealloc_tensor %sv2 : tensor<32xi32, #SV>
return
}
}
|
