void _starpu_init_sched_policy(struct starpu_machine_config_s *config)
{
/* Perhaps we have to display some help */
display_sched_help_message();
/* Prefetch is activated by default */
use_prefetch = starpu_get_env_number("STARPU_PREFETCH");
if (use_prefetch == -1)
use_prefetch = 1;
/* By default, we don't calibrate */
unsigned do_calibrate = 0;
if (config->user_conf && (config->user_conf->calibrate != -1))
{
do_calibrate = config->user_conf->calibrate;
}
else {
int res = starpu_get_env_number("STARPU_CALIBRATE");
do_calibrate = (res < 0)?0:(unsigned)res;
}
_starpu_set_calibrate_flag(do_calibrate);
struct starpu_sched_policy_s *selected_policy;
selected_policy = select_sched_policy(config);
load_sched_policy(selected_policy);
policy.init_sched(&config->topology, &policy);
}
void _starpu_init_sched_policy(struct _starpu_machine_config *config, struct _starpu_sched_ctx *sched_ctx, struct starpu_sched_policy *selected_policy)
{
/* Perhaps we have to display some help */
display_sched_help_message();
/* Prefetch is activated by default */
use_prefetch = starpu_get_env_number("STARPU_PREFETCH");
if (use_prefetch == -1)
use_prefetch = 1;
/* Set calibrate flag */
_starpu_set_calibrate_flag(config->conf.calibrate);
load_sched_policy(selected_policy, sched_ctx);
_STARPU_TRACE_WORKER_SCHEDULING_PUSH;
sched_ctx->sched_policy->init_sched(sched_ctx->id);
_STARPU_TRACE_WORKER_SCHEDULING_POP;
}
/* We first try to grab the global lock in read mode to check whether the model
* was loaded or not (this is very likely to have been already loaded). If the
* model was not loaded yet, we take the lock in write mode, and if the model
* is still not loaded once we have the lock, we do load it. */
static void load_history_based_model(struct starpu_perfmodel_t *model, unsigned scan_history)
{
STARPU_ASSERT(model);
STARPU_ASSERT(model->symbol);
int already_loaded;
PTHREAD_RWLOCK_RDLOCK(®istered_models_rwlock);
already_loaded = model->is_loaded;
PTHREAD_RWLOCK_UNLOCK(®istered_models_rwlock);
if (already_loaded)
return;
/* The model is still not loaded so we grab the lock in write mode, and
* if it's not loaded once we have the lock, we do load it. */
PTHREAD_RWLOCK_WRLOCK(®istered_models_rwlock);
/* Was the model initialized since the previous test ? */
if (model->is_loaded)
{
PTHREAD_RWLOCK_UNLOCK(®istered_models_rwlock);
return;
}
PTHREAD_RWLOCK_INIT(&model->model_rwlock, NULL);
PTHREAD_RWLOCK_WRLOCK(&model->model_rwlock);
/* make sure the performance model directory exists (or create it) */
_starpu_create_sampling_directory_if_needed();
/*
* We need to keep track of all the model that were opened so that we can
* possibly update them at runtime termination ...
*/
_starpu_register_model(model);
char path[256];
get_model_path(model, path, 256);
_STARPU_DEBUG("Opening performance model file %s for model %s ... ", path, model->symbol);
unsigned calibrate_flag = _starpu_get_calibrate_flag();
model->benchmarking = calibrate_flag;
/* try to open an existing file and load it */
int res;
res = access(path, F_OK);
if (res == 0) {
if (calibrate_flag == 2)
{
/* The user specified that the performance model should
* be overwritten, so we don't load the existing file !
* */
_STARPU_DEBUG("Overwrite existing file\n");
initialize_model(model);
}
else {
/* We load the available file */
_STARPU_DEBUG("File exists\n");
FILE *f;
f = fopen(path, "r");
STARPU_ASSERT(f);
parse_model_file(f, model, scan_history);
fclose(f);
}
}
else {
_STARPU_DEBUG("File does not exists\n");
if (!calibrate_flag) {
_STARPU_DISP("Warning: model %s is not calibrated, forcing calibration for this run. Use the STARPU_CALIBRATE environment variable to control this.\n", model->symbol);
_starpu_set_calibrate_flag(1);
model->benchmarking = 1;
}
initialize_model(model);
}
model->is_loaded = 1;
PTHREAD_RWLOCK_UNLOCK(&model->model_rwlock);
PTHREAD_RWLOCK_UNLOCK(®istered_models_rwlock);
}
