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
112CHAM_context_t *chameleon_context_create()
113{
114 CHAM_context_t *chamctxt;
115
116 if ( chameleon_ctxt != NULL ) {
117 chameleon_error("chameleon_context_create", "a context is already existing\n");
118 return NULL;
119 }
120
121 chamctxt = (CHAM_context_t*)malloc(sizeof(CHAM_context_t));
122 if (chamctxt == NULL) {
123 chameleon_error("chameleon_context_create", "malloc() failed");
124 return NULL;
125 }
126
127 /* These initializations are just in case the user
128 disables autotuning and does not set nb and ib */
129 chamctxt->nb = chameleon_getenv_get_value_int( "CHAMELEON_TILE_SIZE", 384 );
130 chamctxt->ib = chameleon_getenv_get_value_int( "CHAMELEON_INNER_BLOCK_SIZE", 48 );
131 chamctxt->rhblock = chameleon_getenv_get_value_int( "CHAMELEON_HOUSEHOLDER_SIZE", 4 );
132 chamctxt->lookahead = chameleon_getenv_get_value_int( "CHAMELEON_LOOKAHEAD", 1 );
133
134 chamctxt->nworkers = 1;
135 chamctxt->ncudas = 0;
136 chamctxt->nthreads_per_worker = 1;
137
138 chamctxt->warnings_enabled = chameleon_env_on_off( "CHAMELEON_WARNINGS", CHAMELEON_TRUE );
139 chamctxt->autotuning_enabled = chameleon_env_on_off( "CHAMELEON_AUTOTUNING", CHAMELEON_FALSE );
140 chamctxt->parallel_enabled = chameleon_env_on_off( "CHAMELEON_PARALLEL_KERNEL", CHAMELEON_FALSE );
141 chamctxt->statistics_enabled = chameleon_env_on_off( "CHAMELEON_GENERATE_STATS", CHAMELEON_FALSE );
142 chamctxt->progress_enabled = chameleon_env_on_off( "CHAMELEON_PROGRESS", CHAMELEON_FALSE );
143 chamctxt->generic_enabled = chameleon_env_on_off( "CHAMELEON_GENERIC", CHAMELEON_FALSE );
144 chamctxt->autominmax_enabled = chameleon_env_on_off( "CHAMELEON_AUTOMINMAX", CHAMELEON_TRUE );
145 chamctxt->optlacpy_enabled = chameleon_env_on_off( "CHAMELEON_OPTIMIZED_LACPY", CHAMELEON_TRUE );
146
147 chamctxt->runtime_paused = CHAMELEON_FALSE;
148
149 chamctxt->householder = chameleon_getenv_householder( "CHAMELEON_HOUSEHOLDER_MODE", ChamFlatHouseholder );
150 chamctxt->translation = chameleon_getenv_translation( "CHAMELEON_TRANSLATION_MODE", ChamInPlace );
151
152 /* First and last step for main algorithms to get partial traces for example */
153 chamctxt->first_step = chameleon_getenv_get_value_int( "CHAMELEON_FIRST_STEP", 0 );
154 chamctxt->first_step = chameleon_max( chamctxt->first_step, 0 );
155 chamctxt->last_step = chameleon_getenv_get_value_int( "CHAMELEON_LAST_STEP", INT_MAX );
156 chamctxt->last_step = ( chamctxt->last_step >= 0 ) ? chamctxt->last_step : 0;
157
158 /* Initialize scheduler */
159 RUNTIME_context_create(chamctxt);
160
161 chameleon_ctxt = chamctxt;
162 return chamctxt;
163}
164
165
169CHAM_context_t *chameleon_context_self()
170{
171 return chameleon_ctxt;
172}
173
177int chameleon_context_destroy(){
178
179 RUNTIME_context_destroy(chameleon_ctxt);
180 free(chameleon_ctxt);
181 chameleon_ctxt = NULL;
182
183 return CHAMELEON_SUCCESS;
184}
185
209int CHAMELEON_Enable(int option)
210{
211 CHAM_context_t *chamctxt;
212
213 chamctxt = chameleon_context_self();
214 if (chamctxt == NULL) {
215 chameleon_error("CHAMELEON_Enable", "CHAMELEON not initialized");
216 return CHAMELEON_ERR_NOT_INITIALIZED;
217 }
218
219 switch (option)
220 {
221 case CHAMELEON_WARNINGS:
222 chamctxt->warnings_enabled = CHAMELEON_TRUE;
223 break;
224 case CHAMELEON_AUTOTUNING:
225 chamctxt->autotuning_enabled = CHAMELEON_TRUE;
226 break;
227 case CHAMELEON_GENERATE_TRACE:
228 RUNTIME_start_profiling();
229 break;
230 case CHAMELEON_GENERATE_STATS:
231 chamctxt->statistics_enabled = CHAMELEON_TRUE;
232 break;
233 case CHAMELEON_PROGRESS:
234 chamctxt->progress_enabled = CHAMELEON_TRUE;
235 break;
236 case CHAMELEON_GEMM3M:
237#if defined(CBLAS_HAS_ZGEMM3M) && !defined(CHAMELEON_SIMULATION)
238 set_coreblas_gemm3m_enabled(1);
239#else
240 chameleon_error("CHAMELEON_Enable", "cannot enable GEMM3M (not available in cblas)");
241#endif
242 break;
243 case CHAMELEON_PARALLEL_KERNEL:
244 chamctxt->parallel_enabled = CHAMELEON_TRUE;
245 break;
246 case CHAMELEON_GENERIC:
247 chamctxt->generic_enabled = CHAMELEON_TRUE;
248 break;
249 default:
250 chameleon_error("CHAMELEON_Enable", "illegal parameter value");
251 return CHAMELEON_ERR_ILLEGAL_VALUE;
252 case CHAMELEON_BOUND:
253 break;
254 }
255
256 /* Enable at the lower level if required */
257 RUNTIME_enable( chamctxt->schedopt, option );
258
259 return CHAMELEON_SUCCESS;
260}
261
285int CHAMELEON_Disable(int option)
286{
287 CHAM_context_t *chamctxt;
288
289 chamctxt = chameleon_context_self();
290 if (chamctxt == NULL) {
291 chameleon_error("CHAMELEON_Disable", "CHAMELEON not initialized");
292 return CHAMELEON_ERR_NOT_INITIALIZED;
293 }
294 switch ( option )
295 {
296 case CHAMELEON_WARNINGS:
297 chamctxt->warnings_enabled = CHAMELEON_FALSE;
298 break;
299 case CHAMELEON_AUTOTUNING:
300 chamctxt->autotuning_enabled = CHAMELEON_FALSE;
301 break;
302 case CHAMELEON_GENERATE_TRACE:
303 RUNTIME_stop_profiling();
304 break;
305 case CHAMELEON_GENERATE_STATS:
306 chamctxt->statistics_enabled = CHAMELEON_FALSE;
307 break;
308 case CHAMELEON_PROGRESS:
309 chamctxt->progress_enabled = CHAMELEON_FALSE;
310 break;
311 case CHAMELEON_GEMM3M:
312#if defined(CBLAS_HAS_ZGEMM3M) && !defined(CHAMELEON_SIMULATION)
313 set_coreblas_gemm3m_enabled(0);
314#endif
315 break;
316 case CHAMELEON_PARALLEL_KERNEL:
317 chamctxt->parallel_enabled = CHAMELEON_FALSE;
318 break;
319 case CHAMELEON_GENERIC:
320 chamctxt->generic_enabled = CHAMELEON_FALSE;
321 break;
322 default:
323 chameleon_error("CHAMELEON_Disable", "illegal parameter value");
324 return CHAMELEON_ERR_ILLEGAL_VALUE;
325 }
326
327 /* Disable at the lower level if required */
328 RUNTIME_disable( chamctxt->schedopt, option );
329
330 return CHAMELEON_SUCCESS;
331}
332
355int CHAMELEON_Set( int param, int value )
356{
357 CHAM_context_t *chamctxt;
358
359 chamctxt = chameleon_context_self();
360 if (chamctxt == NULL) {
361 chameleon_error("CHAMELEON_Set", "CHAMELEON not initialized");
362 return CHAMELEON_ERR_NOT_INITIALIZED;
363 }
364 switch (param) {
365 case CHAMELEON_TILE_SIZE:
366 if (value <= 0) {
367 chameleon_error("CHAMELEON_Set", "negative tile size");
368 return CHAMELEON_ERR_ILLEGAL_VALUE;
369 }
370 chamctxt->nb = value;
371 if ( chamctxt->autotuning_enabled ) {
372 chamctxt->autotuning_enabled = CHAMELEON_FALSE;
373 chameleon_warning("CHAMELEON_Set", "autotuning has been automatically disable\n");
374 }
375 /* Limit ib to nb */
376 chamctxt->ib = chameleon_min( chamctxt->nb, chamctxt->ib );
377 break;
378 case CHAMELEON_INNER_BLOCK_SIZE:
379 if (value <= 0) {
380 chameleon_error("CHAMELEON_Set", "negative inner block size");
381 return CHAMELEON_ERR_ILLEGAL_VALUE;
382 }
383 if (value > chamctxt->nb) {
384 chameleon_warning("CHAMELEON_Set", "inner block larger than tile");
385 }
386 chamctxt->ib = value;
387 /* Limit ib to nb */
388 chamctxt->ib = chameleon_min( chamctxt->nb, chamctxt->ib );
389
390 if ( chamctxt->autotuning_enabled ) {
391 chamctxt->autotuning_enabled = CHAMELEON_FALSE;
392 chameleon_warning("CHAMELEON_Set", "autotuning has been automatically disable\n");
393 }
394 break;
395 case CHAMELEON_HOUSEHOLDER_MODE:
396 if (value != ChamFlatHouseholder && value != ChamTreeHouseholder) {
397 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_HOUSEHOLDER_MODE");
398 return CHAMELEON_ERR_ILLEGAL_VALUE;
399 }
400 chamctxt->householder = value;
401 break;
402 case CHAMELEON_HOUSEHOLDER_SIZE:
403 if (value <= 0) {
404 chameleon_error("CHAMELEON_Set", "negative householder size");
405 return CHAMELEON_ERR_ILLEGAL_VALUE;
406 }
407 chamctxt->rhblock = value;
408 break;
409 case CHAMELEON_TRANSLATION_MODE:
410 if (value != ChamInPlace && value != ChamOutOfPlace) {
411 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_TRANSLATION_MODE");
412 return CHAMELEON_ERR_ILLEGAL_VALUE;
413 }
414 chamctxt->translation = value;
415 break;
416 case CHAMELEON_LOOKAHEAD:
417 if (value < 1) {
418 chameleon_error("CHAMELEON_Set", "illegal value of CHAMELEON_LOOKAHEAD");
419 return CHAMELEON_ERR_ILLEGAL_VALUE;
420 }
421 chamctxt->lookahead = value;
422 break;
423 default:
424 chameleon_error("CHAMELEON_Set", "unknown parameter");
425 return CHAMELEON_ERR_ILLEGAL_VALUE;
426 }
427
428 return CHAMELEON_SUCCESS;
429}
430
458int CHAMELEON_Get( int param, int *value )
459{
460 CHAM_context_t *chamctxt;
461
462 chamctxt = chameleon_context_self();
463 if (chamctxt == NULL) {
464 chameleon_error("CHAMELEON_Get", "CHAMELEON not initialized");
465 return CHAMELEON_ERR_NOT_INITIALIZED;
466 }
467 switch (param) {
468 case CHAMELEON_TILE_SIZE:
469 *value = chamctxt->nb;
470 return CHAMELEON_SUCCESS;
471 case CHAMELEON_INNER_BLOCK_SIZE:
472 *value = chamctxt->ib;
473 return CHAMELEON_SUCCESS;
474 case CHAMELEON_HOUSEHOLDER_MODE:
475 *value = chamctxt->householder;
476 return CHAMELEON_SUCCESS;
477 case CHAMELEON_HOUSEHOLDER_SIZE:
478 *value = chamctxt->rhblock;
479 return CHAMELEON_SUCCESS;
480 case CHAMELEON_TRANSLATION_MODE:
481 *value = chamctxt->translation;
482 return CHAMELEON_SUCCESS;
483 case CHAMELEON_LOOKAHEAD:
484 *value = chamctxt->lookahead;
485 return CHAMELEON_SUCCESS;
486 case CHAMELEON_RUNTIME:
487 *value = chamctxt->scheduler;
488 return CHAMELEON_SUCCESS;
489 default:
490 chameleon_error("CHAMELEON_Get", "unknown parameter");
491 return CHAMELEON_ERR_ILLEGAL_VALUE;
492 }
493
494 return CHAMELEON_SUCCESS;
495}
496
509CHAM_context_t *CHAMELEON_GetContext()
510{
511 CHAM_context_t *chamctxt;
512
513 chamctxt = chameleon_context_self();
514 if (chamctxt == NULL) {
515 chameleon_error("CHAMELEON_Get", "CHAMELEON not initialized");
516 return NULL;
517 }
518 return chamctxt;
519}
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:169
chameleon_context_create
CHAM_context_t * chameleon_context_create()
Definition context.c:112
chameleon_context_destroy
int chameleon_context_destroy()
Definition context.c:177
CHAMELEON_Set
int CHAMELEON_Set(int param, int value)
Definition context.c:355
CHAMELEON_Get
int CHAMELEON_Get(int param, int *value)
Definition context.c:458
CHAMELEON_Enable
int CHAMELEON_Enable(int option)
Definition context.c:209
CHAMELEON_Disable
int CHAMELEON_Disable(int option)
Definition context.c:285
CHAMELEON_GetContext
CHAM_context_t * CHAMELEON_GetContext()
Definition context.c:509