Change mallocs

mpi/src/mpi_failure_tolerance/starpu_mpi_checkpoint.c

@@ -169,7 +169,7 @@ int starpu_mpi_submit_checkpoint_template(starpu_mpi_checkpoint_template_t cp_te
 		{
 			case STARPU_VALUE:
 				// TODO: Maybe do not pass via starpu handles for external data, and need to reimplement mpi comm layer for
-				arg = calloc(1, sizeof(struct _starpu_mpi_cp_ack_arg_cb));
+				arg = malloc(sizeof(struct _starpu_mpi_cp_ack_arg_cb));
 				arg->tag = item->tag;
 				arg->type = STARPU_VALUE;
 				arg->count = item->count;
@@ -210,7 +210,7 @@ int starpu_mpi_submit_checkpoint_template(starpu_mpi_checkpoint_template_t cp_te
 						break; // We don't want to CP a data that is still at initial state.
 					}
 					_STARPU_MPI_DEBUG(0, "Submit CP: sending starPU data to %d (tag %d)\n", item->backupped_by, (int)starpu_mpi_data_get_tag(handle));
-					arg = calloc(1, sizeof(struct _starpu_mpi_cp_ack_arg_cb));
+					arg = malloc(sizeof(struct _starpu_mpi_cp_ack_arg_cb));
 					arg->rank = item->backupped_by;
 					arg->handle = handle;
 					arg->tag = starpu_mpi_data_get_tag(handle);
@@ -230,7 +230,7 @@ int starpu_mpi_submit_checkpoint_template(starpu_mpi_checkpoint_template_t cp_te
 						break; // We don't want to CP a data that is still at initial state.
 					}
 					_STARPU_MPI_DEBUG(0, "Submit CP: receiving starPU data from %d (tag %d)\n", starpu_mpi_data_get_rank(handle), (int)starpu_mpi_data_get_tag(handle));
-					arg = calloc(1, sizeof(struct _starpu_mpi_cp_ack_arg_cb));
+					arg = malloc(sizeof(struct _starpu_mpi_cp_ack_arg_cb));
 					arg->rank = item->backup_of;
 					arg->handle = handle;
 					arg->tag = starpu_mpi_data_get_tag(handle);

mpi/src/mpi_failure_tolerance/starpu_mpi_checkpoint_package.c

@@ -24,7 +24,7 @@ int _checkpoint_package_data_delete_all();
 
 int checkpoint_package_init()
 {
-	starpu_pthread_mutex_init(&package_package_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&package_package_mutex, NULL);
 	checkpoint_data_list = _starpu_mpi_checkpoint_data_list_new();
 	_starpu_mpi_checkpoint_data_list_init(checkpoint_data_list);
 	return 0;
@@ -33,7 +33,7 @@ int checkpoint_package_init()
 int checkpoint_package_shutdown()
 {
 	_checkpoint_package_data_delete_all();
-	starpu_pthread_mutex_destroy(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&package_package_mutex);
 	return 0;
 }
 
@@ -96,10 +96,10 @@ int checkpoint_package_data_add(int cp_id, int cp_inst, int rank, starpu_mpi_tag
 	checkpoint_data->type = type;
 	checkpoint_data->ptr = ptr;
 	checkpoint_data->count = count;
-	starpu_pthread_mutex_lock(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&package_package_mutex);
 	_stats_store_checkpoint_data(checkpoint_data);
 	_starpu_mpi_checkpoint_data_list_push_back(checkpoint_data_list, checkpoint_data);
-	starpu_pthread_mutex_unlock(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&package_package_mutex);
 	_STARPU_MPI_DEBUG(8, "CP data (%p) added - cpid:%d - cpinst:%d - rank:%d - tag:%ld\n", checkpoint_data->ptr, checkpoint_data->cp_id, checkpoint_data->cp_inst, checkpoint_data->rank, checkpoint_data->tag);
 	return 0;
 }
@@ -135,7 +135,7 @@ int checkpoint_package_data_del(int cp_id, int cp_inst, int rank)
 	int done = 0;
 	size_t size = 0;
 	struct _starpu_mpi_checkpoint_data* next_checkpoint_data = NULL;
-	starpu_pthread_mutex_lock(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&package_package_mutex);
 	struct _starpu_mpi_checkpoint_data* checkpoint_data = _starpu_mpi_checkpoint_data_list_begin(checkpoint_data_list);
 	while (checkpoint_data != _starpu_mpi_checkpoint_data_list_end(checkpoint_data_list))
 	{
@@ -149,7 +149,7 @@ int checkpoint_package_data_del(int cp_id, int cp_inst, int rank)
 		}
 		checkpoint_data = next_checkpoint_data;
 	}
-	starpu_pthread_mutex_unlock(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&package_package_mutex);
 	_STARPU_MPI_DEBUG(0, "cleared %d data from checkpoint database (%ld bytes).\n", done, size);
 
 	return done;
@@ -160,7 +160,7 @@ int _checkpoint_package_data_delete_all()
 	int done = 0;
 	size_t size = 0;
 	struct _starpu_mpi_checkpoint_data* next_checkpoint_data = NULL;
-	starpu_pthread_mutex_lock(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&package_package_mutex);
 	struct _starpu_mpi_checkpoint_data* checkpoint_data = _starpu_mpi_checkpoint_data_list_begin(checkpoint_data_list);
 	while (checkpoint_data != _starpu_mpi_checkpoint_data_list_end(checkpoint_data_list))
 	{
@@ -170,7 +170,7 @@ int _checkpoint_package_data_delete_all()
 		done++;
 		checkpoint_data = next_checkpoint_data;
 	}
-	starpu_pthread_mutex_unlock(&package_package_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&package_package_mutex);
 	_STARPU_MPI_DEBUG(0, "cleared %d data from checkpoint database (%ld bytes).\n", done, size);
 
 	return done;

mpi/src/mpi_failure_tolerance/starpu_mpi_checkpoint_template.c

@@ -43,25 +43,25 @@ typedef int (*backup_of_fn)(int);
 int increment_current_instance()
 {
 	int _inst;
-	starpu_pthread_mutex_lock(&current_instance_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&current_instance_mutex);
 	_inst = ++current_instance;
-	starpu_pthread_mutex_unlock(&current_instance_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&current_instance_mutex);
 	return _inst;
 }
 
 int get_current_instance()
 {
 	int _inst;
-	starpu_pthread_mutex_lock(&current_instance_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&current_instance_mutex);
 	_inst = current_instance;
-	starpu_pthread_mutex_unlock(&current_instance_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&current_instance_mutex);
 	return _inst;
 }
 
 
 void checkpoint_template_lib_init(void) {
-	starpu_pthread_mutex_init(&current_instance_mutex, NULL);
-	starpu_pthread_mutex_init(&cp_template_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&current_instance_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&cp_template_mutex, NULL);
 	starpu_mpi_comm_rank(MPI_COMM_WORLD, &_my_rank);
 	starpu_mpi_comm_size(MPI_COMM_WORLD, &comm_size);
 	current_instance = 0;
@@ -85,14 +85,14 @@ void checkpoint_template_lib_quit(void) {
 
 int _starpu_mpi_checkpoint_template_add_data(starpu_mpi_checkpoint_template_t cp_template, int type, void* ptr, int count, int backupped_by, int backup_of, starpu_mpi_tag_t tag)
 {
-	starpu_pthread_mutex_lock(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cp_template->mutex);
 	STARPU_ASSERT_MSG(!cp_template->frozen, "It is not possible to modify registered checkpoint template.\n");
 	struct _starpu_mpi_checkpoint_template_item* item;
 	item = _starpu_mpi_checkpoint_template_item_create(type, ptr, count, backupped_by, backup_of, tag);
 	_starpu_mpi_checkpoint_template_item_list_push_back(&cp_template->list, item);
 	_checkpoint_template_add_to_backup_arrays(cp_template, backupped_by, backup_of);
 	_STARPU_MPI_DEBUG(5, "New checkpoint data entry %p (data:%p) has been added to cp_template with id:%d. (%s)\n", item, item->ptr, cp_template->cp_id, backupped_by == -1 ? "BACKUP_OF" : "BACKUPPED_BY");
-	starpu_pthread_mutex_unlock(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template->mutex);
 	return 0;
 }
 
@@ -236,19 +236,19 @@ int _starpu_mpi_checkpoint_post_cp_discard_send(starpu_mpi_checkpoint_template_t
 starpu_mpi_checkpoint_template_t _starpu_mpi_get_checkpoint_template_by_id(int checkpoint_id)
 {
 	int i;
-	starpu_pthread_mutex_lock(&cp_template_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cp_template_mutex);
 	for (i=0 ; i < cp_template_array_size ; i++)
 	{
-//		starpu_pthread_mutex_lock(&cp_template_array[i]->mutex);
+//		STARPU_PTHREAD_MUTEX_LOCK(&cp_template_array[i]->mutex);
 		if (cp_template_array[i]->cp_id == checkpoint_id)
 		{
-//			starpu_pthread_mutex_unlock(&cp_template_array[i]->mutex);
-			starpu_pthread_mutex_unlock(&cp_template_mutex);
+//			STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template_array[i]->mutex);
+			STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template_mutex);
 			return cp_template_array[i];
 		}
-//		starpu_pthread_mutex_unlock(&cp_template_array[i]->mutex);
+//		STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template_array[i]->mutex);
 	}
-	starpu_pthread_mutex_unlock(&cp_template_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template_mutex);
 	return NULL;
 }
 
@@ -357,7 +357,7 @@ int _starpu_mpi_checkpoint_template_freeze(starpu_mpi_checkpoint_template_t cp_t
 {
 //	char str[256];
 	int i;
-	starpu_pthread_mutex_lock(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cp_template->mutex);
 	_STARPU_MPI_DEBUG(2, "Start freezing checkpoint id:%d\n", cp_template->cp_id);
 	cp_template->frozen                 = 1;
 	cp_template->message_to_send_number = 0;
@@ -387,16 +387,16 @@ int _starpu_mpi_checkpoint_template_freeze(starpu_mpi_checkpoint_template_t cp_t
 //	}
 //	fprintf(stderr, "%s\n", str);
 
-	starpu_pthread_mutex_unlock(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template->mutex);
 
-	starpu_pthread_mutex_lock(&cp_template_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cp_template_mutex);
 	for (i=0 ; i < cp_template_array_size ; i++)
 	{
 		STARPU_ASSERT_MSG(cp_template_array[i]->cp_id != cp_template->cp_id, "A checkpoint with id %d has already been registered.\n", cp_template->cp_id);
 	}
 	cp_template_array[cp_template_array_size] = cp_template;
 	cp_template_array_size++;
-	starpu_pthread_mutex_unlock(&cp_template_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template_mutex);
 
 	_STARPU_MPI_DEBUG(2, "Checkpoint id:%d is frozen and registered.\n", cp_template->cp_id);
 	return cp_template->size;
@@ -455,7 +455,7 @@ int _checkpoint_template_digest_ack_reception(int checkpoint_id, int checkpoint_
 	int remaining_ack_messages;
 	struct _starpu_mpi_checkpoint_tracker* tracker, *tracker1;
 	starpu_mpi_checkpoint_template_t cp_template = _starpu_mpi_get_checkpoint_template_by_id(checkpoint_id);
-	starpu_pthread_mutex_lock(&cp_template_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cp_template_mutex);
 	_STARPU_MPI_DEBUG(20, "Digesting ack recv: id=%d, inst=%d\n", checkpoint_id, checkpoint_instance);
 
 	tracker = _starpu_mpi_checkpoint_tracker_update(cp_template, checkpoint_id, cp_template->checkpoint_domain, checkpoint_instance);
@@ -499,7 +499,7 @@ int _checkpoint_template_digest_ack_reception(int checkpoint_id, int checkpoint_
 	}
 
 	_STARPU_MPI_DEBUG(20, "Digested\n");
-	starpu_pthread_mutex_unlock(&cp_template_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template_mutex);
 	return 0;
 }
 

mpi/src/mpi_failure_tolerance/starpu_mpi_checkpoint_template.h

@@ -141,7 +141,7 @@ static inline starpu_mpi_checkpoint_template_t _starpu_mpi_checkpoint_template_n
 	starpu_malloc((void**)&_cp_template->backupped_by_array, _CHECKPOINT_TEMPLATE_BACKUPED_RANK_ARRAY_DEFAULT_SIZE);
 	_cp_template->backupped_by_array[0] = -1;
 	_cp_template->backupped_by_array_used_size = 0;
-	starpu_pthread_mutex_init(&_cp_template->mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&_cp_template->mutex, NULL);
 	return _cp_template;
 }
 
@@ -207,7 +207,7 @@ static inline int _starpu_checkpoint_template_free(starpu_mpi_checkpoint_templat
 {
 	struct _starpu_mpi_checkpoint_template_item* item;
 	struct _starpu_mpi_checkpoint_template_item* next_item;
-	starpu_pthread_mutex_lock(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&cp_template->mutex);
 	item = _starpu_mpi_checkpoint_template_get_first_data(cp_template);
 	while (item != _starpu_mpi_checkpoint_template_end(cp_template))
 	{
@@ -215,8 +215,8 @@ static inline int _starpu_checkpoint_template_free(starpu_mpi_checkpoint_templat
 		starpu_free(item);
 		item = next_item;
 	}
-	starpu_pthread_mutex_unlock(&cp_template->mutex);
-	starpu_pthread_mutex_destroy(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&cp_template->mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&cp_template->mutex);
 	starpu_free(cp_template);
 	return 0;
 }

mpi/src/mpi_failure_tolerance/starpu_mpi_checkpoint_tracker.c

@@ -146,38 +146,38 @@ static inline int _domain_tracker_delete_all()
 int _starpu_mpi_checkpoint_tracker_init()
 {
 	domain_tracker_list = _starpu_mpi_checkpoint_domain_tracker_index_list_new();
-	starpu_pthread_mutex_init(&tracker_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&tracker_mutex, NULL);
 	return 0;
 }
 
 int _starpu_mpi_checkpoint_tracker_shutdown()
 {
 	_domain_tracker_delete_all();
-	starpu_pthread_mutex_destroy(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&tracker_mutex);
 	free(domain_tracker_list);
 	return 0;
 }
 
 struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_template_get_tracking_inst_by_id_inst(int cp_domain, int cp_inst) {
-	starpu_pthread_mutex_lock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&tracker_mutex);
 	struct _starpu_mpi_checkpoint_domain_tracker_index *index = get_domain_tracker_index(cp_domain);
 	if (NULL == index) {
-		starpu_pthread_mutex_unlock(&tracker_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 		return NULL;
 	}
 	struct _starpu_mpi_checkpoint_domain_tracker_entry *entry = get_tracker_entry(index, cp_inst);
 	if (NULL == entry)
 	{
-		starpu_pthread_mutex_unlock(&tracker_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 		return NULL;
 	}
-	starpu_pthread_mutex_unlock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 	return &entry->tracker;
 }
 
 struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_template_create_instance_tracker(starpu_mpi_checkpoint_template_t cp_template, int cp_id, int cp_domain, int cp_inst)
 {
-	starpu_pthread_mutex_lock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&tracker_mutex);
 	struct _starpu_mpi_checkpoint_domain_tracker_entry *entry;
 	struct _starpu_mpi_checkpoint_domain_tracker_index *index = get_domain_tracker_index(cp_domain);
 	if (NULL == index)
@@ -185,13 +185,13 @@ struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_template_create_in
 	entry     = get_tracker_entry(index, cp_inst);
 	if (NULL == entry)
 		entry = add_tracker_entry(index, cp_id, cp_inst, cp_domain, cp_template);
-	starpu_pthread_mutex_unlock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 	return &entry->tracker;
 }
 
 struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_tracker_update(starpu_mpi_checkpoint_template_t cp_template, int cp_id, int cp_domain, int cp_instance)
 {
-	starpu_pthread_mutex_lock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&tracker_mutex);
 	struct _starpu_mpi_checkpoint_domain_tracker_entry* entry;
 	struct _starpu_mpi_checkpoint_domain_tracker_index* index = get_domain_tracker_index(cp_domain);
 	if (NULL == index)
@@ -204,7 +204,7 @@ struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_tracker_update(sta
 	}
 	STARPU_ASSERT_MSG(entry->tracker.ack_msg_count>0, "Error. Trying to count ack message while all have already been received. id:%d, inst:%d, remaining_ack_messages:%d\n", entry->tracker.cp_id, entry->instance, entry->tracker.ack_msg_count);
 	entry->tracker.ack_msg_count--;
-	starpu_pthread_mutex_unlock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 	return &entry->tracker;
 }
 
@@ -219,7 +219,7 @@ int _starpu_mpi_checkpoint_check_tracker(struct _starpu_mpi_checkpoint_tracker*
 
 struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_tracker_validate_instance(struct _starpu_mpi_checkpoint_tracker* tracker)
 {
-	starpu_pthread_mutex_lock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&tracker_mutex);
 	// Here we validate a checkpoint and return the old cp info that must be discarded
 	struct _starpu_mpi_checkpoint_tracker* temp_tracker;
 	struct _starpu_mpi_checkpoint_domain_tracker_index* index = get_domain_tracker_index(tracker->cp_domain);
@@ -234,7 +234,7 @@ struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_tracker_validate_i
 		{
 			temp_tracker->old = 1;
 		}
-		starpu_pthread_mutex_unlock(&tracker_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 		return temp_tracker;
 	}
 	else
@@ -245,15 +245,15 @@ struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_tracker_validate_i
 		// The checkpoint to validate is older than the latest validated, just return it to discard it
 		tracker->valid = 1;
 		tracker->old =1;
-		starpu_pthread_mutex_unlock(&tracker_mutex);
+		STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 		return tracker;
 	}
 }
 
 struct _starpu_mpi_checkpoint_tracker* _starpu_mpi_checkpoint_tracker_get_last_valid_tracker(int domain)
 {
-	starpu_pthread_mutex_lock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&tracker_mutex);
 	struct _starpu_mpi_checkpoint_domain_tracker_index* index = get_domain_tracker_index(domain);
-	starpu_pthread_mutex_unlock(&tracker_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&tracker_mutex);
 	return index->last_valid_instance;
 }

mpi/src/mpi_failure_tolerance/starpu_mpi_ft.c

@@ -26,7 +26,7 @@ int                              _my_rank;
 
 int starpu_mpi_ft_turn_on(void)
 {
-	starpu_pthread_mutex_init(&ft_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&ft_mutex, NULL);
 	starpu_mpi_comm_rank(MPI_COMM_WORLD, &_my_rank); //TODO: check compatibility with several Comms behaviour
 	starpu_mpi_ft_service_lib_init();
 	checkpoint_template_lib_init();
@@ -41,7 +41,7 @@ int starpu_mpi_ft_turn_off(void)
 	checkpoint_template_lib_quit();
 	checkpoint_package_shutdown();
 	_starpu_mpi_checkpoint_tracker_shutdown();
-	starpu_pthread_mutex_destroy(&ft_mutex);
+	STARPU_PTHREAD_MUTEX_DESTROY(&ft_mutex);
 	_STARPU_MPI_FT_STATS_WRITE_TO_FD(stderr);
 	_STARPU_MPI_FT_STATS_SHUTDOWN();
 	return 0;

mpi/src/mpi_failure_tolerance/starpu_mpi_ft_service_comms.c

@@ -263,7 +263,7 @@ void starpu_mpi_test_ft_detached_service_requests(void)
 int starpu_mpi_ft_service_lib_init()
 {
 	_starpu_mpi_req_list_init(&detached_ft_service_requests);
-	starpu_pthread_mutex_init(&detached_ft_service_requests_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&detached_ft_service_requests_mutex, NULL);
 
 	return 0;
 }

mpi/src/mpi_failure_tolerance/starpu_mpi_ft_stats.h

@@ -98,7 +98,7 @@ size_t size;
 
 static inline void stat_init()
 {
-	starpu_pthread_mutex_init(&_ft_stats_mutex, NULL);
+	STARPU_PTHREAD_MUTEX_INIT(&_ft_stats_mutex, NULL);
 	size_sample_list_init(&cp_data_in_memory_list);
 	cp_data_msgs_sent_count = 0;
 	cp_data_msgs_sent_total_size = 0;
@@ -122,73 +122,73 @@ static inline void stat_init()
 static inline void _starpu_ft_stats_send_data(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_msgs_sent_count++;
 	cp_data_msgs_sent_total_size+=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_cancel_send_data(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_msgs_sent_count--;
 	cp_data_msgs_sent_total_size-=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_send_data_cached(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_msgs_sent_cached_count++;
 	cp_data_msgs_sent_cached_total_size+=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_recv_data(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_msgs_received_count++;
 	cp_data_msgs_received_total_size+=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_cancel_recv_data(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_msgs_received_count--;
 	cp_data_msgs_received_total_size-=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_recv_data_cached(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_msgs_received_cached_count++;
 	cp_data_msgs_received_cached_total_size+=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_service_msg_send(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	ft_service_msgs_sent_count++;
 	ft_service_msgs_sent_total_size+=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_service_msg_recv(size_t size)
 {
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	ft_service_msgs_received_count++;
 	ft_service_msgs_received_total_size+=size;
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_add_cp_data_in_memory(size_t size)
@@ -196,7 +196,7 @@ static inline void _starpu_ft_stats_add_cp_data_in_memory(size_t size)
 	size_t tmp;
 	struct size_sample *tmp_sample, *sample = malloc(sizeof(struct size_sample));
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	cp_data_in_memory_size_total+=size;
 	tmp_sample = size_sample_list_back(&cp_data_in_memory_list);
 	tmp = (NULL==tmp_sample?0:tmp_sample->size);
@@ -207,7 +207,7 @@ static inline void _starpu_ft_stats_add_cp_data_in_memory(size_t size)
 	}
 	sample->size = tmp;
 	size_sample_list_push_back(&cp_data_in_memory_list, sample);
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _starpu_ft_stats_free_cp_data_in_memory(size_t size)
@@ -215,12 +215,12 @@ static inline void _starpu_ft_stats_free_cp_data_in_memory(size_t size)
 	size_t tmp;
 	struct size_sample* sample = malloc(sizeof(struct size_sample));
 	STARPU_ASSERT_MSG(size != -1, "Cannot count a data of size -1. An error has occured.\n");
-	starpu_pthread_mutex_lock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_LOCK(&_ft_stats_mutex);
 	tmp = size_sample_list_back(&cp_data_in_memory_list)->size;
 	tmp-=size;
 	sample->size = tmp;
 	size_sample_list_push_back(&cp_data_in_memory_list, sample);
-	starpu_pthread_mutex_unlock(&_ft_stats_mutex);
+	STARPU_PTHREAD_MUTEX_UNLOCK(&_ft_stats_mutex);
 }
 
 static inline void _ft_stats_free_cp_data_in_memory_list()