/articles/toma

To get this branch, use:
bzr branch http://darksoft.org/webbzr/articles/toma

« back to all changes in this revision

Viewing changes to figs/slide-gen/reconbench.py

  • Committer: Suren A. Chilingaryan
  • Date: 2018-09-19 03:32:56 UTC
  • Revision ID: csa@suren.me-20180919033256-w9y50i624l5rehny
Benchmarks and figures for slides

Show diffs side-by-side

added added

removed removed

Lines of Context:
figs/slide-gen/reconbench.py
 
1
#! /usr/bin/python
 
2
 
 
3
import sys
 
4
import numpy as np
 
5
import matplotlib as mpl
 
6
import matplotlib.pyplot as plt
 
7
import matplotlib.ticker as ticker
 
8
 
 
9
font=12
 
10
mpl.rcParams.update({'font.size': font})
 
11
 
 
12
ops = 3526656000.
 
13
 
 
14
#colors=['blue', 'green', 'red']
 
15
#colors=['#011268', '#15601a', '#ff676c']
 
16
colors2=['black', 'gray']
 
17
colors=['red', 'orange', 'blue', 'green', '#303030', '#2b83ba', '#fdd5a5']
 
18
 
 
19
#units="mbps"
 
20
#units="gups"
 
21
units="sps"
 
22
 
 
23
def load(name, cols):
 
24
    data = np.genfromtxt(name, usecols = cols, dtype=(float, float))
 
25
    return data
 
26
 
 
27
def load_us(name, cols):
 
28
    data = load(name, cols)
 
29
    return np.apply_along_axis(lambda v: [ v[0], 1000000 * v[1]  ] if v[1] > 0 else [0, 0], 1, data).astype(int)
 
30
 
 
31
 
 
32
def load_gups(name, cols):
 
33
    data = load(name, cols)
 
34
    return np.apply_along_axis(lambda v: [ v[0], round(( 1. * v[0] * v[0] * v[0] ) / v[1] / 1000 / 1000 / 1000)  ] if v[1] > 0 else [0, 0], 1, data).astype(int)
 
35
 
 
36
def load_mbps(name, cols):
 
37
    data = load(name, cols)
 
38
    return np.apply_along_axis(lambda v: [ v[0], round(( 1. * v[0] * v[0] ) / v[1] / 1024 / 1024 )  ] if v[1] > 0 else [0, 0], 1, data).astype(int)
 
39
 
 
40
# slices per second
 
41
def load_sps(name, cols):
 
42
    data = load(name, cols)
 
43
    return np.apply_along_axis(lambda v: [ v[0], round(( 1. ) / v[1] )  ] if v[1] > 0 else [0, 0], 1, data).astype(int)
 
44
 
 
45
def load_xxps(name, cols):
 
46
    if units=="mbps":
 
47
        return load_mbps(name,cols)
 
48
    elif units=="sps":
 
49
        return load_sps(name,cols)
 
50
    else:
 
51
        return load_gups(name, cols)
 
52
 
 
53
def load_usgu(name, cols):
 
54
    data = load(name, cols)
 
55
    return np.apply_along_axis(lambda v: [ v[0], round((v[1] * 1000. * 1000.) / (1. * v[0] * v[0] * v[0] / 1000 / 1000 / 1000)) ] if v[1] > 0 else [0, 0], 1, data).astype(int)
 
56
 
 
57
#def load_gbs(name, cols):
 
58
#    data = load(name, cols)
 
59
#    return np.apply_along_axis(lambda v: [ v[0], round(( 4. * v[0] * v[0] ) / v[1] / 1024 / 1024 )  ] if v[1] > 0 else [0, 0], 1, data).astype(int)
 
60
 
 
61
 
 
62
data = load_xxps('../bench/recon_nonblocking.txt', [0,1])
 
63
gups = data[0::6,:]
 
64
data = load_xxps('../bench/recon_nn_nonblocking.txt', [0,1])
 
65
nn_gups = data[0::6,:]
 
66
data = load_xxps('../bench/recon_dfi_nonblocking.txt', [0,1])
 
67
dfi_gups = data[0::6,:]
 
68
data = load_xxps('../bench/recon_dfi_nonblocking_powpad.txt', [0,1])
 
69
dfipow_gups = data[0::6,:]
 
70
data = load_xxps('../bench/recon_tomoperf.txt', [0,1])
 
71
astra_gups = data[0::3,:]
 
72
ufodfi_gups = data[1::3,:]
 
73
ufofbp_gups = data[2::3,:]
 
74
 
 
75
 
 
76
data = load_mbps('../bench/recon_nonblocking.txt', [0,1])
 
77
gbs = data[0::6,:]
 
78
 
 
79
data = load_mbps('../bench/recon_blocking.txt', [0,1])
 
80
c2c = data[4::6,:]
 
81
data = load_mbps('../bench/recon_r2c.txt', [0,1])
 
82
r2c = data[4::6,:]
 
83
 
 
84
#print c2c
 
85
#print r2c
 
86
 
 
87
 
 
88
 
 
89
nb = load_usgu('../bench/recon_nonblocking.txt', [0,1])
 
90
b = load_usgu('../bench/recon_blocking.txt', [0,1])
 
91
total = nb[0::6,:]
 
92
transfer = (b[1::6,:] + b[2::6,:] + b[3::6,:])
 
93
fft = b[4::6,:]
 
94
bp = b[5::6,:]
 
95
 
 
96
offset=1
 
97
 
 
98
fig, (p) = plt.subplots(1, 1)
 
99
p_s = p.stackplot(total[offset:,0], 1. * bp[offset:,1] / 1000, 1. * fft[offset:,1] / 1000, 1. * transfer[offset:,1] / 1000, labels = ['bp', 'filter', 'transfer'], colors = colors[1:])
 
100
p_t = p.plot(total[offset:,0], 1. * total[offset:,1] / 1000, '-o', label='reconstruction', color='black', markersize=3)
 
101
 
 
102
 
 
103
#p_h = p.plot(hybrid[:,0], hybrid[:,1], '-o', label='hybrid, 2 slices', color=colors[1])
 
104
#p_t = p.plot(tex[:,0], tex[:,1], '-o', label='tex-based, 2 slices', color=colors[2])
 
105
#p_b = p.plot(tex[:,0], base[:,1], '-o', label='standard', color=colors[3])
 
106
 
 
107
ax = plt.gca()
 
108
ax.xaxis.grid(alpha=0.25)
 
109
 
 
110
plt.xlim(256, 4096)
 
111
plt.xlabel("pixels")
 
112
 
 
113
if (font is not None) and (font > 12):
 
114
    plt.xticks(np.concatenate(([256], np.arange(512,4097,512)), axis=0), np.concatenate(([256,''], np.arange(512,4097,512)), axis=0))
 
115
    ax.xaxis.set_label_coords(0.99, -0.09)
 
116
    legend_offset=(0.5,-0.14)
 
117
else:
 
118
    plt.xticks(np.concatenate(([256], np.arange(512,4097,512)), axis=0))
 
119
    ax.xaxis.set_label_coords(0.99, -0.07)
 
120
    legend_offset=(0.5,-0.1)
 
121
 
 
122
ax.yaxis.grid(alpha=0.25)
 
123
plt.ylim(0, 10)
 
124
plt.yticks(np.arange(1,10.1,1))
 
125
 
 
126
plt.ylabel("milliseconds per GU")
 
127
 
 
128
ticks = np.arange(0,10.1,1)
 
129
ticks = np.vectorize(lambda v: 1000 / v if v > 0 else 0.)(ticks).astype(int)
 
130
ticks = np.concatenate(([''], ticks[1::]))
 
131
 
 
132
ax2 = ax.twinx()
 
133
ax2.set_ylabel('GU/s')
 
134
ax2.set_ylim(0, 10)
 
135
ax2.set_yticks(np.arange(0,10.1,1))
 
136
ax2.set_yticklabels(ticks)
 
137
 
 
138
legend = p.legend(loc='upper center', bbox_to_anchor=legend_offset, ncol=4)
 
139
 
 
140
#plt.savefig('reconbench.pdf', dpi=300, bbox_inches='tight', bbox_extra_artists=(legend,))
 
141
plt.savefig('reconbench.pdf', dpi=300, bbox_inches='tight')
 
142
plt.close()
 
143
 
 
144
 
 
145
r2c = np.array([i for i in r2c if (not (i[0]&(i[0]-1)))])
 
146
c2c = np.array([i for i in c2c if (not (i[0]&(i[0]-1)))])
 
147
 
 
148
fig, (p) = plt.subplots(1, 1)
 
149
p_c2c = p.plot(c2c[offset:,0], c2c[offset:,1], '-o', label='complex', color=colors[1], markersize=3)
 
150
p_r2c = p.plot(r2c[offset:,0], r2c[offset:,1], '-o', label='real', color=colors[2], markersize=3)
 
151
 
 
152
ax = plt.gca()
 
153
ax.xaxis.grid(alpha=0.25)
 
154
plt.xticks(np.concatenate(([256], np.arange(512,4097,512)), axis=0))
 
155
plt.xlim(256, 4096)
 
156
plt.xlabel("pixels")
 
157
ax.xaxis.set_label_coords(0.99, -0.07)
 
158
 
 
159
ax.yaxis.grid(alpha=0.25)
 
160
#plt.yticks(np.arange(0,10.1,1))
 
161
#plt.ylim(0, 10)
 
162
plt.ylabel("MB/s")
 
163
 
 
164
ax2 = ax.twinx()
 
165
ax2.set_ylabel('%')
 
166
ax2.set_ylim(50, 80)
 
167
ax2.set_yticks(np.arange(50,125.1,15))
 
168
 
 
169
print 100. * (c2c[offset:,1] - r2c[offset:,1]) / r2c[offset:,1]
 
170
 
 
171
p_speedup = ax2.plot(r2c[offset:,0], 100. * (c2c[offset:,1] - r2c[offset:,1]) / r2c[offset:,1], '-o', label='ratio', color=colors[0], markersize=3)
 
172
ax2.set_ylabel('speed-up')
 
173
 
 
174
legend = p.legend(
 
175
    (p_r2c[0], p_c2c[0], p_speedup[0]), ("R2C", "C2C", "Speed-up"),
 
176
    loc='upper center', bbox_to_anchor=(0.5,-0.1), ncol=4)
 
177
 
 
178
 
 
179
plt.savefig('fftperf.png', dpi=300, bbox_inches='tight')
 
180
 
 
181
plt.close()
 
182
 
 
183
fig, (p) = plt.subplots(1, 1)
 
184
p_gups = p.plot(gups[offset:,0], gups[offset:,1], '-o', label='GU/s', color=colors[0], markersize=3)
 
185
p_nn_gups = p.plot(nn_gups[offset:,0], nn_gups[offset:,1], '-o', label='GU/s', color=colors[1], markersize=3)
 
186
p_dfi_gups = p.plot(dfi_gups[offset:,0], dfi_gups[offset:,1], '-o', label='GU/s', color=colors2[0], markersize=3)
 
187
#p_dfipow_gups = p.plot(dfipow_gups[offset:,0], dfipow_gups[offset:,1], '-o', label='GU/s', color=colors2[1], markersize=3)
 
188
p_astra_gups = p.plot(astra_gups[offset:,0], astra_gups[offset:,1], '-o', label='GU/s', color=colors[2], markersize=3)
 
189
p_ufofbp_gups = p.plot(ufofbp_gups[offset:,0], ufofbp_gups[offset:,1], '-o', label='GU/s', color=colors[3], markersize=3)
 
190
#p_ufodfi_gups = p.plot(ufodfi_gups[offset:,0], ufodfi_gups[offset:,1], '-o', label='GU/s', color=colors[4], markersize=3)
 
191
#p_gbs = p.plot(gbs[offset:,0], gbs[offset:,1], '-o', label='GB/s', color=colors[1], markersize=3)
 
192
 
 
193
ax = plt.gca()
 
194
ax2 = ax.twinx()
 
195
 
 
196
ax.grid(True)
 
197
ax.xaxis.grid(alpha=0.25)
 
198
plt.xticks(np.concatenate(([256], np.arange(512,4097,512)), axis=0))
 
199
plt.xlim(256, 4096)
 
200
plt.xlabel("pixels")
 
201
ax.xaxis.set_label_coords(0.99, -0.07)
 
202
 
 
203
if units=="mbps":
 
204
    yminor = ticker.MultipleLocator(50)
 
205
    for axis in [ax,ax2]:
 
206
        axis.set_yticks(np.arange(0,1201,200))
 
207
        axis.set_ylim(0, 1200)
 
208
        axis.yaxis.set_minor_locator(yminor)
 
209
    ax.set_ylabel("MB/s")
 
210
    
 
211
elif units=="gups":
 
212
    yminor = ticker.MultipleLocator(50)
 
213
    for axis in [ax,ax2]:
 
214
        axis.set_yticks(np.concatenate((np.arange(0,2001,250),[2300]), axis=0))
 
215
        axis.set_ylim(0, 2300)
 
216
        axis.yaxis.set_minor_locator(yminor)
 
217
    ax.set_ylabel("GU/s")
 
218
 
 
219
 
 
220
 
 
221
legend = p.legend(
 
222
    (p_gups[0], p_nn_gups[0], p_dfi_gups[0], p_astra_gups[0], p_ufofbp_gups[0]), ("FBP/Lin", "FBP/NN", "DFI", "ASTRA", "UFO/FBP"),
 
223
    loc='upper right', bbox_to_anchor=(1.40,1.05), ncol=1)
 
224
 
 
225
#    loc='upper center', bbox_to_anchor=(0.5,-0.1), ncol=4)
 
226
 
 
227
 
 
228
plt.savefig('reconperf-%s.png' % units, dpi=300, bbox_inches='tight')