OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
performancePlots.cpp
1/*
2 * performancePlots.cpp
3 *
4 * Created on: Sep 10, 2019
5 * Author: i-bird
6 */
7
8#include "performancePlots.hpp"
9
10bool isTestInSet(std::set<std::string> &testSet, std::string name)
11{
12 auto it = testSet.find(name);
13 bool res = it != testSet.end();
14 std::cout << "isTestInSet - key=\""+ name +"\", found=" << res << std::endl;
15 return res;
16}
17
18void write_test_report(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet)
19{
20 const char *perfResultsXmlFile = "SparseGridGpu_performance.xml";
21
22 unsigned int plotCounter = 0;
23
24 plotDense2DHost(report_sparsegrid_funcs, testSet, plotCounter);
25 plotSparse2DHost(report_sparsegrid_funcs, testSet, plotCounter);
26 plotDense2D(report_sparsegrid_funcs, testSet, plotCounter);
27 plotDense2DComparison(report_sparsegrid_funcs, testSet, plotCounter);
28 plotDense2DZ(report_sparsegrid_funcs, testSet, plotCounter);
29 plotDense2DZComparison(report_sparsegrid_funcs, testSet, plotCounter);
30 plotDense2DGetComparison(report_sparsegrid_funcs, testSet, plotCounter);
31 plotDense2DSkeletonComparison(report_sparsegrid_funcs, testSet, plotCounter);
32 plotDense3D(report_sparsegrid_funcs, testSet, plotCounter);
33 plotDense3DComparison(report_sparsegrid_funcs, testSet, plotCounter);
34 plotSparse2DComparison(report_sparsegrid_funcs, testSet, plotCounter);
35 plotSparse3D(report_sparsegrid_funcs, testSet, plotCounter);
36 plotDenseSparse2DComparison(report_sparsegrid_funcs, testSet, plotCounter);
37
38 plotDense2DStencilInsert(report_sparsegrid_funcs, testSet, plotCounter);
39 plotDense2DStencilInsertComparison(report_sparsegrid_funcs, testSet, plotCounter);
40 plotDense2DStencilInplaceInsertComparison(report_sparsegrid_funcs, testSet, plotCounter);
41 plotDense2DStencilInplaceInsertComparison16(report_sparsegrid_funcs, testSet, plotCounter);
42 plotInsertSingle2D(report_sparsegrid_funcs, testSet, plotCounter);
43 plotInsertBlock2D(report_sparsegrid_funcs, testSet, plotCounter);
44
45 plotGetSingle2D(report_sparsegrid_funcs, testSet, plotCounter);
46 plotGetNeighbourhood2D(report_sparsegrid_funcs, testSet, plotCounter);
47
48
49
50 std::string file_xml_results(test_dir);
51 file_xml_results += std::string("/") + std::string(perfResultsXmlFile);
52
53 boost::property_tree::xml_writer_settings<std::string> settings(' ', 4);
54 boost::property_tree::write_xml(file_xml_results, report_sparsegrid_funcs.graphs, std::locale(), settings);
55
56 std::string file_xml_ref(test_dir);
57// file_xml_ref += std::string("/openfpm_pdata/SparseGridGpu_performance_ref.xml"); // This the normal setup
58 file_xml_ref += std::string("/") + std::string(perfResultsXmlFile); // This is our setup to get the stdDev on plots
59
60 GoogleChart cg;
61
62 StandardXMLPerformanceGraph(file_xml_results, file_xml_ref, cg, 1);
63
64 addUpdateTime(cg,1,"data","SparseGridGpu_performance");
65 cg.write("SparseGridGpu_performance.html");
66}
67
68void plotDenseSparse2DComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
69 unsigned int plotCounter)
70{// 2D Dense sparse comparisons
71
72 std::string dim = "2";
73 std::string pattern = "sparse";
74 std::string linMode = "N";
75 std::string baseDense = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
76 std::string baseSparse = "performance.SparseGridGpu.device.stencil." + pattern + "." + linMode + "." + dim + "D";
77
78 if( isTestInSet(testSet, baseDense + ".8.gridScaling")
79 && isTestInSet(testSet, baseSparse + ".05.gridScaling")
80 && isTestInSet(testSet, baseSparse + ".08.gridScaling")
81 && isTestInSet(testSet, baseSparse + ".09.gridScaling") )
82 {
83 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
84 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
85 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
86 baseSparse + ".05.gridScaling(0).blockSize"));
87 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
88 "SparseGridGPU stencil dense-" + pattern + " " + linMode + " " + dim + "D"
89 + " grid scaling performance, blockEdge=" + std::to_string(bes));
90 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
91 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
92 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
93 baseDense + ".8.gridScaling(#).GFlops.mean");
94 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
95 baseSparse + ".05.gridScaling(#).GFlops.mean");
96 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
97 baseSparse + ".08.gridScaling(#).GFlops.mean");
98 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
99 baseSparse + ".09.gridScaling(#).GFlops.mean");
100 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
101 baseDense + ".8.gridScaling(#).gridSize.x");
102 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
103 baseSparse + ".05.gridScaling(#).gridSize.x");
104 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
105 baseSparse + ".08.gridScaling(#).gridSize.x");
106 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
107 baseSparse + ".09.gridScaling(#).gridSize.x");
108 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
109
110 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
111 "Dense");
112 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
113 "0.5 sparse");
114 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
115 "0.8 sparse");
116 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title",
117 "0.9 sparse");
118 ++plotCounter;
119 }
120 if( isTestInSet(testSet, baseDense + ".blockScaling")
121 && isTestInSet(testSet, baseSparse + ".05.blockScaling")
122 && isTestInSet(testSet, baseSparse + ".08.blockScaling")
123 && isTestInSet(testSet, baseSparse + ".09.blockScaling") )
124 {
125 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
126 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
127 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
128 baseSparse + ".05.blockScaling(0).gridSize.x"));
129 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
130 "SparseGridGPU stencil dense-" + pattern + " " + linMode + " " + dim + "D"
131 + " grid scaling performance, gridEdge=" + std::to_string(bes));
132 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "BlockEdgeSize");
133 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
134 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
135 baseDense + ".blockScaling(#).GFlops.mean");
136 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
137 baseSparse + ".05.blockScaling(#).GFlops.mean");
138 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
139 baseSparse + ".08.blockScaling(#).GFlops.mean");
140 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
141 baseSparse + ".09.blockScaling(#).GFlops.mean");
142 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
143 baseDense + ".blockScaling(#).blockSize");
144 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
145 baseSparse + ".05.blockScaling(#).blockSize");
146 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
147 baseSparse + ".08.blockScaling(#).blockSize");
148 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
149 baseSparse + ".09.blockScaling(#).blockSize");
150 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
151
152 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
153 "Dense");
154 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
155 "0.5 sparse");
156 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
157 "0.8 sparse");
158 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title",
159 "0.9 sparse");
160 ++plotCounter;
161 }
162}
163
164void plotSparse3D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
165 unsigned int &plotCounter)
166{// Sparse 3D
167 std::string dim = "3";
168 std::string pattern = "sparse";
169 std::string linMode = "N";
170 std::string base = "performance.SparseGridGpu.device.stencil." + pattern + "." + linMode + "." + dim + "D";
171
172 if( isTestInSet(testSet, base + ".05.gridScaling") )
173 {
174 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
175 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
176 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
177 "SparseGridGPU stencil " + pattern + " " + linMode + " " + dim + "D"
178 + " grid scaling performance");
179 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
180 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
181 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
182 base + "05.gridScaling(#).GFlops.mean");
183 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
184 base + "05.gridScaling(#).gridSize.x");
185 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
186 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
187 base + "05.gridScaling(0).blockSize"));
188 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
189 "blockEdge=" + std::to_string(bes));
190 ++plotCounter;
191 }
192 if( isTestInSet(testSet, base + ".05.blockScaling") )
193 {
194 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
195 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
196 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
197 "SparseGridGPU stencil "+pattern+" "+linMode+" "+dim+"D"
198 +" block scaling performance");
199 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
200 "BlockEdgeSize");
201 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
202 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
203 base + "05.blockScaling(#).GFlops.mean");
204 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
205 base + "05.blockScaling(#).blockSize");
206 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
207 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
208 base + "05.blockScaling(0).gridSize.x"));
209 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
210 "gridEdge=" + std::to_string(ges));
211 ++plotCounter;
212 }
213}
214
215void plotSparse2DComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
216 unsigned int &plotCounter)
217{// Sparse 2D
218 std::string dim = "2";
219 std::string pattern = "sparse";
220 std::string linMode = "N";
221 std::string baseSparse = "performance.SparseGridGpu.device.stencil." + pattern + "." + linMode + "." + dim + "D";
222
223 if( isTestInSet(testSet, baseSparse + ".05.gridScaling")
224 && isTestInSet(testSet, baseSparse + ".08.gridScaling")
225 && isTestInSet(testSet, baseSparse + ".09.gridScaling") )
226 {
227 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
228 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
229 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
230 baseSparse + ".05.gridScaling(0).blockSize"));
231 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
232 "SparseGridGPU stencil " + pattern + " " + linMode + " " + dim + "D"
233 + " grid scaling performance, blockEdge=" + std::to_string(bes));
234 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
235 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
236 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
237 baseSparse + ".05.gridScaling(#).GFlops.mean");
238 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
239 baseSparse + ".08.gridScaling(#).GFlops.mean");
240 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
241 baseSparse + ".09.gridScaling(#).GFlops.mean");
242 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
243 baseSparse + ".05.gridScaling(#).gridSize.x");
244 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
245 baseSparse + ".08.gridScaling(#).gridSize.x");
246 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
247 baseSparse + ".09.gridScaling(#).gridSize.x");
248 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
249
250 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
251 "0.5 sparse");
252 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
253 "0.8 sparse");
254 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
255 "0.9 sparse");
256 ++plotCounter;
257 }
258 if( isTestInSet(testSet, baseSparse + ".05.blockScaling")
259 && isTestInSet(testSet, baseSparse + ".08.blockScaling")
260 && isTestInSet(testSet, baseSparse + ".09.blockScaling") )
261 {
262 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
263 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
264 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
265 baseSparse + ".05.blockScaling(0).gridSize.x"));
266 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
267 "SparseGridGPU stencil " + pattern + " " + linMode + " " + dim + "D"
268 + " grid scaling performance, gridEdge=" + std::to_string(bes));
269 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "BlockEdgeSize");
270 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
271 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
272 baseSparse + ".05.blockScaling(#).GFlops.mean");
273 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
274 baseSparse + ".08.blockScaling(#).GFlops.mean");
275 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
276 baseSparse + ".09.blockScaling(#).GFlops.mean");
277 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
278 baseSparse + ".05.blockScaling(#).blockSize");
279 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
280 baseSparse + ".08.blockScaling(#).blockSize");
281 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
282 baseSparse + ".09.blockScaling(#).blockSize");
283 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
284
285 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
286 "0.5 sparse");
287 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
288 "0.8 sparse");
289 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
290 "0.9 sparse");
291 ++plotCounter;
292 }
293}
294
295void plotDense3D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
296 unsigned int &plotCounter)
297{// Dense 3D
298 std::string dim = "3";
299 std::string linMode = "N";
300 std::string base = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
301
302 if( isTestInSet(testSet, base + ".gridScaling") )
303 {
304 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
305 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
306 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
307 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
308 " grid scaling performance");
309 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
310 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
311 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
312 base + ".gridScaling(#).GFlops.mean");
313 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
314 base + ".gridScaling(#).gridSize.x");
315 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
316 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
317 base + ".gridScaling(0).blockSize"));
318 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
319 "blockEdge=" + std::to_string(bes));
320 ++plotCounter;
321 }
322 if( isTestInSet(testSet, base + ".blockScaling") )
323 {
324 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
325 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
326 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
327 "SparseGridGPU stencil "+linMode+" "+dim+"D"+" block scaling performance");
328 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
329 "BlockEdgeSize");
330 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
331 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
332 base + ".blockScaling(#).GFlops.mean");
333 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
334 base + ".blockScaling(#).blockSize");
335 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
336 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
337 base + ".blockScaling(0).gridSize.x"));
338 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
339 "gridEdge=" + std::to_string(ges));
340 ++plotCounter;
341 }
342}
343
344void plotDense2DZ(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
345 unsigned int &plotCounter)
346{// Dense 2D Z-morton
347 std::string dim = "2";
348 std::string linMode = "Z";
349 std::string base = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
350
351 if( isTestInSet(testSet, base + ".gridScaling") )
352 {
353 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
354 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
355 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
356 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
357 " grid scaling performance");
358 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
359 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
360 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
361 base + ".gridScaling(#).GFlops.mean");
362 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
363 base + ".gridScaling(#).gridSize.x");
364 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
365 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
366 base + ".gridScaling(0).blockSize"));
367 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
368 "blockEdge=" + std::to_string(bes));
369 ++plotCounter;
370 }
371 if( isTestInSet(testSet, base + ".blockScaling") )
372 {
373 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
374 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
375 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
376 "SparseGridGPU stencil "+linMode+" "+dim+"D"+" block scaling performance");
377 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
378 "BlockEdgeSize");
379 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
380 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
381 base + ".blockScaling(#).GFlops.mean");
382 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
383 base + ".blockScaling(#).blockSize");
384 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
385 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
386 base + ".blockScaling(0).gridSize.x"));
387 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
388 "gridEdge=" + std::to_string(ges));
389 ++plotCounter;
390 }
391}
392
393void plotDense2DHost(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
394 unsigned int &plotCounter)
395{// Dense 2D
396 std::string dim = "2";
397 std::string linMode = "N";
398 std::string base = "performance.SparseGridGpu.host.stencil.dense." + linMode + "." + dim + "D";
399
400 if( isTestInSet(testSet, base + ".gridScaling") )
401 {
402 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
403 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
404 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
405 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
406 " grid scaling performance");
407 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
408 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
409 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
410 base + ".gridScaling(#).GFlops.mean");
411 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
412 base + ".gridScaling(#).gridSize.x");
413 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
414 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
415 base + ".gridScaling(0).blockSize"));
416 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
417 "blockEdge=" + std::to_string(bes));
418 ++plotCounter;
419 }
420 if( isTestInSet(testSet, base + ".blockScaling") )
421 {
422 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
423 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
424 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
425 "SparseGridGPU stencil "+linMode+" "+dim+"D"+" block scaling performance");
426 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
427 "BlockEdgeSize");
428 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
429 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
430 base + ".blockScaling(#).GFlops.mean");
431 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
432 base + ".blockScaling(#).blockSize");
433 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
434 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
435 base + ".blockScaling(0).gridSize.x"));
436 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
437 "gridEdge=" + std::to_string(ges));
438 ++plotCounter;
439 }
440}
441void plotSparse2DHost(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
442 unsigned int &plotCounter)
443{// Dense 2D
444 std::string dim = "2";
445 std::string linMode = "N";
446 std::string base = "performance.SparseGridGpu.host.stencil.sparse." + linMode + "." + dim + "D";
447
448 if( isTestInSet(testSet, base + ".05.gridScaling") )
449 {
450 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
451 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
452 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
453 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
454 " grid scaling performance");
455 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
456 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
457 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
458 base + ".05.gridScaling(#).GFlops.mean");
459 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
460 base + ".05.gridScaling(#).gridSize.x");
461 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
462 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
463 base + ".05.gridScaling(0).blockSize"));
464 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
465 "blockEdge=" + std::to_string(bes));
466 ++plotCounter;
467 }
468 if( isTestInSet(testSet, base + ".05.blockScaling") )
469 {
470 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
471 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
472 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
473 "SparseGridGPU stencil "+linMode+" "+dim+"D"+" block scaling performance");
474 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
475 "BlockEdgeSize");
476 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
477 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
478 base + ".05.blockScaling(#).GFlops.mean");
479 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
480 base + ".05.blockScaling(#).blockSize");
481 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
482 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
483 base + ".05.blockScaling(0).gridSize.x"));
484 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
485 "gridEdge=" + std::to_string(ges));
486 ++plotCounter;
487 }
488}
489
490void plotDense2D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
491 unsigned int &plotCounter)
492{// Dense 2D
493 std::string dim = "2";
494 std::string linMode = "N";
495 std::string base = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
496
497 if( isTestInSet(testSet, base + ".gridScaling") )
498 {
499 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
500 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
501 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
502 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
503 " grid scaling performance");
504 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
505 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
506 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
507 base + ".gridScaling(#).GFlops.mean");
508 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
509 base + ".gridScaling(#).gridSize.x");
510 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
511 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
512 base + ".gridScaling(0).blockSize"));
513 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
514 "blockEdge=" + std::to_string(bes));
515 ++plotCounter;
516 }
517 if( isTestInSet(testSet, base + ".blockScaling") )
518 {
519 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
520 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
521 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
522 "SparseGridGPU stencil "+linMode+" "+dim+"D"+" block scaling performance");
523 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
524 "BlockEdgeSize");
525 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
526 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
527 base + ".blockScaling(#).GFlops.mean");
528 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
529 base + ".blockScaling(#).blockSize");
530 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
531 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
532 base + ".blockScaling(0).gridSize.x"));
533 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
534 "gridEdge=" + std::to_string(ges));
535 ++plotCounter;
536 }
537}
538
539void plotDense2DComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
540 unsigned int &plotCounter)
541{// Dense 2D
542 std::string dim = "2";
543 std::string linMode = "N";
544 std::string base = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
545
546 if( isTestInSet(testSet, base + ".2.gridScaling")
547 && isTestInSet(testSet, base + ".4.gridScaling")
548 && isTestInSet(testSet, base + ".8.gridScaling")
549 && isTestInSet(testSet, base + ".16.gridScaling")
550 && isTestInSet(testSet, base + ".32.gridScaling")
551 )
552 {
553 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
554 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
555 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
556 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
557 " grid scaling performance");
558 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
559 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
560
561 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
562 base + ".2.gridScaling(#).GFlops.mean");
563 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
564 base + ".4.gridScaling(#).GFlops.mean");
565 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
566 base + ".8.gridScaling(#).GFlops.mean");
567 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
568 base + ".16.gridScaling(#).GFlops.mean");
569 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
570 base + ".32.gridScaling(#).GFlops.mean");
571
572 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
573 base + ".2.gridScaling(#).gridSize.x");
574 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
575 base + ".4.gridScaling(#).gridSize.x");
576 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
577 base + ".8.gridScaling(#).gridSize.x");
578 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
579 base + ".16.gridScaling(#).gridSize.x");
580 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
581 base + ".32.gridScaling(#).gridSize.x");
582
583
584 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
585
586 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "blockEdge=2");
587 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "blockEdge=4");
588 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title", "blockEdge=8");
589 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title", "blockEdge=16");
590 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title", "blockEdge=32");
591
592 ++plotCounter;
593 }
594}
595
596void plotDense2DSkeletonComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
597 unsigned int &plotCounter)
598{// Dense 2D
599 std::string dim = "2";
600 std::string linMode = "N";
601 std::string base = "performance.SparseGridGpu.device.skeleton.dense." + linMode + "." + dim + "D";
602
603 if( isTestInSet(testSet, base + ".2.gridScaling")
604 && isTestInSet(testSet, base + ".4.gridScaling")
605 && isTestInSet(testSet, base + ".8.gridScaling")
606 && isTestInSet(testSet, base + ".16.gridScaling")
607 && isTestInSet(testSet, base + ".32.gridScaling")
608 )
609 {
610 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
611 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
612 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
613 "SparseGridGPU skeleton stencil " + linMode + " " + dim + "D" +
614 " grid scaling performance");
615 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
616 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G Elem/s");
617
618 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
619 base + ".2.gridScaling(#).GFlops.mean");
620 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
621 base + ".4.gridScaling(#).GFlops.mean");
622 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
623 base + ".8.gridScaling(#).GFlops.mean");
624 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
625 base + ".16.gridScaling(#).GFlops.mean");
626 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
627 base + ".32.gridScaling(#).GFlops.mean");
628
629 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
630 base + ".2.gridScaling(#).gridSize.x");
631 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
632 base + ".4.gridScaling(#).gridSize.x");
633 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
634 base + ".8.gridScaling(#).gridSize.x");
635 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
636 base + ".16.gridScaling(#).gridSize.x");
637 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
638 base + ".32.gridScaling(#).gridSize.x");
639
640
641 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
642
643 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "blockEdge=2");
644 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "blockEdge=4");
645 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title", "blockEdge=8");
646 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title", "blockEdge=16");
647 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title", "blockEdge=32");
648
649 ++plotCounter;
650 }
651}
652
653void plotDense2DGetComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
654 unsigned int &plotCounter)
655{// Dense 2D
656 std::string dim = "2";
657 std::string linMode = "N";
658 std::string base = "performance.SparseGridGpu.device.stencilGet.dense." + linMode + "." + dim + "D";
659
660 if( isTestInSet(testSet, base + ".2.gridScaling")
661 && isTestInSet(testSet, base + ".4.gridScaling")
662 && isTestInSet(testSet, base + ".8.gridScaling")
663 && isTestInSet(testSet, base + ".16.gridScaling")
664 && isTestInSet(testSet, base + ".32.gridScaling")
665 )
666 {
667 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
668 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
669 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
670 "SparseGridGPU GET stencil " + linMode + " " + dim + "D" +
671 " grid scaling performance");
672 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
673 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G Flops/s");
674
675 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
676 base + ".2.gridScaling(#).GFlops.mean");
677 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
678 base + ".4.gridScaling(#).GFlops.mean");
679 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
680 base + ".8.gridScaling(#).GFlops.mean");
681 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
682 base + ".16.gridScaling(#).GFlops.mean");
683 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
684 base + ".32.gridScaling(#).GFlops.mean");
685
686 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
687 base + ".2.gridScaling(#).gridSize.x");
688 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
689 base + ".4.gridScaling(#).gridSize.x");
690 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
691 base + ".8.gridScaling(#).gridSize.x");
692 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
693 base + ".16.gridScaling(#).gridSize.x");
694 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
695 base + ".32.gridScaling(#).gridSize.x");
696
697
698 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
699
700 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "blockEdge=2");
701 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "blockEdge=4");
702 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title", "blockEdge=8");
703 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title", "blockEdge=16");
704 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title", "blockEdge=32");
705
706 ++plotCounter;
707 }
708}
709
710void plotDense2DZComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
711 unsigned int &plotCounter)
712{// Dense 2D
713 std::string dim = "2";
714 std::string linMode = "Z";
715 std::string base = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
716
717 if( isTestInSet(testSet, base + ".2.gridScaling")
718 && isTestInSet(testSet, base + ".4.gridScaling")
719 && isTestInSet(testSet, base + ".8.gridScaling")
720 && isTestInSet(testSet, base + ".16.gridScaling")
721 && isTestInSet(testSet, base + ".32.gridScaling")
722 )
723 {
724 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
725 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
726 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
727 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
728 " grid scaling performance");
729 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
730 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
731
732 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
733 base + ".2.gridScaling(#).GFlops.mean");
734 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
735 base + ".4.gridScaling(#).GFlops.mean");
736 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
737 base + ".8.gridScaling(#).GFlops.mean");
738 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
739 base + ".16.gridScaling(#).GFlops.mean");
740 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
741 base + ".32.gridScaling(#).GFlops.mean");
742
743 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
744 base + ".2.gridScaling(#).gridSize.x");
745 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
746 base + ".4.gridScaling(#).gridSize.x");
747 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
748 base + ".8.gridScaling(#).gridSize.x");
749 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
750 base + ".16.gridScaling(#).gridSize.x");
751 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
752 base + ".32.gridScaling(#).gridSize.x");
753
754
755 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
756
757 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "blockEdge=2");
758 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "blockEdge=4");
759 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title", "blockEdge=8");
760 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title", "blockEdge=16");
761 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title", "blockEdge=32");
762
763 ++plotCounter;
764 }
765}
766
767void plotDense3DComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
768 unsigned int &plotCounter)
769{// Dense 2D
770 std::string dim = "3";
771 std::string linMode = "N";
772 std::string base = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
773
774 if( isTestInSet(testSet, base + ".2.gridScaling")
775 && isTestInSet(testSet, base + ".4.gridScaling")
776 && isTestInSet(testSet, base + ".8.gridScaling")
777 )
778 {
779 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
780 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
781 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
782 "SparseGridGPU stencil " + linMode + " " + dim + "D" +
783 " grid scaling performance");
784 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
785 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
786
787 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
788 base + ".2.gridScaling(#).GFlops.mean");
789 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
790 base + ".4.gridScaling(#).GFlops.mean");
791 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
792 base + ".8.gridScaling(#).GFlops.mean");
793
794 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
795 base + ".2.gridScaling(#).gridSize.x");
796 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
797 base + ".4.gridScaling(#).gridSize.x");
798 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
799 base + ".8.gridScaling(#).gridSize.x");
800
801
802 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
803
804 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "blockEdge=2");
805 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "blockEdge=4");
806 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title", "blockEdge=8");
807
808 ++plotCounter;
809 }
810}
811
812void plotDense2DStencilInsert(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
813 unsigned int &plotCounter)
814{// Dense 2D
815 std::string dim = "2";
816 std::string linMode = "N";
817 std::string base = "performance.SparseGridGpu.device.stencilInsert.dense." + linMode + "." + dim + "D";
818
819 if( isTestInSet(testSet, base + ".gridScaling") )
820 {
821 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
822 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
823 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
824 "SparseGridGPU stencil-insert " + linMode + " " + dim + "D" +
825 " grid scaling performance");
826 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
827 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
828 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
829 base + ".gridScaling(#).GFlops.mean");
830 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
831 base + ".gridScaling(#).gridSize.x");
832 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
833 int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
834 base + ".gridScaling(0).blockSize"));
835 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
836 "blockEdge=" + std::to_string(bes));
837 ++plotCounter;
838 }
839 if( isTestInSet(testSet, base + ".blockScaling") )
840 {
841 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
842 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
843 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
844 "SparseGridGPU stencil-insert "+linMode+" "+dim+"D"+" block scaling performance");
845 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
846 "BlockEdgeSize");
847 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
848 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
849 base + ".blockScaling(#).GFlops.mean");
850 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
851 base + ".blockScaling(#).blockSize");
852 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
853 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
854 base + ".blockScaling(0).gridSize.x"));
855 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
856 "gridEdge=" + std::to_string(ges));
857 ++plotCounter;
858 }
859}
860
861void plotDense2DStencilInsertComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
862 unsigned int &plotCounter)
863{// Dense 2D
864 std::string dim = "2";
865 std::string linMode = "N";
866 std::string base = "performance.SparseGridGpu.device.stencilInsert.dense." + linMode + "." + dim + "D";
867
868 if( isTestInSet(testSet, base + ".8.gridScaling")
869 && isTestInSet(testSet, base + ".16.gridScaling")
870 )
871 {
872 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
873 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
874 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
875 "SparseGridGPU stencil-insert " + linMode + " " + dim + "D" +
876 " grid scaling performance");
877 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
878 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
879
880 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
881 base + ".8.gridScaling(#).GFlops.mean");
882 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
883 base + ".16.gridScaling(#).GFlops.mean");
884
885 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
886 base + ".8.gridScaling(#).gridSize.x");
887 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
888 base + ".16.gridScaling(#).gridSize.x");
889
890 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
891
892 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "blockEdge=8");
893 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "blockEdge=16");
894
895 ++plotCounter;
896 }
897}
898
899void plotDense2DStencilInplaceInsertComparison(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
900 unsigned int &plotCounter)
901{// Dense 2D
902 std::string dim = "2";
903 std::string linMode = "N";
904 std::string baseInplace = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
905 std::string baseInsert = "performance.SparseGridGpu.device.stencilInsert.dense." + linMode + "." + dim + "D";
906
907 if( isTestInSet(testSet, baseInplace + ".8.gridScaling")
908 && isTestInSet(testSet, baseInsert + ".8.gridScaling")
909 )
910 {
911 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
912 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
913 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
914 "SparseGridGPU stencil in-place vs. insert " + linMode + " " + dim + "D" +
915 " - blockEdge=8");
916 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
917 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
918
919 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
920 baseInplace + ".8.gridScaling(#).GFlops.mean");
921 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
922 baseInsert + ".8.gridScaling(#).GFlops.mean");
923
924 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
925 baseInplace + ".8.gridScaling(#).gridSize.x");
926 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
927 baseInsert + ".8.gridScaling(#).gridSize.x");
928
929 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
930
931 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "In-place");
932 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "Insert");
933
934 ++plotCounter;
935 }
936}
937
938void plotDense2DStencilInplaceInsertComparison16(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
939 unsigned int &plotCounter)
940{// Dense 2D
941 std::string dim = "2";
942 std::string linMode = "N";
943 std::string baseInplace = "performance.SparseGridGpu.device.stencil.dense." + linMode + "." + dim + "D";
944 std::string baseInsert = "performance.SparseGridGpu.device.stencilInsert.dense." + linMode + "." + dim + "D";
945
946 if( isTestInSet(testSet, baseInplace + ".16.gridScaling")
947 && isTestInSet(testSet, baseInsert + ".16.gridScaling")
948 )
949 {
950 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
951 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
952 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
953 "SparseGridGPU stencil in-place vs. insert " + linMode + " " + dim + "D" +
954 " - blockEdge=16");
955 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
956 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G flops/s");
957
958 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
959 baseInplace + ".16.gridScaling(#).GFlops.mean");
960 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
961 baseInsert + ".16.gridScaling(#).GFlops.mean");
962
963 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
964 baseInplace + ".16.gridScaling(#).gridSize.x");
965 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
966 baseInsert + ".16.gridScaling(#).gridSize.x");
967
968 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
969
970 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title", "In-place");
971 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title", "Insert");
972
973 ++plotCounter;
974 }
975}
976
977void plotInsertSingle2D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
978 unsigned int &plotCounter)
979{
980 std::string dim = "2";
981 std::string insertMode = "single";
982 std::string base = "performance.SparseGridGpu.device.insert.dense." + insertMode + "." + dim + "D";
983
984 if( isTestInSet(testSet, base + ".2.gridScaling")
985 && isTestInSet(testSet, base + ".4.gridScaling")
986 && isTestInSet(testSet, base + ".8.gridScaling")
987 )
988 {
989 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
990 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
991 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
992 "SparseGridGPU insert " + insertMode + " " + dim + "D" +
993 " grid scaling performance");
994 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
995 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "M Inserts/s");
996 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
997 base + ".2.gridScaling(#).Minsert.mean");
998 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
999 base + ".4.gridScaling(#).Minsert.mean");
1000 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
1001 base + ".8.gridScaling(#).Minsert.mean");
1002 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1003 base + ".2.gridScaling(#).gridSize.x");
1004 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
1005 base + ".4.gridScaling(#).gridSize.x");
1006 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
1007 base + ".8.gridScaling(#).gridSize.x");
1008 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
1009// int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1010// base + ".gridScaling(0).blockSize"));
1011 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1012 "blockEdge=2");
1013 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
1014 "blockEdge=4");
1015 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
1016 "blockEdge=8");
1017 ++plotCounter;
1018 }
1019 if( isTestInSet(testSet, base + ".blockScaling") )
1020 {
1021 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1022 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1023 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1024 "SparseGridGPU insert "+insertMode+" "+dim+"D"+" block scaling performance");
1025 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
1026 "BlockEdgeSize");
1027 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "M Inserts/s");
1028 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1029 base + ".blockScaling(#).Minsert.mean");
1030 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1031 base + ".blockScaling(#).blockSize");
1032 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
1033 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1034 base + ".blockScaling(0).gridSize.x"));
1035 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1036 "gridEdge=" + std::to_string(ges));
1037 ++plotCounter;
1038 }
1039}
1040
1041void plotInsertBlock2D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
1042 unsigned int &plotCounter)
1043{
1044 std::string dim = "2";
1045 std::string insertMode = "block";
1046 std::string base = "performance.SparseGridGpu.device.insert.dense." + insertMode + "." + dim + "D";
1047
1048 if( isTestInSet(testSet, base + ".2.gridScaling")
1049 && isTestInSet(testSet, base + ".4.gridScaling")
1050 && isTestInSet(testSet, base + ".8.gridScaling")
1051 && isTestInSet(testSet, base + ".16.gridScaling")
1052 && isTestInSet(testSet, base + ".32.gridScaling")
1053 )
1054 {
1055 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1056 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1057 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1058 "SparseGridGPU insert " + insertMode + " " + dim + "D" +
1059 " grid scaling performance");
1060 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
1061 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "M Inserts/s");
1062 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1063 base + ".2.gridScaling(#).Minsert.mean");
1064 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
1065 base + ".4.gridScaling(#).Minsert.mean");
1066 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
1067 base + ".8.gridScaling(#).Minsert.mean");
1068 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
1069 base + ".16.gridScaling(#).Minsert.mean");
1070 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
1071 base + ".32.gridScaling(#).Minsert.mean");
1072 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1073 base + ".2.gridScaling(#).gridSize.x");
1074 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
1075 base + ".4.gridScaling(#).gridSize.x");
1076 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
1077 base + ".8.gridScaling(#).gridSize.x");
1078 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
1079 base + ".16.gridScaling(#).gridSize.x");
1080 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
1081 base + ".32.gridScaling(#).gridSize.x");
1082 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
1083// int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1084// base + ".gridScaling(0).blockSize"));
1085 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1086 "blockEdge=2");
1087 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
1088 "blockEdge=4");
1089 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
1090 "blockEdge=8");
1091 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title",
1092 "blockEdge=16");
1093 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title",
1094 "blockEdge=32");
1095 ++plotCounter;
1096 }
1097 if( isTestInSet(testSet, base + ".blockScaling") )
1098 {
1099 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1100 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1101 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1102 "SparseGridGPU insert "+insertMode+" "+dim+"D"+" block scaling performance");
1103 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
1104 "BlockEdgeSize");
1105 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "M Inserts/s");
1106 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1107 base + ".blockScaling(#).Minsert.mean");
1108 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1109 base + ".blockScaling(#).blockSize");
1110 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
1111 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1112 base + ".blockScaling(0).gridSize.x"));
1113 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1114 "gridEdge=" + std::to_string(ges));
1115 ++plotCounter;
1116 }
1117}
1118
1119void plotGetSingle2D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
1120 unsigned int &plotCounter)
1121{
1122 std::string dim = "2";
1123 std::string getMode = "single";
1124 std::string base = "performance.SparseGridGpu.device.get.dense." + getMode + "." + dim + "D";
1125
1126 if( isTestInSet(testSet, base + ".2.gridScaling")
1127 && isTestInSet(testSet, base + ".4.gridScaling")
1128 && isTestInSet(testSet, base + ".8.gridScaling")
1129 && isTestInSet(testSet, base + ".16.gridScaling")
1130 && isTestInSet(testSet, base + ".32.gridScaling")
1131 )
1132 {
1133 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1134 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1135 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1136 "SparseGridGPU get " + getMode + " " + dim + "D" +
1137 " grid scaling performance");
1138 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
1139 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G Gets/s");
1140 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1141 base + ".2.gridScaling(#).Gget.mean");
1142 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
1143 base + ".4.gridScaling(#).Gget.mean");
1144 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
1145 base + ".8.gridScaling(#).Gget.mean");
1146 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
1147 base + ".16.gridScaling(#).Gget.mean");
1148 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
1149 base + ".32.gridScaling(#).Gget.mean");
1150 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1151 base + ".2.gridScaling(#).gridSize.x");
1152 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
1153 base + ".4.gridScaling(#).gridSize.x");
1154 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
1155 base + ".8.gridScaling(#).gridSize.x");
1156 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
1157 base + ".16.gridScaling(#).gridSize.x");
1158 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
1159 base + ".32.gridScaling(#).gridSize.x");
1160 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
1161// int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1162// base + ".gridScaling(0).blockSize"));
1163 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1164 "blockEdge=2");
1165 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
1166 "blockEdge=4");
1167 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
1168 "blockEdge=8");
1169 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title",
1170 "blockEdge=16");
1171 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title",
1172 "blockEdge=32");
1173 ++plotCounter;
1174 }
1175 if( isTestInSet(testSet, base + ".blockScaling") )
1176 {
1177 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1178 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1179 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1180 "SparseGridGPU get "+getMode+" "+dim+"D"+" block scaling performance");
1181 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
1182 "BlockEdgeSize");
1183 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G Gets/s");
1184 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1185 base + ".blockScaling(#).Gget.mean");
1186 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1187 base + ".blockScaling(#).blockSize");
1188 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
1189 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1190 base + ".blockScaling(0).gridSize.x"));
1191 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1192 "gridEdge=" + std::to_string(ges));
1193 ++plotCounter;
1194 }
1195}
1196
1197void plotGetNeighbourhood2D(report_sparse_grid_tests &report_sparsegrid_funcs, std::set<std::string> &testSet,
1198 unsigned int &plotCounter)
1199{
1200 std::string dim = "2";
1201 std::string getMode = "neighbourhood";
1202 std::string base = "performance.SparseGridGpu.device.get.dense." + getMode + "." + dim + "D";
1203
1204 if( isTestInSet(testSet, base + ".2.gridScaling")
1205 && isTestInSet(testSet, base + ".4.gridScaling")
1206 && isTestInSet(testSet, base + ".8.gridScaling")
1207 && isTestInSet(testSet, base + ".16.gridScaling")
1208 && isTestInSet(testSet, base + ".32.gridScaling")
1209 )
1210 {
1211 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1212 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1213 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1214 "SparseGridGPU get " + getMode + " " + dim + "D" +
1215 " grid scaling performance");
1216 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title", "GridEdgeSize");
1217 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G Gets/s");
1218 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1219 base + ".2.gridScaling(#).Gget.mean");
1220 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).source",
1221 base + ".4.gridScaling(#).Gget.mean");
1222 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).source",
1223 base + ".8.gridScaling(#).Gget.mean");
1224 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).source",
1225 base + ".16.gridScaling(#).Gget.mean");
1226 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).source",
1227 base + ".32.gridScaling(#).Gget.mean");
1228 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1229 base + ".2.gridScaling(#).gridSize.x");
1230 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(1).source",
1231 base + ".4.gridScaling(#).gridSize.x");
1232 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(2).source",
1233 base + ".8.gridScaling(#).gridSize.x");
1234 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(3).source",
1235 base + ".16.gridScaling(#).gridSize.x");
1236 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(4).source",
1237 base + ".32.gridScaling(#).gridSize.x");
1238 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x", true);
1239// int bes = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1240// base + ".gridScaling(0).blockSize"));
1241 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1242 "blockEdge=2");
1243 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(1).title",
1244 "blockEdge=4");
1245 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(2).title",
1246 "blockEdge=8");
1247 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(3).title",
1248 "blockEdge=16");
1249 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(4).title",
1250 "blockEdge=32");
1251 ++plotCounter;
1252 }
1253 if( isTestInSet(testSet, base + ".blockScaling") )
1254 {
1255 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").type", "line");
1256 report_sparsegrid_funcs.graphs.put("graphs.graph(" + std::to_string(plotCounter) + ").interpolation", "none");
1257 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").title",
1258 "SparseGridGPU get "+getMode+" "+dim+"D"+" block scaling performance");
1259 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.title",
1260 "BlockEdgeSize");
1261 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.title", "G Gets/s");
1262 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).source",
1263 base + ".blockScaling(#).Gget.mean");
1264 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").x.data(0).source",
1265 base + ".blockScaling(#).blockSize");
1266 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").options.log_x",true);
1267 int ges = static_cast<int>( report_sparsegrid_funcs.graphs.template get<double>(
1268 base + ".blockScaling(0).gridSize.x"));
1269 report_sparsegrid_funcs.graphs.add("graphs.graph(" + std::to_string(plotCounter) + ").y.data(0).title",
1270 "gridEdge=" + std::to_string(ges));
1271 ++plotCounter;
1272 }
1273}
1274
GoogleChart
Small class to produce graph with Google chart in HTML.
Definition GoogleChart.hpp:216
GoogleChart::write
void write(std::string file)
It write the graphs on file in html format using Google charts.
Definition GoogleChart.hpp:959
report_sparse_grid_tests
Definition performancePlots.hpp:19