5
5
6
6
from util import RandomScipySparseTensorLoader , RandomPydataSparseTensorLoader
7
7
8
- @pytest .mark .skip (reason = "too slow right now" )
9
- def bench_add_window (tacoBench ):
10
- dim = 10000
11
- matrix = random (dim , dim , format = "csr" ).todense ()
12
- def bench ():
13
- x = matrix [1 :(dim - 1 ), 1 :(dim - 1 )]
14
- res = x + x
15
- tacoBench (bench )
8
+ # Want to run these windows so that they operate on
9
+ # * A small, constant size grid: 500x500
10
+ # * A constant fraction of the tensor size : 1/4 x 1/4
11
+ # * Almost the entire tensor (I'm unsure what the point of this comparison is)
12
+ # * No windowing (TACO should use a window so we can measure the overhead).
13
+ # These options map to the corresponding config values:
14
+ sizeConfigs = ["constant" , "constant-fraction" , "almost-whole" , "no-windowing" ]
15
+
16
+ def sliceTensor (tensor , dim , config ):
17
+ if config == "constant" :
18
+ return tensor [250 :750 , 250 :750 ]
19
+ elif config == "constant-fraction" :
20
+ size = dim // 4
21
+ start = dim // 4
22
+ return tensor [start :(start + size ), start :(start + size )]
23
+ elif config == "almost-whole" :
24
+ return tensor [1 :(dim - 1 ), 1 :(dim - 1 )]
25
+ elif config == "no-windowing" :
26
+ return tensor
27
+ else :
28
+ assert (False )
16
29
17
30
@pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
18
31
@pytest .mark .parametrize ("format" , ['csr' , 'csc' ])
19
- def bench_add_sparse_window (tacoBench , dim , format ):
32
+ @pytest .mark .parametrize ("config" , sizeConfigs )
33
+ def bench_add_sparse_window (tacoBench , dim , format , config ):
20
34
loader = RandomScipySparseTensorLoader (format )
21
35
matrix = loader .random ((dim , dim ), 0.01 )
22
36
def bench ():
23
- x = matrix [ 1 :( dim - 1 ), 1 :( dim - 1 )]
37
+ x = sliceTensor ( matrix , dim , config )
24
38
res = x + x
25
39
# Sanity check that this has a similar runtime as taco.
26
40
# res = matrix + matrix
@@ -29,47 +43,75 @@ def bench():
29
43
# TODO (rohany): This is really slow (compared to scipy.sparse). Check with hameer
30
44
# that this result makes sense.
31
45
@pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
32
- def bench_add_pydata_sparse_window (tacoBench , dim ):
46
+ @pytest .mark .parametrize ("config" , sizeConfigs )
47
+ def bench_add_pydata_sparse_window (tacoBench , dim , config ):
33
48
loader = RandomPydataSparseTensorLoader ()
34
49
matrix = loader .random ((dim , dim ), 0.01 )
35
50
def bench ():
36
- x = matrix [ 1 :( dim - 1 ), 1 :( dim - 1 )]
51
+ x = sliceTensor ( matrix , dim , config )
37
52
res = x + x
38
53
tacoBench (bench )
39
54
55
+ # TODO (rohany): Parametrize the below tests by appropriate windowing config.
56
+
40
57
@pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
41
58
@pytest .mark .parametrize ("format" , ['csr' , 'csc' ])
42
59
def bench_add_sparse_strided_window (tacoBench , dim , format ):
43
- matrix = random (dim , dim , format = format )
60
+ loader = ScipySparseTensorLoader (format )
61
+ matrix = loader .random ((dim , dim ), 0.01 )
44
62
def bench ():
45
63
x = matrix [1 :(dim - 1 ):4 , 1 :(dim - 1 ):4 ]
46
64
res = x + x
47
65
tacoBench (bench )
48
66
49
67
@pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
50
68
@pytest .mark .parametrize ("format" , ['csr' , 'csc' ])
51
- def bench_add_multiple_sparse_windows (tacoBench , dim , format ):
52
- matrix1 = random (dim , dim , format = format )
53
- matrix2 = random (dim , dim , format = format )
69
+ def bench_add_sparse_index_set (tacoBench , dim , format ):
70
+ indexes = [i * 2 for i in range (0 , dim // 2 )]
71
+ loader = ScipySparseTensorLoader (format )
72
+ matrix = loader .random ((dim , dim ), 0.01 )
54
73
def bench ():
55
- res = matrix1 [1 :(dim - 1 ), 1 :(dim - 1 )] + matrix2 [1 :(dim - 1 ), 1 :(dim - 1 )] + matrix1 [0 :(dim - 2 ), 0 :(dim - 2 )]
74
+ x = matrix [:, indexes ]
75
+ res = x + x
56
76
tacoBench (bench )
57
77
58
78
@pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
59
- @ pytest . mark . parametrize ( "format" , [ 'csr' , 'csc' ])
60
- def bench_add_sparse_strided_window ( tacoBench , dim , format ):
61
- matrix = random (dim , dim , format = format )
79
+ def bench_add_pydata_sparse_strided_window ( tacoBench , dim ):
80
+ loader = RandomPydataSparseTensorLoader ()
81
+ matrix = loader . random (( dim , dim ), 0.01 )
62
82
def bench ():
63
- x = matrix [1 :(dim - 1 ):2 , 1 :(dim - 1 ):2 ]
83
+ x = matrix [1 :(dim - 1 ):4 , 1 :(dim - 1 ):4 ]
64
84
res = x + x
65
85
tacoBench (bench )
66
86
87
+ # TODO (rohany): This is really slow (compared to scipy.sparse). Check with hameer
88
+ # that this result makes sense.
67
89
@pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
68
- @ pytest . mark . parametrize ( "format" , [ 'csr' , 'csc' ])
69
- def bench_add_sparse_index_set ( tacoBench , dim , format ):
90
+ def bench_add_pydata_sparse_index_set ( tacoBench , dim ):
91
+ loader = RandomPydataSparseTensorLoader ()
70
92
indexes = [i * 2 for i in range (0 , dim // 2 )]
71
- matrix = random (dim , dim , format = format )
93
+ matrix = loader . random (( dim , dim ), 0.01 )
72
94
def bench ():
73
95
x = matrix [:, indexes ]
74
96
res = x + x
75
97
tacoBench (bench )
98
+
99
+ # TODO (rohany): I don't know if we care about this benchmark.
100
+ @pytest .mark .parametrize ("dim" , [5000 , 10000 , 20000 ])
101
+ @pytest .mark .parametrize ("format" , ['csr' , 'csc' ])
102
+ def bench_add_multiple_sparse_windows (tacoBench , dim , format ):
103
+ matrix1 = random (dim , dim , format = format )
104
+ matrix2 = random (dim , dim , format = format )
105
+ def bench ():
106
+ res = matrix1 [1 :(dim - 1 ), 1 :(dim - 1 )] + matrix2 [1 :(dim - 1 ), 1 :(dim - 1 )] + matrix1 [0 :(dim - 2 ), 0 :(dim - 2 )]
107
+ tacoBench (bench )
108
+
109
+ @pytest .mark .skip (reason = "too slow right now" )
110
+ def bench_add_window (tacoBench ):
111
+ dim = 10000
112
+ matrix = random (dim , dim , format = "csr" ).todense ()
113
+ def bench ():
114
+ x = matrix [1 :(dim - 1 ), 1 :(dim - 1 )]
115
+ res = x + x
116
+ tacoBench (bench )
117
+
0 commit comments