bug fixing

include/starpu_task.h

@@ -183,7 +183,7 @@ struct starpu_task {
 	 from the ones provided by the appl*/
 	unsigned control_task;
 
-	int checkpoint;
+	int hypervisor_tag;
 };
 
 /* It is possible to initialize statically allocated tasks with this value.
@@ -210,7 +210,7 @@ struct starpu_task {
 	.starpu_private = NULL,				\
 	.sched_ctx = 0,					\
 	.control_task = 0,				\
-		.checkpoint = 0				\
+		.hypervisor_tag = 0			\
 };
 
 /*

include/starpu_util.h

@@ -239,7 +239,7 @@ int starpu_data_cpy(starpu_data_handle dst_handle, starpu_data_handle src_handle
 #define STARPU_PRIORITY		(1<<7)	/* Priority associated to the task */
 #define STARPU_EXECUTE_ON_NODE	(1<<8)	/* Used by MPI to define which task is going to execute the codelet */
 #define STARPU_EXECUTE_ON_DATA	(1<<9)	/* Used by MPI to define which task is going to execute the codelet */
-#define STARPU_CHECKPOINT	(1<<10)	/* Used to checkpoint a task after whose execution we'll execute  a code */
+#define STARPU_HYPERVISOR_TAG	(1<<10)	/* Used to checkpoint a task after whose execution we'll execute  a code */
 
 /* Wrapper to create a task. */
 int starpu_insert_task(starpu_codelet *cl, ...);

sched_ctx_hypervisor/examples/cholesky/cholesky_implicit.c

@@ -69,7 +69,7 @@ static void callback_turn_spmd_on(void *arg __attribute__ ((unused)))
 	cl22.type = STARPU_SPMD;
 }
 
-int checkpoints = 1;
+int hypervisor_tag = 1;
 static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 {
 	struct timeval start;
@@ -91,9 +91,9 @@ static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 					   STARPU_PRIORITY, prio_level,
 					   STARPU_RW, sdatakk,
 					   STARPU_CALLBACK, (k == 3*nblocks/4)?callback_turn_spmd_on:NULL,
-					   STARPU_CHECKPOINT, checkpoints,
+					   STARPU_HYPERVISOR_TAG, hypervisor_tag,
 					   0);
-			set_hypervisor_conf(START_BENCH, checkpoints++);
+			set_hypervisor_conf(START_BENCH, hypervisor_tag++);
 		}
 		else
 			starpu_insert_task(&cl11,
@@ -127,10 +127,10 @@ static void _cholesky(starpu_data_handle dataA, unsigned nblocks)
 								   STARPU_R, sdataki,
 								   STARPU_R, sdatakj,
 								   STARPU_RW, sdataij,
-								   STARPU_CHECKPOINT, checkpoints,
+								   STARPU_HYPERVISOR_TAG, hypervisor_tag,
 								   0);
 						
-						set_hypervisor_conf(END_BENCH, checkpoints++);
+						set_hypervisor_conf(END_BENCH, hypervisor_tag++);
 					}
 					
 					else

sched_ctx_hypervisor/examples/sched_ctx_utils/sched_ctx_utils.c

@@ -259,7 +259,7 @@ void construct_contexts(void (*bench)(unsigned, unsigned))
 				   NULL);
 }
 
-void set_hypervisor_conf(int event, int checkpoint)
+void set_hypervisor_conf(int event, int task_tag)
 {
 	unsigned *id = pthread_getspecific(key);
 	pthread_mutex_lock(&mut);
@@ -284,11 +284,11 @@ void set_hypervisor_conf(int event, int checkpoint)
 		}
  		
 
-		sched_ctx_hypervisor_advise(p2.ctx, p2.procs, p2.nprocs, &reply2[checkpoint]);
-		if(reply2[checkpoint].procs)
+		sched_ctx_hypervisor_advise(p2.ctx, p2.procs, p2.nprocs, &reply2[task_tag]);
+		if(reply2[task_tag].procs)
 			sched_ctx_hypervisor_ioctl(p2.ctx,
-						   HYPERVISOR_MAX_IDLE, reply2[checkpoint].procs, reply2[checkpoint].nprocs, max_idle_time_small,
-						   HYPERVISOR_TIME_TO_APPLY, checkpoint,
+						   HYPERVISOR_MAX_IDLE, reply2[task_tag].procs, reply2[task_tag].nprocs, max_idle_time_small,
+						   HYPERVISOR_TIME_TO_APPLY, task_tag,
 						   HYPERVISOR_GRANULARITY, 1,
 						   NULL);
 	}

sched_ctx_hypervisor/src/sched_ctx_hypervisor.c

@@ -148,14 +148,14 @@ void sched_ctx_hypervisor_ioctl(unsigned sched_ctx, ...)
 
 	int arg_type;
 	int stop = 0;
-	int task_checkpoint = -1;
+	int task_tag = -1;
 
 	while ((arg_type = va_arg(varg_list, int)) != 0) 
 	{
 		switch(arg_type)
 		{
 		case HYPERVISOR_TIME_TO_APPLY:
-			task_checkpoint = va_arg(varg_list, int);
+			task_tag = va_arg(varg_list, int);
 			stop = 1;
 			break;
 
@@ -170,9 +170,9 @@ void sched_ctx_hypervisor_ioctl(unsigned sched_ctx, ...)
 	va_start(varg_list, sched_ctx);
 
 	/* hypervisor configuration to be considered later */
-	void *data = hypervisor.policy.ioctl(sched_ctx, varg_list, (task_checkpoint > 0));
+	void *data = hypervisor.policy.ioctl(sched_ctx, varg_list, (task_tag > 0));
 	if(data != NULL)
-		_starpu_htbl_insert_32(&hypervisor.configurations[sched_ctx], (uint32_t)task_checkpoint, data);
+		_starpu_htbl_insert_32(&hypervisor.configurations[sched_ctx], (uint32_t)task_tag, data);
 
 	return;
 }
@@ -295,10 +295,10 @@ static void poped_task_cb(unsigned sched_ctx, int worker)
 	hypervisor.resize = ((ntasks - npoped_tasks) > 0);
 }
 
-static void post_exec_hook_cb(unsigned sched_ctx, int task_checkpoint)
+static void post_exec_hook_cb(unsigned sched_ctx, int task_tag)
 {
-	STARPU_ASSERT(task_checkpoint > 0);
-	void *data = _starpu_htbl_search_32(hypervisor.configurations[sched_ctx], (uint32_t)task_checkpoint);
+	STARPU_ASSERT(task_tag > 0);
+	void *data = _starpu_htbl_search_32(hypervisor.configurations[sched_ctx], (uint32_t)task_tag);
 	if(data != NULL)	
 		sched_ctx_hypervisor_set_data(sched_ctx, data);
 }

src/core/sched_ctx.c

@@ -40,8 +40,7 @@ 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++;	}
 	else 
 	{
 		/* remove context from worker */
@@ -126,7 +125,6 @@ static void _starpu_add_workers_to_sched_ctx(struct starpu_sched_ctx *sched_ctx,
 		}
 	}
 
-
 	if(added_workers)
 	{
 		if(*n_added_workers > 0)
@@ -308,8 +306,7 @@ static void _starpu_check_workers(int *workerids, int nworkers)
 
 }
 
-void starpu_add_workers_to_sched_ctx(int *workers_to_add, int nworkers_to_add,
-				     unsigned sched_ctx_id)
+void starpu_add_workers_to_sched_ctx(int *workers_to_add, int nworkers_to_add, unsigned sched_ctx_id)
 {
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 	int added_workers[nworkers_to_add];
@@ -320,16 +317,16 @@ void starpu_add_workers_to_sched_ctx(int *workers_to_add, int nworkers_to_add,
 
 	PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
 	_starpu_add_workers_to_sched_ctx(sched_ctx, workers_to_add, nworkers_to_add, added_workers, &n_added_workers);
-	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
 
 	if(n_added_workers > 0)
 		_starpu_update_workers(added_workers, n_added_workers, sched_ctx->id);
+
+	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);
        
 	return;
 }
 
-void starpu_remove_workers_from_sched_ctx(int *workers_to_remove, int nworkers_to_remove, 
-					  unsigned sched_ctx_id)
+void starpu_remove_workers_from_sched_ctx(int *workers_to_remove, int nworkers_to_remove, unsigned sched_ctx_id)
 {
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
 	int removed_workers[nworkers_to_remove];
@@ -340,10 +337,11 @@ void starpu_remove_workers_from_sched_ctx(int *workers_to_remove, int nworkers_t
 
 	PTHREAD_MUTEX_LOCK(&sched_ctx->changing_ctx_mutex);
 	_starpu_remove_workers_from_sched_ctx(sched_ctx, workers_to_remove, nworkers_to_remove, removed_workers, &n_removed_workers);
-	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);	
+
 	if(n_removed_workers > 0)
 		_starpu_update_workers(removed_workers, n_removed_workers, sched_ctx->id);
-       
+
+	PTHREAD_MUTEX_UNLOCK(&sched_ctx->changing_ctx_mutex);	       
 	return;
 }
 
@@ -527,8 +525,11 @@ void* starpu_get_sched_ctx_policy_data(unsigned sched_ctx_id)
 void starpu_worker_set_sched_condition(unsigned sched_ctx_id, int workerid, pthread_mutex_t *sched_mutex, pthread_cond_t *sched_cond)
 {
 	struct starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(sched_ctx_id);
-	sched_ctx->sched_mutex[workerid] = sched_mutex;
-	sched_ctx->sched_cond[workerid] = sched_cond;
+	if(sched_ctx->sched_mutex && sched_ctx->sched_cond)
+	{
+		sched_ctx->sched_mutex[workerid] = sched_mutex;
+		sched_ctx->sched_cond[workerid] = sched_cond;
+	}
 }
 
 void starpu_worker_get_sched_condition(unsigned sched_ctx_id, int workerid, pthread_mutex_t **sched_mutex, pthread_cond_t **sched_cond)

src/core/sched_policy.c

@@ -419,9 +419,9 @@ 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->checkpoint > 0 && sched_ctx != NULL && 
+	if(task->hypervisor_tag > 0 && sched_ctx != NULL && 
 	   sched_ctx->id != 0 && sched_ctx->criteria != NULL)
-		sched_ctx->criteria->post_exec_hook_cb(sched_ctx->id, task->checkpoint);
+		sched_ctx->criteria->post_exec_hook_cb(sched_ctx->id, task->hypervisor_tag);
 #endif //STARPU_USE_SCHED_CTX_HYPERVISOR
 
 	if (sched_ctx->sched_policy->post_exec_hook)

src/core/task.c

@@ -84,7 +84,7 @@ void starpu_task_init(struct starpu_task *task)
 	
 	task->control_task = 0;
 
-	task->checkpoint = 0;
+	task->hypervisor_tag = 0;
 }
 
 /* Free all the ressources allocated for a task, without deallocating the task

src/sched_policies/heft.c

@@ -136,6 +136,14 @@ static void heft_post_exec_hook(struct starpu_task *task)
 	pthread_mutex_t *sched_mutex;
 	pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(sched_ctx_id, workerid, &sched_mutex, &sched_cond);
+	/* the tasks concerning changings of the the ctxs were not executed in order */
+	if(!sched_mutex)
+	{
+		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(workerid);
+		sched_mutex = &workerarg->sched_mutex;
+		sched_cond = &workerarg->sched_cond;
+		starpu_worker_set_sched_condition(sched_ctx_id, workerid, sched_mutex, sched_cond);
+	}
 	/* Once we have executed the task, we can update the predicted amount
 	 * of work. */
 	PTHREAD_MUTEX_LOCK(sched_mutex);
@@ -163,13 +171,21 @@ static void heft_push_task_notify(struct starpu_task *task, int workerid)
 	pthread_mutex_t *sched_mutex;
 	pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(sched_ctx_id, workerid, &sched_mutex, &sched_cond);
+	/* the tasks concerning changings of the the ctxs were not executed in order */
+	if(!sched_mutex)
+	{
+		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(workerid);
+		sched_mutex = &workerarg->sched_mutex;
+		sched_cond = &workerarg->sched_cond;
+		starpu_worker_set_sched_condition(sched_ctx_id, workerid, sched_mutex, sched_cond);
+	}
 
 	/* Update the predictions */
 	PTHREAD_MUTEX_LOCK(sched_mutex);
 
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
 	starpu_call_pushed_task_cb(workerid);
-#endif STARPU_USE_SCHED_CTX_HYPERVISOR
+#endif //STARPU_USE_SCHED_CTX_HYPERVISOR
 
 	/* Sometimes workers didn't take the tasks as early as we expected */
 	exp_start[workerid] = STARPU_MAX(exp_start[workerid], starpu_timing_now());
@@ -198,11 +214,19 @@ static int push_task_on_best_worker(struct starpu_task *task, int best_workerid,
 	pthread_mutex_t *sched_mutex;
 	pthread_cond_t *sched_cond;
 	starpu_worker_get_sched_condition(sched_ctx_id, best_workerid, &sched_mutex, &sched_cond);
+	/* the tasks concerning changings of the the ctxs were not executed in order */
+	if(!sched_mutex)
+	{
+		struct starpu_worker_s *workerarg = _starpu_get_worker_struct(best_workerid);
+		sched_mutex = &workerarg->sched_mutex;
+		sched_cond = &workerarg->sched_cond;
+		starpu_worker_set_sched_condition(sched_ctx_id, best_workerid, sched_mutex, sched_cond);
+	}
 
 	PTHREAD_MUTEX_LOCK(sched_mutex);
 #ifdef STARPU_USE_SCHED_CTX_HYPERVISOR
 	starpu_call_pushed_task_cb(best_workerid);
-#endif STARPU_USE_SCHED_CTX_HYPERVISOR
+#endif //STARPU_USE_SCHED_CTX_HYPERVISOR
 
 	exp_end[best_workerid] += predicted;
 	exp_len[best_workerid] += predicted;

src/util/starpu_insert_task_utils.c

@@ -193,9 +193,9 @@ int _starpu_insert_task_create_and_submit(char *arg_buffer, starpu_codelet *cl,
 		else if (arg_type==STARPU_EXECUTE_ON_DATA) {
 			va_arg(varg_list, starpu_data_handle);
 		}
-		else if (arg_type==STARPU_CHECKPOINT) {
-			int checkpoint = va_arg(varg_list, int);
-			(*task)->checkpoint = checkpoint;
+		else if (arg_type==STARPU_HYPERVISOR_TAG) {
+			int hypervisor_tag = va_arg(varg_list, int);
+			(*task)->hypervisor_tag = hypervisor_tag;
 		}
 	}