Logo AND Algorithmique Numérique Distribuée

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