src: use tabs instead of spaces and remove trailing whitespaces

src/common/barrier.c

@@ -35,14 +35,14 @@ int _starpu_barrier_test(struct _starpu_barrier *barrier)
 	 * Check whether any threads are known to be waiting; report
 	 * "BUSY" if so.
 	 */
-        _STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
-        if (barrier->reached_exit != barrier->count)
+	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
+	if (barrier->reached_exit != barrier->count)
 	{
-                _STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
-                return EBUSY;
-        }
-        _STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
-        return 0;
+		_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
+		return EBUSY;
+	}
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);
+	return 0;
 }
 
 int _starpu_barrier_destroy(struct _starpu_barrier *barrier)
@@ -64,7 +64,7 @@ int _starpu_barrier_wait(struct _starpu_barrier *barrier)
 {
 	int ret=0;
 
-        // Wait until all threads enter the barrier
+	// Wait until all threads enter the barrier
 	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 	barrier->reached_exit=0;
 	barrier->reached_start++;
@@ -76,11 +76,11 @@ int _starpu_barrier_wait(struct _starpu_barrier *barrier)
 	}
 	else
 	{
-                _STARPU_PTHREAD_COND_WAIT(&barrier->cond,&barrier->mutex);
+		_STARPU_PTHREAD_COND_WAIT(&barrier->cond,&barrier->mutex);
 	}
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
 
-        // Count number of threads that exit the barrier
+	// Count number of threads that exit the barrier
 	_STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex_exit);
 	barrier->reached_exit ++;
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex_exit);

src/common/fxt.c

@@ -76,9 +76,9 @@ static void _starpu_profile_set_tracefile(void *last, ...)
 	va_list vl;
 	char *user;
 
-        char *fxt_prefix = getenv("STARPU_FXT_PREFIX");
-        if (!fxt_prefix)
-			fxt_prefix = "/tmp/";
+	char *fxt_prefix = getenv("STARPU_FXT_PREFIX");
+	if (!fxt_prefix)
+	     fxt_prefix = "/tmp/";
 
 	va_start(vl, last);
 	vsprintf(_STARPU_PROF_FILE_USER, fxt_prefix, vl);
@@ -96,9 +96,9 @@ static void _starpu_profile_set_tracefile(void *last, ...)
 
 void starpu_set_profiling_id(int new_id)
 {
-        _STARPU_DEBUG("Set id to <%d>\n", new_id);
+	_STARPU_DEBUG("Set id to <%d>\n", new_id);
 	_starpu_id = new_id;
-        _starpu_profile_set_tracefile(NULL);
+	_starpu_profile_set_tracefile(NULL);
 }
 
 void _starpu_start_fxt_profiling(void)

src/common/list.h

@@ -28,10 +28,10 @@
  *      + pour les listes : FOO_list
  *      + pour les itérateurs : FOO
  *  - déclare les accesseurs suivants :
- *     * création d'une cellule 
- *   FOO_t      FOO_new(void);  
+ *     * création d'une cellule
+ *   FOO_t      FOO_new(void);
  *     * suppression d'une cellule
- *   void       FOO_delete(FOO_t); 
+ *   void       FOO_delete(FOO_t);
  *     * création d'une liste (vide)
  *   FOO_list_t FOO_list_new(void);
  *     * suppression d'une liste
@@ -171,5 +171,3 @@
     { if ((i->_next == NULL) && i != l->_tail) return 0; \
       if (i->_next == i) return 0; \
       i=i->_next;} return 1; }
-
-

src/common/timing.c

@@ -105,14 +105,14 @@ void _starpu_clock_gettime(struct timespec *ts)
 #if defined(__i386__) || defined(__pentium__) || defined(__pentiumpro__) || defined(__i586__) || defined(__i686__) || defined(__k6__) || defined(__k7__) || defined(__x86_64__)
 union starpu_u_tick
 {
-  uint64_t tick;
-
-  struct
-  {
-    uint32_t low;
-    uint32_t high;
-  }
-  sub;
+	uint64_t tick;
+
+	struct
+	{
+		uint32_t low;
+		uint32_t high;
+	}
+		sub;
 };
 
 #define STARPU_GET_TICK(t) __asm__ volatile("rdtsc" : "=a" ((t).sub.low), "=d" ((t).sub.high))
@@ -127,36 +127,36 @@ static int _starpu_inited = 0;
 
 void _starpu_timing_init(void)
 {
-  static union starpu_u_tick t1, t2;
-  int i;
-
-  if (_starpu_inited) return;
+	static union starpu_u_tick t1, t2;
+	int i;
 
-  _starpu_residual = (unsigned long long)1 << 63;
+	if (_starpu_inited) return;
 
-  for(i = 0; i < 20; i++)
-    {
-      STARPU_GET_TICK(t1);
-      STARPU_GET_TICK(t2);
-      _starpu_residual = STARPU_MIN(_starpu_residual, STARPU_TICK_RAW_DIFF(t1, t2));
-    }
+	_starpu_residual = (unsigned long long)1 << 63;
 
-  {
-    struct timeval tv1,tv2;
+	for(i = 0; i < 20; i++)
+	{
+		STARPU_GET_TICK(t1);
+		STARPU_GET_TICK(t2);
+		_starpu_residual = STARPU_MIN(_starpu_residual, STARPU_TICK_RAW_DIFF(t1, t2));
+	}
 
-    STARPU_GET_TICK(t1);
-    gettimeofday(&tv1,0);
-    usleep(500000);
-    STARPU_GET_TICK(t2);
-    gettimeofday(&tv2,0);
-    _starpu_scale = ((tv2.tv_sec*1e6 + tv2.tv_usec) -
-		     (tv1.tv_sec*1e6 + tv1.tv_usec)) /
-      (double)(STARPU_TICK_DIFF(t1, t2));
-  }
+	{
+		struct timeval tv1,tv2;
+
+		STARPU_GET_TICK(t1);
+		gettimeofday(&tv1,0);
+		usleep(500000);
+		STARPU_GET_TICK(t2);
+		gettimeofday(&tv2,0);
+		_starpu_scale = ((tv2.tv_sec*1e6 + tv2.tv_usec) -
+				 (tv1.tv_sec*1e6 + tv1.tv_usec)) /
+			(double)(STARPU_TICK_DIFF(t1, t2));
+	}
 
-  STARPU_GET_TICK(_starpu_reference_start_tick);
+	STARPU_GET_TICK(_starpu_reference_start_tick);
 
-  _starpu_inited = 1;
+	_starpu_inited = 1;
 }
 
 void _starpu_clock_gettime(struct timespec *ts)

src/core/perfmodel/perfmodel_bus.c

@@ -110,7 +110,7 @@ static void measure_bandwidth_between_host_and_dev_on_cpu_with_cuda(int dev, int
 
 	/* hack to avoid third party libs to rebind threads */
 	_starpu_bind_thread_on_cpu(config, cpu);
-	
+
 	/* hack to force the initialization */
 	cudaFree(0);
 

src/core/sched_ctx.c

@@ -44,10 +44,10 @@ static void change_worker_sched_ctx(unsigned sched_ctx_id)
 		struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 		/* add context to worker */
 		worker->sched_ctx[worker_sched_ctx_id] = sched_ctx;
-		worker->nsched_ctxs++;	
+		worker->nsched_ctxs++;
 		worker->active_ctx = sched_ctx_id;
 	}
-	else 
+	else
 	{
 		/* remove context from worker */
 		if(worker->sched_ctx[worker_sched_ctx_id]->sched_policy)
@@ -83,12 +83,12 @@ static void _starpu_update_workers(int *workerids, int nworkers, int sched_ctx_i
 		worker[i] = _starpu_get_worker_struct(workerids[i]);
 
 		/* if the current thread requires resize it's no need
-		   to send itsefl a message in order to change its 
+		   to send itsefl a message in order to change its
 		   sched_ctx info */
 		if(curr_worker && curr_worker == worker[i])
 			change_worker_sched_ctx(sched_ctx_id);
 		else
-		{			
+		{
 			worker[i]->tasks[sched_ctx_id] = starpu_task_create();
 			worker[i]->tasks[sched_ctx_id]->cl = &sched_ctx_info_cl;
 			worker[i]->tasks[sched_ctx_id]->cl_arg = (void*)(uintptr_t)sched_ctx_id;
@@ -104,7 +104,7 @@ static void _starpu_update_workers(int *workerids, int nworkers, int sched_ctx_i
 			_starpu_exclude_task_from_dag(worker[i]->tasks[sched_ctx_id]);
 
 			_starpu_task_submit_internally(worker[i]->tasks[sched_ctx_id]);
-		}		
+		}
 	}
 }
 
@@ -114,7 +114,7 @@ void starpu_stop_task_submission()
 	_starpu_task_submit_internally(&stop_submission_task);
 }
 
-static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx, int *workerids, int nworkers, 
+static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx, int *workerids, int nworkers,
 				       int *added_workers, int *n_added_workers)
 {
 	struct starpu_sched_ctx_worker_collection *workers = sched_ctx->workers;
@@ -133,12 +133,12 @@ static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx
 			int worker = workers->add(workers, (workerids == NULL ? i : workerids[i]));
 			if(worker >= 0)
 			{
-				added_workers[(*n_added_workers)++] = worker;		
+				added_workers[(*n_added_workers)++] = worker;
 			}
 		}
 		else
 		{
-			int worker = (workerids == NULL ? i : workerids[i]); 
+			int worker = (workerids == NULL ? i : workerids[i]);
 			workers->add(workers, worker);
 			workers_to_add[i] = worker;
 		}
@@ -147,15 +147,15 @@ static void _starpu_add_workers_to_sched_ctx(struct _starpu_sched_ctx *sched_ctx
 	if(added_workers)
 	{
 		if(*n_added_workers > 0)
-			sched_ctx->sched_policy->add_workers(sched_ctx->id, added_workers, *n_added_workers);	
+			sched_ctx->sched_policy->add_workers(sched_ctx->id, added_workers, *n_added_workers);
 	}
 	else
-		sched_ctx->sched_policy->add_workers(sched_ctx->id, workers_to_add, nworkers_to_add);		
+		sched_ctx->sched_policy->add_workers(sched_ctx->id, workers_to_add, nworkers_to_add);
 
 	return;
 }
 
-static void _starpu_remove_workers_from_sched_ctx(struct _starpu_sched_ctx *sched_ctx, int *workerids, 
+static void _starpu_remove_workers_from_sched_ctx(struct _starpu_sched_ctx *sched_ctx, int *workerids,
 						  int nworkers, int *removed_workers, int *n_removed_workers)
 {
 	struct starpu_sched_ctx_worker_collection *workers = sched_ctx->workers;
@@ -203,7 +203,7 @@ static void _starpu_remove_workers_from_sched_ctx(struct _starpu_sched_ctx *sche
 }
 
 
-struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int *workerids, 
+struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int *workerids,
 				  int nworkers_ctx, unsigned is_initial_sched,
 				  const char *sched_name)
 {
@@ -217,13 +217,13 @@ struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 	struct _starpu_sched_ctx *sched_ctx = &config->sched_ctxs[id];
 	sched_ctx->id = id;
 
-	config->topology.nsched_ctxs++;	
+	config->topology.nsched_ctxs++;
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx_manag);
 
 	int nworkers = config->topology.nworkers;
-	
+
 	STARPU_ASSERT(nworkers_ctx <= nworkers);
-  
+
 	_STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->changing_ctx_mutex, NULL);
 	_STARPU_PTHREAD_MUTEX_INIT(&sched_ctx->empty_ctx_mutex, NULL);
 
@@ -241,7 +241,7 @@ struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 	sched_ctx->sched_mutex = (_starpu_pthread_mutex_t**)malloc(STARPU_NMAXWORKERS * sizeof(_starpu_pthread_mutex_t*));
 	sched_ctx->sched_cond = (_starpu_pthread_cond_t**)malloc(STARPU_NMAXWORKERS * sizeof(_starpu_pthread_cond_t*));
 
-	
+
 	/*init the strategy structs and the worker_collection of the ressources of the context */
 	_starpu_init_sched_policy(config, sched_ctx, policy_name);
 
@@ -271,17 +271,17 @@ struct _starpu_sched_ctx*  _starpu_create_sched_ctx(const char *policy_name, int
 	{
 		sched_ctx->pop_counter[w] = 0;
 	}
-	
+
 	return sched_ctx;
 }
 
 static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_archtype arch, unsigned allow_overlap)
 {
 	int pus[max];
-	int npus = 0; 
+	int npus = 0;
 	int i;
 	int n = 0;
-		
+
 	struct _starpu_machine_config *config = (struct _starpu_machine_config *)_starpu_get_machine_config();
 	if(config->topology.nsched_ctxs == 1)
 	{
@@ -295,10 +295,10 @@ static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_ar
 	{
 		unsigned enough_ressources = 0;
 		npus = starpu_worker_get_nids_ctx_free_by_type(arch, pus, max);
-       
+
 		for(i = 0; i < npus; i++)
 			workers[(*nw)++] = pus[i];
-		
+
 		if(npus == max)
 			/*we have enough available resources */
 			enough_ressources = 1;
@@ -337,13 +337,13 @@ static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_ar
 			if(npus >= min)
 				enough_ressources = 1;
 		}
-		
+
 		if(!enough_ressources)
 		{
-			/* if there is no available workers to satisfy the  minimum required 
+			/* if there is no available workers to satisfy the  minimum required
 			 give them workers proportional to their requirements*/
 			int global_npus = starpu_worker_get_count_by_type(arch);
-			
+
 			int req_npus = 0;
 
 			int s;
@@ -352,7 +352,7 @@ static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_ar
 					req_npus += arch == STARPU_CPU_WORKER ? config->sched_ctxs[s].min_ncpus : config->sched_ctxs[s].min_ngpus;
 
 			req_npus += min;
-			
+
 			for(s = 1; s < STARPU_NMAX_SCHED_CTXS; s++)
 			{
 				if(config->sched_ctxs[s].id != STARPU_NMAX_SCHED_CTXS)
@@ -362,8 +362,8 @@ static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_ar
 
 					int _npus = 0;
 					int _pus[STARPU_NMAXWORKERS];
-				
-					_npus = starpu_get_workers_of_sched_ctx(config->sched_ctxs[s].id, _pus, arch);					
+
+					_npus = starpu_get_workers_of_sched_ctx(config->sched_ctxs[s].id, _pus, arch);
 					if(needed_npus < (double)_npus)
 					{
 						double npus_to_rem = (double)_npus - needed_npus;
@@ -374,7 +374,7 @@ static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_ar
 
 						int pus_to_remove[npus_to_remove];
 						int c = 0;
-						
+
 /*TODO: hierarchical ctxs: get npus_to_remove good workers: close to the other ones I already assigned to the ctx */
 						for(i = _npus-1; i >= (_npus - npus_to_remove); i--)
 						{
@@ -391,7 +391,7 @@ static void _get_workers(int min, int max, int *workers, int *nw, enum starpu_ar
 	}
 }
 
-unsigned starpu_sched_ctx_create_inside_interval(const char *policy_name, const char *sched_name, 
+unsigned starpu_sched_ctx_create_inside_interval(const char *policy_name, const char *sched_name,
 						 int min_ncpus, int max_ncpus, int min_ngpus, int max_ngpus,
 						 unsigned allow_overlap)
 {
@@ -412,15 +412,15 @@ unsigned starpu_sched_ctx_create_inside_interval(const char *policy_name, const
 	sched_ctx->max_ncpus = max_ncpus;
 	sched_ctx->min_ngpus = min_ngpus;
 	sched_ctx->max_ngpus = max_ngpus;
-	
+
 	_starpu_update_workers(sched_ctx->workers->workerids, sched_ctx->workers->nworkers, sched_ctx->id);
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
 	sched_ctx->perf_counters = NULL;
 #endif
 	return sched_ctx->id;
-	
+
 }
-unsigned starpu_sched_ctx_create(const char *policy_name, int *workerids, 
+unsigned starpu_sched_ctx_create(const char *policy_name, int *workerids,
 				 int nworkers, const char *sched_name)
 {
 	struct _starpu_sched_ctx *sched_ctx = NULL;
@@ -445,7 +445,7 @@ void starpu_set_perf_counters(unsigned sched_ctx_id, struct starpu_performance_c
 /* free all structures for the context */
 static void _starpu_delete_sched_ctx(struct _starpu_sched_ctx *sched_ctx)
 {
-	_starpu_deinit_sched_policy(sched_ctx);		
+	_starpu_deinit_sched_policy(sched_ctx);
 	free(sched_ctx->sched_policy);
 	free(sched_ctx->sched_mutex);
 	free(sched_ctx->sched_cond);
@@ -487,7 +487,7 @@ void starpu_sched_ctx_delete(unsigned sched_ctx_id, unsigned inheritor_sched_ctx
 	{
 		_starpu_delete_sched_ctx(sched_ctx);
 	}
-	return;	
+	return;
 }
 
 /* called after the workers are terminated so we don't have anything else to do but free the memory*/
@@ -517,7 +517,7 @@ static void _starpu_check_workers(int *workerids, int nworkers)
 	{
 		/* take care the user does not ask for a resource that does not exist */
 		STARPU_ASSERT(workerids[i] >= 0 &&  workerids[i] <= nworkers_conf);
-	}		
+	}
 }
 
 void _starpu_fetch_tasks_from_empty_ctx_list(struct _starpu_sched_ctx *sched_ctx)
@@ -531,7 +531,7 @@ void _starpu_fetch_tasks_from_empty_ctx_list(struct _starpu_sched_ctx *sched_ctx
 		struct starpu_task *old_task = starpu_task_list_pop_back(&sched_ctx->empty_ctx_tasks);
 		unlocked = 1;
 		_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->empty_ctx_mutex);
-		
+
 		if(old_task == &stop_submission_task)
 			break;
 
@@ -563,7 +563,7 @@ void starpu_sched_ctx_add_workers(int *workers_to_add, int nworkers_to_add, unsi
 	}
 
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
-	
+
 	_starpu_fetch_tasks_from_empty_ctx_list(sched_ctx);
 
 	return;
@@ -583,7 +583,7 @@ void starpu_sched_ctx_remove_workers(int *workers_to_remove, int nworkers_to_rem
 	if(n_removed_workers > 0)
 		_starpu_update_workers(removed_workers, n_removed_workers, sched_ctx->id);
 
-	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);	       
+	_STARPU_PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
 	return;
 }
 
@@ -660,10 +660,10 @@ static unsigned _starpu_worker_get_sched_ctx_id(struct _starpu_worker *worker, u
 int _starpu_wait_for_all_tasks_of_sched_ctx(unsigned sched_ctx_id)
 {
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
-	
+
 	if (STARPU_UNLIKELY(!_starpu_worker_may_perform_blocking_calls()))
 	  return -EDEADLK;
-	
+
 	return _starpu_barrier_counter_wait_for_empty_counter(&sched_ctx->tasks_barrier);
 }
 
@@ -802,7 +802,7 @@ struct starpu_sched_ctx_worker_collection* starpu_sched_ctx_create_worker_collec
 		sched_ctx->workers->deinit = worker_list.deinit;
 		sched_ctx->workers->init_cursor = worker_list.init_cursor;
 		sched_ctx->workers->deinit_cursor = worker_list.deinit_cursor;
-		sched_ctx->workers->type = WORKER_LIST; 
+		sched_ctx->workers->type = WORKER_LIST;
 		break;
 	}
 
@@ -826,15 +826,15 @@ struct starpu_sched_ctx_worker_collection* starpu_sched_ctx_get_worker_collectio
 int starpu_get_workers_of_sched_ctx(unsigned sched_ctx_id, int *pus, enum starpu_archtype arch)
 {
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
-	
+
 	struct starpu_sched_ctx_worker_collection *workers = sched_ctx->workers;
 	int worker;
 
 	int npus = 0;
-	
+
 	if(workers->init_cursor)
 		workers->init_cursor(workers);
-	
+
 	while(workers->has_next(workers))
 	{
 		worker = workers->get_next(workers);
@@ -842,7 +842,7 @@ int starpu_get_workers_of_sched_ctx(unsigned sched_ctx_id, int *pus, enum starpu
 		if(curr_arch == arch)
 			pus[npus++] = worker;
 	}
-	
+
 	if (workers->deinit_cursor)
 		workers->deinit_cursor(workers);
 	return npus;
@@ -859,7 +859,7 @@ unsigned starpu_sched_ctx_get_nworkers(unsigned sched_ctx_id)
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 	if(sched_ctx != NULL)
 		return sched_ctx->workers->nworkers;
-	else 
+	else
 		return 0;
 
 }
@@ -936,14 +936,14 @@ void starpu_set_turn_to_other_ctx(int workerid, unsigned sched_ctx_id)
 	for(i = 0; i < STARPU_NMAX_SCHED_CTXS; i++)
 	{
 		other_sched_ctx = worker->sched_ctx[i];
-		if(other_sched_ctx != NULL && other_sched_ctx->id != STARPU_NMAX_SCHED_CTXS && 
+		if(other_sched_ctx != NULL && other_sched_ctx->id != STARPU_NMAX_SCHED_CTXS &&
 		   other_sched_ctx->id != 0 && other_sched_ctx->id != sched_ctx_id)
 		{
 			worker->active_ctx = other_sched_ctx->id;
 			active_sched_ctx = other_sched_ctx;
 			break;
 		}
-	}		
+	}
 
 	if(worker->active_ctx != sched_ctx_id)
 	{
@@ -953,7 +953,7 @@ void starpu_set_turn_to_other_ctx(int workerid, unsigned sched_ctx_id)
 
 double starpu_get_max_time_worker_on_ctx(void)
 {
-	return max_time_worker_on_ctx;	
+	return max_time_worker_on_ctx;
 }
 
 void starpu_sched_ctx_set_inheritor(unsigned sched_ctx_id, unsigned inheritor)

src/drivers/cpu/driver_cpu.c

@@ -181,7 +181,7 @@ _starpu_get_worker_from_driver(struct starpu_driver *d)
 	nworkers = starpu_worker_get_ids_by_type(STARPU_CPU_WORKER, workers, d->id.cpu_id+1);
 	if (nworkers >= 0 && (unsigned) nworkers < d->id.cpu_id)
 		return NULL; // No device was found.
-	
+
 	return _starpu_get_worker_struct(workers[d->id.cpu_id]);
 }
 
@@ -200,9 +200,9 @@ int _starpu_cpu_driver_init(struct starpu_driver *d)
 
 	cpu_worker->status = STATUS_UNKNOWN;
 
-	_STARPU_TRACE_WORKER_INIT_END
+	_STARPU_TRACE_WORKER_INIT_END;
 
-        /* tell the main thread that we are ready */
+	/* tell the main thread that we are ready */
 	_STARPU_PTHREAD_MUTEX_LOCK(&cpu_worker->mutex);
 	cpu_worker->worker_is_initialized = 1;
 	_STARPU_PTHREAD_COND_SIGNAL(&cpu_worker->ready_cond);
@@ -223,7 +223,7 @@ int _starpu_cpu_driver_run_once(struct starpu_driver *d STARPU_ATTRIBUTE_UNUSED)
 	_starpu_datawizard_progress(memnode, 1);
 	_STARPU_TRACE_END_PROGRESS(memnode);
 
-        struct _starpu_job *j;
+	struct _starpu_job *j;
 	struct starpu_task *task;
 	int res;
 

src/drivers/opencl/driver_opencl_utils.c

@@ -44,12 +44,12 @@ int _starpu_opencl_locate_file(const char *source_file_name, char *located_file_
 {
 	int ret = EXIT_FAILURE;
 
-        _STARPU_DEBUG("Trying to locate <%s>\n", source_file_name);
-        if (access(source_file_name, R_OK) == 0)
+	_STARPU_DEBUG("Trying to locate <%s>\n", source_file_name);
+	if (access(source_file_name, R_OK) == 0)
 	{
-                strcpy(located_file_name, source_file_name);
+		strcpy(located_file_name, source_file_name);
 		ret = EXIT_SUCCESS;
-        }
+	}
 
 	if (ret == EXIT_FAILURE && _starpu_opencl_program_dir)
 	{
@@ -96,28 +96,28 @@ int _starpu_opencl_locate_file(const char *source_file_name, char *located_file_
 		}
 	}
 
-        return ret;
+	return ret;
 }
 
 cl_int starpu_opencl_load_kernel(cl_kernel *kernel, cl_command_queue *queue, struct starpu_opencl_program *opencl_programs,
                                  const char *kernel_name, int devid)
 {
-        cl_int err;
+	cl_int err;
 	cl_device_id device;
-        cl_program program;
+	cl_program program;
 
-        starpu_opencl_get_device(devid, &device);
-        starpu_opencl_get_queue(devid, queue);
+	starpu_opencl_get_device(devid, &device);
+	starpu_opencl_get_queue(devid, queue);
 
-        program = opencl_programs->programs[devid];
-        if (!program)
+	program = opencl_programs->programs[devid];
+	if (!program)
 	{
-                _STARPU_DISP("Program not available for device <%d>\n", devid);
-                return CL_INVALID_PROGRAM;
-        }
+		_STARPU_DISP("Program not available for device <%d>\n", devid);
+		return CL_INVALID_PROGRAM;
+	}
 
-        // Create the compute kernel in the program we wish to run
-        *kernel = clCreateKernel(program, kernel_name, &err);
+	// Create the compute kernel in the program we wish to run
+	*kernel = clCreateKernel(program, kernel_name, &err);
 	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
@@ -132,37 +132,36 @@ cl_int starpu_opencl_release_kernel(cl_kernel kernel)
 	if (STARPU_UNLIKELY(err != CL_SUCCESS))
 		STARPU_OPENCL_REPORT_ERROR(err);
 
-        return CL_SUCCESS;
+	return CL_SUCCESS;
 }
 
 static
 char *_starpu_opencl_load_program_source(const char *filename)
 {
-        struct stat statbuf;
-        FILE        *fh;
-        char        *source;
-        int         x;
-        char        c;
+	struct stat statbuf;
+	FILE        *fh;
+	char        *source;
+	int         x;
+	char        c;
 
-        fh = fopen(filename, "r");
-        if (!fh)
-                return NULL;
+	fh = fopen(filename, "r");
+	if (!fh)
+		return NULL;
 
-        stat(filename, &statbuf);
-        source = (char *) malloc(statbuf.st_size + 1);
+	stat(filename, &statbuf);
+	source = (char *) malloc(statbuf.st_size + 1);
 
-        for(c=(char)fgetc(fh), x=0 ; c != EOF ; c =(char)fgetc(fh), x++)
+	for(c=(char)fgetc(fh), x=0 ; c != EOF ; c =(char)fgetc(fh), x++)
 	{
 		source[x] = c;
-        }
-        source[x] = '\0';
-
+	}
+	source[x] = '\0';
 
-        _STARPU_DEBUG("OpenCL kernel <%s>\n", source);
+	_STARPU_DEBUG("OpenCL kernel <%s>\n", source);
 
-        fclose(fh);
+	fclose(fh);
 
-        return source;
+	return source;
 }
 
 
@@ -246,60 +245,59 @@ static
 int _starpu_opencl_compile_or_load_opencl_from_string(const char *opencl_program_source, const char* build_options,
 						      struct starpu_opencl_program *opencl_programs, const char* source_file_name)
 {
-        unsigned int dev;
-        unsigned int nb_devices;
+	unsigned int dev;
+	unsigned int nb_devices;
 
-        nb_devices = _starpu_opencl_get_device_count();
-        // Iterate over each device
-        for(dev = 0; dev < nb_devices; dev ++)
+	nb_devices = _starpu_opencl_get_device_count();
+	// Iterate over each device
+	for(dev = 0; dev < nb_devices; dev ++)
 	{
-                cl_device_id device;
-                cl_context   context;
-                cl_program   program;
-                cl_int       err;
+		cl_device_id device;
+		cl_context   context;
+		cl_program   program;
+		cl_int       err;
 
 		if (opencl_programs)
 			opencl_programs->programs[dev] = NULL;
 
-                starpu_opencl_get_device(dev, &device);
-                starpu_opencl_get_context(dev, &context);
-                if (context == NULL)
+		starpu_opencl_get_device(dev, &device);
+		starpu_opencl_get_context(dev, &context);
+		if (context == NULL)
 		{
-                        _STARPU_DEBUG("[%u] is not a valid OpenCL context\n", dev);
-                        continue;
-                }
+			_STARPU_DEBUG("[%u] is not a valid OpenCL context\n", dev);
+			continue;
+		}
 
-                // Create the compute program from the source buffer
-                program = clCreateProgramWithSource(context, 1, (const char **) &opencl_program_source, NULL, &err);
-                if (!program || err != CL_SUCCESS) {
+		// Create the compute program from the source buffer
+		program = clCreateProgramWithSource(context, 1, (const char **) &opencl_program_source, NULL, &err);
+		if (!program || err != CL_SUCCESS) {
 			_STARPU_DISP("Error: Failed to load program source!\n");
 			return EXIT_FAILURE;
 		}
 
-                // Build the program executable
-                err = clBuildProgram(program, 1, &device, build_options, NULL, NULL);
+		// Build the program executable
+		err = clBuildProgram(program, 1, &device, build_options, NULL, NULL);
 
 		// Get the status
 		{
-		     cl_build_status status;
-		     size_t len;
-		     static char buffer[4096] = "";
-
-		     clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
-		     if (len > 2)
-			  _STARPU_DISP("Compilation output\n%s\n", buffer);
-
-		     clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL);
-		     if (err != CL_SUCCESS || status != CL_BUILD_SUCCESS)
-		     {
-			  _STARPU_DISP("Error: Failed to build program executable!\n");
-			  _STARPU_DISP("clBuildProgram: %d - clGetProgramBuildInfo: %d\n", err, status);
-			  return EXIT_FAILURE;
-		     }
+			cl_build_status status;
+			size_t len;
+			static char buffer[4096] = "";
+
+			clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
+			if (len > 2)
+				_STARPU_DISP("Compilation output\n%s\n", buffer);
 
+			clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL);
+			if (err != CL_SUCCESS || status != CL_BUILD_SUCCESS)
+			{
+				_STARPU_DISP("Error: Failed to build program executable!\n");
+				_STARPU_DISP("clBuildProgram: %d - clGetProgramBuildInfo: %d\n", err, status);
+				return EXIT_FAILURE;
+			}
 		}
 
-                // Store program
+		// Store program
 		if (opencl_programs)
 			opencl_programs->programs[dev] = program;
 		else
@@ -331,21 +329,21 @@ int _starpu_opencl_compile_or_load_opencl_from_string(const char *opencl_program
 			free(binary);
 			_STARPU_DEBUG("File <%s> created\n", binary_file_name);
 		}
-        }
-        return EXIT_SUCCESS;
+	}
+	return EXIT_SUCCESS;
 }
 
 void starpu_opencl_load_program_source(const char *source_file_name, char *located_file_name, char *located_dir_name, char *opencl_program_source)
 {
-        // Locate source file
-        _starpu_opencl_locate_file(source_file_name, located_file_name, located_dir_name);
-        _STARPU_DEBUG("Source file name : <%s>\n", located_file_name);
-        _STARPU_DEBUG("Source directory name : <%s>\n", located_dir_name);
+	// Locate source file
+	_starpu_opencl_locate_file(source_file_name, located_file_name, located_dir_name);
+	_STARPU_DEBUG("Source file name : <%s>\n", located_file_name);
+	_STARPU_DEBUG("Source directory name : <%s>\n", located_dir_name);
 
-        // Load the compute program from disk into a char *
-        char *source = _starpu_opencl_load_program_source(located_file_name);
-        if(!source)
-                _STARPU_ERROR("Failed to load compute program from file <%s>!\n", located_file_name);
+	// Load the compute program from disk into a char *
+	char *source = _starpu_opencl_load_program_source(located_file_name);
+	if(!source)
+		_STARPU_ERROR("Failed to load compute program from file <%s>!\n", located_file_name);
 
 	sprintf(opencl_program_source, "%s", source);
 }
@@ -354,8 +352,8 @@ static
 int _starpu_opencl_compile_or_load_opencl_from_file(const char *source_file_name, struct starpu_opencl_program *opencl_programs, const char* build_options)
 {
 	int nb_devices;
-        char located_file_name[1024];
-        char located_dir_name[1024];
+	char located_file_name[1024];
+	char located_dir_name[1024];
 	char new_build_options[1024];
 	char opencl_program_source[16384];
 
@@ -376,7 +374,7 @@ int _starpu_opencl_compile_or_load_opencl_from_file(const char *source_file_name
 		sprintf(new_build_options, "-I %s", located_dir_name);
 	_STARPU_DEBUG("Build options: <%s>\n", new_build_options);
 
-        return _starpu_opencl_compile_or_load_opencl_from_string(opencl_program_source, new_build_options, opencl_programs, source_file_name);
+	return _starpu_opencl_compile_or_load_opencl_from_string(opencl_program_source, new_build_options, opencl_programs, source_file_name);
 }
 
 int starpu_opencl_compile_opencl_from_file(const char *source_file_name, const char* build_options)
@@ -403,17 +401,17 @@ int starpu_opencl_load_opencl_from_file(const char *source_file_name, struct sta
 
 int starpu_opencl_load_binary_opencl(const char *kernel_id, struct starpu_opencl_program *opencl_programs)
 {
-        unsigned int dev;
-        unsigned int nb_devices;
+	unsigned int dev;
+	unsigned int nb_devices;
 
-        nb_devices = _starpu_opencl_get_device_count();
-        // Iterate over each device
-        for(dev = 0; dev < nb_devices; dev ++)
+	nb_devices = _starpu_opencl_get_device_count();
+	// Iterate over each device
+	for(dev = 0; dev < nb_devices; dev ++)
 	{
-                cl_device_id device;
-                cl_context   context;
-                cl_program   program;
-                cl_int       err;
+		cl_device_id device;
+		cl_context   context;
+		cl_program   program;
+		cl_int       err;
 		char        *binary;
 		char         binary_file_name[1024];
 		size_t       length;
@@ -421,50 +419,50 @@ int starpu_opencl_load_binary_opencl(const char *kernel_id, struct starpu_opencl
 
 		opencl_programs->programs[dev] = NULL;
 
-                starpu_opencl_get_device(dev, &device);
-                starpu_opencl_get_context(dev, &context);
-                if (context == NULL)
+		starpu_opencl_get_device(dev, &device);
+		starpu_opencl_get_context(dev, &context);
+		if (context == NULL)
 		{
-                        _STARPU_DEBUG("[%u] is not a valid OpenCL context\n", dev);
-                        continue;
-                }
+			_STARPU_DEBUG("[%u] is not a valid OpenCL context\n", dev);
+			continue;
+		}
 
 		// Load the binary buffer
 		err = _starpu_opencl_get_binary_name(binary_file_name, 1024, kernel_id, dev, device);
 		if (STARPU_UNLIKELY(err != CL_SUCCESS)) STARPU_OPENCL_REPORT_ERROR(err);
 		binary = _starpu_opencl_load_program_binary(binary_file_name, &length);
 
-                // Create the compute program from the binary buffer
-                program = clCreateProgramWithBinary(context, 1, &device, &length, (const unsigned char **) &binary, &binary_status, &err);
-                if (!program || err != CL_SUCCESS) {
+		// Create the compute program from the binary buffer
+		program = clCreateProgramWithBinary(context, 1, &device, &length, (const unsigned char **) &binary, &binary_status, &err);
+		if (!program || err != CL_SUCCESS)
+		{
 			_STARPU_DISP("Error: Failed to load program binary!\n");
 			return EXIT_FAILURE;
 		}
 
-                // Build the program executable
-                err = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
+		// Build the program executable
+		err = clBuildProgram(program, 1, &device, NULL, NULL, NULL);
 
 		// Get the status
 		{
-		     cl_build_status status;
-		     size_t len;
-		     static char buffer[4096] = "";
-
-		     clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
-		     if (len > 2)
-			  _STARPU_DISP("Compilation output\n%s\n", buffer);
-
-		     clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL);
-		     if (err != CL_SUCCESS || status != CL_BUILD_SUCCESS)
-		     {
-			  _STARPU_DISP("Error: Failed to build program executable!\n");
-			  _STARPU_DISP("clBuildProgram: %d - clGetProgramBuildInfo: %d\n", err, status);
-			  return EXIT_FAILURE;
-		     }
+			cl_build_status status;
+			size_t len;
+			static char buffer[4096] = "";
 
+			clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);
+			if (len > 2)
+				_STARPU_DISP("Compilation output\n%s\n", buffer);
+
+			clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, NULL);
+			if (err != CL_SUCCESS || status != CL_BUILD_SUCCESS)
+			{
+				_STARPU_DISP("Error: Failed to build program executable!\n");
+				_STARPU_DISP("clBuildProgram: %d - clGetProgramBuildInfo: %d\n", err, status);
+				return EXIT_FAILURE;
+			}
 		}
 
-                // Store program
+		// Store program
 		opencl_programs->programs[dev] = program;
 	}
 	return 0;
@@ -472,15 +470,15 @@ int starpu_opencl_load_binary_opencl(const char *kernel_id, struct starpu_opencl
 
 int starpu_opencl_unload_opencl(struct starpu_opencl_program *opencl_programs)
 {
-        unsigned int dev;
-        unsigned int nb_devices;
+	unsigned int dev;
+	unsigned int nb_devices;
 
 	if (!starpu_opencl_worker_get_count())
 		return 0;
 
-        nb_devices = _starpu_opencl_get_device_count();
-        // Iterate over each device
-        for(dev = 0; dev < nb_devices; dev ++)
+	nb_devices = _starpu_opencl_get_device_count();
+	// Iterate over each device
+	for(dev = 0; dev < nb_devices; dev ++)
 	{
 		if (opencl_programs->programs[dev])
 		{
@@ -489,8 +487,8 @@ int starpu_opencl_unload_opencl(struct starpu_opencl_program *opencl_programs)
 			if (STARPU_UNLIKELY(err != CL_SUCCESS))
 				STARPU_OPENCL_REPORT_ERROR(err);
 		}
-        }
-        return 0;
+	}
+	return 0;
 }
 
 int starpu_opencl_collect_stats(cl_event event STARPU_ATTRIBUTE_UNUSED)

src/util/execute_on_all.c

@@ -62,7 +62,7 @@ void starpu_execute_on_specific_workers(void (*func)(void*), void * arg, unsigne
 
 	for (w = 0; w < num_workers; w++)
 	{
-	  unsigned worker = workers[w];
+		unsigned worker = workers[w];
 		tasks[w] = starpu_task_create();
 
 		tasks[w]->cl = &wrapper_cl;
@@ -73,11 +73,11 @@ void starpu_execute_on_specific_workers(void (*func)(void*), void * arg, unsigne
 
 		tasks[w]->detach = 0;
 		tasks[w]->destroy = 0;
-   
+
 #ifdef STARPU_USE_FXT
 		_starpu_get_job_associated_to_task(tasks[w])->model_name = name;
 #endif
-   
+
 		_starpu_exclude_task_from_dag(tasks[w]);
 
 		ret = starpu_task_submit(tasks[w]);

src/util/misc.c

@@ -42,7 +42,7 @@ const char *_starpu_job_get_model_name(struct _starpu_job *j)
 
 #ifdef STARPU_USE_FXT
 	if (!ret)
-                ret = j->model_name;
+		ret = j->model_name;
 #endif
-        return ret;
+	return ret;
 }

src/util/starpu_insert_task.c

@@ -29,7 +29,7 @@ void starpu_codelet_pack_args(char **arg_buffer, size_t *arg_buffer_size, ...)
 
 	/* Compute the size */
 	va_start(varg_list, arg_buffer_size);
-        *arg_buffer_size = _starpu_insert_task_get_arg_size(varg_list);
+	*arg_buffer_size = _starpu_insert_task_get_arg_size(varg_list);
 
 	va_start(varg_list, arg_buffer_size);
 	_starpu_codelet_pack_args(*arg_buffer_size, arg_buffer, varg_list);
@@ -71,7 +71,7 @@ int starpu_insert_task(struct starpu_codelet *cl, ...)
 	/* Compute the size */
 	size_t arg_buffer_size = 0;
 	va_start(varg_list, cl);
-        arg_buffer_size = _starpu_insert_task_get_arg_size(varg_list);
+	arg_buffer_size = _starpu_insert_task_get_arg_size(varg_list);
 
 	if (arg_buffer_size)
 	{
@@ -80,7 +80,7 @@ int starpu_insert_task(struct starpu_codelet *cl, ...)
 	}
 
 	va_start(varg_list, cl);
-        struct starpu_task *task = starpu_task_create();
+	struct starpu_task *task = starpu_task_create();
 	int ret = _starpu_insert_task_create_and_submit(arg_buffer, arg_buffer_size, cl, &task, varg_list);
 
 	if (ret == -ENODEV)
@@ -88,6 +88,5 @@ int starpu_insert_task(struct starpu_codelet *cl, ...)
 		task->destroy = 0;
 		starpu_task_destroy(task);
 	}
-        return ret;
+	return ret;
 }
-

src/util/starpu_insert_task_utils.c

@@ -47,9 +47,9 @@ void starpu_task_insert_callback_wrapper(void *_cl_arg_wrapper)
 size_t _starpu_insert_task_get_arg_size(va_list varg_list)
 {
 	int arg_type;
-        size_t arg_buffer_size;
+	size_t arg_buffer_size;
 
-        arg_buffer_size = 0;
+	arg_buffer_size = 0;
 
 	arg_buffer_size += sizeof(char);
 
@@ -104,12 +104,12 @@ size_t _starpu_insert_task_get_arg_size(va_list varg_list)
 	}
 
 	va_end(varg_list);
-        return arg_buffer_size;
+	return arg_buffer_size;
 }
 
 int _starpu_codelet_pack_args(size_t arg_buffer_size, char **arg_buffer, va_list varg_list)
 {
-        int arg_type;
+	int arg_type;
 	unsigned current_arg_offset = 0;
 	unsigned char nargs = 0;
 
@@ -193,7 +193,7 @@ int _starpu_codelet_pack_args(size_t arg_buffer_size, char **arg_buffer, va_list
 
 int _starpu_insert_task_create_and_submit(char *arg_buffer, size_t arg_buffer_size, struct starpu_codelet *cl, struct starpu_task **task, va_list varg_list)
 {
-        int arg_type;
+	int arg_type;
 	unsigned current_buffer = 0;
 
 	struct insert_task_cb_wrapper *cl_arg_wrapper = (struct insert_task_cb_wrapper *) malloc(sizeof(struct insert_task_cb_wrapper));
@@ -282,12 +282,12 @@ int _starpu_insert_task_create_and_submit(char *arg_buffer, size_t arg_buffer_si
 			(void)va_arg(varg_list, starpu_data_handle_t);
 		}
 
-		else if (arg_type==STARPU_HYPERVISOR_TAG) 
+		else if (arg_type==STARPU_HYPERVISOR_TAG)
 		{
 			int hypervisor_tag = va_arg(varg_list, int);
 			(*task)->hypervisor_tag = hypervisor_tag;
 		}
-		else if (arg_type==STARPU_HYPERVISOR_FLOPS) 
+		else if (arg_type==STARPU_HYPERVISOR_FLOPS)
 		{
 			int flops = va_arg(varg_list, int);
 			(*task)->flops = flops;
@@ -328,5 +328,5 @@ int _starpu_insert_task_create_and_submit(char *arg_buffer, size_t arg_buffer_si
 		free(cl_arg_wrapper);
 	}
 
-        return ret;
+	return ret;
 }