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-2014. 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 #include "mc/mc.h"
  17 #include "xbt/replay.h"
  18 #include "simgrid/modelchecker.h"
  19
  20 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_mpi_dt, smpi,
  21                                 "Logging specific to SMPI (datatype)");
  22
  23 #define CREATE_MPI_DATATYPE(name, type)       \
  24   static s_smpi_mpi_datatype_t mpi_##name = { \
  25     sizeof(type),  /* size */                 \
  26     0,             /*was 1 has_subtype*/             \
  27     0,             /* lb */                   \
  28     sizeof(type),  /* ub = lb + size */       \
  29     DT_FLAG_BASIC,  /* flags */              \
  30     NULL           /* pointer on extended struct*/ \
  31   };                                          \
  32 MPI_Datatype name = &mpi_##name;
  33
  34 #define CREATE_MPI_DATATYPE_NULL(name)       \
  35   static s_smpi_mpi_datatype_t mpi_##name = { \
  36     0,  /* size */                 \
  37     0,             /*was 1 has_subtype*/             \
  38     0,             /* lb */                   \
  39     0,  /* ub = lb + size */       \
  40     DT_FLAG_BASIC,  /* flags */              \
  41     NULL           /* pointer on extended struct*/ \
  42   };                                          \
  43 MPI_Datatype name = &mpi_##name;
  44
  45 //The following are datatypes for the MPI functions MPI_MAXLOC and MPI_MINLOC.
  46 typedef struct {
  47   float value;
  48   int index;
  49 } float_int;
  50 typedef struct {
  51   float value;
  52   float index;
  53 } float_float;
  54 typedef struct {
  55   double value;
  56   double index;
  57 } double_double;
  58 typedef struct {
  59   long value;
  60   int index;
  61 } long_int;
  62 typedef struct {
  63   double value;
  64   int index;
  65 } double_int;
  66 typedef struct {
  67   short value;
  68   int index;
  69 } short_int;
  70 typedef struct {
  71   int value;
  72   int index;
  73 } int_int;
  74 typedef struct {
  75   long double value;
  76   int index;
  77 } long_double_int;
  78
  79 // Predefined data types
  80 CREATE_MPI_DATATYPE(MPI_CHAR, char);
  81 CREATE_MPI_DATATYPE(MPI_SHORT, short);
  82 CREATE_MPI_DATATYPE(MPI_INT, int);
  83 CREATE_MPI_DATATYPE(MPI_LONG, long);
  84 CREATE_MPI_DATATYPE(MPI_LONG_LONG, long long);
  85 CREATE_MPI_DATATYPE(MPI_SIGNED_CHAR, signed char);
  86 CREATE_MPI_DATATYPE(MPI_UNSIGNED_CHAR, unsigned char);
  87 CREATE_MPI_DATATYPE(MPI_UNSIGNED_SHORT, unsigned short);
  88 CREATE_MPI_DATATYPE(MPI_UNSIGNED, unsigned int);
  89 CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG, unsigned long);
  90 CREATE_MPI_DATATYPE(MPI_UNSIGNED_LONG_LONG, unsigned long long);
  91 CREATE_MPI_DATATYPE(MPI_FLOAT, float);
  92 CREATE_MPI_DATATYPE(MPI_DOUBLE, double);
  93 CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE, long double);
  94 CREATE_MPI_DATATYPE(MPI_WCHAR, wchar_t);
  95 CREATE_MPI_DATATYPE(MPI_C_BOOL, _Bool);
  96 CREATE_MPI_DATATYPE(MPI_INT8_T, int8_t);
  97 CREATE_MPI_DATATYPE(MPI_INT16_T, int16_t);
  98 CREATE_MPI_DATATYPE(MPI_INT32_T, int32_t);
  99 CREATE_MPI_DATATYPE(MPI_INT64_T, int64_t);
 100 CREATE_MPI_DATATYPE(MPI_UINT8_T, uint8_t);
 101 CREATE_MPI_DATATYPE(MPI_UINT16_T, uint16_t);
 102 CREATE_MPI_DATATYPE(MPI_UINT32_T, uint32_t);
 103 CREATE_MPI_DATATYPE(MPI_UINT64_T, uint64_t);
 104 CREATE_MPI_DATATYPE(MPI_C_FLOAT_COMPLEX, float _Complex);
 105 CREATE_MPI_DATATYPE(MPI_C_DOUBLE_COMPLEX, double _Complex);
 106 CREATE_MPI_DATATYPE(MPI_C_LONG_DOUBLE_COMPLEX, long double _Complex);
 107 CREATE_MPI_DATATYPE(MPI_AINT, MPI_Aint);
 108 CREATE_MPI_DATATYPE(MPI_OFFSET, MPI_Offset);
 109
 110 CREATE_MPI_DATATYPE(MPI_FLOAT_INT, float_int);
 111 CREATE_MPI_DATATYPE(MPI_LONG_INT, long_int);
 112 CREATE_MPI_DATATYPE(MPI_DOUBLE_INT, double_int);
 113 CREATE_MPI_DATATYPE(MPI_SHORT_INT, short_int);
 114 CREATE_MPI_DATATYPE(MPI_2INT, int_int);
 115 CREATE_MPI_DATATYPE(MPI_2FLOAT, float_float);
 116 CREATE_MPI_DATATYPE(MPI_2DOUBLE, double_double);
 117
 118 CREATE_MPI_DATATYPE(MPI_LONG_DOUBLE_INT, long_double_int);
 119
 120 CREATE_MPI_DATATYPE_NULL(MPI_UB);
 121 CREATE_MPI_DATATYPE_NULL(MPI_LB);
 122 CREATE_MPI_DATATYPE_NULL(MPI_PACKED);
 123 // Internal use only
 124 CREATE_MPI_DATATYPE(MPI_PTR, void*);
 125
 126
 127 size_t smpi_datatype_size(MPI_Datatype datatype)
 128 {
 129   return datatype->size;
 130 }
 131
 132
 133
 134 MPI_Aint smpi_datatype_lb(MPI_Datatype datatype)
 135 {
 136   return datatype->lb;
 137 }
 138
 139 MPI_Aint smpi_datatype_ub(MPI_Datatype datatype)
 140 {
 141   return datatype->ub;
 142 }
 143
 144 int smpi_datatype_extent(MPI_Datatype datatype, MPI_Aint * lb,
 145                          MPI_Aint * extent)
 146 {
 147   *lb = datatype->lb;
 148   *extent = datatype->ub - datatype->lb;
 149   return MPI_SUCCESS;
 150 }
 151
 152 MPI_Aint smpi_datatype_get_extent(MPI_Datatype datatype){
 153   return datatype->ub - datatype->lb;
 154 }
 155
 156 int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype,
 157                        void *recvbuf, int recvcount, MPI_Datatype recvtype)
 158 {
 159   int count;
 160
 161   /* First check if we really have something to do */
 162   if (recvcount > 0 && recvbuf != sendbuf) {
 163     /* FIXME: treat packed cases */
 164     sendcount *= smpi_datatype_size(sendtype);
 165     recvcount *= smpi_datatype_size(recvtype);
 166     count = sendcount < recvcount ? sendcount : recvcount;
 167
 168     if(sendtype->has_subtype == 0 && recvtype->has_subtype == 0) {
 169       if(!_xbt_replay_is_active()) memcpy(recvbuf, sendbuf, count);
 170     }
 171     else if (sendtype->has_subtype == 0)
 172     {
 173       s_smpi_subtype_t *subtype =  recvtype->substruct;
 174       subtype->unserialize( sendbuf, recvbuf,1, subtype);
 175     }
 176     else if (recvtype->has_subtype == 0)
 177     {
 178       s_smpi_subtype_t *subtype =  sendtype->substruct;
 179       subtype->serialize(sendbuf, recvbuf,1, subtype);
 180     }else{
 181       s_smpi_subtype_t *subtype =  sendtype->substruct;
 182
 183
 184       void * buf_tmp = xbt_malloc(count);
 185
 186       subtype->serialize( sendbuf, buf_tmp,count/smpi_datatype_size(sendtype), subtype);
 187       subtype =  recvtype->substruct;
 188       subtype->unserialize( buf_tmp, recvbuf,count/smpi_datatype_size(recvtype), subtype);
 189
 190       free(buf_tmp);
 191     }
 192   }
 193
 194   return sendcount > recvcount ? MPI_ERR_TRUNCATE : MPI_SUCCESS;
 195 }
 196
 197 /*
 198  *  Copies noncontiguous data into contiguous memory.
 199  *  @param contiguous_vector - output vector
 200  *  @param noncontiguous_vector - input vector
 201  *  @param type - pointer contening :
 202  *      - stride - stride of between noncontiguous data
 203  *      - block_length - the width or height of blocked matrix
 204  *      - count - the number of rows of matrix
 205  */
 206 void serialize_vector( const void *noncontiguous_vector,
 207                        void *contiguous_vector,
 208                        size_t count,
 209                        void *type)
 210 {
 211   s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type;
 212   int i;
 213   char* contiguous_vector_char = (char*)contiguous_vector;
 214   char* noncontiguous_vector_char = (char*)noncontiguous_vector;
 215
 216   for (i = 0; i < type_c->block_count * count; i++) {
 217       if (type_c->old_type->has_subtype == 0)
 218         memcpy(contiguous_vector_char,
 219                noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype);
 220       else
 221         ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_vector_char,
 222                                                                      contiguous_vector_char,
 223                                                                      type_c->block_length,
 224                                                                      type_c->old_type->substruct);
 225
 226     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 227     if((i+1)%type_c->block_count ==0)
 228     noncontiguous_vector_char += type_c->block_length*smpi_datatype_get_extent(type_c->old_type);
 229     else
 230     noncontiguous_vector_char += type_c->block_stride*smpi_datatype_get_extent(type_c->old_type);
 231   }
 232 }
 233
 234 /*
 235  *  Copies contiguous data into noncontiguous memory.
 236  *  @param noncontiguous_vector - output vector
 237  *  @param contiguous_vector - input vector
 238  *  @param type - pointer contening :
 239  *      - stride - stride of between noncontiguous data
 240  *      - block_length - the width or height of blocked matrix
 241  *      - count - the number of rows of matrix
 242  */
 243 void unserialize_vector( const void *contiguous_vector,
 244                          void *noncontiguous_vector,
 245                          size_t count,
 246                          void *type)
 247 {
 248   s_smpi_mpi_vector_t* type_c = (s_smpi_mpi_vector_t*)type;
 249   int i;
 250
 251   char* contiguous_vector_char = (char*)contiguous_vector;
 252   char* noncontiguous_vector_char = (char*)noncontiguous_vector;
 253
 254   for (i = 0; i < type_c->block_count * count; i++) {
 255     if (type_c->old_type->has_subtype == 0)
 256       memcpy(noncontiguous_vector_char,
 257              contiguous_vector_char, type_c->block_length * type_c->size_oldtype);
 258     else
 259       ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char,
 260                                                                      noncontiguous_vector_char,
 261                                                                      type_c->block_length,
 262                                                                      type_c->old_type->substruct);
 263     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 264     if((i+1)%type_c->block_count ==0)
 265     noncontiguous_vector_char += type_c->block_length*smpi_datatype_get_extent(type_c->old_type);
 266     else
 267     noncontiguous_vector_char += type_c->block_stride*smpi_datatype_get_extent(type_c->old_type);
 268   }
 269 }
 270
 271 /*
 272  * Create a Sub type vector to be able to serialize and unserialize it
 273  * the structure s_smpi_mpi_vector_t is derived from s_smpi_subtype which
 274  * required the functions unserialize and serialize
 275  *
 276  */
 277 s_smpi_mpi_vector_t* smpi_datatype_vector_create( int block_stride,
 278                                                   int block_length,
 279                                                   int block_count,
 280                                                   MPI_Datatype old_type,
 281                                                   int size_oldtype){
 282   s_smpi_mpi_vector_t *new_t= xbt_new(s_smpi_mpi_vector_t,1);
 283   new_t->base.serialize = &serialize_vector;
 284   new_t->base.unserialize = &unserialize_vector;
 285   new_t->base.subtype_free = &free_vector;
 286   new_t->block_stride = block_stride;
 287   new_t->block_length = block_length;
 288   new_t->block_count = block_count;
 289   new_t->old_type = old_type;
 290   new_t->size_oldtype = size_oldtype;
 291   return new_t;
 292 }
 293
 294 void smpi_datatype_create(MPI_Datatype* new_type, int size,int lb, int ub, int has_subtype,
 295                           void *struct_type, int flags){
 296   MPI_Datatype new_t= xbt_new(s_smpi_mpi_datatype_t,1);
 297   new_t->size = size;
 298   new_t->has_subtype = size>0? has_subtype:0;
 299   new_t->lb = lb;
 300   new_t->ub = ub;
 301   new_t->flags = flags;
 302   new_t->substruct = struct_type;
 303   new_t->in_use=0;
 304   *new_type = new_t;
 305
 306 #ifdef HAVE_MC
 307   if(MC_is_active())
 308     MC_ignore(&(new_t->in_use), sizeof(new_t->in_use));
 309 #endif
 310 }
 311
 312 void smpi_datatype_free(MPI_Datatype* type){
 313
 314   if((*type)->flags & DT_FLAG_PREDEFINED)return;
 315
 316   //if still used, mark for deletion
 317   if((*type)->in_use!=0){
 318       (*type)->flags |=DT_FLAG_DESTROYED;
 319       return;
 320   }
 321
 322   if ((*type)->has_subtype == 1){
 323     ((s_smpi_subtype_t *)(*type)->substruct)->subtype_free(type);
 324     xbt_free((*type)->substruct);
 325   }
 326   xbt_free(*type);
 327
 328 }
 329
 330 void smpi_datatype_use(MPI_Datatype type){
 331   if(type)type->in_use++;
 332
 333 #ifdef HAVE_MC
 334   if(MC_is_active())
 335     MC_ignore(&(type->in_use), sizeof(type->in_use));
 336 #endif
 337 }
 338
 339
 340 void smpi_datatype_unuse(MPI_Datatype type){
 341   if(type && type->in_use-- == 0 && (type->flags & DT_FLAG_DESTROYED))
 342     smpi_datatype_free(&type);
 343
 344 #ifdef HAVE_MC
 345   if(MC_is_active())
 346     MC_ignore(&(type->in_use), sizeof(type->in_use));
 347 #endif
 348 }
 349
 350
 351
 352
 353 /*
 354 Contiguous Implementation
 355 */
 356
 357
 358 /*
 359  *  Copies noncontiguous data into contiguous memory.
 360  *  @param contiguous_hvector - output hvector
 361  *  @param noncontiguous_hvector - input hvector
 362  *  @param type - pointer contening :
 363  *      - stride - stride of between noncontiguous data, in bytes
 364  *      - block_length - the width or height of blocked matrix
 365  *      - count - the number of rows of matrix
 366  */
 367 void serialize_contiguous( const void *noncontiguous_hvector,
 368                        void *contiguous_hvector,
 369                        size_t count,
 370                        void *type)
 371 {
 372   s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type;
 373   char* contiguous_vector_char = (char*)contiguous_hvector;
 374   char* noncontiguous_vector_char = (char*)noncontiguous_hvector+type_c->lb;
 375   memcpy(contiguous_vector_char,
 376            noncontiguous_vector_char, count* type_c->block_count * type_c->size_oldtype);
 377 }
 378 /*
 379  *  Copies contiguous data into noncontiguous memory.
 380  *  @param noncontiguous_vector - output hvector
 381  *  @param contiguous_vector - input hvector
 382  *  @param type - pointer contening :
 383  *      - stride - stride of between noncontiguous data, in bytes
 384  *      - block_length - the width or height of blocked matrix
 385  *      - count - the number of rows of matrix
 386  */
 387 void unserialize_contiguous( const void *contiguous_vector,
 388                          void *noncontiguous_vector,
 389                          size_t count,
 390                          void *type)
 391 {
 392   s_smpi_mpi_contiguous_t* type_c = (s_smpi_mpi_contiguous_t*)type;
 393   char* contiguous_vector_char = (char*)contiguous_vector;
 394   char* noncontiguous_vector_char = (char*)noncontiguous_vector+type_c->lb;
 395
 396   memcpy(noncontiguous_vector_char,
 397            contiguous_vector_char, count*  type_c->block_count * type_c->size_oldtype);
 398 }
 399
 400 void free_contiguous(MPI_Datatype* d){
 401 }
 402
 403 /*
 404  * Create a Sub type contiguous to be able to serialize and unserialize it
 405  * the structure s_smpi_mpi_contiguous_t is derived from s_smpi_subtype which
 406  * required the functions unserialize and serialize
 407  *
 408  */
 409 s_smpi_mpi_contiguous_t* smpi_datatype_contiguous_create( MPI_Aint lb,
 410                                                   int block_count,
 411                                                   MPI_Datatype old_type,
 412                                                   int size_oldtype){
 413   s_smpi_mpi_contiguous_t *new_t= xbt_new(s_smpi_mpi_contiguous_t,1);
 414   new_t->base.serialize = &serialize_contiguous;
 415   new_t->base.unserialize = &unserialize_contiguous;
 416   new_t->base.subtype_free = &free_contiguous;
 417   new_t->lb = lb;
 418   new_t->block_count = block_count;
 419   new_t->old_type = old_type;
 420   new_t->size_oldtype = size_oldtype;
 421   return new_t;
 422 }
 423
 424
 425
 426
 427 int smpi_datatype_contiguous(int count, MPI_Datatype old_type, MPI_Datatype* new_type, MPI_Aint lb)
 428 {
 429   int retval;
 430   if(old_type->has_subtype){
 431           //handle this case as a hvector with stride equals to the extent of the datatype
 432           return smpi_datatype_hvector(count, 1, smpi_datatype_get_extent(old_type), old_type, new_type);
 433   }
 434
 435   s_smpi_mpi_contiguous_t* subtype = smpi_datatype_contiguous_create( lb,
 436                                                                 count,
 437                                                                 old_type,
 438                                                                 smpi_datatype_size(old_type));
 439
 440   smpi_datatype_create(new_type,
 441                                           count * smpi_datatype_size(old_type),
 442                                           lb,lb + count * smpi_datatype_size(old_type),
 443                                           1,subtype, DT_FLAG_CONTIGUOUS);
 444   retval=MPI_SUCCESS;
 445   return retval;
 446 }
 447
 448 int smpi_datatype_vector(int count, int blocklen, int stride, MPI_Datatype old_type, MPI_Datatype* new_type)
 449 {
 450   int retval;
 451   if (blocklen<0) return MPI_ERR_ARG;
 452   MPI_Aint lb = 0;
 453   MPI_Aint ub = 0;
 454   if(count>0){
 455     lb=smpi_datatype_lb(old_type);
 456     ub=((count-1)*stride+blocklen-1)*smpi_datatype_get_extent(old_type)+smpi_datatype_ub(old_type);
 457   }
 458   if(old_type->has_subtype || stride != blocklen){
 459
 460
 461     s_smpi_mpi_vector_t* subtype = smpi_datatype_vector_create( stride,
 462                                                                 blocklen,
 463                                                                 count,
 464                                                                 old_type,
 465                                                                 smpi_datatype_size(old_type));
 466     smpi_datatype_create(new_type,
 467                          count * (blocklen) * smpi_datatype_size(old_type), lb,
 468                          ub,
 469                          1,
 470                          subtype,
 471                          DT_FLAG_VECTOR);
 472     retval=MPI_SUCCESS;
 473   }else{
 474     /* in this situation the data are contignous thus it's not
 475      * required to serialize and unserialize it*/
 476     smpi_datatype_create(new_type, count * blocklen *
 477                          smpi_datatype_size(old_type), 0, ((count -1) * stride + blocklen)*
 478                          smpi_datatype_size(old_type),
 479                          0,
 480                          NULL,
 481                          DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS);
 482     retval=MPI_SUCCESS;
 483   }
 484   return retval;
 485 }
 486
 487 void free_vector(MPI_Datatype* d){
 488 }
 489
 490 /*
 491 Hvector Implementation - Vector with stride in bytes
 492 */
 493
 494
 495 /*
 496  *  Copies noncontiguous data into contiguous memory.
 497  *  @param contiguous_hvector - output hvector
 498  *  @param noncontiguous_hvector - input hvector
 499  *  @param type - pointer contening :
 500  *      - stride - stride of between noncontiguous data, in bytes
 501  *      - block_length - the width or height of blocked matrix
 502  *      - count - the number of rows of matrix
 503  */
 504 void serialize_hvector( const void *noncontiguous_hvector,
 505                        void *contiguous_hvector,
 506                        size_t count,
 507                        void *type)
 508 {
 509   s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type;
 510   int i;
 511   char* contiguous_vector_char = (char*)contiguous_hvector;
 512   char* noncontiguous_vector_char = (char*)noncontiguous_hvector;
 513
 514   for (i = 0; i < type_c->block_count * count; i++) {
 515     if (type_c->old_type->has_subtype == 0)
 516       memcpy(contiguous_vector_char,
 517            noncontiguous_vector_char, type_c->block_length * type_c->size_oldtype);
 518     else
 519       ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_vector_char,
 520                                                                    contiguous_vector_char,
 521                                                                    type_c->block_length,
 522                                                                    type_c->old_type->substruct);
 523
 524     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 525     if((i+1)%type_c->block_count ==0)
 526     noncontiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 527     else
 528     noncontiguous_vector_char += type_c->block_stride;
 529   }
 530 }
 531 /*
 532  *  Copies contiguous data into noncontiguous memory.
 533  *  @param noncontiguous_vector - output hvector
 534  *  @param contiguous_vector - input hvector
 535  *  @param type - pointer contening :
 536  *      - stride - stride of between noncontiguous data, in bytes
 537  *      - block_length - the width or height of blocked matrix
 538  *      - count - the number of rows of matrix
 539  */
 540 void unserialize_hvector( const void *contiguous_vector,
 541                          void *noncontiguous_vector,
 542                          size_t count,
 543                          void *type)
 544 {
 545   s_smpi_mpi_hvector_t* type_c = (s_smpi_mpi_hvector_t*)type;
 546   int i;
 547
 548   char* contiguous_vector_char = (char*)contiguous_vector;
 549   char* noncontiguous_vector_char = (char*)noncontiguous_vector;
 550
 551   for (i = 0; i < type_c->block_count * count; i++) {
 552     if (type_c->old_type->has_subtype == 0)
 553       memcpy(noncontiguous_vector_char,
 554            contiguous_vector_char, type_c->block_length * type_c->size_oldtype);
 555     else
 556       ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_vector_char,
 557                                                                      noncontiguous_vector_char,
 558                                                                      type_c->block_length,
 559                                                                      type_c->old_type->substruct);
 560     contiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 561     if((i+1)%type_c->block_count ==0)
 562     noncontiguous_vector_char += type_c->block_length*type_c->size_oldtype;
 563     else
 564     noncontiguous_vector_char += type_c->block_stride;
 565   }
 566 }
 567
 568 /*
 569  * Create a Sub type vector to be able to serialize and unserialize it
 570  * the structure s_smpi_mpi_vector_t is derived from s_smpi_subtype which
 571  * required the functions unserialize and serialize
 572  *
 573  */
 574 s_smpi_mpi_hvector_t* smpi_datatype_hvector_create( MPI_Aint block_stride,
 575                                                   int block_length,
 576                                                   int block_count,
 577                                                   MPI_Datatype old_type,
 578                                                   int size_oldtype){
 579   s_smpi_mpi_hvector_t *new_t= xbt_new(s_smpi_mpi_hvector_t,1);
 580   new_t->base.serialize = &serialize_hvector;
 581   new_t->base.unserialize = &unserialize_hvector;
 582   new_t->base.subtype_free = &free_hvector;
 583   new_t->block_stride = block_stride;
 584   new_t->block_length = block_length;
 585   new_t->block_count = block_count;
 586   new_t->old_type = old_type;
 587   new_t->size_oldtype = size_oldtype;
 588   return new_t;
 589 }
 590
 591 //do nothing for vector types
 592 void free_hvector(MPI_Datatype* d){
 593 }
 594
 595 int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, MPI_Datatype old_type, MPI_Datatype* new_type)
 596 {
 597   int retval;
 598   if (blocklen<0) return MPI_ERR_ARG;
 599   MPI_Aint lb = 0;
 600   MPI_Aint ub = 0;
 601   if(count>0){
 602     lb=smpi_datatype_lb(old_type);
 603     ub=((count-1)*stride)+(blocklen-1)*smpi_datatype_get_extent(old_type)+smpi_datatype_ub(old_type);
 604   }
 605   if(old_type->has_subtype || stride != blocklen*smpi_datatype_get_extent(old_type)){
 606     s_smpi_mpi_hvector_t* subtype = smpi_datatype_hvector_create( stride,
 607                                                                   blocklen,
 608                                                                   count,
 609                                                                   old_type,
 610                                                                   smpi_datatype_size(old_type));
 611
 612     smpi_datatype_create(new_type, count * blocklen * smpi_datatype_size(old_type),
 613                                                  lb,ub,
 614                          1,
 615                          subtype,
 616                          DT_FLAG_VECTOR);
 617     retval=MPI_SUCCESS;
 618   }else{
 619     smpi_datatype_create(new_type, count * blocklen *
 620                                              smpi_datatype_size(old_type),0,count * blocklen *
 621                                              smpi_datatype_size(old_type),
 622                                             0,
 623                                             NULL,
 624                                             DT_FLAG_VECTOR|DT_FLAG_CONTIGUOUS);
 625     retval=MPI_SUCCESS;
 626   }
 627   return retval;
 628 }
 629
 630
 631 /*
 632 Indexed Implementation
 633 */
 634
 635 /*
 636  *  Copies noncontiguous data into contiguous memory.
 637  *  @param contiguous_indexed - output indexed
 638  *  @param noncontiguous_indexed - input indexed
 639  *  @param type - pointer contening :
 640  *      - block_lengths - the width or height of blocked matrix
 641  *      - block_indices - indices of each data, in element
 642  *      - count - the number of rows of matrix
 643  */
 644 void serialize_indexed( const void *noncontiguous_indexed,
 645                        void *contiguous_indexed,
 646                        size_t count,
 647                        void *type)
 648 {
 649   s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type;
 650   int i,j;
 651   char* contiguous_indexed_char = (char*)contiguous_indexed;
 652   char* noncontiguous_indexed_char = (char*)noncontiguous_indexed+type_c->block_indices[0] * type_c->size_oldtype;
 653   for(j=0; j<count;j++){
 654     for (i = 0; i < type_c->block_count; i++) {
 655       if (type_c->old_type->has_subtype == 0)
 656         memcpy(contiguous_indexed_char,
 657                      noncontiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype);
 658       else
 659         ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_indexed_char,
 660                                                                      contiguous_indexed_char,
 661                                                                      type_c->block_lengths[i],
 662                                                                      type_c->old_type->substruct);
 663
 664
 665       contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype;
 666       if (i<type_c->block_count-1)noncontiguous_indexed_char = (char*)noncontiguous_indexed + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type);
 667       else noncontiguous_indexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type);
 668     }
 669     noncontiguous_indexed=(void*)noncontiguous_indexed_char;
 670   }
 671 }
 672 /*
 673  *  Copies contiguous data into noncontiguous memory.
 674  *  @param noncontiguous_indexed - output indexed
 675  *  @param contiguous_indexed - input indexed
 676  *  @param type - pointer contening :
 677  *      - block_lengths - the width or height of blocked matrix
 678  *      - block_indices - indices of each data, in element
 679  *      - count - the number of rows of matrix
 680  */
 681 void unserialize_indexed( const void *contiguous_indexed,
 682                          void *noncontiguous_indexed,
 683                          size_t count,
 684                          void *type)
 685 {
 686
 687   s_smpi_mpi_indexed_t* type_c = (s_smpi_mpi_indexed_t*)type;
 688   int i,j;
 689   char* contiguous_indexed_char = (char*)contiguous_indexed;
 690   char* noncontiguous_indexed_char = (char*)noncontiguous_indexed+type_c->block_indices[0]*smpi_datatype_get_extent(type_c->old_type);
 691   for(j=0; j<count;j++){
 692     for (i = 0; i < type_c->block_count; i++) {
 693       if (type_c->old_type->has_subtype == 0)
 694         memcpy(noncontiguous_indexed_char ,
 695              contiguous_indexed_char, type_c->block_lengths[i] * type_c->size_oldtype);
 696       else
 697         ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_indexed_char,
 698                                                                        noncontiguous_indexed_char,
 699                                                                        type_c->block_lengths[i],
 700                                                                        type_c->old_type->substruct);
 701
 702       contiguous_indexed_char += type_c->block_lengths[i]*type_c->size_oldtype;
 703       if (i<type_c->block_count-1)
 704         noncontiguous_indexed_char = (char*)noncontiguous_indexed + type_c->block_indices[i+1]*smpi_datatype_get_extent(type_c->old_type);
 705       else noncontiguous_indexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type);
 706     }
 707     noncontiguous_indexed=(void*)noncontiguous_indexed_char;
 708   }
 709 }
 710
 711 void free_indexed(MPI_Datatype* type){
 712   xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_lengths);
 713   xbt_free(((s_smpi_mpi_indexed_t *)(*type)->substruct)->block_indices);
 714 }
 715
 716 /*
 717  * Create a Sub type indexed to be able to serialize and unserialize it
 718  * the structure s_smpi_mpi_indexed_t is derived from s_smpi_subtype which
 719  * required the functions unserialize and serialize
 720  */
 721 s_smpi_mpi_indexed_t* smpi_datatype_indexed_create( int* block_lengths,
 722                                                   int* block_indices,
 723                                                   int block_count,
 724                                                   MPI_Datatype old_type,
 725                                                   int size_oldtype){
 726   s_smpi_mpi_indexed_t *new_t= xbt_new(s_smpi_mpi_indexed_t,1);
 727   new_t->base.serialize = &serialize_indexed;
 728   new_t->base.unserialize = &unserialize_indexed;
 729   new_t->base.subtype_free = &free_indexed;
 730  //TODO : add a custom function for each time to clean these
 731   new_t->block_lengths= xbt_new(int, block_count);
 732   new_t->block_indices= xbt_new(int, block_count);
 733   int i;
 734   for(i=0;i<block_count;i++){
 735     new_t->block_lengths[i]=block_lengths[i];
 736     new_t->block_indices[i]=block_indices[i];
 737   }
 738   new_t->block_count = block_count;
 739   new_t->old_type = old_type;
 740   new_t->size_oldtype = size_oldtype;
 741   return new_t;
 742 }
 743
 744
 745 int smpi_datatype_indexed(int count, int* blocklens, int* indices, MPI_Datatype old_type, MPI_Datatype* new_type)
 746 {
 747   int i;
 748   int retval;
 749   int size = 0;
 750   int contiguous=1;
 751   MPI_Aint lb = 0;
 752   MPI_Aint ub = 0;
 753   if(count>0){
 754     lb=indices[0]*smpi_datatype_get_extent(old_type);
 755     ub=indices[0]*smpi_datatype_get_extent(old_type) + blocklens[0]*smpi_datatype_ub(old_type);
 756   }
 757
 758   for(i=0; i< count; i++){
 759     if   (blocklens[i]<0)
 760       return MPI_ERR_ARG;
 761     size += blocklens[i];
 762
 763     if(indices[i]*smpi_datatype_get_extent(old_type)+smpi_datatype_lb(old_type)<lb)
 764         lb = indices[i]*smpi_datatype_get_extent(old_type)+smpi_datatype_lb(old_type);
 765     if(indices[i]*smpi_datatype_get_extent(old_type)+blocklens[i]*smpi_datatype_ub(old_type)>ub)
 766         ub = indices[i]*smpi_datatype_get_extent(old_type)+blocklens[i]*smpi_datatype_ub(old_type);
 767
 768     if ( (i< count -1) && (indices[i]+blocklens[i] != indices[i+1]) )contiguous=0;
 769   }
 770   if (old_type->has_subtype == 1)
 771     contiguous=0;
 772
 773   if(!contiguous){
 774     s_smpi_mpi_indexed_t* subtype = smpi_datatype_indexed_create( blocklens,
 775                                                                   indices,
 776                                                                   count,
 777                                                                   old_type,
 778                                                                   smpi_datatype_size(old_type));
 779      smpi_datatype_create(new_type,  size *
 780                          smpi_datatype_size(old_type),lb,ub,1, subtype, DT_FLAG_DATA);
 781   }else{
 782     s_smpi_mpi_contiguous_t* subtype = smpi_datatype_contiguous_create( lb,
 783                                                                   size,
 784                                                                   old_type,
 785                                                                   smpi_datatype_size(old_type));
 786     smpi_datatype_create(new_type,  size *
 787                          smpi_datatype_size(old_type),lb,ub,1, subtype, DT_FLAG_DATA|DT_FLAG_CONTIGUOUS);
 788   }
 789   retval=MPI_SUCCESS;
 790   return retval;
 791 }
 792
 793
 794 /*
 795 Hindexed Implementation - Indexed with indices in bytes
 796 */
 797
 798 /*
 799  *  Copies noncontiguous data into contiguous memory.
 800  *  @param contiguous_hindexed - output hindexed
 801  *  @param noncontiguous_hindexed - input hindexed
 802  *  @param type - pointer contening :
 803  *      - block_lengths - the width or height of blocked matrix
 804  *      - block_indices - indices of each data, in bytes
 805  *      - count - the number of rows of matrix
 806  */
 807 void serialize_hindexed( const void *noncontiguous_hindexed,
 808                        void *contiguous_hindexed,
 809                        size_t count,
 810                        void *type)
 811 {
 812   s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type;
 813   int i,j;
 814   char* contiguous_hindexed_char = (char*)contiguous_hindexed;
 815   char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed+ type_c->block_indices[0];
 816   for(j=0; j<count;j++){
 817     for (i = 0; i < type_c->block_count; i++) {
 818       if (type_c->old_type->has_subtype == 0)
 819         memcpy(contiguous_hindexed_char,
 820                      noncontiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype);
 821       else
 822         ((s_smpi_subtype_t*)type_c->old_type->substruct)->serialize( noncontiguous_hindexed_char,
 823                                                                      contiguous_hindexed_char,
 824                                                                      type_c->block_lengths[i],
 825                                                                      type_c->old_type->substruct);
 826
 827       contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype;
 828       if (i<type_c->block_count-1)noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1];
 829       else noncontiguous_hindexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type);
 830     }
 831     noncontiguous_hindexed=(void*)noncontiguous_hindexed_char;
 832   }
 833 }
 834 /*
 835  *  Copies contiguous data into noncontiguous memory.
 836  *  @param noncontiguous_hindexed - output hindexed
 837  *  @param contiguous_hindexed - input hindexed
 838  *  @param type - pointer contening :
 839  *      - block_lengths - the width or height of blocked matrix
 840  *      - block_indices - indices of each data, in bytes
 841  *      - count - the number of rows of matrix
 842  */
 843 void unserialize_hindexed( const void *contiguous_hindexed,
 844                          void *noncontiguous_hindexed,
 845                          size_t count,
 846                          void *type)
 847 {
 848   s_smpi_mpi_hindexed_t* type_c = (s_smpi_mpi_hindexed_t*)type;
 849   int i,j;
 850
 851   char* contiguous_hindexed_char = (char*)contiguous_hindexed;
 852   char* noncontiguous_hindexed_char = (char*)noncontiguous_hindexed+ type_c->block_indices[0];
 853   for(j=0; j<count;j++){
 854     for (i = 0; i < type_c->block_count; i++) {
 855       if (type_c->old_type->has_subtype == 0)
 856         memcpy(noncontiguous_hindexed_char,
 857                contiguous_hindexed_char, type_c->block_lengths[i] * type_c->size_oldtype);
 858       else
 859         ((s_smpi_subtype_t*)type_c->old_type->substruct)->unserialize( contiguous_hindexed_char,
 860                                                                        noncontiguous_hindexed_char,
 861                                                                        type_c->block_lengths[i],
 862                                                                        type_c->old_type->substruct);
 863
 864       contiguous_hindexed_char += type_c->block_lengths[i]*type_c->size_oldtype;
 865       if (i<type_c->block_count-1)noncontiguous_hindexed_char = (char*)noncontiguous_hindexed + type_c->block_indices[i+1];
 866       else noncontiguous_hindexed_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_type);
 867     }
 868     noncontiguous_hindexed=(void*)noncontiguous_hindexed_char;
 869   }
 870 }
 871
 872 void free_hindexed(MPI_Datatype* type){
 873   xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_lengths);
 874   xbt_free(((s_smpi_mpi_hindexed_t *)(*type)->substruct)->block_indices);
 875 }
 876
 877 /*
 878  * Create a Sub type hindexed to be able to serialize and unserialize it
 879  * the structure s_smpi_mpi_hindexed_t is derived from s_smpi_subtype which
 880  * required the functions unserialize and serialize
 881  */
 882 s_smpi_mpi_hindexed_t* smpi_datatype_hindexed_create( int* block_lengths,
 883                                                   MPI_Aint* block_indices,
 884                                                   int block_count,
 885                                                   MPI_Datatype old_type,
 886                                                   int size_oldtype){
 887   s_smpi_mpi_hindexed_t *new_t= xbt_new(s_smpi_mpi_hindexed_t,1);
 888   new_t->base.serialize = &serialize_hindexed;
 889   new_t->base.unserialize = &unserialize_hindexed;
 890   new_t->base.subtype_free = &free_hindexed;
 891  //TODO : add a custom function for each time to clean these
 892   new_t->block_lengths= xbt_new(int, block_count);
 893   new_t->block_indices= xbt_new(MPI_Aint, block_count);
 894   int i;
 895   for(i=0;i<block_count;i++){
 896     new_t->block_lengths[i]=block_lengths[i];
 897     new_t->block_indices[i]=block_indices[i];
 898   }
 899   new_t->block_count = block_count;
 900   new_t->old_type = old_type;
 901   new_t->size_oldtype = size_oldtype;
 902   return new_t;
 903 }
 904
 905
 906 int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype old_type, MPI_Datatype* new_type)
 907 {
 908   int i;
 909   int retval;
 910   int size = 0;
 911   int contiguous=1;
 912   MPI_Aint lb = 0;
 913   MPI_Aint ub = 0;
 914   if(count>0){
 915     lb=indices[0] + smpi_datatype_lb(old_type);
 916     ub=indices[0] + blocklens[0]*smpi_datatype_ub(old_type);
 917   }
 918   for(i=0; i< count; i++){
 919     if   (blocklens[i]<0)
 920       return MPI_ERR_ARG;
 921     size += blocklens[i];
 922
 923     if(indices[i]+smpi_datatype_lb(old_type)<lb) lb = indices[i]+smpi_datatype_lb(old_type);
 924     if(indices[i]+blocklens[i]*smpi_datatype_ub(old_type)>ub) ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_type);
 925
 926     if ( (i< count -1) && (indices[i]+blocklens[i]*smpi_datatype_size(old_type) != indices[i+1]) )contiguous=0;
 927   }
 928   if (old_type->has_subtype == 1 || lb!=0)
 929     contiguous=0;
 930
 931   if(!contiguous){
 932     s_smpi_mpi_hindexed_t* subtype = smpi_datatype_hindexed_create( blocklens,
 933                                                                   indices,
 934                                                                   count,
 935                                                                   old_type,
 936                                                                   smpi_datatype_size(old_type));
 937     smpi_datatype_create(new_type,  size * smpi_datatype_size(old_type),
 938                                                  lb,
 939                          ub
 940                          ,1, subtype, DT_FLAG_DATA);
 941   }else{
 942     s_smpi_mpi_contiguous_t* subtype = smpi_datatype_contiguous_create( lb,
 943                                                                   size,
 944                                                                   old_type,
 945                                                                   smpi_datatype_size(old_type));
 946     smpi_datatype_create(new_type,  size * smpi_datatype_size(old_type),
 947                                              0,size * smpi_datatype_size(old_type),
 948                                              1, subtype, DT_FLAG_DATA|DT_FLAG_CONTIGUOUS);
 949   }
 950   retval=MPI_SUCCESS;
 951   return retval;
 952 }
 953
 954
 955 /*
 956 struct Implementation - Indexed with indices in bytes
 957 */
 958
 959 /*
 960  *  Copies noncontiguous data into contiguous memory.
 961  *  @param contiguous_struct - output struct
 962  *  @param noncontiguous_struct - input struct
 963  *  @param type - pointer contening :
 964  *      - stride - stride of between noncontiguous data
 965  *      - block_length - the width or height of blocked matrix
 966  *      - count - the number of rows of matrix
 967  */
 968 void serialize_struct( const void *noncontiguous_struct,
 969                        void *contiguous_struct,
 970                        size_t count,
 971                        void *type)
 972 {
 973   s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type;
 974   int i,j;
 975   char* contiguous_struct_char = (char*)contiguous_struct;
 976   char* noncontiguous_struct_char = (char*)noncontiguous_struct+ type_c->block_indices[0];
 977   for(j=0; j<count;j++){
 978     for (i = 0; i < type_c->block_count; i++) {
 979       if (type_c->old_types[i]->has_subtype == 0)
 980         memcpy(contiguous_struct_char,
 981              noncontiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i]));
 982       else
 983         ((s_smpi_subtype_t*)type_c->old_types[i]->substruct)->serialize( noncontiguous_struct_char,
 984                                                                          contiguous_struct_char,
 985                                                                          type_c->block_lengths[i],
 986                                                                          type_c->old_types[i]->substruct);
 987
 988
 989       contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]);
 990       if (i<type_c->block_count-1)noncontiguous_struct_char = (char*)noncontiguous_struct + type_c->block_indices[i+1];
 991       else noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_types[i]);//let's hope this is MPI_UB ?
 992     }
 993     noncontiguous_struct=(void*)noncontiguous_struct_char;
 994   }
 995 }
 996 /*
 997  *  Copies contiguous data into noncontiguous memory.
 998  *  @param noncontiguous_struct - output struct
 999  *  @param contiguous_struct - input struct
1000  *  @param type - pointer contening :
1001  *      - stride - stride of between noncontiguous data
1002  *      - block_length - the width or height of blocked matrix
1003  *      - count - the number of rows of matrix
1004  */
1005 void unserialize_struct( const void *contiguous_struct,
1006                          void *noncontiguous_struct,
1007                          size_t count,
1008                          void *type)
1009 {
1010   s_smpi_mpi_struct_t* type_c = (s_smpi_mpi_struct_t*)type;
1011   int i,j;
1012
1013   char* contiguous_struct_char = (char*)contiguous_struct;
1014   char* noncontiguous_struct_char = (char*)noncontiguous_struct+ type_c->block_indices[0];
1015   for(j=0; j<count;j++){
1016     for (i = 0; i < type_c->block_count; i++) {
1017       if (type_c->old_types[i]->has_subtype == 0)
1018         memcpy(noncontiguous_struct_char,
1019              contiguous_struct_char, type_c->block_lengths[i] * smpi_datatype_size(type_c->old_types[i]));
1020       else
1021         ((s_smpi_subtype_t*)type_c->old_types[i]->substruct)->unserialize( contiguous_struct_char,
1022                                                                            noncontiguous_struct_char,
1023                                                                            type_c->block_lengths[i],
1024                                                                            type_c->old_types[i]->substruct);
1025
1026       contiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_size(type_c->old_types[i]);
1027       if (i<type_c->block_count-1)noncontiguous_struct_char =  (char*)noncontiguous_struct + type_c->block_indices[i+1];
1028       else noncontiguous_struct_char += type_c->block_lengths[i]*smpi_datatype_get_extent(type_c->old_types[i]);
1029     }
1030     noncontiguous_struct=(void*)noncontiguous_struct_char;
1031
1032   }
1033 }
1034
1035 void free_struct(MPI_Datatype* type){
1036   xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_lengths);
1037   xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->block_indices);
1038   xbt_free(((s_smpi_mpi_struct_t *)(*type)->substruct)->old_types);
1039 }
1040
1041 /*
1042  * Create a Sub type struct to be able to serialize and unserialize it
1043  * the structure s_smpi_mpi_struct_t is derived from s_smpi_subtype which
1044  * required the functions unserialize and serialize
1045  */
1046 s_smpi_mpi_struct_t* smpi_datatype_struct_create( int* block_lengths,
1047                                                   MPI_Aint* block_indices,
1048                                                   int block_count,
1049                                                   MPI_Datatype* old_types){
1050   s_smpi_mpi_struct_t *new_t= xbt_new(s_smpi_mpi_struct_t,1);
1051   new_t->base.serialize = &serialize_struct;
1052   new_t->base.unserialize = &unserialize_struct;
1053   new_t->base.subtype_free = &free_struct;
1054  //TODO : add a custom function for each time to clean these
1055   new_t->block_lengths= xbt_new(int, block_count);
1056   new_t->block_indices= xbt_new(MPI_Aint, block_count);
1057   new_t->old_types=  xbt_new(MPI_Datatype, block_count);
1058   int i;
1059   for(i=0;i<block_count;i++){
1060     new_t->block_lengths[i]=block_lengths[i];
1061     new_t->block_indices[i]=block_indices[i];
1062     new_t->old_types[i]=old_types[i];
1063   }
1064   //new_t->block_lengths = block_lengths;
1065   //new_t->block_indices = block_indices;
1066   new_t->block_count = block_count;
1067   //new_t->old_types = old_types;
1068   return new_t;
1069 }
1070
1071
1072 int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, MPI_Datatype* old_types, MPI_Datatype* new_type)
1073 {
1074   int i;
1075   size_t size = 0;
1076   int contiguous=1;
1077   size = 0;
1078   MPI_Aint lb = 0;
1079   MPI_Aint ub = 0;
1080   if(count>0){
1081     lb=indices[0] + smpi_datatype_lb(old_types[0]);
1082     ub=indices[0] + blocklens[0]*smpi_datatype_ub(old_types[0]);
1083   }
1084   int forced_lb=0;
1085   int forced_ub=0;
1086   for(i=0; i< count; i++){
1087     if (blocklens[i]<0)
1088       return MPI_ERR_ARG;
1089     if (old_types[i]->has_subtype == 1)
1090       contiguous=0;
1091
1092     size += blocklens[i]*smpi_datatype_size(old_types[i]);
1093     if (old_types[i]==MPI_LB){
1094       lb=indices[i];
1095       forced_lb=1;
1096     }
1097     if (old_types[i]==MPI_UB){
1098       ub=indices[i];
1099       forced_ub=1;
1100     }
1101
1102     if(!forced_lb && indices[i]+smpi_datatype_lb(old_types[i])<lb) lb = indices[i];
1103     if(!forced_ub && indices[i]+blocklens[i]*smpi_datatype_ub(old_types[i])>ub) ub = indices[i]+blocklens[i]*smpi_datatype_ub(old_types[i]);
1104
1105     if ( (i< count -1) && (indices[i]+blocklens[i]*smpi_datatype_size(old_types[i]) != indices[i+1]) )contiguous=0;
1106   }
1107
1108   if(!contiguous){
1109     s_smpi_mpi_struct_t* subtype = smpi_datatype_struct_create( blocklens,
1110                                                               indices,
1111                                                               count,
1112                                                               old_types);
1113
1114     smpi_datatype_create(new_type,  size, lb, ub,1, subtype, DT_FLAG_DATA);
1115   }else{
1116     s_smpi_mpi_contiguous_t* subtype = smpi_datatype_contiguous_create( lb,
1117                                                                   size,
1118                                                                   MPI_CHAR,
1119                                                                   1);
1120     smpi_datatype_create(new_type,  size, lb, ub,1, subtype, DT_FLAG_DATA|DT_FLAG_CONTIGUOUS);
1121   }
1122   return MPI_SUCCESS;
1123 }
1124
1125 void smpi_datatype_commit(MPI_Datatype *datatype)
1126 {
1127   (*datatype)->flags=  ((*datatype)->flags | DT_FLAG_COMMITED);
1128 }
1129
1130 typedef struct s_smpi_mpi_op {
1131   MPI_User_function *func;
1132   int is_commute;
1133 } s_smpi_mpi_op_t;
1134
1135 #define MAX_OP(a, b)  (b) = (a) < (b) ? (b) : (a)
1136 #define MIN_OP(a, b)  (b) = (a) < (b) ? (a) : (b)
1137 #define SUM_OP(a, b)  (b) += (a)
1138 #define PROD_OP(a, b) (b) *= (a)
1139 #define LAND_OP(a, b) (b) = (a) && (b)
1140 #define LOR_OP(a, b)  (b) = (a) || (b)
1141 #define LXOR_OP(a, b) (b) = (!(a) && (b)) || ((a) && !(b))
1142 #define BAND_OP(a, b) (b) &= (a)
1143 #define BOR_OP(a, b)  (b) |= (a)
1144 #define BXOR_OP(a, b) (b) ^= (a)
1145 #define MAXLOC_OP(a, b)  (b) = (a.value) < (b.value) ? (b) : (a)
1146 #define MINLOC_OP(a, b)  (b) = (a.value) < (b.value) ? (a) : (b)
1147 //TODO : MINLOC & MAXLOC
1148
1149 #define APPLY_FUNC(a, b, length, type, func) \
1150 {                                          \
1151   int i;                                   \
1152   type* x = (type*)(a);                    \
1153   type* y = (type*)(b);                    \
1154   for(i = 0; i < *(length); i++) {         \
1155     func(x[i], y[i]);                      \
1156   }                                        \
1157 }
1158
1159 static void max_func(void *a, void *b, int *length,
1160                      MPI_Datatype * datatype)
1161 {
1162   if (*datatype == MPI_CHAR) {
1163     APPLY_FUNC(a, b, length, char, MAX_OP);
1164   } else if (*datatype == MPI_SHORT) {
1165     APPLY_FUNC(a, b, length, short, MAX_OP);
1166   } else if (*datatype == MPI_INT) {
1167     APPLY_FUNC(a, b, length, int, MAX_OP);
1168   } else if (*datatype == MPI_LONG) {
1169     APPLY_FUNC(a, b, length, long, MAX_OP);
1170   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1171     APPLY_FUNC(a, b, length, unsigned short, MAX_OP);
1172   } else if (*datatype == MPI_UNSIGNED) {
1173     APPLY_FUNC(a, b, length, unsigned int, MAX_OP);
1174   } else if (*datatype == MPI_UNSIGNED_LONG) {
1175     APPLY_FUNC(a, b, length, unsigned long, MAX_OP);
1176   } else if (*datatype == MPI_FLOAT) {
1177     APPLY_FUNC(a, b, length, float, MAX_OP);
1178   } else if (*datatype == MPI_DOUBLE) {
1179     APPLY_FUNC(a, b, length, double, MAX_OP);
1180   } else if (*datatype == MPI_LONG_DOUBLE) {
1181     APPLY_FUNC(a, b, length, long double, MAX_OP);
1182   }
1183 }
1184
1185 static void min_func(void *a, void *b, int *length,
1186                      MPI_Datatype * datatype)
1187 {
1188   if (*datatype == MPI_CHAR) {
1189     APPLY_FUNC(a, b, length, char, MIN_OP);
1190   } else if (*datatype == MPI_SHORT) {
1191     APPLY_FUNC(a, b, length, short, MIN_OP);
1192   } else if (*datatype == MPI_INT) {
1193     APPLY_FUNC(a, b, length, int, MIN_OP);
1194   } else if (*datatype == MPI_LONG) {
1195     APPLY_FUNC(a, b, length, long, MIN_OP);
1196   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1197     APPLY_FUNC(a, b, length, unsigned short, MIN_OP);
1198   } else if (*datatype == MPI_UNSIGNED) {
1199     APPLY_FUNC(a, b, length, unsigned int, MIN_OP);
1200   } else if (*datatype == MPI_UNSIGNED_LONG) {
1201     APPLY_FUNC(a, b, length, unsigned long, MIN_OP);
1202   } else if (*datatype == MPI_FLOAT) {
1203     APPLY_FUNC(a, b, length, float, MIN_OP);
1204   } else if (*datatype == MPI_DOUBLE) {
1205     APPLY_FUNC(a, b, length, double, MIN_OP);
1206   } else if (*datatype == MPI_LONG_DOUBLE) {
1207     APPLY_FUNC(a, b, length, long double, MIN_OP);
1208   }
1209 }
1210
1211 static void sum_func(void *a, void *b, int *length,
1212                      MPI_Datatype * datatype)
1213 {
1214   if (*datatype == MPI_CHAR) {
1215     APPLY_FUNC(a, b, length, char, SUM_OP);
1216   } else if (*datatype == MPI_SHORT) {
1217     APPLY_FUNC(a, b, length, short, SUM_OP);
1218   } else if (*datatype == MPI_INT) {
1219     APPLY_FUNC(a, b, length, int, SUM_OP);
1220   } else if (*datatype == MPI_LONG) {
1221     APPLY_FUNC(a, b, length, long, SUM_OP);
1222   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1223     APPLY_FUNC(a, b, length, unsigned short, SUM_OP);
1224   } else if (*datatype == MPI_UNSIGNED) {
1225     APPLY_FUNC(a, b, length, unsigned int, SUM_OP);
1226   } else if (*datatype == MPI_UNSIGNED_LONG) {
1227     APPLY_FUNC(a, b, length, unsigned long, SUM_OP);
1228   } else if (*datatype == MPI_FLOAT) {
1229     APPLY_FUNC(a, b, length, float, SUM_OP);
1230   } else if (*datatype == MPI_DOUBLE) {
1231     APPLY_FUNC(a, b, length, double, SUM_OP);
1232   } else if (*datatype == MPI_LONG_DOUBLE) {
1233     APPLY_FUNC(a, b, length, long double, SUM_OP);
1234   } else if (*datatype == MPI_C_FLOAT_COMPLEX) {
1235     APPLY_FUNC(a, b, length, float _Complex, SUM_OP);
1236   } else if (*datatype == MPI_C_DOUBLE_COMPLEX) {
1237     APPLY_FUNC(a, b, length, double _Complex, SUM_OP);
1238   } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) {
1239     APPLY_FUNC(a, b, length, long double _Complex, SUM_OP);
1240   }
1241 }
1242
1243 static void prod_func(void *a, void *b, int *length,
1244                       MPI_Datatype * datatype)
1245 {
1246   if (*datatype == MPI_CHAR) {
1247     APPLY_FUNC(a, b, length, char, PROD_OP);
1248   } else if (*datatype == MPI_SHORT) {
1249     APPLY_FUNC(a, b, length, short, PROD_OP);
1250   } else if (*datatype == MPI_INT) {
1251     APPLY_FUNC(a, b, length, int, PROD_OP);
1252   } else if (*datatype == MPI_LONG) {
1253     APPLY_FUNC(a, b, length, long, PROD_OP);
1254   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1255     APPLY_FUNC(a, b, length, unsigned short, PROD_OP);
1256   } else if (*datatype == MPI_UNSIGNED) {
1257     APPLY_FUNC(a, b, length, unsigned int, PROD_OP);
1258   } else if (*datatype == MPI_UNSIGNED_LONG) {
1259     APPLY_FUNC(a, b, length, unsigned long, PROD_OP);
1260   } else if (*datatype == MPI_FLOAT) {
1261     APPLY_FUNC(a, b, length, float, PROD_OP);
1262   } else if (*datatype == MPI_DOUBLE) {
1263     APPLY_FUNC(a, b, length, double, PROD_OP);
1264   } else if (*datatype == MPI_LONG_DOUBLE) {
1265     APPLY_FUNC(a, b, length, long double, PROD_OP);
1266   } else if (*datatype == MPI_C_FLOAT_COMPLEX) {
1267     APPLY_FUNC(a, b, length, float _Complex, PROD_OP);
1268   } else if (*datatype == MPI_C_DOUBLE_COMPLEX) {
1269     APPLY_FUNC(a, b, length, double _Complex, PROD_OP);
1270   } else if (*datatype == MPI_C_LONG_DOUBLE_COMPLEX) {
1271     APPLY_FUNC(a, b, length, long double _Complex, PROD_OP);
1272   }
1273 }
1274
1275 static void land_func(void *a, void *b, int *length,
1276                       MPI_Datatype * datatype)
1277 {
1278   if (*datatype == MPI_CHAR) {
1279     APPLY_FUNC(a, b, length, char, LAND_OP);
1280   } else if (*datatype == MPI_SHORT) {
1281     APPLY_FUNC(a, b, length, short, LAND_OP);
1282   } else if (*datatype == MPI_INT) {
1283     APPLY_FUNC(a, b, length, int, LAND_OP);
1284   } else if (*datatype == MPI_LONG) {
1285     APPLY_FUNC(a, b, length, long, LAND_OP);
1286   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1287     APPLY_FUNC(a, b, length, unsigned short, LAND_OP);
1288   } else if (*datatype == MPI_UNSIGNED) {
1289     APPLY_FUNC(a, b, length, unsigned int, LAND_OP);
1290   } else if (*datatype == MPI_UNSIGNED_LONG) {
1291     APPLY_FUNC(a, b, length, unsigned long, LAND_OP);
1292   } else if (*datatype == MPI_C_BOOL) {
1293     APPLY_FUNC(a, b, length, _Bool, LAND_OP);
1294   }
1295 }
1296
1297 static void lor_func(void *a, void *b, int *length,
1298                      MPI_Datatype * datatype)
1299 {
1300   if (*datatype == MPI_CHAR) {
1301     APPLY_FUNC(a, b, length, char, LOR_OP);
1302   } else if (*datatype == MPI_SHORT) {
1303     APPLY_FUNC(a, b, length, short, LOR_OP);
1304   } else if (*datatype == MPI_INT) {
1305     APPLY_FUNC(a, b, length, int, LOR_OP);
1306   } else if (*datatype == MPI_LONG) {
1307     APPLY_FUNC(a, b, length, long, LOR_OP);
1308   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1309     APPLY_FUNC(a, b, length, unsigned short, LOR_OP);
1310   } else if (*datatype == MPI_UNSIGNED) {
1311     APPLY_FUNC(a, b, length, unsigned int, LOR_OP);
1312   } else if (*datatype == MPI_UNSIGNED_LONG) {
1313     APPLY_FUNC(a, b, length, unsigned long, LOR_OP);
1314   } else if (*datatype == MPI_C_BOOL) {
1315     APPLY_FUNC(a, b, length, _Bool, LOR_OP);
1316   }
1317 }
1318
1319 static void lxor_func(void *a, void *b, int *length,
1320                       MPI_Datatype * datatype)
1321 {
1322   if (*datatype == MPI_CHAR) {
1323     APPLY_FUNC(a, b, length, char, LXOR_OP);
1324   } else if (*datatype == MPI_SHORT) {
1325     APPLY_FUNC(a, b, length, short, LXOR_OP);
1326   } else if (*datatype == MPI_INT) {
1327     APPLY_FUNC(a, b, length, int, LXOR_OP);
1328   } else if (*datatype == MPI_LONG) {
1329     APPLY_FUNC(a, b, length, long, LXOR_OP);
1330   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1331     APPLY_FUNC(a, b, length, unsigned short, LXOR_OP);
1332   } else if (*datatype == MPI_UNSIGNED) {
1333     APPLY_FUNC(a, b, length, unsigned int, LXOR_OP);
1334   } else if (*datatype == MPI_UNSIGNED_LONG) {
1335     APPLY_FUNC(a, b, length, unsigned long, LXOR_OP);
1336   } else if (*datatype == MPI_C_BOOL) {
1337     APPLY_FUNC(a, b, length, _Bool, LXOR_OP);
1338   }
1339 }
1340
1341 static void band_func(void *a, void *b, int *length,
1342                       MPI_Datatype * datatype)
1343 {
1344   if (*datatype == MPI_CHAR) {
1345     APPLY_FUNC(a, b, length, char, BAND_OP);
1346   }
1347   if (*datatype == MPI_SHORT) {
1348     APPLY_FUNC(a, b, length, short, BAND_OP);
1349   } else if (*datatype == MPI_INT) {
1350     APPLY_FUNC(a, b, length, int, BAND_OP);
1351   } else if (*datatype == MPI_LONG) {
1352     APPLY_FUNC(a, b, length, long, BAND_OP);
1353   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1354     APPLY_FUNC(a, b, length, unsigned short, BAND_OP);
1355   } else if (*datatype == MPI_UNSIGNED) {
1356     APPLY_FUNC(a, b, length, unsigned int, BAND_OP);
1357   } else if (*datatype == MPI_UNSIGNED_LONG) {
1358     APPLY_FUNC(a, b, length, unsigned long, BAND_OP);
1359   } else if (*datatype == MPI_BYTE) {
1360     APPLY_FUNC(a, b, length, uint8_t, BAND_OP);
1361   }
1362 }
1363
1364 static void bor_func(void *a, void *b, int *length,
1365                      MPI_Datatype * datatype)
1366 {
1367   if (*datatype == MPI_CHAR) {
1368     APPLY_FUNC(a, b, length, char, BOR_OP);
1369   } else if (*datatype == MPI_SHORT) {
1370     APPLY_FUNC(a, b, length, short, BOR_OP);
1371   } else if (*datatype == MPI_INT) {
1372     APPLY_FUNC(a, b, length, int, BOR_OP);
1373   } else if (*datatype == MPI_LONG) {
1374     APPLY_FUNC(a, b, length, long, BOR_OP);
1375   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1376     APPLY_FUNC(a, b, length, unsigned short, BOR_OP);
1377   } else if (*datatype == MPI_UNSIGNED) {
1378     APPLY_FUNC(a, b, length, unsigned int, BOR_OP);
1379   } else if (*datatype == MPI_UNSIGNED_LONG) {
1380     APPLY_FUNC(a, b, length, unsigned long, BOR_OP);
1381   } else if (*datatype == MPI_BYTE) {
1382     APPLY_FUNC(a, b, length, uint8_t, BOR_OP);
1383   }
1384 }
1385
1386 static void bxor_func(void *a, void *b, int *length,
1387                       MPI_Datatype * datatype)
1388 {
1389   if (*datatype == MPI_CHAR) {
1390     APPLY_FUNC(a, b, length, char, BXOR_OP);
1391   } else if (*datatype == MPI_SHORT) {
1392     APPLY_FUNC(a, b, length, short, BXOR_OP);
1393   } else if (*datatype == MPI_INT) {
1394     APPLY_FUNC(a, b, length, int, BXOR_OP);
1395   } else if (*datatype == MPI_LONG) {
1396     APPLY_FUNC(a, b, length, long, BXOR_OP);
1397   } else if (*datatype == MPI_UNSIGNED_SHORT) {
1398     APPLY_FUNC(a, b, length, unsigned short, BXOR_OP);
1399   } else if (*datatype == MPI_UNSIGNED) {
1400     APPLY_FUNC(a, b, length, unsigned int, BXOR_OP);
1401   } else if (*datatype == MPI_UNSIGNED_LONG) {
1402     APPLY_FUNC(a, b, length, unsigned long, BXOR_OP);
1403   } else if (*datatype == MPI_BYTE) {
1404     APPLY_FUNC(a, b, length, uint8_t, BXOR_OP);
1405   }
1406 }
1407
1408 static void minloc_func(void *a, void *b, int *length,
1409                         MPI_Datatype * datatype)
1410 {
1411   if (*datatype == MPI_FLOAT_INT) {
1412     APPLY_FUNC(a, b, length, float_int, MINLOC_OP);
1413   } else if (*datatype == MPI_LONG_INT) {
1414     APPLY_FUNC(a, b, length, long_int, MINLOC_OP);
1415   } else if (*datatype == MPI_DOUBLE_INT) {
1416     APPLY_FUNC(a, b, length, double_int, MINLOC_OP);
1417   } else if (*datatype == MPI_SHORT_INT) {
1418     APPLY_FUNC(a, b, length, short_int, MINLOC_OP);
1419   } else if (*datatype == MPI_2INT) {
1420     APPLY_FUNC(a, b, length, int_int, MINLOC_OP);
1421   } else if (*datatype == MPI_LONG_DOUBLE_INT) {
1422     APPLY_FUNC(a, b, length, long_double_int, MINLOC_OP);
1423   } else if (*datatype == MPI_2FLOAT) {
1424     APPLY_FUNC(a, b, length, float_float, MINLOC_OP);
1425   } else if (*datatype == MPI_2DOUBLE) {
1426     APPLY_FUNC(a, b, length, double_double, MINLOC_OP);
1427   }
1428 }
1429
1430 static void maxloc_func(void *a, void *b, int *length,
1431                         MPI_Datatype * datatype)
1432 {
1433   if (*datatype == MPI_FLOAT_INT) {
1434     APPLY_FUNC(a, b, length, float_int, MAXLOC_OP);
1435   } else if (*datatype == MPI_LONG_INT) {
1436     APPLY_FUNC(a, b, length, long_int, MAXLOC_OP);
1437   } else if (*datatype == MPI_DOUBLE_INT) {
1438     APPLY_FUNC(a, b, length, double_int, MAXLOC_OP);
1439   } else if (*datatype == MPI_SHORT_INT) {
1440     APPLY_FUNC(a, b, length, short_int, MAXLOC_OP);
1441   } else if (*datatype == MPI_2INT) {
1442     APPLY_FUNC(a, b, length, int_int, MAXLOC_OP);
1443   } else if (*datatype == MPI_LONG_DOUBLE_INT) {
1444     APPLY_FUNC(a, b, length, long_double_int, MAXLOC_OP);
1445   } else if (*datatype == MPI_2FLOAT) {
1446     APPLY_FUNC(a, b, length, float_float, MAXLOC_OP);
1447   } else if (*datatype == MPI_2DOUBLE) {
1448     APPLY_FUNC(a, b, length, double_double, MAXLOC_OP);
1449   }
1450 }
1451
1452
1453 #define CREATE_MPI_OP(name, func)                             \
1454   static s_smpi_mpi_op_t mpi_##name = { &(func) /* func */, TRUE }; \
1455 MPI_Op name = &mpi_##name;
1456
1457 CREATE_MPI_OP(MPI_MAX, max_func);
1458 CREATE_MPI_OP(MPI_MIN, min_func);
1459 CREATE_MPI_OP(MPI_SUM, sum_func);
1460 CREATE_MPI_OP(MPI_PROD, prod_func);
1461 CREATE_MPI_OP(MPI_LAND, land_func);
1462 CREATE_MPI_OP(MPI_LOR, lor_func);
1463 CREATE_MPI_OP(MPI_LXOR, lxor_func);
1464 CREATE_MPI_OP(MPI_BAND, band_func);
1465 CREATE_MPI_OP(MPI_BOR, bor_func);
1466 CREATE_MPI_OP(MPI_BXOR, bxor_func);
1467 CREATE_MPI_OP(MPI_MAXLOC, maxloc_func);
1468 CREATE_MPI_OP(MPI_MINLOC, minloc_func);
1469
1470 MPI_Op smpi_op_new(MPI_User_function * function, int commute)
1471 {
1472   MPI_Op op;
1473   op = xbt_new(s_smpi_mpi_op_t, 1);
1474   op->func = function;
1475   op-> is_commute = commute;
1476   return op;
1477 }
1478
1479 int smpi_op_is_commute(MPI_Op op)
1480 {
1481   return (op==MPI_OP_NULL) ? 1 : op-> is_commute;
1482 }
1483
1484 void smpi_op_destroy(MPI_Op op)
1485 {
1486   xbt_free(op);
1487 }
1488
1489 void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len,
1490                    MPI_Datatype * datatype)
1491 {
1492   if(smpi_privatize_global_variables){ //we need to switch here, as the called function may silently touch global variables
1493     XBT_VERB("Applying operation, switch to the right data frame ");
1494     switch_data_segment(smpi_process_index());
1495   }
1496
1497   if(!_xbt_replay_is_active())
1498   op->func(invec, inoutvec, len, datatype);
1499 }