MAGMA  1.2.0
MatrixAlgebraonGPUandMulticoreArchitectures
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
auto_tune.cpp
Go to the documentation of this file.
1 /*
2  -- MAGMA (version 1.2.0) --
3  Univ. of Tennessee, Knoxville
4  Univ. of California, Berkeley
5  Univ. of Colorado, Denver
6  May 2012
7 */
8 
9 #include <stdio.h>
10 #include <string.h>
11 
12 #include "magma.h"
13 
14 extern "C" void
15 auto_tune (char algorithm, char precision, magma_int_t ncores, magma_int_t ncorespsocket,
16  magma_int_t m, magma_int_t n, magma_int_t *nb, magma_int_t *ob, magma_int_t *ib,
17  magma_int_t *nthreads, magma_int_t *nquarkthreads)
18 {
19 /* -- MAGMA (version 1.2.0) --
20  Univ. of Tennessee, Knoxville
21  Univ. of California, Berkeley
22  Univ. of Colorado, Denver
23  May 2012
24 
25  Purpose
26  =======
27  This function initializes tunable parameters to be used for
28  subsequent calls to hybrid routines in the MAGMA library.
29 
30  The idea is to use the matrix size together with the number of cores
31  and the number of cores per socket to do a table lookup for tunable
32  parameter values based on existing research results.
33 
34  Arguments
35  =========
36  algorithm (input) CHAR
37  'q' QR
38  'l' LU
39  'c' Choleskey
40 
41  precision (input) CHAR
42  's' Single
43  'd' Double
44  'c' Complex single
45  'z' Complex double
46 
47  ncores (input) INTEGER
48  Number of cores
49 
50  ncorespsocket (intput) INTEGER
51  Number of cores per socket
52 
53  m (input) INTEGER
54  Number of rows
55 
56  n (intput) INTEGER
57  Number of columns
58 
59  nb (output) INTEGER
60  Block size
61 
62  ob (output) INTEGER
63  Outer block size
64 
65  ib (output) INTEGER
66  Inner block size
67 
68  nthreads (output) INTEGER
69  Number of MAMGMA threads
70 
71  nquarkthreads (output) INTEGER
72  Number of QUARK threads
73 
74  ===================================================================== */
75 
76  /* if QR */
77  if (algorithm == 'q') {
78 
79  /* The best inner block size is always 12 */
80  *ib = 12;
81 
82  /* The best number of QUARK threads is the number of cores per socket, in general */
83  *nquarkthreads = ncorespsocket;
84 
85  /* 0 <= m <= 2080 */
86  if ((m > 0) && (m <= 2080)) {
87 
88  *nb = 64;
89  *ob = 64;
90 
91  *nthreads = 2;
92 
93  }
94 
95  /* 2080 < m <= 3360 */
96  if ((m > 2080) && (m <= 3360)) {
97 
98  *nb = 128;
99  *ob = 128;
100 
101  *nthreads = 6;
102  if ((*nthreads + *nquarkthreads) > ncores)
103  *nthreads = ncores - *nquarkthreads;
104 
105  }
106 
107  /* 3360 < m <= 4640 */
108  if ((m > 3360) && (m <= 4640)) {
109 
110  *nb = 128;
111  *ob = 128;
112 
113  *nthreads = 14;
114  if ((*nthreads + *nquarkthreads) > ncores)
115  *nthreads = ncores - *nquarkthreads;
116 
117  }
118 
119  /* 4640 < m <= 5920 */
120  if ((m > 4640) && (m <= 5920)) {
121 
122  *nb = 128;
123  *ob = 160;
124 
125  *nthreads = 18;
126  if ((*nthreads + *nquarkthreads) > ncores)
127  *nthreads = ncores - *nquarkthreads;
128 
129  /* ncores = 12; ncorespsocket = 6 */
130  if ((ncores == 12) && (ncorespsocket == 6)) {
131 
132  *ob = 128;
133 
134  *nquarkthreads = 4;
135  *nthreads = 8;
136 
137  }
138 
139  }
140 
141  /* 5920 < m <= 7200 */
142  if ((m > 5920) && (m <= 7200)) {
143 
144  *nb = 128;
145  *ob = 160;
146 
147  *nthreads = 22;
148  if ((*nthreads + *nquarkthreads) > ncores)
149  *nthreads = ncores - *nquarkthreads;
150 
151  /* ncores = 12; ncorespsocket = 6 */
152  if ((ncores == 12) && (ncorespsocket == 6)) {
153 
154  *ob = 128;
155 
156  *nquarkthreads = 4;
157  *nthreads = 8;
158 
159  }
160 
161  }
162 
163  /* 7200 < m <= 8480 */
164  if ((m > 7200) && (m <= 8480)) {
165 
166  *nb = 128;
167  *ob = 160;
168 
169  *nthreads = 26;
170  if ((*nthreads + *nquarkthreads) > ncores)
171  *nthreads = ncores - *nquarkthreads;
172 
173  /* ncores = 12; ncorespsocket = 6 */
174  if ((ncores == 12) && (ncorespsocket == 6)) {
175 
176  *ob = 128;
177 
178  *nquarkthreads = 3;
179  *nthreads = 9;
180 
181  }
182 
183  }
184 
185  /* 8480 < m <= 9760 */
186  if ((m > 8480) && (m <= 9760)) {
187 
188  *nb = 128;
189  *ob = 160;
190 
191  *nthreads = 30;
192  if ((*nthreads + *nquarkthreads) > ncores)
193  *nthreads = ncores - *nquarkthreads;
194 
195  /* ncores = 12; ncorespsocket = 6 */
196  if ((ncores == 12) && (ncorespsocket == 6)) {
197 
198  *ob = 128;
199 
200  *nquarkthreads = 3;
201  *nthreads = 9;
202 
203  if (precision == 's'){
204 
205  *nb = 192;
206  *ob = 192;
207 
208  }
209 
210  }
211 
212  }
213 
214  /* 9760 < m <= 11040 */
215  if ((m > 9760) && (m <= 11040)) {
216 
217  *nb = 128;
218  *ob = 160;
219 
220  *nthreads = 34;
221  if ((*nthreads + *nquarkthreads) > ncores)
222  *nthreads = ncores - *nquarkthreads;
223 
224  /* ncores = 12; ncorespsocket = 6 */
225  if ((ncores == 12) && (ncorespsocket == 6)) {
226 
227  *ob = 128;
228 
229  *nquarkthreads = 2;
230  *nthreads = 10;
231 
232  if (precision == 's'){
233 
234  *nb = 192;
235  *ob = 192;
236 
237  }
238 
239  }
240 
241  }
242 
243  /* 11040 < m <= 12320 */
244  if ((m > 11040) && (m <= 12320)) {
245 
246  *nb = 128;
247  *ob = 160;
248 
249  *nthreads = 36;
250  if ((*nthreads + *nquarkthreads) > ncores)
251  *nthreads = ncores - *nquarkthreads;
252 
253  /* ncores = 12; ncorespsocket = 6 */
254  if ((ncores == 12) && (ncorespsocket == 6)) {
255 
256  *ob = 224;
257 
258  if (precision == 'c'){
259 
260  *ob = 128;
261 
262  }
263 
264  *nquarkthreads = 2;
265  *nthreads = 10;
266 
267  if (precision == 's'){
268 
269  *nb = 192;
270  *ob = 192;
271 
272  }
273 
274  }
275 
276  }
277 
278  /* 12320 < m <= 13600 */
279  if ((m > 12320) && (m <= 13600)) {
280 
281  *nb = 128;
282  *ob = 160;
283 
284  *nthreads = 42;
285  if ((*nthreads + *nquarkthreads) > ncores)
286  *nthreads = ncores - *nquarkthreads;
287 
288  if (precision == 'z'){
289 
290  *ob = 192;
291 
292  }
293 
294  /* ncores = 12; ncorespsocket = 6 */
295  if ((ncores == 12) && (ncorespsocket == 6)) {
296 
297  *ob = 224;
298 
299  if (precision == 'c'){
300 
301  *ob = 128;
302 
303  }
304 
305  *nquarkthreads = 2;
306  *nthreads = 10;
307 
308  if (precision == 's'){
309 
310  *nb = 192;
311  *ob = 224;
312 
313  }
314 
315  }
316 
317  }
318 
319  /* 13600 < m <= 15220 */
320  if ((m > 13600) && (m <= 15220)) {
321 
322  *nb = 128;
323  *ob = 192;
324 
325  *nthreads = 42;
326  if ((*nthreads + *nquarkthreads) > ncores)
327  *nthreads = ncores - *nquarkthreads;
328 
329  if (precision == 'd'){
330 
331  *ob = 160;
332 
333  }
334 
335  /* ncores = 12; ncorespsocket = 6 */
336  if ((ncores == 12) && (ncorespsocket == 6)) {
337 
338  *ob = 224;
339 
340  if (precision == 'c'){
341 
342  *ob = 160;
343 
344  }
345 
346  *nquarkthreads = 2;
347  *nthreads = 10;
348 
349  if (precision == 's'){
350 
351  *nb = 192;
352  *ob = 224;
353 
354  }
355 
356  }
357 
358  }
359 
360  /* 15220 < m <= 16800 */
361  if ((m > 15220) && (m <= 16800)) {
362 
363  *nb = 128;
364  *ob = 192;
365 
366  *nthreads = 42;
367  if ((*nthreads + *nquarkthreads) > ncores)
368  *nthreads = ncores - *nquarkthreads;
369 
370  if (precision == 'd'){
371 
372  *nb = 160;
373  *ob = 200;
374 
375  }
376 
377  if (precision == 'c'){
378 
379  *ob = 160;
380 
381  }
382 
383  /* ncores = 12; ncorespsocket = 6 */
384  if ((ncores == 12) && (ncorespsocket == 6)) {
385 
386  *ob = 224;
387 
388  if (precision == 'c'){
389 
390  *ob = 192;
391 
392  }
393 
394  *nquarkthreads = 2;
395  *nthreads = 10;
396 
397  if (precision == 's'){
398 
399  *nb = 192;
400  *ob = 224;
401 
402  }
403 
404  }
405 
406  }
407 
408  /* 16800 < m */
409  if (m > 16800) {
410 
411  *nb = 128;
412  *ob = 224;
413 
414  *nthreads = 42;
415  if ((*nthreads + *nquarkthreads) > ncores)
416  *nthreads = ncores - *nquarkthreads;
417 
418  if (precision == 'd'){
419 
420  *nb = 160;
421  *ob = 200;
422 
423  }
424 
425  if (precision == 'c'){
426 
427  *ob = 192;
428 
429  }
430 
431  /* ncores = 12; ncorespsocket = 6 */
432  if ((ncores == 12) && (ncorespsocket == 6)) {
433 
434  *ob = 256;
435 
436  if (precision == 'c'){
437 
438  *ob = 192;
439 
440  }
441 
442  *nquarkthreads = 2;
443  *nthreads = 10;
444 
445  if (precision == 's'){
446 
447  *nb = 192;
448  *ob = 224;
449 
450  }
451 
452  }
453 
454  }
455 
456  }
457 
458 }
459