merge fixes

configure.ac

@@ -1893,9 +1893,9 @@ AC_MSG_NOTICE([
 	       FFT Support:                                 $fft_support
 	       GCC plug-in:                                 $build_gcc_plugin
 	       GCC plug-in test suite (requires GNU Guile): $run_gcc_plugin_test_suite
-	       SOCL enabled:  $build_socl
-               Scheduler Hypervisor: $build_sched_ctx_hypervisor
-               SOCL test suite: $run_socl_check
+	       SOCL enabled:                                $build_socl
+               SOCL test suite:                             $run_socl_check
+               Scheduler Hypervisor:                        $build_sched_ctx_hypervisor
                simgrid enabled:                             $enable_simgrid
                ayudame enabled:                             $ac_cv_header_Ayudame_h
 ])

examples/sched_ctx/sched_ctx.c

@@ -21,6 +21,7 @@
 #define NTASKS 1000
 int tasks_executed = 0;
 pthread_mutex_t mut;
+
 static void sched_ctx_func(void *descr[] __attribute__ ((unused)), void *arg __attribute__ ((unused)))
 {
 	pthread_mutex_lock(&mut);
@@ -33,7 +34,7 @@ static struct starpu_codelet sched_ctx_codelet =
 	.where = STARPU_CPU|STARPU_CUDA|STARPU_OPENCL,
 	.cpu_funcs = {sched_ctx_func, NULL},
 	.cuda_funcs = {sched_ctx_func, NULL},
-    .opencl_funcs = {sched_ctx_func, NULL},
+	.opencl_funcs = {sched_ctx_func, NULL},
 	.model = NULL,
 	.nbuffers = 0
 };
@@ -43,7 +44,6 @@ int main(int argc, char **argv)
 {
 	int ntasks = NTASKS;
 	int ret;
-	struct starpu_conf conf;
 
 	ret = starpu_init(NULL);
 	if (ret == -ENODEV)
@@ -57,25 +57,25 @@ int main(int argc, char **argv)
 	pthread_mutex_init(&mut, NULL);
 	int nprocs1 = 1;
 	int nprocs2 = 1;
-    int procs1[20], procs2[20];
+	int procs1[20], procs2[20];
 	procs1[0] = 0;
 	procs2[0] = 0;
 
 #ifdef STARPU_USE_CPU
 	unsigned ncpus =  starpu_cpu_worker_get_count();
-    starpu_worker_get_ids_by_type(STARPU_CPU_WORKER, procs1, ncpus);
+	starpu_worker_get_ids_by_type(STARPU_CPU_WORKER, procs1, ncpus);
 
 	nprocs1 = ncpus;
 #endif
 
 #ifdef STARPU_USE_CUDA
 	unsigned ncuda = starpu_cuda_worker_get_count();
-    starpu_worker_get_ids_by_type(STARPU_CUDA_WORKER, procs2, ncuda);
+	starpu_worker_get_ids_by_type(STARPU_CUDA_WORKER, procs2, ncuda);
 
 	nprocs2 = ncuda;
 #endif
 
-    /*create contexts however you want*/
+	/*create contexts however you want*/
 	unsigned sched_ctx1 = starpu_create_sched_ctx("heft", procs1, nprocs1, "ctx1");
 	unsigned sched_ctx2 = starpu_create_sched_ctx("heft", procs2, nprocs2, "ctx2");
 
@@ -86,13 +86,13 @@ int main(int argc, char **argv)
 	for (i = 0; i < ntasks/2; i++)
 	{
 		struct starpu_task *task = starpu_task_create();
-	
+
 		task->cl = &sched_ctx_codelet;
 		task->cl_arg = NULL;
-	
+
 		/*submit tasks to context*/
 		ret = starpu_task_submit_to_ctx(task,sched_ctx1);
-			
+
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
 	}
 
@@ -104,10 +104,10 @@ int main(int argc, char **argv)
 	for (i = 0; i < ntasks/2; i++)
 	{
 		struct starpu_task *task = starpu_task_create();
-	
+
 		task->cl = &sched_ctx_codelet;
 		task->cl_arg = NULL;
-	
+
 		ret = starpu_task_submit_to_ctx(task,sched_ctx2);
 
 		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");

include/starpu.h

@@ -165,7 +165,7 @@ int starpu_conf_init(struct starpu_conf *conf);
 /* Initialization method: it must be called prior to any other StarPU call
  * Default configuration is used if NULL is passed as argument.
  */
-int starpu_init(struct starpu_conf *conf);// STARPU_WARN_UNUSED_RESULT;
+int starpu_init(struct starpu_conf *conf) STARPU_WARN_UNUSED_RESULT;
 
 /* Shutdown method: note that statistics are only generated once StarPU is
  * shutdown */

include/starpu_scheduler.h

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2010, 2011  Université de Bordeaux 1
+ * Copyright (C) 2010-2012  Université de Bordeaux 1
  * Copyright (C) 2011  Télécom-SudParis
  *
  * StarPU is free software; you can redistribute it and/or modify

include/starpu_task.h

@@ -314,7 +314,7 @@ struct starpu_task *starpu_task_create(void);
  * structure (default behaviour). Calling this function on a statically
  * allocated task results in an undefined behaviour. */
 void starpu_task_destroy(struct starpu_task *task);
-int starpu_task_submit(struct starpu_task *task);// STARPU_WARN_UNUSED_RESULT;
+int starpu_task_submit(struct starpu_task *task) STARPU_WARN_UNUSED_RESULT;
 int starpu_task_submit_to_ctx(struct starpu_task *task, unsigned sched_ctx_id);
 
 /* This function blocks until the task was executed. It is not possible to
@@ -322,7 +322,7 @@ int starpu_task_submit_to_ctx(struct starpu_task *task, unsigned sched_ctx_id);
  * synchronous or detached tasks.
  * Upon successful completion, this function returns 0. Otherwise, -EINVAL
  * indicates that the waited task was either synchronous or detached. */
-int starpu_task_wait(struct starpu_task *task);// STARPU_WARN_UNUSED_RESULT;
+int starpu_task_wait(struct starpu_task *task) STARPU_WARN_UNUSED_RESULT;
 
 /* This function waits until all the tasks that were already submitted have
  * been executed. */

src/core/jobs.c

@@ -412,15 +412,15 @@ int _starpu_push_local_task(struct _starpu_worker *worker, struct starpu_task *t
 	if (STARPU_UNLIKELY(!(worker->worker_mask & task->cl->where)))
 		return -ENODEV;
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(worker->sched_mutex);
 
 	if (back)
 		starpu_task_list_push_back(&worker->local_tasks, task);
 	else
 		starpu_task_list_push_front(&worker->local_tasks, task);
 
-	_STARPU_PTHREAD_COND_BROADCAST(&worker->sched_cond);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	_STARPU_PTHREAD_COND_BROADCAST(worker->sched_cond);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(worker->sched_mutex);
 
 	return 0;
 }

src/core/sched_ctx.c

@@ -761,8 +761,8 @@ void starpu_worker_get_sched_condition(unsigned sched_ctx_id, int workerid, _sta
 	if(!*sched_mutex)
 	{
 		struct _starpu_worker *workerarg = _starpu_get_worker_struct(workerid);
-		*sched_mutex = &workerarg->sched_mutex;
-		*sched_cond = &workerarg->sched_cond;
+		*sched_mutex = workerarg->sched_mutex;
+		*sched_cond = workerarg->sched_cond;
 		starpu_worker_set_sched_condition(sched_ctx_id, workerid, *sched_mutex, *sched_cond);
 	}
 

src/core/sched_policy.c

@@ -225,7 +225,7 @@ static int _starpu_push_task_on_specific_worker(struct starpu_task *task, int wo
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
 	starpu_call_pushed_task_cb(workerid, task->sched_ctx);
 #endif //STARPU_USE_SCHED_CTX_HYPERVISOR
-	
+
 	if (is_basic_worker)
 	{
 		unsigned node = starpu_worker_get_memory_node(workerid);
@@ -292,14 +292,14 @@ static int _starpu_nworkers_able_to_execute_task(struct starpu_task *task, struc
 	struct worker_collection *workers = sched_ctx->workers;
 	if(workers->init_cursor)
 		workers->init_cursor(workers);
-	
+
 	while(workers->has_next(workers))
 	{
 		worker = workers->get_next(workers);
 		if (starpu_worker_can_execute_task(worker, task, 0) && starpu_is_ctxs_turn(worker, sched_ctx->id))
 			nworkers++;
 	}
-	
+
 	if(workers->init_cursor)
 		workers->deinit_cursor(workers);
 	return nworkers;
@@ -311,14 +311,14 @@ int _starpu_push_task(struct _starpu_job *j)
 {
 	struct starpu_task *task = j->task;
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(task->sched_ctx);
-	unsigned nworkers = 0; 
+	unsigned nworkers = 0;
 
 	if(!sched_ctx->is_initial_sched)
 	{
-		/*if there are workers in the ctx that are not able to execute tasks 
+		/*if there are workers in the ctx that are not able to execute tasks
 		  we consider the ctx empty */
 		nworkers = _starpu_nworkers_able_to_execute_task(task, sched_ctx);
-		
+
 		if(nworkers == 0)
 		{
 			if(task->already_pushed)
@@ -338,7 +338,7 @@ int _starpu_push_task(struct _starpu_job *j)
 			}
 		}
 	}
-	
+
 	_STARPU_LOG_IN();
 
 	_starpu_increment_nready_tasks();
@@ -377,9 +377,9 @@ int _starpu_push_task(struct _starpu_job *j)
 			ret = _starpu_push_task(j);
 		}
 	}
-	
+
 	_starpu_profiling_set_task_push_end_time(task);
-	
+
 	_STARPU_LOG_OUT();
 	return ret;
 }
@@ -472,16 +472,16 @@ struct _starpu_sched_ctx* _get_next_sched_ctx_to_pop_into(struct _starpu_worker
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
 	{
 		sched_ctx = worker->sched_ctx[i];
-		
-		if(sched_ctx != NULL && sched_ctx->id != STARPU_NMAX_SCHED_CTXS && 
-		   sched_ctx->pop_counter[worker->workerid] < worker->nsched_ctxs && 
+
+		if(sched_ctx != NULL && sched_ctx->id != STARPU_NMAX_SCHED_CTXS &&
+		   sched_ctx->pop_counter[worker->workerid] < worker->nsched_ctxs &&
 		   smallest_counter > sched_ctx->pop_counter[worker->workerid])
 		{
 			good_sched_ctx = sched_ctx;
 			smallest_counter = sched_ctx->pop_counter[worker->workerid];
 		}
 	}
-	
+
 	if(good_sched_ctx == NULL)
 	{
 		for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -490,7 +490,7 @@ struct _starpu_sched_ctx* _get_next_sched_ctx_to_pop_into(struct _starpu_worker
 			if(sched_ctx != NULL && sched_ctx->id != STARPU_NMAX_SCHED_CTXS)
 				sched_ctx->pop_counter[worker->workerid] = 0;
 		}
-		
+
 		return _get_next_sched_ctx_to_pop_into(worker);
 	}
 	return good_sched_ctx;
@@ -510,18 +510,18 @@ struct starpu_task *_starpu_pop_task(struct _starpu_worker *worker)
 		_starpu_clock_gettime(&pop_start_time);
 
 pick:
-	_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(worker->sched_mutex);
 	/* perhaps there is some local task to be executed first */
 	task = _starpu_pop_local_task(worker);
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
-	
-	
+	_STARPU_PTHREAD_MUTEX_UNLOCK(worker->sched_mutex);
+
+
 	/* get tasks from the stacks of the strategy */
 	if(!task)
 	{
 		struct _starpu_sched_ctx *sched_ctx;
 		_starpu_pthread_mutex_t *sched_ctx_mutex;
-		
+
 		int been_here[STARPU_NMAX_SCHED_CTXS];
 		int i;
 		for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
@@ -539,7 +539,7 @@ pick:
 				if(sched_ctx_mutex != NULL)
 				{
 					_STARPU_PTHREAD_MUTEX_LOCK(sched_ctx_mutex);
-					
+
 					if (sched_ctx->sched_policy && sched_ctx->sched_policy->pop_task)
 						task = sched_ctx->sched_policy->pop_task(sched_ctx->id);
 
@@ -551,9 +551,9 @@ pick:
 			if((!task && sched_ctx->pop_counter[worker->workerid] == 0 && been_here[sched_ctx->id]) || worker->nsched_ctxs == 1)
 				break;
 
-			
+
 			been_here[sched_ctx->id] = 1;
-			
+
 			sched_ctx->pop_counter[worker->workerid]++;
 
 		}
@@ -585,7 +585,7 @@ pick:
 	if (!task)
 		goto profiling;
 
-	/* Make sure we do not bother with all the multiformat-specific code if 
+	/* Make sure we do not bother with all the multiformat-specific code if
 	 * it is not necessary. */
 	if (!_starpu_task_uses_multiformat_handles(task))
 		goto profiling;
@@ -603,7 +603,7 @@ pick:
 	node = starpu_worker_get_memory_node(worker_id);
 
 	/*
-	 * We do have a task that uses multiformat handles. Let's create the 
+	 * We do have a task that uses multiformat handles. Let's create the
 	 * required conversion tasks.
 	 */
 	unsigned i;
@@ -672,7 +672,7 @@ void _starpu_sched_post_exec_hook(struct starpu_task *task)
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(task->sched_ctx);
 
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
-	if(task->hypervisor_tag > 0 && sched_ctx != NULL && 
+	if(task->hypervisor_tag > 0 && sched_ctx != NULL &&
 	   sched_ctx->id != 0 && sched_ctx->perf_counters != NULL)
 		sched_ctx->perf_counters->notify_post_exec_hook(sched_ctx->id, task->hypervisor_tag);
 #endif //STARPU_USE_SCHED_CTX_HYPERVISOR
@@ -685,7 +685,7 @@ void _starpu_wait_on_sched_event(void)
 {
 	struct _starpu_worker *worker = _starpu_get_local_worker_key();
 
-	_STARPU_PTHREAD_MUTEX_LOCK(&worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(worker->sched_mutex);
 
 	_starpu_handle_all_pending_node_data_requests(worker->memory_node);
 
@@ -697,7 +697,7 @@ void _starpu_wait_on_sched_event(void)
 #endif
 	}
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&worker->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_UNLOCK(worker->sched_mutex);
 }
 
 /* The scheduling policy may put tasks directly into a worker's local queue so
@@ -710,9 +710,8 @@ int starpu_push_local_task(int workerid, struct starpu_task *task, int back)
 	struct _starpu_worker *worker = _starpu_get_worker_struct(workerid);
 
 	int ret =  _starpu_push_local_task(worker, task, back);
-	
+
 	task->scheduled = 1;
 
 	return ret;
 }
-

src/core/workers.c

@@ -247,8 +247,8 @@ static struct _starpu_worker_set gordon_worker_set;
 
 static void _starpu_init_worker_queue(struct _starpu_worker *workerarg)
 {
-	_starpu_pthread_cond_t *cond = &workerarg->sched_cond;
-	_starpu_pthread_mutex_t *mutex = &workerarg->sched_mutex;
+	_starpu_pthread_cond_t *cond = workerarg->sched_cond;
+	_starpu_pthread_mutex_t *mutex = workerarg->sched_mutex;
 
 	unsigned memory_node = workerarg->memory_node;
 
@@ -375,8 +375,8 @@ static void _starpu_launch_drivers(struct _starpu_machine_config *config)
 		/* afterwards there would be a mutex + cond for the list of each strategy */
 		workerarg->run_by_starpu = 1;
 
-		_STARPU_PTHREAD_MUTEX_INIT(&workerarg->sched_mutex, NULL);
-		_STARPU_PTHREAD_COND_INIT(&workerarg->sched_cond, NULL);
+		_STARPU_PTHREAD_MUTEX_INIT(workerarg->sched_mutex, NULL);
+		_STARPU_PTHREAD_COND_INIT(workerarg->sched_cond, NULL);
 
 		/* if some codelet's termination cannot be handled directly :
 		 * for instance in the Gordon driver, Gordon tasks' callbacks
@@ -786,14 +786,11 @@ int starpu_init(struct starpu_conf *user_conf)
 	 * threads */
 	_starpu_initialize_current_task_key();
 
-
-	struct _starpu_sched_ctx *sched_ctx;
 	if(user_conf == NULL)
-		sched_ctx = _starpu_create_sched_ctx(NULL, NULL, -1, 1, "init");
+		_starpu_create_sched_ctx(NULL, NULL, -1, 1, "init");
 	else
-		sched_ctx = _starpu_create_sched_ctx(user_conf->sched_policy_name, NULL, -1, 1, "init");
+		_starpu_create_sched_ctx(user_conf->sched_policy_name, NULL, -1, 1, "init");
 
-//	starpu_set_sched_ctx(&sched_ctx->id);
 	_starpu_initialize_registered_performance_models();
 
 	/* Launch "basic" workers (ie. non-combined workers) */
@@ -930,9 +927,9 @@ void starpu_display_stats()
 	if ((stats = getenv("STARPU_WORKER_STATS")) && atoi(stats))
 		starpu_worker_profiling_helper_display_summary();
 }
+
 void starpu_shutdown(void)
 {
-	const char *stats;
 	_STARPU_PTHREAD_MUTEX_LOCK(&init_mutex);
 	init_count--;
 	if (init_count)

src/core/workers.h

@@ -70,8 +70,8 @@ struct _starpu_worker
 	int worker_size; /* size of the worker in case we use a combined worker */
         _starpu_pthread_cond_t ready_cond; /* indicate when the worker is ready */
 	unsigned memory_node; /* which memory node is the worker associated with ? */
-	_starpu_pthread_cond_t sched_cond; /* condition variable used when the worker waits for tasks. */
-	_starpu_pthread_mutex_t sched_mutex; /* mutex protecting sched_cond */
+	_starpu_pthread_cond_t *sched_cond; /* condition variable used when the worker waits for tasks. */
+	_starpu_pthread_mutex_t *sched_mutex; /* mutex protecting sched_cond */
 	struct starpu_task_list local_tasks; /* this queue contains tasks that have been explicitely submitted to that queue */
 	struct starpu_task *current_task; /* task currently executed by this worker */
 	struct _starpu_worker_set *set; /* in case this worker belongs to a set */

src/datawizard/filters.c

@@ -20,6 +20,7 @@
 #include <datawizard/filters.h>
 #include <datawizard/footprint.h>
 #include <datawizard/interfaces/data_interface.h>
+#include <core/task.h>
 
 static void starpu_data_create_children(starpu_data_handle_t handle, unsigned nchildren, struct starpu_data_filter *f);
 

src/datawizard/filters.h

@@ -24,7 +24,7 @@
 
 #include <starpu.h>
 #include <common/config.h>
-#include <core/task.h>
+
 void
 _starpu_filter_nparts_compute_chunk_size_and_offset(unsigned n, unsigned nparts,
 					     size_t elemsize, unsigned id,

src/drivers/driver_common/driver_common.c

@@ -167,7 +167,7 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *args, int wor
 		 * from popping a task from the scheduler to blocking. Otherwise the
 		 * driver may go block just after the scheduler got a new task to be
 		 * executed, and thus hanging. */
-		_STARPU_PTHREAD_MUTEX_LOCK(&args->sched_mutex);
+		_STARPU_PTHREAD_MUTEX_LOCK(args->sched_mutex);
 
 		if (_starpu_worker_get_status(workerid) != STATUS_SLEEPING)
 		{
@@ -177,9 +177,9 @@ struct starpu_task *_starpu_get_worker_task(struct _starpu_worker *args, int wor
 		}
 
 		if (_starpu_worker_can_block(memnode))
-			_STARPU_PTHREAD_COND_WAIT(&args->sched_cond, &args->sched_mutex);
+			_STARPU_PTHREAD_COND_WAIT(args->sched_cond, args->sched_mutex);
 
-		_STARPU_PTHREAD_MUTEX_UNLOCK(&args->sched_mutex);
+		_STARPU_PTHREAD_MUTEX_UNLOCK(args->sched_mutex);
 
 		return NULL;
 	}

src/sched_policies/deque_modeling_policy_data_aware.c

@@ -53,6 +53,11 @@ typedef struct {
 	long int ready_task_cnt;
 } dmda_data;
 
+static double alpha = _STARPU_DEFAULT_ALPHA;
+static double beta = _STARPU_DEFAULT_BETA;
+static double _gamma = _STARPU_DEFAULT_GAMMA;
+static double idle_power = 0.0;
+
 #ifdef STARPU_USE_TOP
 static const float alpha_minimum=0;
 static const float alpha_maximum=10.0;

src/sched_policies/random_policy.c

@@ -107,7 +107,7 @@ static void random_add_workers(unsigned sched_ctx_id, int *workerids, unsigned n
 	{
 		workerid = workerids[i];
 		struct _starpu_worker *workerarg = _starpu_get_worker_struct(workerid);
-		starpu_worker_set_sched_condition(sched_ctx_id, workerid, &workerarg->sched_mutex, &workerarg->sched_cond);
+		starpu_worker_set_sched_condition(sched_ctx_id, workerid, workerarg->sched_mutex, workerarg->sched_cond);
 	}
 }
 

src/top/starpu_top.c

@@ -105,6 +105,9 @@ static void starpu_top_get_device_type(int id, char* type)
 	case STARPU_GORDON_WORKER:
 		strncpy(type, "GORDON",9);
 		break;
+	case STARPU_ANY_WORKER:
+		strncpy(type, "ANY",9);
+		break;
 	}
 }
 

src/worker_collection/worker_list.c

@@ -33,7 +33,7 @@ static unsigned _worker_belongs_to_ctx(struct worker_collection *workers, int wo
 	int *workerids = (int *)workers->workerids;
 	unsigned nworkers = workers->nworkers;
 	
-	int i;
+	unsigned i;
 	for(i = 0; i < nworkers; i++)
 	{
 		if(workerids[i] == workerid)