mic: add MP_COMMAND and NODE in starpu_mp_command and starpu_mp_node_kind enum values

src/core/topology.c

@@ -463,7 +463,7 @@ _starpu_init_mic_node (struct _starpu_machine_config *config, int mic_idx,
 	/* Let's create the node structure, we'll communicate with the peer
 	 * through scif thanks to it */
 	mic_nodes[mic_idx] =
-		_starpu_mp_common_node_create(STARPU_MIC_SOURCE, mic_idx);
+		_starpu_mp_common_node_create(STARPU_NODE_MIC_SOURCE, mic_idx);
 
 	return 0;
 }
@@ -884,7 +884,7 @@ _starpu_init_mp_config (struct _starpu_machine_config *config,
 static void
 _starpu_deinit_mic_node (unsigned mic_idx)
 {
-	_starpu_mp_common_send_command(mic_nodes[mic_idx], STARPU_EXIT, NULL, 0);
+	_starpu_mp_common_send_command(mic_nodes[mic_idx], STARPU_MP_COMMAND_EXIT, NULL, 0);
 
 	COIProcessDestroy(_starpu_mic_process[mic_idx], -1, 0, NULL, NULL);
 

src/drivers/mic/driver_mic_sink.c

@@ -167,7 +167,7 @@ void _starpu_mic_sink_allocate(const struct _starpu_mp_node *mp_node, void *arg,
 	size_t size = *(size_t *)(arg);
 
 	if (posix_memalign(&addr, STARPU_MIC_PAGE_SIZE, size) != 0)
-		_starpu_mp_common_send_command(mp_node, STARPU_ERROR_ALLOCATE, NULL, 0);
+		_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ERROR_ALLOCATE, NULL, 0);
 
 #ifndef STARPU_DISABLE_ASYNCHRONOUS_MIC_COPY
 	scif_epd_t epd = mp_node->host_sink_dt_connection.mic_endpoint;
@@ -176,11 +176,11 @@ void _starpu_mic_sink_allocate(const struct _starpu_mp_node *mp_node, void *arg,
 	if (scif_register(epd, addr, window_size, (off_t)addr, SCIF_PROT_READ | SCIF_PROT_WRITE, SCIF_MAP_FIXED) < 0)
 	{
 		free(addr);
-		_starpu_mp_common_send_command(mp_node, STARPU_ERROR_ALLOCATE, NULL, 0);
+		_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ERROR_ALLOCATE, NULL, 0);
 	}
 #endif
 
-	_starpu_mp_common_send_command(mp_node, STARPU_ANSWER_ALLOCATE, &addr, sizeof(addr));
+	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ANSWER_ALLOCATE, &addr, sizeof(addr));
 }
 
 /* Unregister and free memory. */

src/drivers/mic/driver_mic_source.c

@@ -263,7 +263,7 @@ starpu_mic_kernel_t _starpu_mic_src_get_kernel_from_codelet(struct starpu_codele
 		/* If user dont define any starpu_mic_fun_t in cl->mic_func we try to use
 		 * cpu_func_name.
 		 */
-		char *func_name = _starpu_task_get_cpu_name_nth_implementation(cl, nimpl);
+		const char *func_name = _starpu_task_get_cpu_name_nth_implementation(cl, nimpl);
 		if (func_name)
 		{
 			starpu_mic_func_symbol_t symbol;
@@ -298,7 +298,7 @@ void(* _starpu_mic_src_get_kernel_from_job(const struct _starpu_mp_node *node ST
 		/* If user dont define any starpu_mic_fun_t in cl->mic_func we try to use
 		 * cpu_func_name.
 		 */
-		char *func_name = _starpu_task_get_cpu_name_nth_implementation(j->task->cl, j->nimpl);
+		const char *func_name = _starpu_task_get_cpu_name_nth_implementation(j->task->cl, j->nimpl);
 		if (func_name)
 		{
 			starpu_mic_func_symbol_t symbol;
@@ -397,7 +397,7 @@ void _starpu_mic_free_memory(void *addr, size_t size, unsigned memory_node)
 	const struct _starpu_mp_node *mp_node = _starpu_mic_src_get_mp_node_from_memory_node(memory_node);
 	struct _starpu_mic_free_command cmd = {addr, size};
 
-	return _starpu_mp_common_send_command(mp_node, STARPU_FREE, &cmd, sizeof(cmd));
+	return _starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_FREE, &cmd, sizeof(cmd));
 }
 
 /* Transfert SIZE bytes from the address pointed by SRC in the SRC_NODE memory

src/drivers/mp_common/mp_common.c

@@ -33,47 +33,47 @@ const char *_starpu_mp_common_command_to_string(const int command)
 {
 	switch(command)
 	{
-		case STARPU_EXIT:
+		case STARPU_MP_COMMAND_EXIT:
 			return "EXIT";
-		case STARPU_EXECUTE:
+		case STARPU_MP_COMMAND_EXECUTE:
 			return "EXECUTE";
-		case STARPU_ERROR_EXECUTE:
+		case STARPU_MP_COMMAND_ERROR_EXECUTE:
 			return "ERROR_EXECUTE";
-		case STARPU_LOOKUP:
+		case STARPU_MP_COMMAND_LOOKUP:
 			return "LOOKUP";
-		case STARPU_ANSWER_LOOKUP:
+		case STARPU_MP_COMMAND_ANSWER_LOOKUP:
 			return "ANSWER_LOOKUP";
-		case STARPU_ERROR_LOOKUP:
+		case STARPU_MP_COMMAND_ERROR_LOOKUP:
 			return "ERROR_LOOKUP";
-		case STARPU_ALLOCATE:
+		case STARPU_MP_COMMAND_ALLOCATE:
 			return "ALLOCATE";
-		case STARPU_ANSWER_ALLOCATE:
+		case STARPU_MP_COMMAND_ANSWER_ALLOCATE:
 			return "ANSWER_ALLOCATE";
-		case STARPU_ERROR_ALLOCATE:
+		case STARPU_MP_COMMAND_ERROR_ALLOCATE:
 			return "ERROR_ALLOCATE";
-		case STARPU_FREE:
+		case STARPU_MP_COMMAND_FREE:
 			return "FREE";
-		case STARPU_RECV_FROM_HOST:
+		case STARPU_MP_COMMAND_RECV_FROM_HOST:
 			return "RECV_FROM_HOST";
-		case STARPU_SEND_TO_HOST:
+		case STARPU_MP_COMMAND_SEND_TO_HOST:
 			return "SEND_TO_HOST";
-		case STARPU_RECV_FROM_SINK:
+		case STARPU_MP_COMMAND_RECV_FROM_SINK:
 			return "RECV_FROM_SINK";
-		case STARPU_SEND_TO_SINK:
+		case STARPU_MP_COMMAND_SEND_TO_SINK:
 			return "SEND_TO_SINK";
-		case STARPU_TRANSFER_COMPLETE:
+		case STARPU_MP_COMMAND_TRANSFER_COMPLETE:
 			return "TRANSFER_COMPLETE";
-		case STARPU_SINK_NBCORES:
+		case STARPU_MP_COMMAND_SINK_NBCORES:
 			return "SINK_NBCORES";
-		case STARPU_ANSWER_SINK_NBCORES:
+		case STARPU_MP_COMMAND_ANSWER_SINK_NBCORES:
 			return "ANSWER_SINK_NBCORES";
-		case STARPU_EXECUTION_SUBMITTED:
+		case STARPU_MP_COMMAND_EXECUTION_SUBMITTED:
 			return "EXECUTION_SUBMITTED";
-		case STARPU_EXECUTION_COMPLETED:
+		case STARPU_MP_COMMAND_EXECUTION_COMPLETED:
 			return "EXECUTION_COMPLETED";
-		case STARPU_PRE_EXECUTION:
+		case STARPU_MP_COMMAND_PRE_EXECUTION:
 			return "PRE_EXECUTION";
-		case STARPU_SYNC_WORKERS:
+		case STARPU_MP_COMMAND_SYNC_WORKERS:
 			return "SYNC_WORKERS";
 		default:
 			return "<invalid command code>";
@@ -84,17 +84,17 @@ const char *_starpu_mp_common_node_kind_to_string(const int kind)
 {
 	switch(kind)
 	{
-		case STARPU_MIC_SINK:
+		case STARPU_NODE_MIC_SINK:
 			return "MIC_SINK";
-		case STARPU_MIC_SOURCE:
+		case STARPU_NODE_MIC_SOURCE:
 			return "MIC_SOURCE";
-		case STARPU_SCC_SINK:
+		case STARPU_NODE_SCC_SINK:
 			return "SCC_SINK";
-		case STARPU_SCC_SOURCE:
+		case STARPU_NODE_SCC_SOURCE:
 			return "SCC_SOURCE";
-		case STARPU_MPI_SINK:
+		case STARPU_NODE_MPI_SINK:
 			return "MPI_SINK";
-		case STARPU_MPI_SOURCE:
+		case STARPU_NODE_MPI_SOURCE:
 			return "MPI_SOURCE";
 		default:
 			return "<invalid command code>";
@@ -118,7 +118,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 	switch(node->kind)
 	{
 #ifdef STARPU_USE_MIC
-	case STARPU_MIC_SOURCE:
+	case STARPU_NODE_MIC_SOURCE:
 	{
 		node->nb_mp_sinks = starpu_mic_worker_get_count();
 		node->devid = peer_id;
@@ -143,7 +143,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 	}
 	break;
 
-	case STARPU_MIC_SINK:
+	case STARPU_NODE_MIC_SINK:
 	{
 		node->devid = atoi(starpu_getenv("_STARPU_MIC_DEVID"));
 		node->nb_mp_sinks = atoi(starpu_getenv("_STARPU_MIC_NB"));
@@ -171,12 +171,12 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 #endif /* STARPU_USE_MIC */
 
 #ifdef STARPU_USE_SCC
-	case STARPU_SCC_SOURCE:
+	case STARPU_NODE_SCC_SOURCE:
 	{
 		node->init = _starpu_scc_src_init;
 		node->deinit = NULL;
 		node->report_error = _starpu_scc_common_report_rcce_error;
-				
+
 		node->mp_recv_is_ready = _starpu_scc_common_recv_is_ready;
 		node->mp_send = _starpu_scc_common_send;
 		node->mp_recv = _starpu_scc_common_recv;
@@ -194,7 +194,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 	}
 	break;
 
-	case STARPU_SCC_SINK:
+	case STARPU_NODE_SCC_SINK:
 	{
 		node->init = _starpu_scc_sink_init;
 		node->launch_workers = _starpu_scc_sink_launch_workers;
@@ -220,11 +220,11 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 #endif /* STARPU_USE_SCC */
 
 #ifdef STARPU_USE_MPI
-	case STARPU_MPI_SOURCE:
+	case STARPU_NODE_MPI_SOURCE:
 		STARPU_ABORT();
 		break;
 
-	case STARPU_MPI_SINK:
+	case STARPU_NODE_MPI_SINK:
 		STARPU_ABORT();
 		break;
 #endif /* STARPU_USE_MPI */
@@ -244,7 +244,7 @@ _starpu_mp_common_node_create(enum _starpu_mp_node_kind node_kind,
 	STARPU_PTHREAD_MUTEX_INIT(&node->message_queue_mutex,NULL);
 
 	/* If the node is a sink then we must initialize some field */
-	if(node->kind == STARPU_MIC_SINK || node->kind == STARPU_SCC_SINK)
+	if(node->kind == STARPU_NODE_MIC_SINK || node->kind == STARPU_NODE_SCC_SINK)
 	{
 		int i;
 		node->is_running = 1;
@@ -272,11 +272,11 @@ void _starpu_mp_common_node_destroy(struct _starpu_mp_node *node)
 {
 	if (node->deinit)
 		node->deinit(node);
-		
+
 	STARPU_PTHREAD_MUTEX_DESTROY(&node->message_queue_mutex);
 
 	/* If the node is a sink then we must destroy some field */
-	if(node->kind == STARPU_MIC_SINK || node->kind == STARPU_SCC_SINK)
+	if(node->kind == STARPU_NODE_MIC_SINK || node->kind == STARPU_NODE_SCC_SINK)
 	{
 		int i;
 		for(i=0; i<node->nb_cores; i++)

src/drivers/mp_common/mp_common.h

@@ -42,40 +42,40 @@
 	(node)->report_error(__starpu_func__, __FILE__, __LINE__, (status))
 enum _starpu_mp_command
 {
-	STARPU_EXIT,
-	STARPU_EXECUTE,
-	STARPU_ERROR_EXECUTE,
-	STARPU_LOOKUP,
-	STARPU_ANSWER_LOOKUP,
-	STARPU_ERROR_LOOKUP,
-	STARPU_ALLOCATE,
-	STARPU_ANSWER_ALLOCATE,
-	STARPU_ERROR_ALLOCATE,
-	STARPU_FREE,
-	STARPU_RECV_FROM_HOST,
-	STARPU_SEND_TO_HOST,
-	STARPU_RECV_FROM_SINK,
-	STARPU_SEND_TO_SINK,
-	STARPU_TRANSFER_COMPLETE,
-	STARPU_SINK_NBCORES,
-	STARPU_ANSWER_SINK_NBCORES,
-	STARPU_EXECUTION_SUBMITTED,
-	STARPU_EXECUTION_COMPLETED,
-	STARPU_PRE_EXECUTION,
-	STARPU_SYNC_WORKERS,
+	STARPU_MP_COMMAND_EXIT,
+	STARPU_MP_COMMAND_EXECUTE,
+	STARPU_MP_COMMAND_ERROR_EXECUTE,
+	STARPU_MP_COMMAND_LOOKUP,
+	STARPU_MP_COMMAND_ANSWER_LOOKUP,
+	STARPU_MP_COMMAND_ERROR_LOOKUP,
+	STARPU_MP_COMMAND_ALLOCATE,
+	STARPU_MP_COMMAND_ANSWER_ALLOCATE,
+	STARPU_MP_COMMAND_ERROR_ALLOCATE,
+	STARPU_MP_COMMAND_FREE,
+	STARPU_MP_COMMAND_RECV_FROM_HOST,
+	STARPU_MP_COMMAND_SEND_TO_HOST,
+	STARPU_MP_COMMAND_RECV_FROM_SINK,
+	STARPU_MP_COMMAND_SEND_TO_SINK,
+	STARPU_MP_COMMAND_TRANSFER_COMPLETE,
+	STARPU_MP_COMMAND_SINK_NBCORES,
+	STARPU_MP_COMMAND_ANSWER_SINK_NBCORES,
+	STARPU_MP_COMMAND_EXECUTION_SUBMITTED,
+	STARPU_MP_COMMAND_EXECUTION_COMPLETED,
+	STARPU_MP_COMMAND_PRE_EXECUTION,
+	STARPU_MP_COMMAND_SYNC_WORKERS,
 };
 
 const char *_starpu_mp_common_command_to_string(const int command);
 
 enum _starpu_mp_node_kind
 {
-	STARPU_MIC_SINK,
-	STARPU_MIC_SOURCE,
-	STARPU_SCC_SINK,
-	STARPU_SCC_SOURCE,
-	STARPU_MPI_SINK,
-	STARPU_MPI_SOURCE,
-	STARPU_INVALID_KIND
+	STARPU_NODE_MIC_SINK,
+	STARPU_NODE_MIC_SOURCE,
+	STARPU_NODE_SCC_SINK,
+	STARPU_NODE_SCC_SOURCE,
+	STARPU_NODE_MPI_SINK,
+	STARPU_NODE_MPI_SOURCE,
+	STARPU_NODE_INVALID_KIND
 };
 
 const char *_starpu_mp_common_node_kind_to_string(const int kind);

src/drivers/mp_common/sink_common.c

@@ -42,13 +42,13 @@ static enum _starpu_mp_node_kind _starpu_sink_common_get_kind(void)
 	STARPU_ASSERT(node_kind);
 
 	if (!strcmp(node_kind, "STARPU_MIC"))
-		return STARPU_MIC_SINK;
+		return STARPU_NODE_MIC_SINK;
 	else if (!strcmp(node_kind, "STARPU_SCC"))
-		return STARPU_SCC_SINK;
+		return STARPU_NODE_SCC_SINK;
 	else if (!strcmp(node_kind, "STARPU_MPI"))
-		return STARPU_MPI_SINK;
+		return STARPU_NODE_MPI_SINK;
 	else
-		return STARPU_INVALID_KIND;
+		return STARPU_NODE_INVALID_KIND;
 }
 
 /* Send to host the number of cores of the sink device
@@ -56,7 +56,7 @@ static enum _starpu_mp_node_kind _starpu_sink_common_get_kind(void)
 static void _starpu_sink_common_get_nb_cores (struct _starpu_mp_node *node)
 {
 	// Process packet received from `_starpu_src_common_sink_cores'.
-     	_starpu_mp_common_send_command (node, STARPU_ANSWER_SINK_NBCORES,
+     	_starpu_mp_common_send_command (node, STARPU_MP_COMMAND_ANSWER_SINK_NBCORES,
 					&node->nb_cores, sizeof (int));
 }
 
@@ -73,10 +73,10 @@ static void _starpu_sink_common_lookup(const struct _starpu_mp_node *node,
 	/* If we couldn't find the function, let's send an error to the host.
 	 * The user probably made a mistake in the name */
 	if (func)
-		_starpu_mp_common_send_command(node, STARPU_ANSWER_LOOKUP,
+		_starpu_mp_common_send_command(node, STARPU_MP_COMMAND_ANSWER_LOOKUP,
 					       &func, sizeof(func));
 	else
-		_starpu_mp_common_send_command(node, STARPU_ERROR_LOOKUP,
+		_starpu_mp_common_send_command(node, STARPU_MP_COMMAND_ERROR_LOOKUP,
 					       NULL, 0);
 }
 
@@ -93,10 +93,10 @@ void _starpu_sink_common_allocate(const struct _starpu_mp_node *mp_node,
 	/* If the allocation fail, let's send an error to the host.
 	 */
 	if (addr)
-		_starpu_mp_common_send_command(mp_node, STARPU_ANSWER_ALLOCATE,
+		_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ANSWER_ALLOCATE,
 					       &addr, sizeof(addr));
 	else
-		_starpu_mp_common_send_command(mp_node, STARPU_ERROR_ALLOCATE,
+		_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ERROR_ALLOCATE,
 					       NULL, 0);
 }
 
@@ -137,7 +137,7 @@ static void _starpu_sink_common_copy_from_sink(const struct _starpu_mp_node *mp_
 
 	mp_node->dt_recv_from_device(mp_node, cmd->devid, cmd->addr, cmd->size);
 
-	_starpu_mp_common_send_command(mp_node, STARPU_TRANSFER_COMPLETE, NULL, 0);
+	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_TRANSFER_COMPLETE, NULL, 0);
 }
 
 static void _starpu_sink_common_copy_to_sink(const struct _starpu_mp_node *mp_node,
@@ -219,13 +219,13 @@ static void _starpu_sink_common_recv_workers(struct _starpu_mp_node * node, void
 void _starpu_sink_common_worker(void)
 {
 	struct _starpu_mp_node *node = NULL;
-	enum _starpu_mp_command command = STARPU_EXIT;
+	enum _starpu_mp_command command = STARPU_MP_COMMAND_EXIT;
 	int arg_size = 0;
 	void *arg = NULL;
 	int exit_starpu = 0;
 	enum _starpu_mp_node_kind node_kind = _starpu_sink_common_get_kind();
 
-	if (node_kind == STARPU_INVALID_KIND)
+	if (node_kind == STARPU_NODE_INVALID_KIND)
 		_STARPU_ERROR("No valid sink kind retrieved, use the"
 			      "STARPU_SINK environment variable to specify"
 			      "this\n");
@@ -245,44 +245,44 @@ void _starpu_sink_common_worker(void)
 			command = _starpu_mp_common_recv_command(node, &arg, &arg_size);
 			switch(command)
 			{
-				case STARPU_EXIT:
+				case STARPU_MP_COMMAND_EXIT:
 					exit_starpu = 1;
 					break;
-				case STARPU_EXECUTE:
+				case STARPU_MP_COMMAND_EXECUTE:
 					node->execute(node, arg, arg_size);
 					break;
-				case STARPU_SINK_NBCORES:
+				case STARPU_MP_COMMAND_SINK_NBCORES:
 					_starpu_sink_common_get_nb_cores(node);
 					break;
-				case STARPU_LOOKUP:
+				case STARPU_MP_COMMAND_LOOKUP:
 					_starpu_sink_common_lookup(node, (char *) arg);
 					break;
 
-				case STARPU_ALLOCATE:
+				case STARPU_MP_COMMAND_ALLOCATE:
 					node->allocate(node, arg, arg_size);
 					break;
 
-				case STARPU_FREE:
+				case STARPU_MP_COMMAND_FREE:
 					node->free(node, arg, arg_size);
 					break;
 
-				case STARPU_RECV_FROM_HOST:
+				case STARPU_MP_COMMAND_RECV_FROM_HOST:
 					_starpu_sink_common_copy_from_host(node, arg, arg_size);
 					break;
 
-				case STARPU_SEND_TO_HOST:
+				case STARPU_MP_COMMAND_SEND_TO_HOST:
 					_starpu_sink_common_copy_to_host(node, arg, arg_size);
 					break;
 
-				case STARPU_RECV_FROM_SINK:
+				case STARPU_MP_COMMAND_RECV_FROM_SINK:
 					_starpu_sink_common_copy_from_sink(node, arg, arg_size);
 					break;
 
-				case STARPU_SEND_TO_SINK:
+				case STARPU_MP_COMMAND_SEND_TO_SINK:
 					_starpu_sink_common_copy_to_sink(node, arg, arg_size);
 					break;
 
-				case STARPU_SYNC_WORKERS:
+				case STARPU_MP_COMMAND_SYNC_WORKERS:
 					_starpu_sink_common_recv_workers(node, arg, arg_size);
 					break;
 				default:
@@ -375,7 +375,7 @@ static void _starpu_sink_common_pre_execution_message(struct _starpu_mp_node *no
 {
 	/* Init message to tell the sink that the execution has begun */
 	struct mp_message * message = mp_message_new();
-	message->type = STARPU_PRE_EXECUTION;
+	message->type = STARPU_MP_COMMAND_PRE_EXECUTION;
 	STARPU_MALLOC(message->buffer, sizeof(int));
 	*(int *) message->buffer = task->combined_workerid;
 	message->size = sizeof(int);
@@ -392,7 +392,7 @@ static void _starpu_sink_common_execution_completed_message(struct _starpu_mp_no
 {
 	/* Init message to tell the sink that the execution is completed */
 	struct mp_message * message = mp_message_new();
-	message->type = STARPU_EXECUTION_COMPLETED;
+	message->type = STARPU_MP_COMMAND_EXECUTION_COMPLETED;
 	STARPU_MALLOC(message->buffer, sizeof(int));
 	*(int*) message->buffer = task->coreid;
 	message->size = sizeof(int);
@@ -618,7 +618,7 @@ void _starpu_sink_common_execute(struct _starpu_mp_node *node,
 
 
 	//_STARPU_DEBUG("telling host that we have submitted the task %p.\n", task->kernel);
-	_starpu_mp_common_send_command(node, STARPU_EXECUTION_SUBMITTED,
+	_starpu_mp_common_send_command(node, STARPU_MP_COMMAND_EXECUTION_SUBMITTED,
 			NULL, 0);
 
 	//_STARPU_DEBUG("executing the task %p\n", task->kernel);

src/drivers/mp_common/source_common.c

@@ -114,11 +114,11 @@ static int _starpu_src_common_handle_async(const struct _starpu_mp_node *node ST
 	struct _starpu_worker_set * worker_set=NULL;
 	switch(answer)
 	{
-		case STARPU_EXECUTION_COMPLETED:
+		case STARPU_MP_COMMAND_EXECUTION_COMPLETED:
 			worker_set = _starpu_get_worker_struct(starpu_worker_get_id())->set;
 			_starpu_src_common_process_completed_job(worker_set, arg, arg_size);
 			break;
-		case STARPU_PRE_EXECUTION:
+		case STARPU_MP_COMMAND_PRE_EXECUTION:
 			_starpu_src_common_pre_exec(arg,arg_size);
 			break;
 		default:
@@ -154,8 +154,8 @@ int _starpu_src_common_store_message(struct _starpu_mp_node *node,
 	struct mp_message * message = NULL;
 	switch(answer)
 	{
-		case STARPU_EXECUTION_COMPLETED:
-		case STARPU_PRE_EXECUTION:
+		case STARPU_MP_COMMAND_EXECUTION_COMPLETED:
+		case STARPU_MP_COMMAND_PRE_EXECUTION:
 			message = mp_message_new();
 			message->type = answer;
 			STARPU_MALLOC(message->buffer, arg_size);
@@ -213,7 +213,7 @@ static void _starpu_src_common_recv_async(struct _starpu_mp_node * node)
 	{
 		answer = _starpu_mp_common_recv_command (node, arg, arg_size);
 
-		if(answer == STARPU_EXECUTION_COMPLETED)
+		if(answer == STARPU_MP_COMMAND_EXECUTION_COMPLETED)
 		{
 			int coreid;
 			STARPU_ASSERT(sizeof(coreid) == *arg_size);
@@ -244,11 +244,11 @@ int _starpu_src_common_sink_nbcores (const struct _starpu_mp_node *node, int *bu
 	void *arg;
 	int arg_size = sizeof (int);
 
-	_starpu_mp_common_send_command (node, STARPU_SINK_NBCORES, NULL, 0);
+	_starpu_mp_common_send_command (node, STARPU_MP_COMMAND_SINK_NBCORES, NULL, 0);
 
 	answer = _starpu_mp_common_recv_command (node, &arg, &arg_size);
 
-	STARPU_ASSERT (answer == STARPU_ANSWER_SINK_NBCORES && arg_size == sizeof (int));
+	STARPU_ASSERT(answer == STARPU_MP_COMMAND_ANSWER_SINK_NBCORES && arg_size == sizeof (int));
 
 	memcpy (buf, arg, arg_size);
 
@@ -271,13 +271,13 @@ int _starpu_src_common_lookup(struct _starpu_mp_node *node,
 	arg_size = (strlen(func_name) + 1) * sizeof(char);
 
 	//_STARPU_DEBUG("Looking up %s\n", func_name);
-	_starpu_mp_common_send_command(node, STARPU_LOOKUP, (void *) func_name,
+	_starpu_mp_common_send_command(node, STARPU_MP_COMMAND_LOOKUP, (void *) func_name,
 			arg_size);
 
 	answer = _starpu_src_common_wait_command_sync(node, (void **) &arg,
 			&arg_size);
 
-	if (answer == STARPU_ERROR_LOOKUP)
+	if (answer == STARPU_MP_COMMAND_ERROR_LOOKUP)
 	{
 		_STARPU_DISP("Error looking up symbol %s\n", func_name);
 		return -ESPIPE;
@@ -285,7 +285,7 @@ int _starpu_src_common_lookup(struct _starpu_mp_node *node,
 
 	/* We have to be sure the device answered the right question and the
 	 * answer has the right size */
-	STARPU_ASSERT(answer == STARPU_ANSWER_LOOKUP);
+	STARPU_ASSERT(answer == STARPU_MP_COMMAND_ANSWER_LOOKUP);
 	STARPU_ASSERT(arg_size == sizeof(*func_ptr));
 
 	memcpy(func_ptr, arg, arg_size);
@@ -384,13 +384,13 @@ int _starpu_src_common_execute_kernel(struct _starpu_mp_node *node,
 	if (cl_arg)
 		memcpy((void*) buffer_ptr, cl_arg, cl_arg_size);
 
-	_starpu_mp_common_send_command(node, STARPU_EXECUTE, buffer, buffer_size);
+	_starpu_mp_common_send_command(node, STARPU_MP_COMMAND_EXECUTE, buffer, buffer_size);
 	enum _starpu_mp_command answer = _starpu_src_common_wait_command_sync(node, &arg, &arg_size);
 
-	if (answer == STARPU_ERROR_EXECUTE)
+	if (answer == STARPU_MP_COMMAND_ERROR_EXECUTE)
 		return -EINVAL;
 
-	STARPU_ASSERT(answer == STARPU_EXECUTION_SUBMITTED);
+	STARPU_ASSERT(answer == STARPU_MP_COMMAND_EXECUTION_SUBMITTED);
 
 	free(buffer);
 
@@ -454,15 +454,15 @@ int _starpu_src_common_allocate(struct _starpu_mp_node *mp_node,
 	void *arg;
 	int arg_size;
 
-	_starpu_mp_common_send_command(mp_node, STARPU_ALLOCATE, &size,
+	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_ALLOCATE, &size,
 			sizeof(size));
 
 	answer = _starpu_src_common_wait_command_sync(mp_node, &arg, &arg_size);
 
-	if (answer == STARPU_ERROR_ALLOCATE)
+	if (answer == STARPU_MP_COMMAND_ERROR_ALLOCATE)
 		return 1;
 
-	STARPU_ASSERT(answer == STARPU_ANSWER_ALLOCATE &&
+	STARPU_ASSERT(answer == STARPU_MP_COMMAND_ANSWER_ALLOCATE &&
 			arg_size == sizeof(*addr));
 
 	memcpy(addr, arg, arg_size);
@@ -476,7 +476,7 @@ int _starpu_src_common_allocate(struct _starpu_mp_node *mp_node,
 void _starpu_src_common_free(const struct _starpu_mp_node *mp_node,
 		void *addr)
 {
-	_starpu_mp_common_send_command(mp_node, STARPU_FREE, &addr, sizeof(addr));
+	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_FREE, &addr, sizeof(addr));
 }
 
 /* Send SIZE bytes pointed by SRC to DST on the sink linked to the MP_NODE.
@@ -486,7 +486,7 @@ int _starpu_src_common_copy_host_to_sink(const struct _starpu_mp_node *mp_node,
 {
 	struct _starpu_mp_transfer_command cmd = {size, dst};
 
-	_starpu_mp_common_send_command(mp_node, STARPU_RECV_FROM_HOST, &cmd, sizeof(cmd));
+	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_RECV_FROM_HOST, &cmd, sizeof(cmd));
 	mp_node->dt_send(mp_node, src, size);
 
 	return 0;
@@ -499,7 +499,7 @@ int _starpu_src_common_copy_sink_to_host(const struct _starpu_mp_node *mp_node,
 {
 	struct _starpu_mp_transfer_command cmd = {size, src};
 
-	_starpu_mp_common_send_command(mp_node, STARPU_SEND_TO_HOST, &cmd, sizeof(cmd));
+	_starpu_mp_common_send_command(mp_node, STARPU_MP_COMMAND_SEND_TO_HOST, &cmd, sizeof(cmd));
 	mp_node->dt_recv(mp_node, dst, size);
 
 	return 0;
@@ -518,19 +518,19 @@ int _starpu_src_common_copy_sink_to_sink(const struct _starpu_mp_node *src_node,
 	struct _starpu_mp_transfer_command_to_device cmd = {dst_node->peer_id, size, src};
 
 	/* Tell source to send data to dest. */
-	_starpu_mp_common_send_command(src_node, STARPU_SEND_TO_SINK, &cmd, sizeof(cmd));
+	_starpu_mp_common_send_command(src_node, STARPU_MP_COMMAND_SEND_TO_SINK, &cmd, sizeof(cmd));
 
 	cmd.devid = src_node->peer_id;
 	cmd.size = size;
 	cmd.addr = dst;
 
 	/* Tell dest to receive data from source. */
-	_starpu_mp_common_send_command(dst_node, STARPU_RECV_FROM_SINK, &cmd, sizeof(cmd));
+	_starpu_mp_common_send_command(dst_node, STARPU_MP_COMMAND_RECV_FROM_SINK, &cmd, sizeof(cmd));
 
 	/* Wait for answer from dest to know wether transfer is finished. */
 	answer = _starpu_mp_common_recv_command(dst_node, &arg, &arg_size);
 
-	STARPU_ASSERT(answer == STARPU_TRANSFER_COMPLETE);
+	STARPU_ASSERT(answer == STARPU_MP_COMMAND_TRANSFER_COMPLETE);
 
 	return 0;
 }
@@ -661,7 +661,7 @@ static void _starpu_src_common_send_workers(struct _starpu_mp_node * node, int b
 	msg[4] = starpu_worker_get_count();
 
 	/* tell the sink node that we will send him all workers */
-	_starpu_mp_common_send_command(node, STARPU_SYNC_WORKERS,
+	_starpu_mp_common_send_command(node, STARPU_MP_COMMAND_SYNC_WORKERS,
 			&msg, sizeof(msg));
 
 	/* Send all worker to the sink node */