mpi: store the name of the MPI datatype in the starpu-mpi request

mpi/src/starpu_mpi.c

@@ -101,6 +101,7 @@ static void _starpu_mpi_request_init(struct _starpu_mpi_req **req)
 	(*req)->data_handle = NULL;
 
 	(*req)->datatype = 0;
+	(*req)->datatype_name = NULL;
 	(*req)->ptr = NULL;
 	(*req)->count = -1;
 	(*req)->registered_datatype = -1;
@@ -176,7 +177,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 		 * before the next submission of the envelope-catching request. */
 		if (req->is_internal_req)
 		{
-			_starpu_mpi_handle_allocate_datatype(req->data_handle, &req->datatype, &req->registered_datatype);
+			_starpu_mpi_handle_allocate_datatype(req->data_handle, req);
 			if (req->registered_datatype == 1)
 			{
 				req->count = 1;
@@ -191,7 +192,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 
 			_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",
 					  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr,
-					  _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype);
+					  req->datatype_name, (int)req->count, req->registered_datatype);
 			_starpu_mpi_req_list_push_front(ready_requests, req);
 
 			/* inform the starpu mpi thread that the request has been pushed in the ready_requests list */
@@ -242,7 +243,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 				if (sync_req)
 				{
 					req->sync = 1;
-					_starpu_mpi_handle_allocate_datatype(req->data_handle, &req->datatype, &req->registered_datatype);
+					_starpu_mpi_handle_allocate_datatype(req->data_handle, req);
 					if (req->registered_datatype == 1)
 					{
 						req->count = 1;
@@ -272,7 +273,7 @@ static void _starpu_mpi_submit_ready_request(void *arg)
 		_starpu_mpi_req_list_push_front(ready_requests, req);
 		_STARPU_MPI_DEBUG(3, "Pushing new request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d \n",
 				  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr,
-				  _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype);
+				  req->datatype_name, (int)req->count, req->registered_datatype);
 	}
 
 	newer_requests = 1;
@@ -332,7 +333,7 @@ static void _starpu_mpi_isend_data_func(struct _starpu_mpi_req *req)
 {
 	_STARPU_MPI_LOG_IN();
 
-	_STARPU_MPI_DEBUG(20, "post MPI isend request %p type %s tag %d src %d data %p datasize %ld ptr %p datatype '%s' count %d registered_datatype %d sync %d\n", req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, starpu_data_get_size(req->data_handle), req->ptr, _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype, req->sync);
+	_STARPU_MPI_DEBUG(30, "post MPI isend request %p type %s tag %d src %d data %p datasize %ld ptr %p datatype '%s' count %d registered_datatype %d sync %d\n", req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, starpu_data_get_size(req->data_handle), req->ptr, req->datatype_name, (int)req->count, req->registered_datatype, req->sync);
 
 	_starpu_mpi_comm_amounts_inc(req->node_tag.comm, req->node_tag.rank, req->datatype, req->count);
 
@@ -366,7 +367,7 @@ static void _starpu_mpi_isend_data_func(struct _starpu_mpi_req *req)
 
 static void _starpu_mpi_isend_size_func(struct _starpu_mpi_req *req)
 {
-	_starpu_mpi_handle_allocate_datatype(req->data_handle, &req->datatype, &req->registered_datatype);
+	_starpu_mpi_handle_allocate_datatype(req->data_handle, req);
 
 	req->envelope = calloc(1,sizeof(struct _starpu_mpi_envelope));
 	req->envelope->mode = _STARPU_MPI_ENVELOPE_DATA;
@@ -395,7 +396,7 @@ static void _starpu_mpi_isend_size_func(struct _starpu_mpi_req *req)
 		if (req->envelope->size != -1)
  		{
  			// We already know the size of the data, let's send it to overlap with the packing of the data
-			_STARPU_MPI_DEBUG(20, "Sending size %ld (%ld %s) to node %d (first call to pack)\n", req->envelope->size, sizeof(req->count), _starpu_mpi_datatype(MPI_BYTE), req->node_tag.rank);
+			_STARPU_MPI_DEBUG(20, "Sending size %ld (%ld %s) to node %d (first call to pack)\n", req->envelope->size, sizeof(req->count), "MPI_BYTE", req->node_tag.rank);
 			req->count = req->envelope->size;
 			_STARPU_MPI_COMM_TO_DEBUG(sizeof(struct _starpu_mpi_envelope), MPI_BYTE, req->node_tag.rank, _STARPU_MPI_TAG_ENVELOPE, _STARPU_MPI_TAG_ENVELOPE, req->node_tag.comm);
 			ret = MPI_Isend(req->envelope, sizeof(struct _starpu_mpi_envelope), MPI_BYTE, req->node_tag.rank, _STARPU_MPI_TAG_ENVELOPE, req->node_tag.comm, &req->size_req);
@@ -407,7 +408,7 @@ static void _starpu_mpi_isend_size_func(struct _starpu_mpi_req *req)
 		if (req->envelope->size == -1)
  		{
  			// We know the size now, let's send it
-			_STARPU_MPI_DEBUG(20, "Sending size %ld (%ld %s) to node %d (second call to pack)\n", req->envelope->size, sizeof(req->count), _starpu_mpi_datatype(MPI_BYTE), req->node_tag.rank);
+			_STARPU_MPI_DEBUG(20, "Sending size %ld (%ld %s) to node %d (second call to pack)\n", req->envelope->size, sizeof(req->count), "MPI_BYTE", req->node_tag.rank);
 			_STARPU_MPI_COMM_TO_DEBUG(sizeof(struct _starpu_mpi_envelope), MPI_BYTE, req->node_tag.rank, _STARPU_MPI_TAG_ENVELOPE, _STARPU_MPI_TAG_ENVELOPE, req->node_tag.comm);
 			ret = MPI_Isend(req->envelope, sizeof(struct _starpu_mpi_envelope), MPI_BYTE, req->node_tag.rank, _STARPU_MPI_TAG_ENVELOPE, req->node_tag.comm, &req->size_req);
 			STARPU_MPI_ASSERT_MSG(ret == MPI_SUCCESS, "when sending size, MPI_Isend returning %s", _starpu_mpi_get_mpi_code(ret));
@@ -516,7 +517,7 @@ static void _starpu_mpi_irecv_data_func(struct _starpu_mpi_req *req)
 {
 	_STARPU_MPI_LOG_IN();
 
-	_STARPU_MPI_DEBUG(20, "post MPI irecv request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d \n", req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr, _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype);
+	_STARPU_MPI_DEBUG(20, "post MPI irecv request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d \n", req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr, req->datatype_name, (int)req->count, req->registered_datatype);
 
 	_STARPU_MPI_TRACE_IRECV_SUBMIT_BEGIN(req->node_tag.rank, req->node_tag.data_tag);
 
@@ -723,7 +724,7 @@ static void _starpu_mpi_test_func(struct _starpu_mpi_req *testing_req)
 	struct _starpu_mpi_req *req = testing_req->other_request;
 
 	_STARPU_MPI_DEBUG(2, "Test request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d \n",
-			  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr, _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype);
+			  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr, req->datatype_name, (int)req->count, req->registered_datatype);
 
 	_STARPU_MPI_TRACE_UTESTING_BEGIN(req->node_tag.rank, req->node_tag.data_tag);
 
@@ -919,7 +920,7 @@ static void _starpu_mpi_handle_request_termination(struct _starpu_mpi_req *req)
 
 	_STARPU_MPI_DEBUG(2, "complete MPI request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d internal_req %p\n",
 			  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr,
-			  _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype, req->internal_req);
+			  req->datatype_name, (int)req->count, req->registered_datatype, req->internal_req);
 
 	if (req->internal_req)
 	{
@@ -1156,7 +1157,7 @@ static void _starpu_mpi_handle_ready_request(struct _starpu_mpi_req *req)
 
 	/* submit the request to MPI */
 	_STARPU_MPI_DEBUG(2, "Handling new request %p type %s tag %d src %d data %p ptr %p datatype '%s' count %d registered_datatype %d \n",
-			  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr, _starpu_mpi_datatype(req->datatype), (int)req->count, req->registered_datatype);
+			  req, _starpu_mpi_request_type(req->request_type), req->node_tag.data_tag, req->node_tag.rank, req->data_handle, req->ptr, req->datatype_name, (int)req->count, req->registered_datatype);
 	req->func(req);
 
 	_STARPU_MPI_LOG_OUT();
@@ -1467,7 +1468,7 @@ static void *_starpu_mpi_progress_thread_func(void *arg)
 						_STARPU_MPI_DEBUG(2000, "Request sync %d\n", envelope->sync);
 
 						early_request->sync = envelope->sync;
-						_starpu_mpi_handle_allocate_datatype(early_request->data_handle, &early_request->datatype, &early_request->registered_datatype);
+						_starpu_mpi_handle_allocate_datatype(early_request->data_handle, early_request);
 						if (early_request->registered_datatype == 1)
 						{
 							early_request->count = 1;

mpi/src/starpu_mpi_datatype.c

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009-2011, 2015  Université de Bordeaux
- * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015  CNRS
+ * Copyright (C) 2010, 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
@@ -155,7 +155,7 @@ static starpu_mpi_datatype_allocate_func_t handle_to_datatype_funcs[STARPU_MAX_I
 	[STARPU_MULTIFORMAT_INTERFACE_ID] = NULL,
 };
 
-void _starpu_mpi_handle_allocate_datatype(starpu_data_handle_t data_handle, MPI_Datatype *datatype, int *registered_datatype)
+void _starpu_mpi_handle_allocate_datatype(starpu_data_handle_t data_handle, struct _starpu_mpi_req *req)
 {
 	enum starpu_data_interface_id id = starpu_data_get_interface_id(data_handle);
 
@@ -163,8 +163,8 @@ void _starpu_mpi_handle_allocate_datatype(starpu_data_handle_t data_handle, MPI_
 	{
 		starpu_mpi_datatype_allocate_func_t func = handle_to_datatype_funcs[id];
 		STARPU_ASSERT_MSG(func, "Handle To Datatype Function not defined for StarPU data interface %d", id);
-		func(data_handle, datatype);
-		*registered_datatype = 1;
+		func(data_handle, &req->datatype);
+		req->registered_datatype = 1;
 	}
 	else
 	{
@@ -175,16 +175,27 @@ void _starpu_mpi_handle_allocate_datatype(starpu_data_handle_t data_handle, MPI_
 		if (table)
 		{
 			STARPU_ASSERT_MSG(table->allocate_datatype_func, "Handle To Datatype Function not defined for StarPU data interface %d", id);
-			table->allocate_datatype_func(data_handle, datatype);
-			*registered_datatype = 1;
+			table->allocate_datatype_func(data_handle, &req->datatype);
+			req->registered_datatype = 1;
 		}
 		else
 		{
 			/* The datatype is not predefined by StarPU */
-			*datatype = MPI_BYTE;
-			*registered_datatype = 0;
+			req->datatype = MPI_BYTE;
+			req->registered_datatype = 0;
 		}
 	}
+#ifdef STARPU_VERBOSE
+	{
+		char datatype_name[128];
+		int datatype_name_len;
+		MPI_Type_get_name(req->datatype, datatype_name, &datatype_name_len);
+		if (strcmp(datatype_name, "") == 0)
+			req->datatype_name = strdup("User defined datatype");
+		else
+			req->datatype_name = strdup(datatype_name);
+	}
+#endif
 }
 
 static void _starpu_mpi_handle_free_simple_datatype(MPI_Datatype *datatype)
@@ -255,42 +266,6 @@ void _starpu_mpi_handle_free_datatype(starpu_data_handle_t data_handle, MPI_Data
 	/* else the datatype is not predefined by StarPU */
 }
 
-char *_starpu_mpi_datatype(MPI_Datatype datatype)
-{
-	if (datatype == MPI_DATATYPE_NULL) return "MPI_DATATYPE_NULL";
-	if (datatype == MPI_CHAR) return "MPI_CHAR";
-	if (datatype == MPI_UNSIGNED_CHAR) return "MPI_UNSIGNED_CHAR";
-	if (datatype == MPI_BYTE) return "MPI_BYTE";
-	if (datatype == MPI_SHORT) return "MPI_SHORT";
-	if (datatype == MPI_UNSIGNED_SHORT) return "MPI_UNSIGNED_SHORT";
-	if (datatype == MPI_INT) return "MPI_INT";
-	if (datatype == MPI_UNSIGNED) return "MPI_UNSIGNED";
-	if (datatype == MPI_LONG) return "MPI_LONG";
-	if (datatype == MPI_UNSIGNED_LONG) return "MPI_UNSIGNED_LONG";
-	if (datatype == MPI_FLOAT) return "MPI_FLOAT";
-	if (datatype == MPI_DOUBLE) return "MPI_DOUBLE";
-	if (datatype == MPI_LONG_DOUBLE) return "MPI_LONG_DOUBLE";
-	if (datatype == MPI_LONG_LONG) return "MPI_LONG_LONG";
-	if (datatype == MPI_LONG_INT) return "MPI_LONG_INT";
-	if (datatype == MPI_SHORT_INT) return "MPI_SHORT_INT";
-	if (datatype == MPI_FLOAT_INT) return "MPI_FLOAT_INT";
-	if (datatype == MPI_DOUBLE_INT) return "MPI_DOUBLE_INT";
-	if (datatype == MPI_2INT) return "MPI_2INT";
-	if (datatype == MPI_2DOUBLE_PRECISION) return "MPI_2DOUBLE_PRECISION";
-	if (datatype == MPI_COMPLEX) return "MPI_COMPLEX";
-	if (datatype == MPI_DOUBLE_COMPLEX) return "MPI_DOUBLE_COMPLEX";
-	if (datatype == MPI_LOGICAL) return "MPI_LOGICAL";
-	if (datatype == MPI_REAL) return "MPI_REAL";
-	if (datatype == MPI_REAL4) return "MPI_REAL4";
-	if (datatype == MPI_REAL8) return "MPI_REAL8";
-	if (datatype == MPI_DOUBLE_PRECISION) return "MPI_DOUBLE_PRECISION";
-	if (datatype == MPI_INTEGER) return "MPI_INTEGER";
-	if (datatype == MPI_INTEGER4) return "MPI_INTEGER4";
-	if (datatype == MPI_PACKED) return "MPI_PACKED";
-	if (datatype == 0) return "Unknown datatype";
-	return "User defined MPI Datatype";
-}
-
 int starpu_mpi_datatype_register(starpu_data_handle_t handle, starpu_mpi_datatype_allocate_func_t allocate_datatype_func, starpu_mpi_datatype_free_func_t free_datatype_func)
 {
 	enum starpu_data_interface_id id = starpu_data_get_interface_id(handle);

mpi/src/starpu_mpi_datatype.h

@@ -1,7 +1,7 @@
 /* StarPU --- Runtime system for heterogeneous multicore architectures.
  *
  * Copyright (C) 2009-2011  Université de Bordeaux
- * Copyright (C) 2010, 2012, 2013, 2015  CNRS
+ * Copyright (C) 2010, 2012, 2013, 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
@@ -19,6 +19,7 @@
 #define __STARPU_MPI_DATATYPE_H__
 
 #include <starpu_mpi.h>
+#include <starpu_mpi_private.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,9 +28,8 @@ extern "C" {
 void _starpu_mpi_datatype_init(void);
 void _starpu_mpi_datatype_free(void);
 
-void _starpu_mpi_handle_allocate_datatype(starpu_data_handle_t data_handle, MPI_Datatype *datatype, int *registered_datatype);
+void _starpu_mpi_handle_allocate_datatype(starpu_data_handle_t data_handle, struct _starpu_mpi_req *req);
 void _starpu_mpi_handle_free_datatype(starpu_data_handle_t data_handle, MPI_Datatype *datatype);
-char *_starpu_mpi_datatype(MPI_Datatype datatype);
 
 #ifdef __cplusplus
 }

mpi/src/starpu_mpi_private.h

@@ -165,6 +165,7 @@ LIST_TYPE(_starpu_mpi_req,
 
 	/* description of the data to be sent/received */
 	MPI_Datatype datatype;
+	char *datatype_name;
 	void *ptr;
 	starpu_ssize_t count;
 	int registered_datatype;