src/smpi/smpi_mpi_dt.c

   1 /* smpi_mpi_dt.c -- MPI primitives to handle datatypes                        */
   2 /* FIXME: a very incomplete implementation                                    */
   3
   4 /* Copyright (c) 2009, 2010. The SimGrid Team.
   5  * All rights reserved.                                                     */
   6
   7 /* This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the license (GNU LGPL) which comes with this package. */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "private.h"
  15 #include "smpi_mpi_dt_private.h"
  16
  17 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi_dt, smpi,
  18                                 "Logging specific to SMPI (datatype)");
  19
  20 #define CREATE_MPI_DATATYPE(name, type)       \
  21   static s_smpi_mpi_datatype_t mpi_##name = { \
  22     sizeof(type),  /* size */                 \
  23     0,             /*was 1 has_subtype*/             \
  24     0,             /* lb */                   \
  25     sizeof(type),  /* ub = lb + size */       \
  26     DT_FLAG_BASIC,  /* flags */              \
  27     NULL           /* pointer on extended struct*/ \
  28   };                                          \
  29 MPI_Datatype name = &mpi_##name;
  30
  31
  32 //The following are datatypes for the MPI functions MPI_MAXLOC and MPI_MINLOC.
  33 typedef struct {
  34   float value;
  35   int index;
  36 } float_int;
  37 typedef struct {
  38   long value;
  39   int index;
  40 } long_int;
  41 typedef struct {
  42   double value;
  43   int index;
  44 } double_int;
  45 typedef struct {
  46   short value;
  47   int index;
  48 } short_int;
  49 typedef struct {
  50   int value;
  51   int index;
  52 } int_int;
  53 typedef struct {
  54   long double value;
  55   int index;
  56 } long_double_int;
  57
  58 // Predefined data types
  59 CREATE_MPI_DATATYPE(MPI_CHAR, char);
  60 CREATE_MPI_DATATYPE(MPI_SHORT, short);
  61 CREATE_MPI_DATATYPE(MPI_INT, int);
  62 CREATE_MPI_DATATYPE(MPI_LONG, long);
  63 CREATE_MPI_DATATYPE(MPI_LONG_LONG, long long);
  64 CREATE_MPI_DATATYPE(MPI_SIGNED_CHAR, signed char);
  65 CREATE_MPI_DATATYPE(MPI_UNSIGNED_CHAR, unsigned char);
  66 CREATE_MPI_DATATYPE(MPI_UNSIGNED_SHORT, unsigned short);
  67 CREATE_MPI_DATATYPE(MPI_UNSIGNED, unsigned int);
  68 CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG, unsigned long);
  69 CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG_LONG, unsigned long long);
  70 CREATE_MPI_DATATYPE(MPI_FLOAT, float);
  71 CREATE_MPI_DATATYPE(MPI_DOUBLE, double);
  72 CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE, long double);
  73 CREATE_MPI_DATATYPE(MPI_WCHAR, wchar_t);
  74 CREATE_MPI_DATATYPE(MPI_C_BOOL, _Bool);
  75 CREATE_MPI_DATATYPE(MPI_INT8_T, int8_t);
  76 CREATE_MPI_DATATYPE(MPI_INT16_T, int16_t);
  77 CREATE_MPI_DATATYPE(MPI_INT32_T, int32_t);
  78 CREATE_MPI_DATATYPE(MPI_INT64_T, int64_t);
  79 CREATE_MPI_DATATYPE(MPI_UINT8_T, uint8_t);
  80 CREATE_MPI_DATATYPE(MPI_UINT16_T, uint16_t);
  81 CREATE_MPI_DATATYPE(MPI_UINT32_T, uint32_t);
  82 CREATE_MPI_DATATYPE(MPI_UINT64_T, uint64_t);
  83 CREATE_MPI_DATATYPE(MPI_C_FLOAT_COMPLEX, float _Complex);
  84 CREATE_MPI_DATATYPE(MPI_C_DOUBLE_COMPLEX, double _Complex);
  85 CREATE_MPI_DATATYPE(MPI_C_LONG_DOUBLE_COMPLEX, long double _Complex);
  86 CREATE_MPI_DATATYPE(MPI_AINT, MPI_Aint);
  87 CREATE_MPI_DATATYPE(MPI_OFFSET, MPI_Offset);
  88
  89 CREATE_MPI_DATATYPE(MPI_FLOAT_INT, float_int);
  90 CREATE_MPI_DATATYPE(MPI_LONG_INT, long_int);
  91 CREATE_MPI_DATATYPE(MPI_DOUBLE_INT, double_int);
  92 CREATE_MPI_DATATYPE(MPI_SHORT_INT, short_int);
  93 CREATE_MPI_DATATYPE(MPI_2INT, int_int);
  94 CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, long_double_int);
  95
  96 // Internal use only
  97 CREATE_MPI_DATATYPE(MPI_PTR, void*);
  98
  99
 100 size_t smpi_datatype_size(MPI_Datatype datatype)
 101 {
 102   return datatype->size;
 103 }
 104
 105
 106
 107 MPI_Aint smpi_datatype_lb(MPI_Datatype datatype)
 108 {
 109   return datatype->lb;
 110 }
 111
 112 MPI_Aint smpi_datatype_ub(MPI_Datatype datatype)
 113 {
 114   return datatype->ub;
 115 }
 116
 117 int smpi_datatype_extent(MPI_Datatype datatype, MPI_Aint * lb,
 118                          MPI_Aint * extent)
 119 {
 120   int retval;
 121
 122   if ((datatype->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) {
 123     retval = MPI_ERR_TYPE;
 124   } else {
 125     *lb = datatype->lb;
 126     *extent = datatype->ub - datatype->lb;
 127     retval = MPI_SUCCESS;
 128   }
 129   return retval;
 130 }
 131
 132 int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
 133                        void *recvbuf, int recvcount, MPI_Datatype recvtype)
 134 {
 135   int retval, count;
 136
 137   /* First check if we really have something to do */
 138   if (recvcount == 0) {
 139     retval = sendcount == 0 ? MPI_SUCCESS : MPI_ERR_TRUNCATE;
 140   } else {
 141     /* FIXME: treat packed cases */
 142     sendcount *= smpi_datatype_size(sendtype);
 143     recvcount *= smpi_datatype_size(recvtype);
 144     count = sendcount < recvcount ? sendcount : recvcount;
 145
 146     if(sendtype->has_subtype == 0 && recvtype->has_subtype == 0) {
 147       memcpy(recvbuf, sendbuf, count);
 148     }
 149     else if (sendtype->has_subtype == 0)
 150     {
 151       s_smpi_subtype_t *subtype =  recvtype->substruct;
 152       subtype->unserialize( sendbuf, recvbuf,1, subtype);
 153     }
 154     else if (recvtype->has_subtype == 0)
 155     {
 156       s_smpi_subtype_t *subtype =  sendtype->substruct;
 157       subtype->serialize(sendbuf, recvbuf,1, subtype);
 158     }else{
 159       s_smpi_subtype_t *subtype =  sendtype->substruct;
 160
 161       s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)sendtype;
 162
 163       void * buf_tmp = malloc(count * type_c->size_oldtype);
 164
 165       subtype->serialize( sendbuf, buf_tmp,1, subtype);
 166       subtype =  recvtype->substruct;
 167       subtype->unserialize(recvbuf, buf_tmp,1, subtype);
 168
 169       free(buf_tmp);
 170     }
 171     retval = sendcount > recvcount ? MPI_ERR_TRUNCATE : MPI_SUCCESS;
 172   }
 173
 174   return retval;
 175 }
 176
 177 /*
 178  *  Copies noncontiguous data into contiguous memory.
 179  *  @param contiguous_vector - output vector
 180  *  @param noncontiguous_vector - input vector
 181  *  @param type - pointer contening :
 182  *      - stride - stride of between noncontiguous data
 183  *      - block_length - the width or height of blocked matrix
 184  *      - count - the number of rows of matrix
 185  */
 186 void serialize_vector( const void *noncontiguous_vector,
 187                        void *contiguous_vector,
 188                        size_t count,
 189                        void *type)
 190 {
 191   s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type;
 192   int i;
 193   char* contiguous_vector_char = (char*)contiguous_vector;
 194   char* noncontiguous_vector_char = (char*)noncontiguous_vector;
 195
 196   for (i = 0; i < type_c->block_count * count; i++) {
 197     memcpy(contiguous_vector_char,
 198            noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype);
 199
 200     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 201     noncontiguous_vector_char += type_c->block_stride*type_c->size_oldtype;
 202   }
 203 }
 204
 205 /*
 206  *  Copies contiguous data into noncontiguous memory.
 207  *  @param noncontiguous_vector - output vector
 208  *  @param contiguous_vector - input vector
 209  *  @param type - pointer contening :
 210  *      - stride - stride of between noncontiguous data
 211  *      - block_length - the width or height of blocked matrix
 212  *      - count - the number of rows of matrix
 213  */
 214 void unserialize_vector( const void *contiguous_vector,
 215                          void *noncontiguous_vector,
 216                          size_t count,
 217                          void *type)
 218 {
 219   s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type;
 220   int i;
 221
 222   char* contiguous_vector_char = (char*)contiguous_vector;
 223   char* noncontiguous_vector_char = (char*)noncontiguous_vector;
 224
 225   for (i = 0; i < type_c->block_count * count; i++) {
 226     memcpy(noncontiguous_vector_char,
 227            contiguous_vector_char, type_c->block_length * type_c->size_oldtype);
 228
 229     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 230     noncontiguous_vector_char += type_c->block_stride*type_c->size_oldtype;
 231   }
 232 }
 233
 234 /*
 235  * Create a Sub type vector to be able to serialize and unserialize it
 236  * the structre s_smpi_mpi_vector_t is derived from s_smpi_subtype which
 237  * required the functions unserialize and serialize
 238  *
 239  */
 240 s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride,
 241                                                   int block_length,
 242                                                   int block_count,
 243                                                   MPI_Datatype old_type,
 244                                                   int size_oldtype){
 245   s_smpi_mpi_vector_t *new_t= xbt_new(s_smpi_mpi_vector_t,1);
 246   new_t->base.serialize = &serialize_vector;
 247   new_t->base.unserialize = &unserialize_vector;
 248   new_t->block_stride = block_stride;
 249   new_t->block_length = block_length;
 250   new_t->block_count = block_count;
 251   new_t->old_type = old_type;
 252   new_t->size_oldtype = size_oldtype;
 253   return new_t;
 254 }
 255
 256 void smpi_datatype_create(MPI_Datatype* new_type, int size, int has_subtype,
 257                           void *struct_type, int flags){
 258   MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1);
 259   new_t->size = size;
 260   new_t->has_subtype = has_subtype;
 261   new_t->lb = 0;
 262   new_t->ub = size;
 263   new_t->flags = flags;
 264   new_t->substruct = struct_type;
 265   *new_type = new_t;
 266 }
 267
 268 void smpi_datatype_free(MPI_Datatype* type){
 269   xbt_free(*type);
 270 }
 271
 272 int smpi_datatype_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type)
 273 {
 274   int retval;
 275   if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) {
 276     retval = MPI_ERR_TYPE;
 277   } else {
 278     smpi_datatype_create(new_type, count *
 279                          smpi_datatype_size(old_type),1,NULL, DT_FLAG_CONTIGUOUS);
 280     retval=MPI_SUCCESS;
 281   }
 282   return retval;
 283 }
 284
 285 int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type)
 286 {
 287   int retval;
 288   if (blocklen<=0) return MPI_ERR_ARG;
 289   if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) {
 290     retval = MPI_ERR_TYPE;
 291   } else {
 292     if(stride != blocklen){
 293       s_smpi_mpi_vector_t* subtype = smpi_datatype_vector_create( stride,
 294                                                                   blocklen,
 295                                                                   count,
 296                                                                   old_type,
 297                                                                   smpi_datatype_size(old_type));
 298
 299       smpi_datatype_create(new_type, count * (blocklen) *
 300                            smpi_datatype_size(old_type),
 301                            1,
 302                            subtype,
 303                            DT_FLAG_VECTOR);
 304       retval=MPI_SUCCESS;
 305     }else{
 306       /* in this situation the data are contignous thus it's not
 307        * required to serialize and unserialize it*/
 308       smpi_datatype_create(new_type, count * (blocklen) *
 309                            smpi_datatype_size(old_type),
 310                            0,
 311                            NULL,
 312                            DT_FLAG_VECTOR);
 313       retval=MPI_SUCCESS;
 314     }
 315   }
 316   return retval;
 317 }
 318
 319 int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type)
 320 {
 321   int retval;
 322   if (blocklen<=0) return MPI_ERR_ARG;
 323   if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) {
 324     retval = MPI_ERR_TYPE;
 325   } else {
 326     /*FIXME: as for the vector the data should be serialized and
 327      * unserialized moreover a structure derived from s_smpi_subtype should
 328      * be created*/
 329     smpi_datatype_create(new_type, count * ((blocklen *
 330                                              smpi_datatype_size(old_type))+stride),
 331                          0,
 332                          NULL,
 333                          DT_FLAG_VECTOR);
 334     retval=MPI_SUCCESS;
 335   }
 336   return retval;
 337 }
 338
 339
 340 int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type)
 341 {
 342   int i;
 343   int retval;
 344   int size = 0;
 345   for(i=0; i< count; i++){
 346     if   (blocklens[i]<=0)
 347       return MPI_ERR_ARG;
 348     size += blocklens[i];
 349   }
 350   if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) {
 351     retval = MPI_ERR_TYPE;
 352   } else {
 353     /*FIXME: as for the vector the data should be serialized and
 354      * unserialized moreover a structure derived from s_smpi_subtype should
 355      * be created*/
 356     smpi_datatype_create(new_type,  (size) *
 357                          smpi_datatype_size(old_type),0, NULL, DT_FLAG_DATA);
 358     retval=MPI_SUCCESS;
 359   }
 360   return retval;
 361 }
 362
 363 int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type)
 364 {
 365   int i;
 366   int retval;
 367   int size = 0;
 368   for(i=0; i< count; i++){
 369     if   (blocklens[i]<=0)
 370       return MPI_ERR_ARG;
 371     size += blocklens[i];
 372   }
 373   if ((old_type->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED) {
 374     retval = MPI_ERR_TYPE;
 375   } else {
 376     /*FIXME: as for the vector the data should be serialized and
 377      * unserialized moreover a structure derived from s_smpi_subtype should
 378      * be created*/
 379     smpi_datatype_create(new_type,(size * smpi_datatype_size(old_type)), 0,NULL, DT_FLAG_DATA);
 380     retval=MPI_SUCCESS;
 381   }
 382   return retval;
 383 }
 384
 385 int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type)
 386 {
 387   int i;
 388   size_t size = 0;
 389   for(i=0; i< count; i++){
 390     if (blocklens[i]<=0)
 391       return MPI_ERR_ARG;
 392     if ((old_types[i]->flags & DT_FLAG_COMMITED) != DT_FLAG_COMMITED)
 393       return MPI_ERR_TYPE;
 394     size += blocklens[i]*smpi_datatype_size(old_types[i]);
 395   }
 396   /*FIXME: as for the vector the data should be serialized and
 397    * unserialized moreover a structure derived from s_smpi_subtype should
 398    * be created*/
 399   smpi_datatype_create(new_type, size,
 400                        0, NULL,
 401                        DT_FLAG_DATA);
 402   return MPI_SUCCESS;
 403 }
 404
 405 void smpi_datatype_commit(MPI_Datatype *datatype)
 406 {
 407   (*datatype)->flags=  ((*datatype)->flags | DT_FLAG_COMMITED);
 408 }
 409
 410 typedef struct s_smpi_mpi_op {
 411   MPI_User_function *func;
 412 } s_smpi_mpi_op_t;
 413
 414 #define MAX_OP(a, b)  (b) = (a) < (b) ? (b) : (a)
 415 #define MIN_OP(a, b)  (b) = (a) < (b) ? (a) : (b)
 416 #define SUM_OP(a, b)  (b) += (a)
 417 #define PROD_OP(a, b) (b) *= (a)
 418 #define LAND_OP(a, b) (b) = (a) && (b)
 419 #define LOR_OP(a, b)  (b) = (a) || (b)
 420 #define LXOR_OP(a, b) (b) = (!(a) && (b)) || ((a) && !(b))
 421 #define BAND_OP(a, b) (b) &= (a)
 422 #define BOR_OP(a, b)  (b) |= (a)
 423 #define BXOR_OP(a, b) (b) ^= (a)
 424 #define MAXLOC_OP(a, b)  (b) = (a.value) < (b.value) ? (b) : (a)
 425 #define MINLOC_OP(a, b)  (b) = (a.value) < (b.value) ? (a) : (b)
 426 //TODO : MINLOC & MAXLOC
 427
 428 #define APPLY_FUNC(a, b, length, type, func) \
 429 {                                          \
 430   int i;                                   \
 431   type* x = (type*)(a);                    \
 432   type* y = (type*)(b);                    \
 433   for(i = 0; i < *(length); i++) {         \
 434     func(x[i], y[i]);                      \
 435   }                                        \
 436 }
 437
 438 static void max_func(void *a, void *b, int *length,
 439                      MPI_Datatype * datatype)
 440 {
 441   if (*datatype == MPI_CHAR) {
 442     APPLY_FUNC(a, b, length, char, MAX_OP);
 443   } else if (*datatype == MPI_SHORT) {
 444     APPLY_FUNC(a, b, length, short, MAX_OP);
 445   } else if (*datatype == MPI_INT) {
 446     APPLY_FUNC(a, b, length, int, MAX_OP);
 447   } else if (*datatype == MPI_LONG) {
 448     APPLY_FUNC(a, b, length, long, MAX_OP);
 449   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 450     APPLY_FUNC(a, b, length, unsigned short, MAX_OP);
 451   } else if (*datatype == MPI_UNSIGNED) {
 452     APPLY_FUNC(a, b, length, unsigned int, MAX_OP);
 453   } else if (*datatype == MPI_UNSIGNED_LONG) {
 454     APPLY_FUNC(a, b, length, unsigned long, MAX_OP);
 455   } else if (*datatype == MPI_FLOAT) {
 456     APPLY_FUNC(a, b, length, float, MAX_OP);
 457   } else if (*datatype == MPI_DOUBLE) {
 458     APPLY_FUNC(a, b, length, double, MAX_OP);
 459   } else if (*datatype == MPI_LONG_DOUBLE) {
 460     APPLY_FUNC(a, b, length, long double, MAX_OP);
 461   }
 462 }
 463
 464 static void min_func(void *a, void *b, int *length,
 465                      MPI_Datatype * datatype)
 466 {
 467   if (*datatype == MPI_CHAR) {
 468     APPLY_FUNC(a, b, length, char, MIN_OP);
 469   } else if (*datatype == MPI_SHORT) {
 470     APPLY_FUNC(a, b, length, short, MIN_OP);
 471   } else if (*datatype == MPI_INT) {
 472     APPLY_FUNC(a, b, length, int, MIN_OP);
 473   } else if (*datatype == MPI_LONG) {
 474     APPLY_FUNC(a, b, length, long, MIN_OP);
 475   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 476     APPLY_FUNC(a, b, length, unsigned short, MIN_OP);
 477   } else if (*datatype == MPI_UNSIGNED) {
 478     APPLY_FUNC(a, b, length, unsigned int, MIN_OP);
 479   } else if (*datatype == MPI_UNSIGNED_LONG) {
 480     APPLY_FUNC(a, b, length, unsigned long, MIN_OP);
 481   } else if (*datatype == MPI_FLOAT) {
 482     APPLY_FUNC(a, b, length, float, MIN_OP);
 483   } else if (*datatype == MPI_DOUBLE) {
 484     APPLY_FUNC(a, b, length, double, MIN_OP);
 485   } else if (*datatype == MPI_LONG_DOUBLE) {
 486     APPLY_FUNC(a, b, length, long double, MIN_OP);
 487   }
 488 }
 489
 490 static void sum_func(void *a, void *b, int *length,
 491                      MPI_Datatype * datatype)
 492 {
 493   if (*datatype == MPI_CHAR) {
 494     APPLY_FUNC(a, b, length, char, SUM_OP);
 495   } else if (*datatype == MPI_SHORT) {
 496     APPLY_FUNC(a, b, length, short, SUM_OP);
 497   } else if (*datatype == MPI_INT) {
 498     APPLY_FUNC(a, b, length, int, SUM_OP);
 499   } else if (*datatype == MPI_LONG) {
 500     APPLY_FUNC(a, b, length, long, SUM_OP);
 501   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 502     APPLY_FUNC(a, b, length, unsigned short, SUM_OP);
 503   } else if (*datatype == MPI_UNSIGNED) {
 504     APPLY_FUNC(a, b, length, unsigned int, SUM_OP);
 505   } else if (*datatype == MPI_UNSIGNED_LONG) {
 506     APPLY_FUNC(a, b, length, unsigned long, SUM_OP);
 507   } else if (*datatype == MPI_FLOAT) {
 508     APPLY_FUNC(a, b, length, float, SUM_OP);
 509   } else if (*datatype == MPI_DOUBLE) {
 510     APPLY_FUNC(a, b, length, double, SUM_OP);
 511   } else if (*datatype == MPI_LONG_DOUBLE) {
 512     APPLY_FUNC(a, b, length, long double, SUM_OP);
 513   } else if (*datatype == MPI_C_FLOAT_COMPLEX) {
 514     APPLY_FUNC(a, b, length, float _Complex, SUM_OP);
 515   } else if (*datatype == MPI_C_DOUBLE_COMPLEX) {
 516     APPLY_FUNC(a, b, length, double _Complex, SUM_OP);
 517   } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) {
 518     APPLY_FUNC(a, b, length, long double _Complex, SUM_OP);
 519   }
 520 }
 521
 522 static void prod_func(void *a, void *b, int *length,
 523                       MPI_Datatype * datatype)
 524 {
 525   if (*datatype == MPI_CHAR) {
 526     APPLY_FUNC(a, b, length, char, PROD_OP);
 527   } else if (*datatype == MPI_SHORT) {
 528     APPLY_FUNC(a, b, length, short, PROD_OP);
 529   } else if (*datatype == MPI_INT) {
 530     APPLY_FUNC(a, b, length, int, PROD_OP);
 531   } else if (*datatype == MPI_LONG) {
 532     APPLY_FUNC(a, b, length, long, PROD_OP);
 533   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 534     APPLY_FUNC(a, b, length, unsigned short, PROD_OP);
 535   } else if (*datatype == MPI_UNSIGNED) {
 536     APPLY_FUNC(a, b, length, unsigned int, PROD_OP);
 537   } else if (*datatype == MPI_UNSIGNED_LONG) {
 538     APPLY_FUNC(a, b, length, unsigned long, PROD_OP);
 539   } else if (*datatype == MPI_FLOAT) {
 540     APPLY_FUNC(a, b, length, float, PROD_OP);
 541   } else if (*datatype == MPI_DOUBLE) {
 542     APPLY_FUNC(a, b, length, double, PROD_OP);
 543   } else if (*datatype == MPI_LONG_DOUBLE) {
 544     APPLY_FUNC(a, b, length, long double, PROD_OP);
 545   } else if (*datatype == MPI_C_FLOAT_COMPLEX) {
 546     APPLY_FUNC(a, b, length, float _Complex, PROD_OP);
 547   } else if (*datatype == MPI_C_DOUBLE_COMPLEX) {
 548     APPLY_FUNC(a, b, length, double _Complex, PROD_OP);
 549   } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) {
 550     APPLY_FUNC(a, b, length, long double _Complex, PROD_OP);
 551   }
 552 }
 553
 554 static void land_func(void *a, void *b, int *length,
 555                       MPI_Datatype * datatype)
 556 {
 557   if (*datatype == MPI_CHAR) {
 558     APPLY_FUNC(a, b, length, char, LAND_OP);
 559   } else if (*datatype == MPI_SHORT) {
 560     APPLY_FUNC(a, b, length, short, LAND_OP);
 561   } else if (*datatype == MPI_INT) {
 562     APPLY_FUNC(a, b, length, int, LAND_OP);
 563   } else if (*datatype == MPI_LONG) {
 564     APPLY_FUNC(a, b, length, long, LAND_OP);
 565   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 566     APPLY_FUNC(a, b, length, unsigned short, LAND_OP);
 567   } else if (*datatype == MPI_UNSIGNED) {
 568     APPLY_FUNC(a, b, length, unsigned int, LAND_OP);
 569   } else if (*datatype == MPI_UNSIGNED_LONG) {
 570     APPLY_FUNC(a, b, length, unsigned long, LAND_OP);
 571   } else if (*datatype == MPI_C_BOOL) {
 572     APPLY_FUNC(a, b, length, _Bool, LAND_OP);
 573   }
 574 }
 575
 576 static void lor_func(void *a, void *b, int *length,
 577                      MPI_Datatype * datatype)
 578 {
 579   if (*datatype == MPI_CHAR) {
 580     APPLY_FUNC(a, b, length, char, LOR_OP);
 581   } else if (*datatype == MPI_SHORT) {
 582     APPLY_FUNC(a, b, length, short, LOR_OP);
 583   } else if (*datatype == MPI_INT) {
 584     APPLY_FUNC(a, b, length, int, LOR_OP);
 585   } else if (*datatype == MPI_LONG) {
 586     APPLY_FUNC(a, b, length, long, LOR_OP);
 587   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 588     APPLY_FUNC(a, b, length, unsigned short, LOR_OP);
 589   } else if (*datatype == MPI_UNSIGNED) {
 590     APPLY_FUNC(a, b, length, unsigned int, LOR_OP);
 591   } else if (*datatype == MPI_UNSIGNED_LONG) {
 592     APPLY_FUNC(a, b, length, unsigned long, LOR_OP);
 593   } else if (*datatype == MPI_C_BOOL) {
 594     APPLY_FUNC(a, b, length, _Bool, LOR_OP);
 595   }
 596 }
 597
 598 static void lxor_func(void *a, void *b, int *length,
 599                       MPI_Datatype * datatype)
 600 {
 601   if (*datatype == MPI_CHAR) {
 602     APPLY_FUNC(a, b, length, char, LXOR_OP);
 603   } else if (*datatype == MPI_SHORT) {
 604     APPLY_FUNC(a, b, length, short, LXOR_OP);
 605   } else if (*datatype == MPI_INT) {
 606     APPLY_FUNC(a, b, length, int, LXOR_OP);
 607   } else if (*datatype == MPI_LONG) {
 608     APPLY_FUNC(a, b, length, long, LXOR_OP);
 609   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 610     APPLY_FUNC(a, b, length, unsigned short, LXOR_OP);
 611   } else if (*datatype == MPI_UNSIGNED) {
 612     APPLY_FUNC(a, b, length, unsigned int, LXOR_OP);
 613   } else if (*datatype == MPI_UNSIGNED_LONG) {
 614     APPLY_FUNC(a, b, length, unsigned long, LXOR_OP);
 615   } else if (*datatype == MPI_C_BOOL) {
 616     APPLY_FUNC(a, b, length, _Bool, LXOR_OP);
 617   }
 618 }
 619
 620 static void band_func(void *a, void *b, int *length,
 621                       MPI_Datatype * datatype)
 622 {
 623   if (*datatype == MPI_CHAR) {
 624     APPLY_FUNC(a, b, length, char, BAND_OP);
 625   }
 626   if (*datatype == MPI_SHORT) {
 627     APPLY_FUNC(a, b, length, short, BAND_OP);
 628   } else if (*datatype == MPI_INT) {
 629     APPLY_FUNC(a, b, length, int, BAND_OP);
 630   } else if (*datatype == MPI_LONG) {
 631     APPLY_FUNC(a, b, length, long, BAND_OP);
 632   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 633     APPLY_FUNC(a, b, length, unsigned short, BAND_OP);
 634   } else if (*datatype == MPI_UNSIGNED) {
 635     APPLY_FUNC(a, b, length, unsigned int, BAND_OP);
 636   } else if (*datatype == MPI_UNSIGNED_LONG) {
 637     APPLY_FUNC(a, b, length, unsigned long, BAND_OP);
 638   } else if (*datatype == MPI_BYTE) {
 639     APPLY_FUNC(a, b, length, uint8_t, BAND_OP);
 640   }
 641 }
 642
 643 static void bor_func(void *a, void *b, int *length,
 644                      MPI_Datatype * datatype)
 645 {
 646   if (*datatype == MPI_CHAR) {
 647     APPLY_FUNC(a, b, length, char, BOR_OP);
 648   } else if (*datatype == MPI_SHORT) {
 649     APPLY_FUNC(a, b, length, short, BOR_OP);
 650   } else if (*datatype == MPI_INT) {
 651     APPLY_FUNC(a, b, length, int, BOR_OP);
 652   } else if (*datatype == MPI_LONG) {
 653     APPLY_FUNC(a, b, length, long, BOR_OP);
 654   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 655     APPLY_FUNC(a, b, length, unsigned short, BOR_OP);
 656   } else if (*datatype == MPI_UNSIGNED) {
 657     APPLY_FUNC(a, b, length, unsigned int, BOR_OP);
 658   } else if (*datatype == MPI_UNSIGNED_LONG) {
 659     APPLY_FUNC(a, b, length, unsigned long, BOR_OP);
 660   } else if (*datatype == MPI_BYTE) {
 661     APPLY_FUNC(a, b, length, uint8_t, BOR_OP);
 662   }
 663 }
 664
 665 static void bxor_func(void *a, void *b, int *length,
 666                       MPI_Datatype * datatype)
 667 {
 668   if (*datatype == MPI_CHAR) {
 669     APPLY_FUNC(a, b, length, char, BXOR_OP);
 670   } else if (*datatype == MPI_SHORT) {
 671     APPLY_FUNC(a, b, length, short, BXOR_OP);
 672   } else if (*datatype == MPI_INT) {
 673     APPLY_FUNC(a, b, length, int, BXOR_OP);
 674   } else if (*datatype == MPI_LONG) {
 675     APPLY_FUNC(a, b, length, long, BXOR_OP);
 676   } else if (*datatype == MPI_UNSIGNED_SHORT) {
 677     APPLY_FUNC(a, b, length, unsigned short, BXOR_OP);
 678   } else if (*datatype == MPI_UNSIGNED) {
 679     APPLY_FUNC(a, b, length, unsigned int, BXOR_OP);
 680   } else if (*datatype == MPI_UNSIGNED_LONG) {
 681     APPLY_FUNC(a, b, length, unsigned long, BXOR_OP);
 682   } else if (*datatype == MPI_BYTE) {
 683     APPLY_FUNC(a, b, length, uint8_t, BXOR_OP);
 684   }
 685 }
 686
 687 static void minloc_func(void *a, void *b, int *length,
 688                         MPI_Datatype * datatype)
 689 {
 690   if (*datatype == MPI_FLOAT_INT) {
 691     APPLY_FUNC(a, b, length, float_int, MINLOC_OP);
 692   } else if (*datatype == MPI_LONG_INT) {
 693     APPLY_FUNC(a, b, length, long_int, MINLOC_OP);
 694   } else if (*datatype == MPI_DOUBLE_INT) {
 695     APPLY_FUNC(a, b, length, double_int, MINLOC_OP);
 696   } else if (*datatype == MPI_SHORT_INT) {
 697     APPLY_FUNC(a, b, length, short_int, MINLOC_OP);
 698   } else if (*datatype == MPI_2INT) {
 699     APPLY_FUNC(a, b, length, int_int, MINLOC_OP);
 700   } else if (*datatype == MPI_LONG_DOUBLE_INT) {
 701     APPLY_FUNC(a, b, length, long_double_int, MINLOC_OP);
 702   }
 703 }
 704
 705 static void maxloc_func(void *a, void *b, int *length,
 706                         MPI_Datatype * datatype)
 707 {
 708   if (*datatype == MPI_FLOAT_INT) {
 709     APPLY_FUNC(a, b, length, float_int, MAXLOC_OP);
 710   } else if (*datatype == MPI_LONG_INT) {
 711     APPLY_FUNC(a, b, length, long_int, MAXLOC_OP);
 712   } else if (*datatype == MPI_DOUBLE_INT) {
 713     APPLY_FUNC(a, b, length, double_int, MAXLOC_OP);
 714   } else if (*datatype == MPI_SHORT_INT) {
 715     APPLY_FUNC(a, b, length, short_int, MAXLOC_OP);
 716   } else if (*datatype == MPI_2INT) {
 717     APPLY_FUNC(a, b, length, int_int, MAXLOC_OP);
 718   } else if (*datatype == MPI_LONG_DOUBLE_INT) {
 719     APPLY_FUNC(a, b, length, long_double_int, MAXLOC_OP);
 720   }
 721 }
 722
 723
 724 #define CREATE_MPI_OP(name, func)                             \
 725   static s_smpi_mpi_op_t mpi_##name = { &(func) /* func */ }; \
 726 MPI_Op name = &mpi_##name;
 727
 728 CREATE_MPI_OP(MPI_MAX, max_func);
 729 CREATE_MPI_OP(MPI_MIN, min_func);
 730 CREATE_MPI_OP(MPI_SUM, sum_func);
 731 CREATE_MPI_OP(MPI_PROD, prod_func);
 732 CREATE_MPI_OP(MPI_LAND, land_func);
 733 CREATE_MPI_OP(MPI_LOR, lor_func);
 734 CREATE_MPI_OP(MPI_LXOR, lxor_func);
 735 CREATE_MPI_OP(MPI_BAND, band_func);
 736 CREATE_MPI_OP(MPI_BOR, bor_func);
 737 CREATE_MPI_OP(MPI_BXOR, bxor_func);
 738 CREATE_MPI_OP(MPI_MAXLOC, maxloc_func);
 739 CREATE_MPI_OP(MPI_MINLOC, minloc_func);
 740
 741 MPI_Op smpi_op_new(MPI_User_function * function, int commute)
 742 {
 743   MPI_Op op;
 744
 745   //FIXME: add commute param
 746   op = xbt_new(s_smpi_mpi_op_t, 1);
 747   op->func = function;
 748   return op;
 749 }
 750
 751 void smpi_op_destroy(MPI_Op op)
 752 {
 753   xbt_free(op);
 754 }
 755
 756 void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len,
 757                    MPI_Datatype * datatype)
 758 {
 759   op->func(invec, inoutvec, len, datatype);
 760 }