Merge branch 'master' of git+ssh://scm.gforge.inria.fr//gitroot/simgrid/simgrid

[simgrid.git] / src / smpi / smpi_mpi_dt.c

diff --git a/src/smpi/smpi_mpi_dt.c b/src/smpi/smpi_mpi_dt.c
index 2ad759c..07bec7c 100644 (file)
--- a/src/smpi/smpi_mpi_dt.c
+++ b/src/smpi/smpi_mpi_dt.c
@@ -22,6 +22,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi_dt, smpi,
 
 #define CREATE_MPI_DATATYPE(name, type)       \
   static s_smpi_mpi_datatype_t mpi_##name = { \
+    (char*) # name,                                   \
     sizeof(type),  /* size */                 \
     0,             /*was 1 has_subtype*/             \
     0,             /* lb */                   \
@@ -33,6 +34,7 @@ MPI_Datatype name = &mpi_##name;
 
 #define CREATE_MPI_DATATYPE_NULL(name)       \
   static s_smpi_mpi_datatype_t mpi_##name = { \
+    (char*) # name,                                   \
     0,  /* size */                 \
     0,             /*was 1 has_subtype*/             \
     0,             /* lb */                   \
@@ -51,6 +53,10 @@ typedef struct {
   float value;
   float index;
 } float_float;
+typedef struct {
+  long value;
+  long index;
+} long_long;
 typedef struct {
   double value;
   double index;
@@ -75,7 +81,10 @@ typedef struct {
   long double value;
   int index;
 } long_double_int;
-
+typedef struct {
+  int64_t value;
+  int64_t index;
+} integer128_t;
 // Predefined data types
 CREATE_MPI_DATATYPE(MPI_CHAR, char);
 CREATE_MPI_DATATYPE(MPI_SHORT, short);
@@ -93,6 +102,7 @@ CREATE_MPI_DATATYPE(MPI_DOUBLE, double);
 CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE, long double);
 CREATE_MPI_DATATYPE(MPI_WCHAR, wchar_t);
 CREATE_MPI_DATATYPE(MPI_C_BOOL, _Bool);
+CREATE_MPI_DATATYPE(MPI_BYTE, int8_t);
 CREATE_MPI_DATATYPE(MPI_INT8_T, int8_t);
 CREATE_MPI_DATATYPE(MPI_INT16_T, int16_t);
 CREATE_MPI_DATATYPE(MPI_INT32_T, int32_t);
@@ -114,6 +124,19 @@ CREATE_MPI_DATATYPE(MPI_SHORT_INT, short_int);
 CREATE_MPI_DATATYPE(MPI_2INT, int_int);
 CREATE_MPI_DATATYPE(MPI_2FLOAT, float_float);
 CREATE_MPI_DATATYPE(MPI_2DOUBLE, double_double);
+CREATE_MPI_DATATYPE(MPI_2LONG, long_long);
+
+CREATE_MPI_DATATYPE(MPI_REAL4, float);
+CREATE_MPI_DATATYPE(MPI_REAL8, float);
+CREATE_MPI_DATATYPE(MPI_REAL16, double);
+CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX8);
+CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX16);
+CREATE_MPI_DATATYPE_NULL(MPI_COMPLEX32);
+CREATE_MPI_DATATYPE(MPI_INTEGER1, int);
+CREATE_MPI_DATATYPE(MPI_INTEGER2, int16_t);
+CREATE_MPI_DATATYPE(MPI_INTEGER4, int32_t);
+CREATE_MPI_DATATYPE(MPI_INTEGER8, int64_t);
+CREATE_MPI_DATATYPE(MPI_INTEGER16, integer128_t);
 
 CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, long_double_int);
 
@@ -151,21 +174,40 @@ MPI_Datatype smpi_datatype_dup(MPI_Datatype datatype)
   memcpy(new_t, datatype, sizeof(s_smpi_mpi_datatype_t));
   if (datatype->has_subtype)
     memcpy(new_t->substruct, datatype->substruct, sizeof(s_smpi_subtype_t));
+  if(datatype->name)
+    new_t->name = strdup(datatype->name);
   return new_t;
 }
 
 int smpi_datatype_extent(MPI_Datatype datatype, MPI_Aint * lb,
                          MPI_Aint * extent)
 {
+  if(datatype == MPI_DATATYPE_NULL){
+    *lb=0;
+    *extent=0;
+    return MPI_SUCCESS;
+  }
   *lb = datatype->lb;
   *extent = datatype->ub - datatype->lb;
   return MPI_SUCCESS;
 }
 
 MPI_Aint smpi_datatype_get_extent(MPI_Datatype datatype){
+  if(datatype == MPI_DATATYPE_NULL){
+    return 0;
+  }
   return datatype->ub - datatype->lb;
 }
 
+void smpi_datatype_get_name(MPI_Datatype datatype, char* name, int* length){
+  *length = strlen(datatype->name);
+  strcpy(name, datatype->name);
+}
+
+void smpi_datatype_set_name(MPI_Datatype datatype, char* name){
+  datatype->name = strdup(name);;
+}
+
 int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
                        void *recvbuf, int recvcount, MPI_Datatype recvtype)
 {
@@ -186,7 +228,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
     else if (sendtype->has_subtype == 0)
     {
       s_smpi_subtype_t *subtype =  recvtype->substruct;
-      subtype->unserialize( sendbuf, recvbuf,1, subtype);
+      subtype->unserialize( sendbuf, recvbuf,1, subtype, MPI_REPLACE);
     }
     else if (recvtype->has_subtype == 0)
     {
@@ -200,7 +242,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
 
       subtype->serialize( sendbuf, buf_tmp,count/smpi_datatype_size(sendtype), subtype);
       subtype =  recvtype->substruct;
-      subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype);
+      subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype, MPI_REPLACE);
 
       free(buf_tmp);
     }
@@ -220,7 +262,7 @@ int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
  */
 void serialize_vector( const void *noncontiguous_vector,
                        void *contiguous_vector,
-                       size_t count,
+                       int count,
                        void *type)
 {
   s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type;
@@ -257,8 +299,9 @@ void serialize_vector( const void *noncontiguous_vector,
  */
 void unserialize_vector( const void *contiguous_vector,
                          void *noncontiguous_vector,
-                         size_t count,
-                         void *type)
+                         int count,
+                         void *type,
+                         MPI_Op op)
 {
   s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type;
   int i;
@@ -268,13 +311,16 @@ void unserialize_vector( const void *contiguous_vector,
 
   for (i = 0; i < type_c->block_count * count; i++) {
     if (type_c->old_type->has_subtype == 0)
-      memcpy(noncontiguous_vector_char,
-             contiguous_vector_char, type_c->block_length * type_c->size_oldtype);
+      smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &type_c->block_length,
+          &type_c->old_type);
+     /* memcpy(noncontiguous_vector_char,
+             contiguous_vector_char, type_c->block_length * type_c->size_oldtype);*/
     else
       ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char,
                                                                      noncontiguous_vector_char,
                                                                      type_c->block_length,
-                                                                     type_c->old_type->substruct);
+                                                                     type_c->old_type->substruct,
+                                                                     op);
     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
     if((i+1)%type_c->block_count ==0)
     noncontiguous_vector_char += type_c->block_length*smpi_datatype_get_extent(type_c->old_type);
@@ -310,6 +356,7 @@ s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride,
 void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int has_subtype,
                           void *struct_type, int flags){
   MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1);
+  new_t->name = NULL;
   new_t->size = size;
   new_t->has_subtype = size>0? has_subtype:0;
   new_t->lb = lb;
@@ -339,6 +386,9 @@ void smpi_datatype_free(MPI_Datatype* type){
     ((s_smpi_subtype_t *)(*type)->substruct)->subtype_free(type);  
     xbt_free((*type)->substruct);
   }
+  if ((*type)->name != NULL){
+    xbt_free((*type)->name);
+  }
   xbt_free(*type);
   *type = MPI_DATATYPE_NULL;
 }
@@ -382,7 +432,7 @@ Contiguous Implementation
  */
 void serialize_contiguous( const void *noncontiguous_hvector,
                        void *contiguous_hvector,
-                       size_t count,
+                       int count,
                        void *type)
 {
   s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type;
@@ -402,15 +452,18 @@ void serialize_contiguous( const void *noncontiguous_hvector,
  */
 void unserialize_contiguous( const void *contiguous_vector,
                          void *noncontiguous_vector,
-                         size_t count,
-                         void *type)
+                         int count,
+                         void *type,
+                         MPI_Op op)
 {
   s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type;
   char* contiguous_vector_char = (char*)contiguous_vector;
   char* noncontiguous_vector_char = (char*)noncontiguous_vector+type_c->lb;
-
-  memcpy(noncontiguous_vector_char,
-           contiguous_vector_char, count*  type_c->block_count * type_c->size_oldtype);
+  int n= count* type_c->block_count;
+  smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &n,
+            &type_c->old_type);
+       /*memcpy(noncontiguous_vector_char,
+           contiguous_vector_char, count*  type_c->block_count * type_c->size_oldtype);*/
 }
 
 void free_contiguous(MPI_Datatype* d){
@@ -522,7 +575,7 @@ Hvector Implementation - Vector with stride in bytes
  */
 void serialize_hvector( const void *noncontiguous_hvector,
                        void *contiguous_hvector,
-                       size_t count,
+                       int count,
                        void *type)
 {
   s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type;
@@ -558,8 +611,9 @@ void serialize_hvector( const void *noncontiguous_hvector,
  */
 void unserialize_hvector( const void *contiguous_vector,
                          void *noncontiguous_vector,
-                         size_t count,
-                         void *type)
+                         int count,
+                         void *type,
+                         MPI_Op op)
 {
   s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type;
   int i;
@@ -569,13 +623,16 @@ void unserialize_hvector( const void *contiguous_vector,
 
   for (i = 0; i < type_c->block_count * count; i++) {
     if (type_c->old_type->has_subtype == 0)
-      memcpy(noncontiguous_vector_char,
-           contiguous_vector_char, type_c->block_length * type_c->size_oldtype);
+      smpi_op_apply(op, contiguous_vector_char, noncontiguous_vector_char, &type_c->block_length,
+                  &type_c->old_type);
+             /*memcpy(noncontiguous_vector_char,
+           contiguous_vector_char, type_c->block_length * type_c->size_oldtype);*/
     else
       ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char,
                                                                      noncontiguous_vector_char,
                                                                      type_c->block_length,
-                                                                     type_c->old_type->substruct);
+                                                                     type_c->old_type->substruct,
+                                                                     op);
     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
     if((i+1)%type_c->block_count ==0)
     noncontiguous_vector_char += type_c->block_length*type_c->size_oldtype;
@@ -664,7 +721,7 @@ Indexed Implementation
  */
 void serialize_indexed( const void *noncontiguous_indexed,
                        void *contiguous_indexed,
-                       size_t count,
+                       int count,
                        void *type)
 {
   s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type;
@@ -701,8 +758,9 @@ void serialize_indexed( const void *noncontiguous_indexed,
  */
 void unserialize_indexed( const void *contiguous_indexed,
                          void *noncontiguous_indexed,
-                         size_t count,
-                         void *type)
+                         int count,
+                         void *type,
+                         MPI_Op op)
 {
 
   s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type;
@@ -712,13 +770,16 @@ void unserialize_indexed( const void *contiguous_indexed,
   for(j=0; j<count;j++){
     for (i = 0; i < type_c->block_count; i++) {
       if (type_c->old_type->has_subtype == 0)
-        memcpy(noncontiguous_indexed_char ,
-             contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype);
+        smpi_op_apply(op, contiguous_indexed_char, noncontiguous_indexed_char, &type_c->block_lengths[i],
+                    &type_c->old_type);
+               /*memcpy(noncontiguous_indexed_char ,
+             contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype);*/
       else
         ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_indexed_char,
                                                                        noncontiguous_indexed_char,
                                                                        type_c->block_lengths[i],
-                                                                       type_c->old_type->substruct);
+                                                                       type_c->old_type->substruct,
+                                                                       op);
 
       contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype;
       if (i<type_c->block_count-1)
@@ -829,7 +890,7 @@ Hindexed Implementation - Indexed with indices in bytes
  */
 void serialize_hindexed( const void *noncontiguous_hindexed,
                        void *contiguous_hindexed,
-                       size_t count,
+                       int count,
                        void *type)
 {
   s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type;
@@ -865,8 +926,9 @@ void serialize_hindexed( const void *noncontiguous_hindexed,
  */
 void unserialize_hindexed( const void *contiguous_hindexed,
                          void *noncontiguous_hindexed,
-                         size_t count,
-                         void *type)
+                         int count,
+                         void *type,
+                         MPI_Op op)
 {
   s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type;
   int i,j;
@@ -876,13 +938,16 @@ void unserialize_hindexed( const void *contiguous_hindexed,
   for(j=0; j<count;j++){
     for (i = 0; i < type_c->block_count; i++) {
       if (type_c->old_type->has_subtype == 0)
-        memcpy(noncontiguous_hindexed_char,
-               contiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype);
+        smpi_op_apply(op, contiguous_hindexed_char, noncontiguous_hindexed_char, &type_c->block_lengths[i],
+                            &type_c->old_type);
+                       /*memcpy(noncontiguous_hindexed_char,
+               contiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype);*/
       else
         ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_hindexed_char,
                                                                        noncontiguous_hindexed_char,
                                                                        type_c->block_lengths[i],
-                                                                       type_c->old_type->substruct);
+                                                                       type_c->old_type->substruct,
+                                                                       op);
 
       contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype;
       if (i<type_c->block_count-1)noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1];
@@ -991,7 +1056,7 @@ struct Implementation - Indexed with indices in bytes
  */
 void serialize_struct( const void *noncontiguous_struct,
                        void *contiguous_struct,
-                       size_t count,
+                       int count,
                        void *type)
 {
   s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type;
@@ -1028,8 +1093,9 @@ void serialize_struct( const void *noncontiguous_struct,
  */
 void unserialize_struct( const void *contiguous_struct,
                          void *noncontiguous_struct,
-                         size_t count,
-                         void *type)
+                         int count,
+                         void *type,
+                         MPI_Op op)
 {
   s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type;
   int i,j;
@@ -1039,13 +1105,16 @@ void unserialize_struct( const void *contiguous_struct,
   for(j=0; j<count;j++){
     for (i = 0; i < type_c->block_count; i++) {
       if (type_c->old_types[i]->has_subtype == 0)
-        memcpy(noncontiguous_struct_char,
-             contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i]));
+        smpi_op_apply(op, contiguous_struct_char, noncontiguous_struct_char, &type_c->block_lengths[i],
+           & type_c->old_types[i]);
+                       /*memcpy(noncontiguous_struct_char,
+             contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i]));*/
       else
         ((s_smpi_subtype_t*)type_c->old_types[i]->substruct)->unserialize( contiguous_struct_char,
                                                                            noncontiguous_struct_char,
                                                                            type_c->block_lengths[i],
-                                                                           type_c->old_types[i]->substruct);
+                                                                           type_c->old_types[i]->substruct,
+                                                                           op);
 
       contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]);
       if (i<type_c->block_count-1)noncontiguous_struct_char =  (char*)noncontiguous_struct + type_c->block_indices[i+1];
@@ -1172,7 +1241,6 @@ typedef struct s_smpi_mpi_op {
 #define BXOR_OP(a, b) (b) ^= (a)
 #define MAXLOC_OP(a, b)  (b) = (a.value) < (b.value) ? (b) : (a)
 #define MINLOC_OP(a, b)  (b) = (a.value) < (b.value) ? (a) : (b)
-#define REPLACE_OP(a,b) (b) = (a)
 
 #define APPLY_FUNC(a, b, length, type, func) \
 {                                          \
@@ -1201,6 +1269,8 @@ static void max_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, MAX_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, MAX_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, MAX_OP);
   } else if (*datatype == MPI_FLOAT) {
     APPLY_FUNC(a, b, length, float, MAX_OP);
   } else if (*datatype == MPI_DOUBLE) {
@@ -1227,6 +1297,8 @@ static void min_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, MIN_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, MIN_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, MIN_OP);
   } else if (*datatype == MPI_FLOAT) {
     APPLY_FUNC(a, b, length, float, MIN_OP);
   } else if (*datatype == MPI_DOUBLE) {
@@ -1253,6 +1325,8 @@ static void sum_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, SUM_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, SUM_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, SUM_OP);
   } else if (*datatype == MPI_FLOAT) {
     APPLY_FUNC(a, b, length, float, SUM_OP);
   } else if (*datatype == MPI_DOUBLE) {
@@ -1285,6 +1359,8 @@ static void prod_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, PROD_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, PROD_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, PROD_OP);
   } else if (*datatype == MPI_FLOAT) {
     APPLY_FUNC(a, b, length, float, PROD_OP);
   } else if (*datatype == MPI_DOUBLE) {
@@ -1317,6 +1393,8 @@ static void land_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, LAND_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, LAND_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, LAND_OP);
   } else if (*datatype == MPI_C_BOOL) {
     APPLY_FUNC(a, b, length, _Bool, LAND_OP);
   }
@@ -1339,6 +1417,8 @@ static void lor_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, LOR_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, LOR_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, LOR_OP);
   } else if (*datatype == MPI_C_BOOL) {
     APPLY_FUNC(a, b, length, _Bool, LOR_OP);
   }
@@ -1361,6 +1441,8 @@ static void lxor_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, LXOR_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, LXOR_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, LXOR_OP);
   } else if (*datatype == MPI_C_BOOL) {
     APPLY_FUNC(a, b, length, _Bool, LXOR_OP);
   }
@@ -1371,8 +1453,7 @@ static void band_func(void *a, void *b, int *length,
 {
   if (*datatype == MPI_CHAR) {
     APPLY_FUNC(a, b, length, char, BAND_OP);
-  }
-  if (*datatype == MPI_SHORT) {
+  }else if (*datatype == MPI_SHORT) {
     APPLY_FUNC(a, b, length, short, BAND_OP);
   } else if (*datatype == MPI_INT) {
     APPLY_FUNC(a, b, length, int, BAND_OP);
@@ -1384,6 +1465,8 @@ static void band_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, BAND_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, BAND_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, BAND_OP);
   } else if (*datatype == MPI_BYTE) {
     APPLY_FUNC(a, b, length, uint8_t, BAND_OP);
   }
@@ -1406,6 +1489,8 @@ static void bor_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, BOR_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, BOR_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, BOR_OP);
   } else if (*datatype == MPI_BYTE) {
     APPLY_FUNC(a, b, length, uint8_t, BOR_OP);
   }
@@ -1428,6 +1513,8 @@ static void bxor_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, unsigned int, BXOR_OP);
   } else if (*datatype == MPI_UNSIGNED_LONG) {
     APPLY_FUNC(a, b, length, unsigned long, BXOR_OP);
+  } else if (*datatype == MPI_UNSIGNED_CHAR) {
+    APPLY_FUNC(a, b, length, unsigned char, BXOR_OP);
   } else if (*datatype == MPI_BYTE) {
     APPLY_FUNC(a, b, length, uint8_t, BXOR_OP);
   }
@@ -1444,6 +1531,8 @@ static void minloc_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, double_int, MINLOC_OP);
   } else if (*datatype == MPI_SHORT_INT) {
     APPLY_FUNC(a, b, length, short_int, MINLOC_OP);
+  } else if (*datatype == MPI_2LONG) {
+    APPLY_FUNC(a, b, length, long_long, MINLOC_OP);
   } else if (*datatype == MPI_2INT) {
     APPLY_FUNC(a, b, length, int_int, MINLOC_OP);
   } else if (*datatype == MPI_LONG_DOUBLE_INT) {
@@ -1466,6 +1555,8 @@ static void maxloc_func(void *a, void *b, int *length,
     APPLY_FUNC(a, b, length, double_int, MAXLOC_OP);
   } else if (*datatype == MPI_SHORT_INT) {
     APPLY_FUNC(a, b, length, short_int, MAXLOC_OP);
+  } else if (*datatype == MPI_2LONG) {
+    APPLY_FUNC(a, b, length, long_long, MAXLOC_OP);
   } else if (*datatype == MPI_2INT) {
     APPLY_FUNC(a, b, length, int_int, MAXLOC_OP);
   } else if (*datatype == MPI_LONG_DOUBLE_INT) {
@@ -1480,23 +1571,7 @@ static void maxloc_func(void *a, void *b, int *length,
 static void replace_func(void *a, void *b, int *length,
                         MPI_Datatype * datatype)
 {
-  if (*datatype == MPI_CHAR) {
-    APPLY_FUNC(a, b, length, char, REPLACE_OP);
-  } else if (*datatype == MPI_SHORT) {
-    APPLY_FUNC(a, b, length, short, REPLACE_OP);
-  } else if (*datatype == MPI_INT) {
-    APPLY_FUNC(a, b, length, int, REPLACE_OP);
-  } else if (*datatype == MPI_LONG) {
-    APPLY_FUNC(a, b, length, long, REPLACE_OP);
-  } else if (*datatype == MPI_UNSIGNED_SHORT) {
-    APPLY_FUNC(a, b, length, unsigned short, REPLACE_OP);
-  } else if (*datatype == MPI_UNSIGNED) {
-    APPLY_FUNC(a, b, length, unsigned int, REPLACE_OP);
-  } else if (*datatype == MPI_UNSIGNED_LONG) {
-    APPLY_FUNC(a, b, length, unsigned long, REPLACE_OP);
-  } else if (*datatype == MPI_BYTE) {
-    APPLY_FUNC(a, b, length, uint8_t, REPLACE_OP);
-  }
+  memcpy(b, a, *length * smpi_datatype_size(*datatype));
 }
 
 #define CREATE_MPI_OP(name, func)                             \