src: minor fixes

src/common/barrier_counter.c

@@ -105,11 +105,11 @@ int _starpu_barrier_counter_increment(struct _starpu_barrier_counter *barrier_c,
 int _starpu_barrier_counter_check(struct _starpu_barrier_counter *barrier_c)
 {
 	struct _starpu_barrier *barrier = &barrier_c->barrier;
-	int ret = 0;
 	STARPU_PTHREAD_MUTEX_LOCK(&barrier->mutex);
 
 	if(barrier->reached_start == 0)
 		STARPU_PTHREAD_COND_BROADCAST(&barrier->cond);
 
 	STARPU_PTHREAD_MUTEX_UNLOCK(&barrier->mutex);
+	return 0;
 }

src/common/utils.c

@@ -159,3 +159,17 @@ void _starpu_gethostname(char *hostname, size_t size)
 			*c = 0;
 	}
 }
+
+void _starpu_sleep(struct timespec ts)
+{
+#ifdef STARPU_HAVE_WINDOWS
+	Sleep((ts.tv_sec * 1000) + (ts.tv_nsec / 1000000));
+#else
+	struct timespec req, rem;
+
+	req = ts;
+	while (nanosleep(&req, &rem))
+		req = rem;
+#endif
+}
+

src/common/utils.h

@@ -118,4 +118,6 @@ const char *_starpu_codelet_get_model_name(struct starpu_codelet *cl);
 
 int _starpu_check_mutex_deadlock(starpu_pthread_mutex_t *mutex);
 
+void _starpu_sleep(struct timespec ts);
+
 #endif // __COMMON_UTILS_H__

src/core/perfmodel/perfmodel.h

@@ -63,6 +63,7 @@ void _starpu_load_history_based_model(struct starpu_perfmodel *model, unsigned s
 void _starpu_load_perfmodel(struct starpu_perfmodel *model);
 void _starpu_initialize_registered_performance_models(void);
 void _starpu_deinitialize_registered_performance_models(void);
+void _starpu_deinitialize_performance_model(struct starpu_perfmodel *model);
 
 double _starpu_regression_based_job_expected_perf(struct starpu_perfmodel *model,
 					struct starpu_perfmodel_arch* arch, struct _starpu_job *j, unsigned nimpl);
@@ -90,6 +91,7 @@ void _starpu_save_bandwidth_and_latency_disk(double bandwidth_write, double band
 					    double latency_write, double latency_read, unsigned node);
 
 int _starpu_read_double(FILE *f, char *format, double *val);
+void _starpu_simgrid_get_platform_path(char *path, size_t maxlen);
 
 #ifdef __cplusplus
 }

src/core/perfmodel/perfmodel_nan.c

@@ -22,6 +22,7 @@
 #include <math.h>
 #include <string.h>
 #include <config.h>
+#include <core/perfmodel/perfmodel.h>
 
 int _starpu_read_double(FILE *f, char *format, double *val)
 {

src/core/sched_ctx.c

@@ -867,7 +867,7 @@ int _starpu_get_nsubmitted_tasks_of_sched_ctx(unsigned sched_ctx_id)
 int _starpu_check_nsubmitted_tasks_of_sched_ctx(unsigned sched_ctx_id)
 {
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
-	_starpu_barrier_counter_check(&sched_ctx->tasks_barrier);
+	return _starpu_barrier_counter_check(&sched_ctx->tasks_barrier);
 }
 
 void _starpu_increment_nready_tasks_of_sched_ctx(unsigned sched_ctx_id, double ready_flops)

src/core/sched_ctx.h

@@ -196,6 +196,8 @@ unsigned _starpu_sched_ctx_get_current_context();
 /* verify how many workers can execute a certain task */
 int _starpu_nworkers_able_to_execute_task(struct starpu_task *task, struct _starpu_sched_ctx *sched_ctx);
 
+void _starpu_fetch_tasks_from_empty_ctx_list(struct _starpu_sched_ctx *sched_ctx);
+
 #ifdef STARPU_USE_SC_HYPERVISOR
 /* Notifies the hypervisor that a tasks was poped from the workers' list */
 void _starpu_sched_ctx_post_exec_task_cb(int workerid, struct starpu_task *task, size_t data_size, uint32_t footprint);

src/core/sched_policy.c

@@ -556,6 +556,7 @@ struct starpu_task *_starpu_create_conversion_task_for_arch(starpu_data_handle_t
 	return conversion_task;
 }
 
+static
 struct _starpu_sched_ctx* _get_next_sched_ctx_to_pop_into(struct _starpu_worker *worker)
 {	
 	struct _starpu_sched_ctx *sched_ctx, *good_sched_ctx = NULL;

src/core/task.c

@@ -40,7 +40,7 @@
 /* XXX this should be reinitialized when StarPU is shutdown (or we should make
  * sure that no task remains !) */
 /* TODO we could make this hierarchical to avoid contention ? */
-static starpu_pthread_cond_t submitted_cond = STARPU_PTHREAD_COND_INITIALIZER;
+//static starpu_pthread_cond_t submitted_cond = STARPU_PTHREAD_COND_INITIALIZER;
 static starpu_pthread_mutex_t submitted_mutex = STARPU_PTHREAD_MUTEX_INITIALIZER;
 
 /* This key stores the task currently handled by the thread, note that we
@@ -1001,19 +1001,6 @@ char *_starpu_task_get_cpu_name_nth_implementation(struct starpu_codelet *cl, un
 	return cl->cpu_funcs_name[nimpl];
 }
 
-void _starpu_sleep(struct timespec ts)
-{
-#ifdef STARPU_HAVE_WINDOWS
-	Sleep((ts.tv_sec * 1000) + (ts.tv_nsec / 1000000));
-#else
-	struct timespec req, rem;
-
-	req = ts;
-	while (nanosleep(&req, &rem))
-		req = rem;
-#endif
-}
-
 static starpu_pthread_t watchdog_thread;
 
 /* Check from times to times that StarPU does finish some tasks */

src/datawizard/interfaces/block_interface.c

@@ -589,9 +589,9 @@ static int copy_opencl_common(void *src_interface, unsigned src_node, void *dst_
 		if (((nx*ny) == src_block->ldz) && (src_block->ldz == dst_block->ldz))
 		{
 			ret = starpu_opencl_copy_async_sync(src_block->dev_handle, src_block->offset, src_node,
-								dst_block->dev_handle, dst_block->offset, dst_node,
-							       src_block->nx*src_block->ny*src_block->nz*src_block->elemsize,
-							       event);
+							    dst_block->dev_handle, dst_block->offset, dst_node,
+							    src_block->nx*src_block->ny*src_block->nz*src_block->elemsize,
+							    event);
                 }
 		else
 		{
@@ -615,8 +615,8 @@ static int copy_opencl_common(void *src_interface, unsigned src_node, void *dst_
 								    dst_block->dev_handle,
 								    dst_block->offset + layer*dst_block->ldz*dst_block->elemsize + j*dst_block->ldy*dst_block->elemsize,
 								    dst_node,
-								       src_block->nx*src_block->elemsize,
-								       event);
+								    src_block->nx*src_block->elemsize,
+								    event);
                         }
                 }
         }

src/drivers/cpu/driver_cpu.c

@@ -190,7 +190,7 @@ _starpu_get_worker_from_driver(struct starpu_driver *d)
 	return _starpu_get_worker_struct(n);
 }
 
-static size_t _starpu_cpu_get_global_mem_size(int nodeid, struct _starpu_machine_config *config)
+static size_t _starpu_cpu_get_global_mem_size(int nodeid STARPU_ATTRIBUTE_UNUSED, struct _starpu_machine_config *config)
 {
 	size_t global_mem;
 	starpu_ssize_t limit;
@@ -201,12 +201,11 @@ static size_t _starpu_cpu_get_global_mem_size(int nodeid, struct _starpu_machine
 #endif
 
 #if defined(STARPU_HAVE_HWLOC)
-        int depth_node;
 	struct _starpu_machine_topology *topology = &config->topology;
 
 #if 0
 	/* Do not limit ourself to a single NUMA node yet, as we don't have real NUMA support for now */
-        depth_node = hwloc_get_type_depth(topology->hwtopology, HWLOC_OBJ_NODE);
+        int depth_node = hwloc_get_type_depth(topology->hwtopology, HWLOC_OBJ_NODE);
 
 	if (depth_node == HWLOC_TYPE_DEPTH_UNKNOWN)
 	     global_mem = hwloc_get_root_obj(topology->hwtopology)->memory.total_memory;

src/drivers/disk/driver_disk.c

@@ -17,6 +17,7 @@
 #include <starpu.h>
 #include <core/disk.h>
 #include <starpu_profiling.h>
+#include <drivers/disk/driver_disk.h>
 
 int _starpu_disk_copy_src_to_disk(void * src, unsigned src_node, void * dst, size_t dst_offset, unsigned dst_node, size_t size, void * async_channel)
 {

src/profiling/profiling.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010-2012  Université de Bordeaux 1
- * Copyright (C) 2010, 2011  Centre National de la Recherche Scientifique
+ * Copyright (C) 2010, 2011, 2013  Centre National de la Recherche Scientifique
  *
  * StarPU is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -69,5 +69,6 @@ void _starpu_profiling_set_task_push_end_time(struct starpu_task *task);
 void _starpu_profiling_init(void);
 
 void _starpu_profiling_terminate(void);
+void _starpu_profiling_reset_counters();
 
 #endif // __PROFILING_H__

src/sched_policies/parallel_eager.c

@@ -157,15 +157,14 @@ static int push_task_peager_policy(struct starpu_task *task)
 
         /*if there are no tasks block */
         /* wake people waiting for a task */
-        int worker = -1;
         struct starpu_worker_collection *workers = starpu_sched_ctx_get_worker_collection(sched_ctx_id);
 
         struct starpu_sched_ctx_iterator it;
         if(workers->init_iterator)
                 workers->init_iterator(workers, &it);
 
-
 #ifndef STARPU_NON_BLOCKING_DRIVERS
+        int worker = -1;
 	while(workers->has_next(workers, &it))
 	{
 		worker = workers->get_next(workers, &it);

src/sched_policies/parallel_heft.c

@@ -561,7 +561,7 @@ static void initialize_parallel_heft_policy(unsigned sched_ctx_id)
 	if (starpu_sched_ctx_max_priority_is_set(sched_ctx_id) == 0)
 		starpu_sched_ctx_set_max_priority(sched_ctx_id, DEFAULT_MAX_PRIORITY);
 	STARPU_ASSERT_MSG(starpu_sched_ctx_get_min_priority(sched_ctx_id) < starpu_sched_ctx_get_max_priority(sched_ctx_id),
-			  "Priority min %d should be lower than priority max\n",
+			  "Priority min %d should be lower than priority max %d\n",
 			  starpu_sched_ctx_get_min_priority(sched_ctx_id), starpu_sched_ctx_get_max_priority(sched_ctx_id));
 
 	starpu_sched_ctx_set_policy_data(sched_ctx_id, (void*)hd);

src/sched_policies/work_stealing_policy.c

@@ -332,6 +332,7 @@ static struct starpu_task *ws_pop_task(unsigned sched_ctx_id)
 	return task;
 }
 
+static
 int ws_push_task(struct starpu_task *task)
 {
 	unsigned sched_ctx_id = task->sched_ctx;

src/util/starpu_task_insert.c

@@ -64,6 +64,7 @@ void starpu_codelet_unpack_args(void *_cl_arg, ...)
 	va_end(varg_list);
 }
 
+static
 int _starpu_task_insert_v(struct starpu_codelet *cl, va_list varg_list)
 {
 	void *arg_buffer = NULL;