mpi/src: add character _ in front of macros STARPU_MPI_MALLOC, STARPU_MPI_CALLOC and STARPU_MPI_REALLOC

mpi/src/starpu_mpi.c

@@ -95,7 +95,7 @@ extern void smpi_process_set_user_data(void *);
 
 static void _starpu_mpi_request_init(struct _starpu_mpi_req **req)
 {
-	STARPU_MPI_CALLOC(*req, 1, sizeof(struct _starpu_mpi_req));
+	_STARPU_MPI_CALLOC(*req, 1, sizeof(struct _starpu_mpi_req));
 
 	/* Initialize the request structure */
 	(*req)->data_handle = NULL;
@@ -199,7 +199,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 			else
 			{
 				STARPU_ASSERT(req->count);
-				STARPU_MPI_MALLOC(req->ptr, req->count);
+				_STARPU_MPI_MALLOC(req->ptr, req->count);
 			}
 
 			_STARPU_MPI_DEBUG(3, "Pushing internal starpu_mpi_irecv request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d \n",
@@ -240,7 +240,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 				req->early_data_handle = early_data_handle;
 
 				struct _starpu_mpi_early_data_cb_args *cb_args;
-				STARPU_MPI_MALLOC(cb_args, sizeof(struct _starpu_mpi_early_data_cb_args));
+				_STARPU_MPI_MALLOC(cb_args, sizeof(struct _starpu_mpi_early_data_cb_args));
 				cb_args->data_handle = req->data_handle;
 				cb_args->early_handle = early_data_handle->handle;
 				cb_args->buffer = early_data_handle->buffer;
@@ -269,7 +269,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 					{
 						req->count = sync_req->count;
 						STARPU_ASSERT(req->count);
-						STARPU_MPI_MALLOC(req->ptr, req->count);
+						_STARPU_MPI_MALLOC(req->ptr, req->count);
 					}
 					_starpu_mpi_req_list_push_front(ready_requests, req);
 					_starpu_mpi_request_destroy(sync_req);
@@ -383,7 +383,7 @@ static void _starpu_mpi_isend_size_func(struct _starpu_mpi_req *req)
 {
 	_starpu_mpi_handle_allocate_datatype(req->data_handle, req);
 
-	STARPU_MPI_CALLOC(req->envelope, 1,sizeof(struct _starpu_mpi_envelope));
+	_STARPU_MPI_CALLOC(req->envelope, 1,sizeof(struct _starpu_mpi_envelope));
 	req->envelope->mode = _STARPU_MPI_ENVELOPE_DATA;
 	req->envelope->data_tag = req->node_tag.data_tag;
 	req->envelope->sync = req->sync;
@@ -538,7 +538,7 @@ static void _starpu_mpi_irecv_data_func(struct _starpu_mpi_req *req)
 	if (req->sync)
 	{
 		struct _starpu_mpi_envelope *_envelope;
-		STARPU_MPI_CALLOC(_envelope, 1, sizeof(struct _starpu_mpi_envelope));
+		_STARPU_MPI_CALLOC(_envelope, 1, sizeof(struct _starpu_mpi_envelope));
 		_envelope->mode = _STARPU_MPI_ENVELOPE_SYNC_READY;
 		_envelope->data_tag = req->node_tag.data_tag;
 		_STARPU_MPI_DEBUG(20, "Telling node %d it can send the data and waiting for the data back ...\n", req->node_tag.rank);
@@ -1224,7 +1224,7 @@ static void _starpu_mpi_receive_early_data(struct _starpu_mpi_envelope *envelope
 		 * to the application when it post a receive for this tag
 		 */
 		_STARPU_MPI_DEBUG(3, "Posting a receive for a data of size %d which has not yet been registered\n", (int)early_data_handle->env->size);
-		STARPU_MPI_MALLOC(early_data_handle->buffer, early_data_handle->env->size);
+		_STARPU_MPI_MALLOC(early_data_handle->buffer, early_data_handle->env->size);
 		starpu_variable_data_register(&early_data_handle->handle, STARPU_MAIN_RAM, (uintptr_t) early_data_handle->buffer, early_data_handle->env->size);
 		//_starpu_mpi_early_data_add(early_data_handle);
 	}
@@ -1296,7 +1296,7 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 #ifdef STARPU_SIMGRID
 	/* Now that MPI is set up, let the rest of simgrid get initialized */
 	char **argv_cpy;
-	STARPU_MPI_MALLOC(argv_cpy, *(argc_argv->argc) * sizeof(char*));
+	_STARPU_MPI_MALLOC(argv_cpy, *(argc_argv->argc) * sizeof(char*));
 	int i;
 	for (i = 0; i < *(argc_argv->argc); i++)
 		argv_cpy[i] = strdup((*(argc_argv->argv))[i]);
@@ -1485,7 +1485,7 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 						else
 						{
 							early_request->count = envelope->size;
-							STARPU_MPI_MALLOC(early_request->ptr, early_request->count);
+							_STARPU_MPI_MALLOC(early_request->ptr, early_request->count);
 							starpu_memory_allocate(STARPU_MAIN_RAM, early_request->count, STARPU_MEMORY_OVERFLOW);
 
 							STARPU_MPI_ASSERT_MSG(early_request->ptr, "cannot allocate message of size %ld\n", early_request->count);
@@ -1588,7 +1588,7 @@ static
 int _starpu_mpi_initialize(int *argc, char ***argv, int initialize_mpi, MPI_Comm comm)
 {
 	struct _starpu_mpi_argc_argv *argc_argv;
-	STARPU_MALLOC(argc_argv, sizeof(struct _starpu_mpi_argc_argv));
+	_STARPU_MALLOC(argc_argv, sizeof(struct _starpu_mpi_argc_argv));
 	argc_argv->initialize_mpi = initialize_mpi;
 	argc_argv->argc = argc;
 	argc_argv->argv = argv;
@@ -1749,7 +1749,7 @@ void starpu_mpi_data_register_comm(starpu_data_handle_t data_handle, int tag, in
 	}
 	else
 	{
-		STARPU_CALLOC(mpi_data, 1, sizeof(struct _starpu_mpi_node_tag));
+		_STARPU_CALLOC(mpi_data, 1, sizeof(struct _starpu_mpi_node_tag));
 		mpi_data->data_tag = -1;
 		mpi_data->rank = -1;
 		mpi_data->comm = MPI_COMM_WORLD;

mpi/src/starpu_mpi_cache.c

@@ -82,10 +82,10 @@ void _starpu_mpi_cache_init(MPI_Comm comm)
 	starpu_mpi_comm_size(comm, &_starpu_cache_comm_size);
 	_STARPU_MPI_DEBUG(2, "Initialising htable for cache\n");
 
-	STARPU_MPI_MALLOC(_cache_sent_data, _starpu_cache_comm_size * sizeof(struct _starpu_data_entry *));
-	STARPU_MPI_MALLOC(_cache_received_data, _starpu_cache_comm_size * sizeof(struct _starpu_data_entry *));
-	STARPU_MPI_MALLOC(_cache_sent_mutex, _starpu_cache_comm_size * sizeof(starpu_pthread_mutex_t));
-	STARPU_MPI_MALLOC(_cache_received_mutex, _starpu_cache_comm_size * sizeof(starpu_pthread_mutex_t));
+	_STARPU_MPI_MALLOC(_cache_sent_data, _starpu_cache_comm_size * sizeof(struct _starpu_data_entry *));
+	_STARPU_MPI_MALLOC(_cache_received_data, _starpu_cache_comm_size * sizeof(struct _starpu_data_entry *));
+	_STARPU_MPI_MALLOC(_cache_sent_mutex, _starpu_cache_comm_size * sizeof(starpu_pthread_mutex_t));
+	_STARPU_MPI_MALLOC(_cache_received_mutex, _starpu_cache_comm_size * sizeof(starpu_pthread_mutex_t));
 
 	for(i=0 ; i<_starpu_cache_comm_size ; i++)
 	{
@@ -291,7 +291,7 @@ void *_starpu_mpi_cache_received_data_set(starpu_data_handle_t data, int mpi_ran
 	if (already_received == NULL)
 	{
 		struct _starpu_data_entry *entry;
-		STARPU_MPI_MALLOC(entry, sizeof(*entry));
+		_STARPU_MPI_MALLOC(entry, sizeof(*entry));
 		entry->data = data;
 		HASH_ADD_PTR(_cache_received_data[mpi_rank], data, entry);
 		_STARPU_MPI_DEBUG(2, "Noting that data %p has already been received by %d\n", data, mpi_rank);
@@ -332,7 +332,7 @@ void *_starpu_mpi_cache_sent_data_set(starpu_data_handle_t data, int dest)
 	if (already_sent == NULL)
 	{
 		struct _starpu_data_entry *entry;
-		STARPU_MPI_MALLOC(entry, sizeof(*entry));
+		_STARPU_MPI_MALLOC(entry, sizeof(*entry));
 		entry->data = data;
 		HASH_ADD_PTR(_cache_sent_data[dest], data, entry);
 		_STARPU_MPI_DEBUG(2, "Noting that data %p has already been sent to %d\n", data, dest);

mpi/src/starpu_mpi_cache_stats.c

@@ -38,7 +38,7 @@ void _starpu_mpi_cache_stats_init(MPI_Comm comm)
 	starpu_mpi_comm_size(comm, &world_size);
 	_STARPU_MPI_DEBUG(1, "allocating for %d nodes\n", world_size);
 
-	STARPU_MPI_CALLOC(comm_cache_amount, world_size, sizeof(size_t));
+	_STARPU_MPI_CALLOC(comm_cache_amount, world_size, sizeof(size_t));
 }
 
 void _starpu_mpi_cache_stats_free()

mpi/src/starpu_mpi_collective.c

@@ -53,7 +53,7 @@ int starpu_mpi_scatter_detached(starpu_data_handle_t *data_handles, int count, i
 	if (callback)
 	{
 		callback_func = _callback_collective;
-		STARPU_MPI_MALLOC(callback_arg, sizeof(struct _callback_arg));
+		_STARPU_MPI_MALLOC(callback_arg, sizeof(struct _callback_arg));
 		callback_arg->count = 0;
 		callback_arg->nb = 0;
 		callback_arg->callback = (rank == root) ? scallback : rcallback;
@@ -121,7 +121,7 @@ int starpu_mpi_gather_detached(starpu_data_handle_t *data_handles, int count, in
 	{
 		callback_func = _callback_collective;
 
-		STARPU_MPI_MALLOC(callback_arg, sizeof(struct _callback_arg));
+		_STARPU_MPI_MALLOC(callback_arg, sizeof(struct _callback_arg));
 		callback_arg->count = 0;
 		callback_arg->nb = 0;
 		callback_arg->callback = callback;

mpi/src/starpu_mpi_comm.c

@@ -46,7 +46,7 @@ void _starpu_mpi_comm_init(MPI_Comm comm)
 {
 	_STARPU_MPI_DEBUG(10, "allocating for %d communicators\n", _starpu_mpi_comm_allocated);
 	_starpu_mpi_comm_allocated=10;
-	STARPU_MPI_CALLOC(_starpu_mpi_comms, _starpu_mpi_comm_allocated, sizeof(struct _starpu_mpi_comm *));
+	_STARPU_MPI_CALLOC(_starpu_mpi_comms, _starpu_mpi_comm_allocated, sizeof(struct _starpu_mpi_comm *));
 	_starpu_mpi_comm_nb=0;
 	_starpu_mpi_comm_tested=0;
 	_starpu_mpi_comms_cache = NULL;
@@ -92,18 +92,18 @@ void _starpu_mpi_comm_register(MPI_Comm comm)
 		{
 			_starpu_mpi_comm_allocated *= 2;
 			_STARPU_MPI_DEBUG(10, "reallocating for %d communicators\n", _starpu_mpi_comm_allocated);
-			STARPU_MPI_REALLOC(_starpu_mpi_comms, _starpu_mpi_comm_allocated * sizeof(struct _starpu_mpi_comm *));
+			_STARPU_MPI_REALLOC(_starpu_mpi_comms, _starpu_mpi_comm_allocated * sizeof(struct _starpu_mpi_comm *));
 		}
 		_STARPU_MPI_DEBUG(10, "registering comm %d (%d) number %d\n", comm, MPI_COMM_WORLD, _starpu_mpi_comm_nb);
 		struct _starpu_mpi_comm *_comm;
-		STARPU_MPI_CALLOC(_comm, 1, sizeof(struct _starpu_mpi_comm));
+		_STARPU_MPI_CALLOC(_comm, 1, sizeof(struct _starpu_mpi_comm));
 		_comm->comm = comm;
-		STARPU_MPI_CALLOC(_comm->envelope, 1,sizeof(struct _starpu_mpi_envelope));
+		_STARPU_MPI_CALLOC(_comm->envelope, 1,sizeof(struct _starpu_mpi_envelope));
 		_comm->posted = 0;
 		_starpu_mpi_comms[_starpu_mpi_comm_nb] = _comm;
 		_starpu_mpi_comm_nb++;
 		struct _starpu_mpi_comm_hashtable *entry;
-		STARPU_MPI_MALLOC(entry, sizeof(*entry));
+		_STARPU_MPI_MALLOC(entry, sizeof(*entry));
 		entry->comm = comm;
 		HASH_ADD(hh, _starpu_mpi_comms_cache, comm, sizeof(entry->comm), entry);
 	}

mpi/src/starpu_mpi_datatype.c

@@ -214,9 +214,9 @@ static void _starpu_mpi_handle_free_complex_datatype(MPI_Datatype *datatype)
 		MPI_Aint *array_of_adds;
 		MPI_Datatype *array_of_datatypes;
 
-		STARPU_MPI_MALLOC(array_of_ints, num_ints * sizeof(int));
-		STARPU_MPI_MALLOC(array_of_adds, num_adds * sizeof(MPI_Aint));
-		STARPU_MPI_MALLOC(array_of_datatypes, num_datatypes * sizeof(MPI_Datatype));
+		_STARPU_MPI_MALLOC(array_of_ints, num_ints * sizeof(int));
+		_STARPU_MPI_MALLOC(array_of_adds, num_adds * sizeof(MPI_Aint));
+		_STARPU_MPI_MALLOC(array_of_datatypes, num_datatypes * sizeof(MPI_Datatype));
 
 		MPI_Type_get_contents(*datatype, num_ints, num_adds, num_datatypes, array_of_ints, array_of_adds, array_of_datatypes);
 		for(i=0 ; i<num_datatypes ; i++)
@@ -284,7 +284,7 @@ int starpu_mpi_datatype_register(starpu_data_handle_t handle, starpu_mpi_datatyp
 	}
 	else
 	{
-		STARPU_MPI_MALLOC(table, sizeof(struct _starpu_mpi_datatype_funcs));
+		_STARPU_MPI_MALLOC(table, sizeof(struct _starpu_mpi_datatype_funcs));
 		table->id = id;
 		table->allocate_datatype_func = allocate_datatype_func;
 		table->free_datatype_func = free_datatype_func;

mpi/src/starpu_mpi_early_data.c

@@ -60,7 +60,7 @@ void _starpu_mpi_early_data_free(void)
 struct _starpu_mpi_early_data_handle *_starpu_mpi_early_data_create(struct _starpu_mpi_envelope *envelope, int source, MPI_Comm comm)
 {
 	struct _starpu_mpi_early_data_handle* early_data_handle;
-	STARPU_MPI_CALLOC(early_data_handle, 1, sizeof(struct _starpu_mpi_early_data_handle));
+	_STARPU_MPI_CALLOC(early_data_handle, 1, sizeof(struct _starpu_mpi_early_data_handle));
 	STARPU_PTHREAD_MUTEX_INIT(&early_data_handle->req_mutex, NULL);
 	STARPU_PTHREAD_COND_INIT(&early_data_handle->req_cond, NULL);
 	early_data_handle->env = envelope;
@@ -109,7 +109,7 @@ void _starpu_mpi_early_data_add(struct _starpu_mpi_early_data_handle *early_data
 	HASH_FIND(hh, _starpu_mpi_early_data_handle_hashmap, &early_data_handle->node_tag, sizeof(struct _starpu_mpi_node_tag), hashlist);
 	if (hashlist == NULL)
 	{
-		STARPU_MPI_MALLOC(hashlist, sizeof(struct _starpu_mpi_early_data_handle_hashlist));
+		_STARPU_MPI_MALLOC(hashlist, sizeof(struct _starpu_mpi_early_data_handle_hashlist));
 		hashlist->list = _starpu_mpi_early_data_handle_list_new();
 		hashlist->node_tag = early_data_handle->node_tag;
 		HASH_ADD(hh, _starpu_mpi_early_data_handle_hashmap, node_tag, sizeof(hashlist->node_tag), hashlist);

mpi/src/starpu_mpi_early_request.c

@@ -106,7 +106,7 @@ void _starpu_mpi_early_request_enqueue(struct _starpu_mpi_req *req)
 	HASH_FIND(hh, _starpu_mpi_early_request_hash, &req->node_tag, sizeof(struct _starpu_mpi_node_tag), hashlist);
 	if (hashlist == NULL)
 	{
-		STARPU_MPI_MALLOC(hashlist, sizeof(struct _starpu_mpi_early_request_hashlist));
+		_STARPU_MPI_MALLOC(hashlist, sizeof(struct _starpu_mpi_early_request_hashlist));
 		hashlist->list = _starpu_mpi_req_list_new();
 		hashlist->node_tag = req->node_tag;
 		HASH_ADD(hh, _starpu_mpi_early_request_hash, node_tag, sizeof(hashlist->node_tag), hashlist);

mpi/src/starpu_mpi_fortran.c

@@ -25,7 +25,7 @@
 struct _starpu_mpi_argc_argv *fstarpu_mpi_argcv_alloc(int argc, int initialize_mpi, int comm_present, MPI_Fint comm)
 {
 	struct _starpu_mpi_argc_argv *argcv;
-	STARPU_MPI_CALLOC(argcv, 1,sizeof(*argcv));
+	_STARPU_MPI_CALLOC(argcv, 1,sizeof(*argcv));
 	argcv->initialize_mpi = initialize_mpi;
 	if (comm_present) {
 		argcv->comm = MPI_Comm_f2c(comm);
@@ -34,7 +34,7 @@ struct _starpu_mpi_argc_argv *fstarpu_mpi_argcv_alloc(int argc, int initialize_m
 	}
 	argcv->fargc = argc;
 	argcv->argc = &argcv->fargc;
-	STARPU_MPI_CALLOC(argcv->fargv, argc, sizeof(char *));
+	_STARPU_MPI_CALLOC(argcv->fargv, argc, sizeof(char *));
 	argcv->argv = &argcv->fargv;
 	return argcv;
 }
@@ -44,7 +44,7 @@ void fstarpu_mpi_argcv_set_arg(struct _starpu_mpi_argc_argv *argcv, int i, int l
 	STARPU_ASSERT(len >= 0);
 	STARPU_ASSERT(i >= 0 && i < argcv->fargc);
 	char *s;
-	STARPU_MPI_MALLOC(s, len+1);
+	_STARPU_MPI_MALLOC(s, len+1);
 	memcpy(s, _s, len);
 	s[len] = '\0';
 	argcv->fargv[i] = s;
@@ -67,7 +67,7 @@ void fstarpu_mpi_argcv_free(struct _starpu_mpi_argc_argv *argcv)
 starpu_mpi_req *fstarpu_mpi_req_alloc(void)
 {
 	void *ptr;
-	STARPU_MPI_CALLOC(ptr, 1, sizeof(starpu_mpi_req));
+	_STARPU_MPI_CALLOC(ptr, 1, sizeof(starpu_mpi_req));
 	return ptr;
 }
 
@@ -79,7 +79,7 @@ void fstarpu_mpi_req_free(starpu_mpi_req *req)
 MPI_Status *fstarpu_mpi_status_alloc(void)
 {
 	void *ptr;
-	STARPU_MPI_CALLOC(ptr, 1, sizeof(MPI_Status));
+	_STARPU_MPI_CALLOC(ptr, 1, sizeof(MPI_Status));
 	return ptr;
 }
 

mpi/src/starpu_mpi_helper.c

@@ -30,7 +30,7 @@ static void starpu_mpi_unlock_tag_callback(void *arg)
 int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle_t data_handle, int dest, int data_tag, MPI_Comm comm, starpu_tag_t tag)
 {
 	starpu_tag_t *tagptr;
-	STARPU_MPI_MALLOC(tagptr, sizeof(starpu_tag_t));
+	_STARPU_MPI_MALLOC(tagptr, sizeof(starpu_tag_t));
 	*tagptr = tag;
 
 	return starpu_mpi_isend_detached(data_handle, dest, data_tag, comm, starpu_mpi_unlock_tag_callback, tagptr);
@@ -40,7 +40,7 @@ int starpu_mpi_isend_detached_unlock_tag(starpu_data_handle_t data_handle, int d
 int starpu_mpi_irecv_detached_unlock_tag(starpu_data_handle_t data_handle, int source, int data_tag, MPI_Comm comm, starpu_tag_t tag)
 {
 	starpu_tag_t *tagptr;
-	STARPU_MPI_MALLOC(tagptr, sizeof(starpu_tag_t));
+	_STARPU_MPI_MALLOC(tagptr, sizeof(starpu_tag_t));
 	*tagptr = tag;
 
 	return starpu_mpi_irecv_detached(data_handle, source, data_tag, comm, starpu_mpi_unlock_tag_callback, tagptr);
@@ -72,7 +72,7 @@ int starpu_mpi_isend_array_detached_unlock_tag(unsigned array_size,
 	if (!array_size)
 		return 0;
 	struct arg_array *arg;
-	STARPU_MPI_MALLOC(arg, sizeof(struct arg_array));
+	_STARPU_MPI_MALLOC(arg, sizeof(struct arg_array));
 
 	arg->array_size = array_size;
 	arg->tag = tag;
@@ -92,7 +92,7 @@ int starpu_mpi_irecv_array_detached_unlock_tag(unsigned array_size, starpu_data_
 	if (!array_size)
 		return 0;
 	struct arg_array *arg;
-	STARPU_MPI_MALLOC(arg, sizeof(struct arg_array));
+	_STARPU_MPI_MALLOC(arg, sizeof(struct arg_array));
 
 	arg->array_size = array_size;
 	arg->tag = tag;

mpi/src/starpu_mpi_private.h

@@ -69,9 +69,9 @@ int _starpu_debug_rank;
 #  endif
 #endif
 
-#define STARPU_MPI_MALLOC(ptr, size) do { ptr = malloc(size); STARPU_MPI_ASSERT_MSG(ptr != NULL, "Cannot allocate %ld bytes\n", size); } while (0)
-#define STARPU_MPI_CALLOC(ptr, nmemb, size) do { ptr = calloc(nmemb, size); STARPU_MPI_ASSERT_MSG(ptr != NULL, "Cannot allocate %ld bytes\n", nmemb*size); } while (0)
-#define STARPU_MPI_REALLOC(ptr, size) do { ptr = realloc(ptr, size); STARPU_MPI_ASSERT_MSG(ptr != NULL, "Cannot reallocate %ld bytes\n", size); } while (0)
+#define _STARPU_MPI_MALLOC(ptr, size) do { ptr = malloc(size); STARPU_MPI_ASSERT_MSG(ptr != NULL, "Cannot allocate %ld bytes\n", size); } while (0)
+#define _STARPU_MPI_CALLOC(ptr, nmemb, size) do { ptr = calloc(nmemb, size); STARPU_MPI_ASSERT_MSG(ptr != NULL, "Cannot allocate %ld bytes\n", nmemb*size); } while (0)
+#define _STARPU_MPI_REALLOC(ptr, size) do { ptr = realloc(ptr, size); STARPU_MPI_ASSERT_MSG(ptr != NULL, "Cannot reallocate %ld bytes\n", size); } while (0)
 
 #ifdef STARPU_VERBOSE
 #  define _STARPU_MPI_COMM_DEBUG(count, datatype, node, tag, utag, comm, way) \

mpi/src/starpu_mpi_select_node.c

@@ -80,7 +80,7 @@ int _starpu_mpi_select_node_with_most_R_data(int me, int nb_nodes, struct starpu
 	int xrank = 0;
 
 	(void)me;
-	STARPU_MPI_CALLOC(size_on_nodes, nb_nodes, sizeof(size_t));
+	_STARPU_MPI_CALLOC(size_on_nodes, nb_nodes, sizeof(size_t));
 
 	for(i= 0 ; i<nb_data ; i++)
 	{

mpi/src/starpu_mpi_stats.c

@@ -39,7 +39,7 @@ void _starpu_mpi_comm_amounts_init(MPI_Comm comm)
 	starpu_mpi_comm_size(comm, &world_size);
 	_STARPU_MPI_DEBUG(1, "allocating for %d nodes\n", world_size);
 
-	STARPU_MPI_CALLOC(comm_amount, world_size, sizeof(size_t));
+	_STARPU_MPI_CALLOC(comm_amount, world_size, sizeof(size_t));
 }
 
 void _starpu_mpi_comm_amounts_free()

mpi/src/starpu_mpi_sync_data.c

@@ -135,7 +135,7 @@ void _starpu_mpi_sync_data_add(struct _starpu_mpi_req *sync_req)
 	HASH_FIND(hh, _starpu_mpi_sync_data_handle_hashmap, &sync_req->node_tag, sizeof(struct _starpu_mpi_node_tag), hashlist);
 	if (hashlist == NULL)
 	{
-		STARPU_MPI_MALLOC(hashlist, sizeof(struct _starpu_mpi_sync_data_handle_hashlist));
+		_STARPU_MPI_MALLOC(hashlist, sizeof(struct _starpu_mpi_sync_data_handle_hashlist));
 		hashlist->list = _starpu_mpi_req_list_new();
 		hashlist->node_tag = sync_req->node_tag;
 		HASH_ADD(hh, _starpu_mpi_sync_data_handle_hashmap, node_tag, sizeof(hashlist->node_tag), hashlist);

mpi/src/starpu_mpi_tag.c

@@ -76,7 +76,7 @@ starpu_data_handle_t _starpu_mpi_data_get_data_handle_from_tag(int tag)
 void _starpu_mpi_data_register_tag(starpu_data_handle_t handle, int tag)
 {
 	struct handle_tag_entry *entry;
-	STARPU_MPI_MALLOC(entry, sizeof(*entry));
+	_STARPU_MPI_MALLOC(entry, sizeof(*entry));
 
 	STARPU_ASSERT_MSG(!(_starpu_mpi_data_get_data_handle_from_tag(tag)),
 			  "There is already a data handle %p registered with the tag %d\n", _starpu_mpi_data_get_data_handle_from_tag(tag), tag);

mpi/src/starpu_mpi_task_insert.c

@@ -192,7 +192,7 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 
 	_STARPU_TRACE_TASK_MPI_DECODE_START();
 
-	STARPU_MPI_MALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+	_STARPU_MPI_MALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 	nb_data = 0;
 	*do_execute = -1;
 	*xrank = -1;
@@ -244,7 +244,7 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 			if (nb_data >= nb_allocated_data)
 			{
 				nb_allocated_data *= 2;
-				STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+				_STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 			}
 			descrs[nb_data].handle = data;
 			descrs[nb_data].mode = mode;
@@ -274,7 +274,7 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 				if (nb_data >= nb_allocated_data)
 				{
 					nb_allocated_data *= 2;
-					STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+					_STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 				}
 				descrs[nb_data].handle = datas[i];
 				descrs[nb_data].mode = mode;
@@ -304,7 +304,7 @@ int _starpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_nod
 				if (nb_data >= nb_allocated_data)
 				{
 					nb_allocated_data *= 2;
-					STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+					_STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 				}
 				descrs[nb_data].handle = _descrs[i].handle;
 				descrs[nb_data].mode = mode;
@@ -712,7 +712,7 @@ void starpu_mpi_redux_data(MPI_Comm comm, starpu_data_handle_t data_handle)
 				 */
 
 				struct _starpu_mpi_redux_data_args *args;
-				STARPU_MPI_MALLOC(args, sizeof(struct _starpu_mpi_redux_data_args));
+				_STARPU_MPI_MALLOC(args, sizeof(struct _starpu_mpi_redux_data_args));
 				args->data_handle = data_handle;
 				args->tag = tag;
 				args->node = i;

mpi/src/starpu_mpi_task_insert_fortran.c

@@ -38,7 +38,7 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 
 	_STARPU_TRACE_TASK_MPI_DECODE_START();
 
-	STARPU_MPI_MALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+	_STARPU_MPI_MALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 	nb_data = 0;
 	*do_execute = -1;
 	*xrank = -1;
@@ -93,7 +93,7 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 			if (nb_data >= nb_allocated_data)
 			{
 				nb_allocated_data *= 2;
-				STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+				_STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 			}
 			descrs[nb_data].handle = data;
 			descrs[nb_data].mode = mode;
@@ -124,7 +124,7 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 				if (nb_data >= nb_allocated_data)
 				{
 					nb_allocated_data *= 2;
-					STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+					_STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 				}
 				descrs[nb_data].handle = datas[i];
 				descrs[nb_data].mode = mode;
@@ -155,7 +155,7 @@ int _fstarpu_mpi_task_decode_v(struct starpu_codelet *codelet, int me, int nb_no
 				if (nb_data >= nb_allocated_data)
 				{
 					nb_allocated_data *= 2;
-					STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
+					_STARPU_MPI_REALLOC(descrs, nb_allocated_data * sizeof(struct starpu_data_descr));
 				}
 				descrs[nb_data].handle = _descrs[i].handle;
 				descrs[nb_data].mode = mode;