mpi/src: introduce macros STARPU_MPI_MALLOC, STARPU_MPI_CALLOC and STARPU_MPI_REALLOC to make sure we always check the return value of stdlib malloc functions

mpi/src/starpu_mpi.c

@@ -95,8 +95,7 @@ extern void smpi_process_set_user_data(void *);
 
 static void _starpu_mpi_request_init(struct _starpu_mpi_req **req)
 {
-	*req = calloc(1, sizeof(struct _starpu_mpi_req));
-	STARPU_MPI_ASSERT_MSG(*req, "Invalid request");
+	STARPU_MPI_CALLOC(*req, 1, sizeof(struct _starpu_mpi_req));
 
 	/* Initialize the request structure */
 	(*req)->data_handle = NULL;
@@ -200,8 +199,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 			else
 			{
 				STARPU_ASSERT(req->count);
-				req->ptr = malloc(req->count);
-				STARPU_MPI_ASSERT_MSG(req->ptr, "cannot allocate message of size %ld\n", 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",
@@ -241,7 +239,8 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 				req->internal_req = early_data_handle->req;
 				req->early_data_handle = early_data_handle;
 
-				struct _starpu_mpi_early_data_cb_args *cb_args = malloc(sizeof(struct _starpu_mpi_early_data_cb_args));
+				struct _starpu_mpi_early_data_cb_args *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;
@@ -270,8 +269,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 					{
 						req->count = sync_req->count;
 						STARPU_ASSERT(req->count);
-						req->ptr = malloc(req->count);
-						STARPU_MPI_ASSERT_MSG(req->ptr, "cannot allocate message of size %ld\n", req->count);
+						STARPU_MPI_MALLOC(req->ptr, req->count);
 					}
 					_starpu_mpi_req_list_push_front(ready_requests, req);
 					_starpu_mpi_request_destroy(sync_req);
@@ -385,7 +383,7 @@ static void _starpu_mpi_isend_size_func(struct _starpu_mpi_req *req)
 {
 	_starpu_mpi_handle_allocate_datatype(req->data_handle, req);
 
-	req->envelope = calloc(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;
@@ -539,7 +537,8 @@ static void _starpu_mpi_irecv_data_func(struct _starpu_mpi_req *req)
 
 	if (req->sync)
 	{
-		struct _starpu_mpi_envelope *_envelope = calloc(1,sizeof(struct _starpu_mpi_envelope));
+		struct _starpu_mpi_envelope *_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);
@@ -1225,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);
-		early_data_handle->buffer = malloc(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 +1295,8 @@ 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 = malloc(*(argc_argv->argc) * sizeof(char*));
+	char **argv_cpy;
+	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;
-							early_request->ptr = malloc(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);
@@ -1587,7 +1587,8 @@ static void _starpu_mpi_add_sync_point_in_fxt(void)
 static
 int _starpu_mpi_initialize(int *argc, char ***argv, int initialize_mpi, MPI_Comm comm)
 {
-	struct _starpu_mpi_argc_argv *argc_argv = malloc(sizeof(struct _starpu_mpi_argc_argv));
+	struct _starpu_mpi_argc_argv *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;
@@ -1748,7 +1749,7 @@ void starpu_mpi_data_register_comm(starpu_data_handle_t data_handle, int tag, in
 	}
 	else
 	{
-		mpi_data = calloc(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

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2011, 2012, 2013, 2014, 2015  CNRS
+ * Copyright (C) 2011, 2012, 2013, 2014, 2015, 2016  CNRS
  * Copyright (C) 2011-2016  Université de Bordeaux
  * Copyright (C) 2014 INRIA
  *
@@ -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");
 
-	_cache_sent_data = malloc(_starpu_cache_comm_size * sizeof(struct _starpu_data_entry *));
-	_cache_received_data = malloc(_starpu_cache_comm_size * sizeof(struct _starpu_data_entry *));
-	_cache_sent_mutex = malloc(_starpu_cache_comm_size * sizeof(starpu_pthread_mutex_t));
-	_cache_received_mutex = malloc(_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++)
 	{
@@ -290,7 +290,8 @@ void *_starpu_mpi_cache_received_data_set(starpu_data_handle_t data, int mpi_ran
 	HASH_FIND_PTR(_cache_received_data[mpi_rank], &data, already_received);
 	if (already_received == NULL)
 	{
-		struct _starpu_data_entry *entry = (struct _starpu_data_entry *)malloc(sizeof(*entry));
+		struct _starpu_data_entry *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);
@@ -330,7 +331,8 @@ void *_starpu_mpi_cache_sent_data_set(starpu_data_handle_t data, int dest)
 	HASH_FIND_PTR(_cache_sent_data[dest], &data, already_sent);
 	if (already_sent == NULL)
 	{
-		struct _starpu_data_entry *entry = (struct _starpu_data_entry *)malloc(sizeof(*entry));
+		struct _starpu_data_entry *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

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2014, 2015  CNRS
+ * Copyright (C) 2014, 2015, 2016  CNRS
  *
  * 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
@@ -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);
 
-	comm_cache_amount = (size_t *) calloc(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

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2011, 2012, 2013, 2014, 2015  CNRS
+ * Copyright (C) 2011, 2012, 2013, 2014, 2015, 2016  CNRS
  *
  * 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
@@ -53,7 +53,7 @@ int starpu_mpi_scatter_detached(starpu_data_handle_t *data_handles, int count, i
 	if (callback)
 	{
 		callback_func = _callback_collective;
-		callback_arg = malloc(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;
 
-		callback_arg = malloc(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_comms = calloc(_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,16 +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_comms = 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 = calloc(1, sizeof(struct _starpu_mpi_comm));
+		struct _starpu_mpi_comm *_comm;
+		STARPU_MPI_CALLOC(_comm, 1, sizeof(struct _starpu_mpi_comm));
 		_comm->comm = comm;
-		_comm->envelope = calloc(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 = (struct _starpu_mpi_comm_hashtable *)malloc(sizeof(*entry));
+		struct _starpu_mpi_comm_hashtable *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

@@ -206,16 +206,18 @@ static void _starpu_mpi_handle_free_simple_datatype(MPI_Datatype *datatype)
 static void _starpu_mpi_handle_free_complex_datatype(MPI_Datatype *datatype)
 {
 	int num_ints, num_adds, num_datatypes, combiner, i;
-	int *array_of_ints;
-	MPI_Aint *array_of_adds;
-	MPI_Datatype *array_of_datatypes;
 
 	MPI_Type_get_envelope(*datatype, &num_ints, &num_adds, &num_datatypes, &combiner);
 	if (combiner != MPI_COMBINER_NAMED)
 	{
-		array_of_ints = (int *) malloc(num_ints * sizeof(int));
-		array_of_adds = (MPI_Aint *) malloc(num_adds * sizeof(MPI_Aint));
-		array_of_datatypes = (MPI_Datatype *) malloc(num_datatypes * sizeof(MPI_Datatype));
+		int *array_of_ints;
+		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));
+
 		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++)
 		{
@@ -282,7 +284,7 @@ int starpu_mpi_datatype_register(starpu_data_handle_t handle, starpu_mpi_datatyp
 	}
 	else
 	{
-		table = malloc(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

@@ -59,8 +59,8 @@ 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 = calloc(1, sizeof(struct _starpu_mpi_early_data_handle));
-	STARPU_ASSERT(early_data_handle);
+	struct _starpu_mpi_early_data_handle* 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)
 	{
-		hashlist = malloc(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)
 	{
-		hashlist = malloc(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

@@ -24,7 +24,8 @@
 /* Fortran related functions */
 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 = calloc(1,sizeof(*argcv));
+	struct _starpu_mpi_argc_argv *argcv;
+	STARPU_MPI_CALLOC(argcv, 1,sizeof(*argcv));
 	argcv->initialize_mpi = initialize_mpi;
 	if (comm_present) {
 		argcv->comm = MPI_Comm_f2c(comm);
@@ -33,7 +34,7 @@ struct _starpu_mpi_argc_argv *fstarpu_mpi_argcv_alloc(int argc, int initialize_m
 	}
 	argcv->fargc = argc;
 	argcv->argc = &argcv->fargc;
-	argcv->fargv = calloc(argc, sizeof(char *));
+	STARPU_MPI_CALLOC(argcv->fargv, argc, sizeof(char *));
 	argcv->argv = &argcv->fargv;
 	return argcv;
 }
@@ -42,7 +43,8 @@ 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 = malloc(len+1);
+	char *s;
+	STARPU_MPI_MALLOC(s, len+1);
 	memcpy(s, _s, len);
 	s[len] = '\0';
 	argcv->fargv[i] = s;
@@ -64,7 +66,9 @@ void fstarpu_mpi_argcv_free(struct _starpu_mpi_argc_argv *argcv)
 
 starpu_mpi_req *fstarpu_mpi_req_alloc(void)
 {
-	return calloc(1, sizeof(starpu_mpi_req));
+	void *ptr;
+	STARPU_MPI_CALLOC(ptr, 1, sizeof(starpu_mpi_req));
+	return ptr;
 }
 
 void fstarpu_mpi_req_free(starpu_mpi_req *req)
@@ -74,7 +78,9 @@ void fstarpu_mpi_req_free(starpu_mpi_req *req)
 
 MPI_Status *fstarpu_mpi_status_alloc(void)
 {
-	return calloc(1, sizeof(MPI_Status));
+	void *ptr;
+	STARPU_MPI_CALLOC(ptr, 1, sizeof(MPI_Status));
+	return ptr;
 }
 
 void fstarpu_mpi_status_free(MPI_Status *status)

mpi/src/starpu_mpi_helper.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2010, 2015  Université de Bordeaux
- * Copyright (C) 2010, 2012, 2014  CNRS
+ * Copyright (C) 2010, 2012, 2014, 2016  CNRS
  *
  * 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
@@ -16,6 +16,7 @@
  */
 
 #include <starpu_mpi.h>
+#include <starpu_mpi_private.h>
 
 static void starpu_mpi_unlock_tag_callback(void *arg)
 {
@@ -28,7 +29,8 @@ 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 = malloc(sizeof(starpu_tag_t));
+	starpu_tag_t *tagptr;
+	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);
@@ -37,7 +39,8 @@ 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 = malloc(sizeof(starpu_tag_t));
+	starpu_tag_t *tagptr;
+	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);
@@ -68,7 +71,8 @@ int starpu_mpi_isend_array_detached_unlock_tag(unsigned array_size,
 {
 	if (!array_size)
 		return 0;
-	struct arg_array *arg = malloc(sizeof(struct arg_array));
+	struct arg_array *arg;
+	STARPU_MPI_MALLOC(arg, sizeof(struct arg_array));
 
 	arg->array_size = array_size;
 	arg->tag = tag;
@@ -87,7 +91,8 @@ int starpu_mpi_irecv_array_detached_unlock_tag(unsigned array_size, starpu_data_
 {
 	if (!array_size)
 		return 0;
-	struct arg_array *arg = malloc(sizeof(struct arg_array));
+	struct arg_array *arg;
+	STARPU_MPI_MALLOC(arg, sizeof(struct arg_array));
 
 	arg->array_size = array_size;
 	arg->tag = tag;

mpi/src/starpu_mpi_private.h

@@ -69,6 +69,10 @@ 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)
+
 #ifdef STARPU_VERBOSE
 #  define _STARPU_MPI_COMM_DEBUG(count, datatype, node, tag, utag, comm, way) \
 	do \

mpi/src/starpu_mpi_select_node.c

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2014, 2015  CNRS
+ * Copyright (C) 2014, 2015, 2016  CNRS
  *
  * 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
@@ -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;
-	size_on_nodes = (size_t *)calloc(1, 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

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2012, 2013  CNRS
+ * Copyright (C) 2012, 2013, 2016  CNRS
  *
  * 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
@@ -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);
 
-	comm_amount = (size_t *) calloc(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)
 	{
-		hashlist = malloc(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

@@ -1,6 +1,6 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
- * Copyright (C) 2011, 2012, 2013, 2014, 2015  CNRS
+ * Copyright (C) 2011, 2012, 2013, 2014, 2015, 2016  CNRS
  * Copyright (C) 2011-2015  Université de Bordeaux
  * Copyright (C) 2014 INRIA
  *
@@ -76,8 +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;
-	entry = (struct handle_tag_entry *) malloc(sizeof(*entry));
-	STARPU_ASSERT(entry != NULL);
+	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();
 
-	descrs = (struct starpu_data_descr *)malloc(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;
-				descrs = (struct starpu_data_descr *)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;
-					descrs = (struct starpu_data_descr *)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;
-					descrs = (struct starpu_data_descr *)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;
@@ -711,7 +711,8 @@ void starpu_mpi_redux_data(MPI_Comm comm, starpu_data_handle_t data_handle)
 				 * reduction.
 				 */
 
-				struct _starpu_mpi_redux_data_args *args = malloc(sizeof(struct _starpu_mpi_redux_data_args));
+				struct _starpu_mpi_redux_data_args *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();
 
-	descrs = (struct starpu_data_descr *)malloc(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;
-				descrs = (struct starpu_data_descr *)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;
-					descrs = (struct starpu_data_descr *)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;
-					descrs = (struct starpu_data_descr *)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;