CHAMELEON 1.4.0
Loading...
Searching...
No Matches
context.c
Go to the documentation of this file.
1
33#include "control/common.h"
34#include "control/auxiliary.h"
35#include "control/context.h"
36#include "chameleon/runtime.h"
37#include <stdlib.h>
38#include <limits.h>
39
40#if !defined(CHAMELEON_SIMULATION)
41#include "coreblas.h"
42#endif
43
47/* master threads context lookup table */
48static CHAM_context_t *chameleon_ctxt = NULL;
49
50static inline cham_householder_t
51chameleon_getenv_householder(char * string, cham_householder_t default_value) {
52 long int ret;
53 char *str = chameleon_getenv(string);
54 if (str == NULL) return default_value;
55
56 if ( sscanf( str, "%ld", &ret ) == 1 ) {
57 switch (ret) {
58 case ChamFlatHouseholder:
59 return ChamFlatHouseholder;
60 case ChamTreeHouseholder:
61 return ChamTreeHouseholder;
62 default:
63 chameleon_error( "chameleon_getenv_householder", "Incorrect householder value" );
64 return default_value;
65 }
66 }
67
68 if(0 == strcasecmp("chamflathouseholder", str)) { return ChamFlatHouseholder; }
69 if(0 == strcasecmp("flat", str)) { return ChamFlatHouseholder; }
70 if(0 == strcasecmp("chamtreehouseholder", str)) { return ChamTreeHouseholder; }
71 if(0 == strcasecmp("tree", str)) { return ChamTreeHouseholder; }
72
73 chameleon_error( "chameleon_getenv_householder", "Incorrect householder type" );
74
75 return default_value;
76}
77
78static inline cham_translation_t
79chameleon_getenv_translation(char * string, cham_translation_t default_value) {
80 long int ret;
81 char *str = chameleon_getenv(string);
82 if (str == NULL) return default_value;
83
84 if ( sscanf( str, "%ld", &ret ) == 1 ) {
85 switch (ret) {
86 case ChamInPlace:
87 return ChamInPlace;
88 case ChamOutOfPlace:
89 return ChamOutOfPlace;
90 default:
91 chameleon_error( "chameleon_getenv_translation", "Incorrect translation value" );
92 return default_value;
93 }
94 }
95
96 if(0 == strcasecmp("chaminplace", str)) { return ChamInPlace; }
97 if(0 == strcasecmp("inplace", str)) { return ChamInPlace; }
98 if(0 == strcasecmp("in", str)) { return ChamInPlace; }
99
100 if(0 == strcasecmp("chamoutofplace", str)) { return ChamOutOfPlace; }
101 if(0 == strcasecmp("outofplace", str)) { return ChamOutOfPlace; }
102 if(0 == strcasecmp("out", str)) { return ChamOutOfPlace; }
103
104 chameleon_error( "chameleon_getenv_translation", "Incorrect translation type" );
105
106 return default_value;
107}
108
109#if defined(CHAMELEON_ENABLE_DAG_COLORS)
110static inline cham_dag_color_t
111chameleon_getenv_dag_color_mode(char * string, cham_dag_color_t default_value) {
112 long int ret;
113 char *str = chameleon_getenv(string);
114 if (str == NULL) return default_value;
115
116 if ( sscanf( str, "%ld", &ret ) == 1 ) {
117 switch (ret) {
118 case ChamDagColorAlgorithm:
119 return ChamDagColorAlgorithm;
120 case ChamDagColorTask:
121 return ChamDagColorTask;
122 default:
123 chameleon_error( "chameleon_getenv_dag_color_mode", "Incorrect DAG color mode value" );
124 return default_value;
125 }
126 }
127
128 if(0 == strcasecmp("chamdagcoloralgorithm", str)) { return ChamDagColorAlgorithm; }
129 if(0 == strcasecmp("algorithm", str)) { return ChamDagColorAlgorithm; }
130 if(0 == strcasecmp("alg", str)) { return ChamDagColorAlgorithm; }
131
132 if(0 == strcasecmp("chamdagcolortask", str)) { return ChamDagColorTask; }
133 if(0 == strcasecmp("task", str)) { return ChamDagColorTask; }
134 if(0 == strcasecmp("tasks", str)) { return ChamDagColorTask; }
135
136 chameleon_error( "chameleon_getenv_dag_color_mode", "Incorrect DAG color mode type" );
137
138 return default_value;
139}
140#endif
141
145CHAM_context_t *chameleon_context_create()
146{
147 CHAM_context_t *chamctxt;
148
149 if ( chameleon_ctxt != NULL ) {
150 chameleon_error("chameleon_context_create", "a context is already existing\n");
151 return NULL;
152 }
153
154 chamctxt = (CHAM_context_t*)malloc(sizeof(CHAM_context_t));
155 if (chamctxt == NULL) {
156 chameleon_error("chameleon_context_create", "malloc() failed");
157 return NULL;
158 }
159
160 /* These initializations are just in case the user
161 disables autotuning and does not set nb and ib */
162 chamctxt->nb = chameleon_getenv_get_value_int( "CHAMELEON_TILE_SIZE", 384 );
163 chamctxt->ib = chameleon_getenv_get_value_int( "CHAMELEON_INNER_BLOCK_SIZE", 48 );
164 chamctxt->rhblock = chameleon_getenv_get_value_int( "CHAMELEON_HOUSEHOLDER_SIZE", 4 );
165 chamctxt->lookahead = chameleon_getenv_get_value_int( "CHAMELEON_LOOKAHEAD", 1 );
166
167 chamctxt->nworkers = 1;
168 chamctxt->ncudas = 0;
169 chamctxt->nthreads_per_worker = 1;
170
171 chamctxt->warnings_enabled = chameleon_env_on_off( "CHAMELEON_WARNINGS", CHAMELEON_TRUE );
172 chamctxt->autotuning_enabled = chameleon_env_on_off( "CHAMELEON_AUTOTUNING", CHAMELEON_FALSE );
173 chamctxt->parallel_enabled = chameleon_env_on_off( "CHAMELEON_PARALLEL_KERNEL", CHAMELEON_FALSE );
174 chamctxt->statistics_enabled = chameleon_env_on_off( "CHAMELEON_GENERATE_STATS", CHAMELEON_FALSE );
175 chamctxt->progress_enabled = chameleon_env_on_off( "CHAMELEON_PROGRESS", CHAMELEON_FALSE );
176 chamctxt->generic_enabled = chameleon_env_on_off( "CHAMELEON_GENERIC", CHAMELEON_FALSE );
177 chamctxt->autominmax_enabled = chameleon_env_on_off( "CHAMELEON_AUTOMINMAX", CHAMELEON_TRUE );
178 chamctxt->optlacpy_enabled = chameleon_env_on_off( "CHAMELEON_OPTIMIZED_LACPY", CHAMELEON_TRUE );
179
180 chamctxt->runtime_paused = CHAMELEON_FALSE;
181
182 chamctxt->householder = chameleon_getenv_householder( "CHAMELEON_HOUSEHOLDER_MODE", ChamFlatHouseholder );
183 chamctxt->translation = chameleon_getenv_translation( "CHAMELEON_TRANSLATION_MODE", ChamInPlace );
184#if defined(CHAMELEON_ENABLE_DAG_COLORS)
185 chamctxt->dag_color_mode = chameleon_getenv_dag_color_mode( "CHAMELEON_DAG_COLOR_MODE", ChamDagColorAlgorithm );
186#endif
187
188 /* First and last step for main algorithms to get partial traces for example */
189 chamctxt->first_step = chameleon_getenv_get_value_int( "CHAMELEON_FIRST_STEP", 0 );
190 chamctxt->first_step = chameleon_max( chamctxt->first_step, 0 );
191 chamctxt->last_step = chameleon_getenv_get_value_int( "CHAMELEON_LAST_STEP", INT_MAX );
192 chamctxt->last_step = ( chamctxt->last_step >= 0 ) ? chamctxt->last_step : 0;
193
194 /* Initialize scheduler */
195 RUNTIME_context_create(chamctxt);
196
197 chameleon_ctxt = chamctxt;
198 return chamctxt;
199}
200
201
205CHAM_context_t *chameleon_context_self()
206{
207 return chameleon_ctxt;
208}
209
213int chameleon_context_destroy(){
214
215 RUNTIME_context_destroy(chameleon_ctxt);
216 free(chameleon_ctxt);
217 chameleon_ctxt = NULL;
218
219 return CHAMELEON_SUCCESS;
220}
221
245int CHAMELEON_Enable(int option)
246{
247 CHAM_context_t *chamctxt;
248
249 chamctxt = chameleon_context_self();
250 if (chamctxt == NULL) {
251 chameleon_error("CHAMELEON_Enable", "CHAMELEON not initialized");
252 return CHAMELEON_ERR_NOT_INITIALIZED;
253 }
254
255 switch (option)
256 {
257 case CHAMELEON_WARNINGS:
258 chamctxt->warnings_enabled = CHAMELEON_TRUE;
259 break;
260 case CHAMELEON_AUTOTUNING:
261 chamctxt->autotuning_enabled = CHAMELEON_TRUE;
262 break;
263 case CHAMELEON_GENERATE_TRACE:
264 RUNTIME_start_profiling();
265 break;
266 case CHAMELEON_GENERATE_STATS:
267 chamctxt->statistics_enabled = CHAMELEON_TRUE;
268 break;
269 case CHAMELEON_PROGRESS:
270 chamctxt->progress_enabled = CHAMELEON_TRUE;
271 break;
272 case CHAMELEON_GEMM3M:
273#if defined(CBLAS_HAS_ZGEMM3M) && !defined(CHAMELEON_SIMULATION)
274 set_coreblas_gemm3m_enabled(1);
275#else
276 chameleon_error("CHAMELEON_Enable", "cannot enable GEMM3M (not available in cblas)");
277#endif
278 break;
279 case CHAMELEON_PARALLEL_KERNEL:
280 chamctxt->parallel_enabled = CHAMELEON_TRUE;
281 break;
282 case CHAMELEON_GENERIC:
283 chamctxt->generic_enabled = CHAMELEON_TRUE;
284 break;
285 default:
286 chameleon_error("CHAMELEON_Enable", "illegal parameter value");
287 return CHAMELEON_ERR_ILLEGAL_VALUE;
288 case CHAMELEON_BOUND:
289 break;
290 }
291
292 /* Enable at the lower level if required */
293 RUNTIME_enable( chamctxt->schedopt, option );
294
295 return CHAMELEON_SUCCESS;
296}
297
321int CHAMELEON_Disable(int option)
322{
323 CHAM_context_t *chamctxt;
324
325 chamctxt = chameleon_context_self();
326 if (chamctxt == NULL) {
327 chameleon_error("CHAMELEON_Disable", "CHAMELEON not initialized");
328 return CHAMELEON_ERR_NOT_INITIALIZED;
329 }
330 switch ( option )
331 {
332 case CHAMELEON_WARNINGS:
333 chamctxt->warnings_enabled = CHAMELEON_FALSE;
334 break;
335 case CHAMELEON_AUTOTUNING:
336 chamctxt->autotuning_enabled = CHAMELEON_FALSE;
337 break;
338 case CHAMELEON_GENERATE_TRACE:
339 RUNTIME_stop_profiling();
340 break;
341 case CHAMELEON_GENERATE_STATS:
342 chamctxt->statistics_enabled = CHAMELEON_FALSE;
343 break;
344 case CHAMELEON_PROGRESS:
345 chamctxt->progress_enabled = CHAMELEON_FALSE;
346 break;
347 case CHAMELEON_GEMM3M:
348#if defined(CBLAS_HAS_ZGEMM3M) && !defined(CHAMELEON_SIMULATION)
349 set_coreblas_gemm3m_enabled(0);
350#endif
351 break;
352 case CHAMELEON_PARALLEL_KERNEL:
353 chamctxt->parallel_enabled = CHAMELEON_FALSE;
354 break;
355 case CHAMELEON_GENERIC:
356 chamctxt->generic_enabled = CHAMELEON_FALSE;
357 break;
358 default:
359 chameleon_error("CHAMELEON_Disable", "illegal parameter value");
360 return CHAMELEON_ERR_ILLEGAL_VALUE;
361 }
362
363 /* Disable at the lower level if required */
364 RUNTIME_disable( chamctxt->schedopt, option );
365
366 return CHAMELEON_SUCCESS;
367}
368
392int CHAMELEON_Set( int param, int value )
393{
394 CHAM_context_t *chamctxt;
395
396 chamctxt = chameleon_context_self();
397 if (chamctxt == NULL) {
398 chameleon_error("CHAMELEON_Set", "CHAMELEON not initialized");
399 return CHAMELEON_ERR_NOT_INITIALIZED;
400 }
401 switch (param) {
402 case CHAMELEON_TILE_SIZE:
403 if (value <= 0) {
404 chameleon_error("CHAMELEON_Set", "negative tile size");
405 return CHAMELEON_ERR_ILLEGAL_VALUE;
406 }
407 chamctxt->nb = value;
408 if ( chamctxt->autotuning_enabled ) {
409 chamctxt->autotuning_enabled = CHAMELEON_FALSE;
410 chameleon_warning("CHAMELEON_Set", "autotuning has been automatically disable\n");
411 }
412 /* Limit ib to nb */
413 chamctxt->ib = chameleon_min( chamctxt->nb, chamctxt->ib );
414 break;
415 case CHAMELEON_INNER_BLOCK_SIZE:
416 if (value <= 0) {
417 chameleon_error("CHAMELEON_Set", "negative inner block size");
418 return CHAMELEON_ERR_ILLEGAL_VALUE;
419 }
420 if (value > chamctxt->nb) {
421 chameleon_warning("CHAMELEON_Set", "inner block larger than tile");
422 }
423 chamctxt->ib = value;
424 /* Limit ib to nb */
425 chamctxt->ib = chameleon_min( chamctxt->nb, chamctxt->ib );
426
427 if ( chamctxt->autotuning_enabled ) {
428 chamctxt->autotuning_enabled = CHAMELEON_FALSE;
429 chameleon_warning("CHAMELEON_Set", "autotuning has been automatically disable\n");
430 }
431 break;
432 case CHAMELEON_HOUSEHOLDER_MODE:
433 if (value != ChamFlatHouseholder && value != ChamTreeHouseholder) {
434 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_HOUSEHOLDER_MODE");
435 return CHAMELEON_ERR_ILLEGAL_VALUE;
436 }
437 chamctxt->householder = value;
438 break;
439 case CHAMELEON_HOUSEHOLDER_SIZE:
440 if (value <= 0) {
441 chameleon_error("CHAMELEON_Set", "negative householder size");
442 return CHAMELEON_ERR_ILLEGAL_VALUE;
443 }
444 chamctxt->rhblock = value;
445 break;
446 case CHAMELEON_TRANSLATION_MODE:
447 if (value != ChamInPlace && value != ChamOutOfPlace) {
448 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_TRANSLATION_MODE");
449 return CHAMELEON_ERR_ILLEGAL_VALUE;
450 }
451 chamctxt->translation = value;
452 break;
453 case CHAMELEON_LOOKAHEAD:
454 if (value < 1) {
455 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_LOOKAHEAD");
456 return CHAMELEON_ERR_ILLEGAL_VALUE;
457 }
458 chamctxt->lookahead = value;
459 break;
460#if defined(CHAMELEON_ENABLE_DAG_COLORS)
461 case CHAMELEON_DAG_COLOR_MODE:
462 if ( ( value != ChamDagColorAlgorithm ) &&
463 ( value != ChamDagColorTask ) )
464 {
465 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_DAG_COLOR_MODE");
466 return CHAMELEON_ERR_ILLEGAL_VALUE;
467 }
468 chamctxt->dag_color_mode = value;
469 break;
470#endif
471 default:
472 chameleon_error("CHAMELEON_Set", "unknown parameter");
473 return CHAMELEON_ERR_ILLEGAL_VALUE;
474 }
475
476 return CHAMELEON_SUCCESS;
477}
478
507int CHAMELEON_Get( int param, int *value )
508{
509 CHAM_context_t *chamctxt;
510
511 chamctxt = chameleon_context_self();
512 if (chamctxt == NULL) {
513 chameleon_error("CHAMELEON_Get", "CHAMELEON not initialized");
514 return CHAMELEON_ERR_NOT_INITIALIZED;
515 }
516 switch (param) {
517 case CHAMELEON_TILE_SIZE:
518 *value = chamctxt->nb;
519 return CHAMELEON_SUCCESS;
520 case CHAMELEON_INNER_BLOCK_SIZE:
521 *value = chamctxt->ib;
522 return CHAMELEON_SUCCESS;
523 case CHAMELEON_HOUSEHOLDER_MODE:
524 *value = chamctxt->householder;
525 return CHAMELEON_SUCCESS;
526 case CHAMELEON_HOUSEHOLDER_SIZE:
527 *value = chamctxt->rhblock;
528 return CHAMELEON_SUCCESS;
529 case CHAMELEON_TRANSLATION_MODE:
530 *value = chamctxt->translation;
531 return CHAMELEON_SUCCESS;
532 case CHAMELEON_LOOKAHEAD:
533 *value = chamctxt->lookahead;
534 return CHAMELEON_SUCCESS;
535 case CHAMELEON_RUNTIME:
536 *value = chamctxt->scheduler;
537 return CHAMELEON_SUCCESS;
538#if defined(CHAMELEON_ENABLE_DAG_COLORS)
539 case CHAMELEON_DAG_COLOR_MODE:
540 *value = chamctxt->dag_color_mode;
541 return CHAMELEON_SUCCESS;
542#endif
543 default:
544 chameleon_error("CHAMELEON_Get", "unknown parameter");
545 return CHAMELEON_ERR_ILLEGAL_VALUE;
546 }
547
548 return CHAMELEON_SUCCESS;
549}
550
563CHAM_context_t *CHAMELEON_GetContext()
564{
565 CHAM_context_t *chamctxt;
566
567 chamctxt = chameleon_context_self();
568 if (chamctxt == NULL) {
569 chameleon_error("CHAMELEON_Get", "CHAMELEON not initialized");
570 return NULL;
571 }
572 return chamctxt;
573}
chameleon_error
void chameleon_error(const char *func_name, const char *msg_text)
Definition auxiliary.c:101
chameleon_warning
void chameleon_warning(const char *func_name, const char *msg_text)
Definition auxiliary.c:74
chameleon_ctxt
static CHAM_context_t * chameleon_ctxt
Definition context.c:48
chameleon_context_self
CHAM_context_t * chameleon_context_self()
Definition context.c:205
chameleon_context_create
CHAM_context_t * chameleon_context_create()
Definition context.c:145
chameleon_context_destroy
int chameleon_context_destroy()
Definition context.c:213
CHAMELEON_Set
int CHAMELEON_Set(int param, int value)
Definition context.c:392
CHAMELEON_Get
int CHAMELEON_Get(int param, int *value)
Definition context.c:507
CHAMELEON_Enable
int CHAMELEON_Enable(int option)
Definition context.c:245
CHAMELEON_Disable
int CHAMELEON_Disable(int option)
Definition context.c:321
CHAMELEON_GetContext
CHAM_context_t * CHAMELEON_GetContext()
Definition context.c:563