Changeset 2137


Ignore:
Timestamp:
05/30/21 23:30:01 (2 months ago)
Author:
yushan
Message:

temporal commit for merging graph into XIOS_coupling

Location:
XIOS/dev/dev_trunk_graph/src
Files:
1 added
68 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_trunk_graph/src/array_new.hpp

    r2019 r2137  
    77#include "buffer_out.hpp" 
    88#include "message.hpp" 
    9 #include "tv_data_display.h" 
    10 #ifdef __GNUC__ 
    11 #include <typeinfo> 
    12 #include <cxxabi.h> 
    13 #endif 
    149#include <cmath> 
    1510 
     
    2217  class CArray ; 
    2318 
    24  template <typename T_numtype,int N_rank> 
    25  int TV_ttf_display_type ( const CArray<T_numtype, N_rank>* array ) ; 
    2619} 
    27  
    28 template <typename T_numtype,int N_rank> 
    29 int TV_ttf_display_type ( const xios::CArray<T_numtype, N_rank>* array ) ; 
    3020 
    3121namespace xios 
     
    3626    private: 
    3727      bool initialized; 
    38       void inc_symbol(void) 
    39       { 
    40         TV_ttf_display_type(this); 
    41       } 
     28 
    4229    public: 
    4330      typedef typename Array<T_numtype,N_rank>::T_default_storage T_default_storage; 
     
    4633      template<typename T_expr> explicit CArray(_bz_ArrayExpr<T_expr> expr) 
    4734        : Array<T_numtype,N_rank>(expr) 
    48         , initialized(true) 
    49       { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } 
     35        , initialized(true) {  } 
    5036 
    5137      CArray(GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    5238        : Array<T_numtype,N_rank>(storage) 
    53         , initialized(false) 
    54       { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     39        , initialized(false) { } 
    5540 
    5641      explicit CArray(int length0, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    5742        : Array<T_numtype,N_rank>(length0, storage) 
    58         , initialized(true) 
    59       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     43        , initialized(true) { } 
    6044 
    6145      CArray(int length0, int length1, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    6246        : Array<T_numtype,N_rank>(length0, length1, storage) 
    63         , initialized(true) 
    64       { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     47        , initialized(true) { } 
    6548 
    6649      CArray(int length0, int length1, int length2, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    6750        : Array<T_numtype,N_rank>(length0, length1, length2, storage) 
    68         , initialized(true) 
    69       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     51        , initialized(true) { } 
    7052 
    7153      CArray(int length0, int length1, int length2, int length3, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    7254        : Array<T_numtype,N_rank>(length0, length1, length2, length3, storage) 
    73         , initialized(true) 
    74       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     55        , initialized(true) { } 
    7556 
    7657      CArray(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    7758        : Array<T_numtype,N_rank>(length0,length1, length2, length3, length4, storage) 
    78         , initialized(true) 
    79       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     59        , initialized(true) { } 
    8060 
    8161      CArray(int length0, int length1, int length2, int length3, int length4, int length5, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    8262        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, storage) 
    83         , initialized(true) 
    84       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     63        , initialized(true) { } 
    8564 
    8665      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    8766        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, storage) 
    88         , initialized(true) 
    89       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     67        , initialized(true) { } 
    9068 
    9169      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, 
    9270             GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    9371        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, storage) 
    94         , initialized(true) 
    95       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     72        , initialized(true) { } 
    9673 
    9774      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, 
    9875             int length7, int length8, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    9976       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, storage) 
    100        , initialized(true) 
    101       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     77       , initialized(true) { } 
    10278 
    10379      CArray(int length0, int length1, int length2, int length3, int length4, 
    10480             int length5, int length6, int length7, int length8, int length9, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    10581        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, storage) 
    106         , initialized(true) 
    107       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     82        , initialized(true) { } 
    10883 
    10984      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, 
    11085             int length7, int length8, int length9, int length10, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    11186       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, length10, storage) 
    112        , initialized(true) 
    113       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     87       , initialized(true) { } 
    11488 
    11589      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    11690        : Array<T_numtype,N_rank>(dataFirst, shape, storage) 
    117         , initialized(true) 
    118       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     91        , initialized(true) { } 
    11992 
    12093      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride, 
    12194             GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    12295        : Array<T_numtype,N_rank>(dataFirst, shape, stride, storage) 
    123         , initialized(true) 
    124       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     96        , initialized(true) { } 
    12597 
    12698      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, preexistingMemoryPolicy deletionPolicy, 
    12799            GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    128100        : Array<T_numtype,N_rank>(dataFirst, shape, deletionPolicy, storage) 
    129         , initialized(true) 
    130       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     101        , initialized(true) { } 
    131102 
    132103      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride, 
    133104             preexistingMemoryPolicy deletionPolicy, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    134105        : Array<T_numtype,N_rank>(dataFirst, shape, stride, deletionPolicy, storage) 
    135         , initialized(true) 
    136       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     106        , initialized(true) { } 
    137107 
    138108      CArray(const TinyVector<int, N_rank>& extent, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    139109        : Array<T_numtype,N_rank>(extent, storage) 
    140         , initialized(true) 
    141       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     110        , initialized(true) { } 
    142111 
    143112      CArray(const TinyVector<int, N_rank>& lbounds, const TinyVector<int, N_rank>& extent, 
    144113             const GeneralArrayStorage<N_rank>& storage) 
    145114        : Array<T_numtype,N_rank>(lbounds, extent, storage) 
    146         , initialized(true) 
    147       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     115        , initialized(true) { } 
    148116 
    149117      CArray(Range r0, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    150118        : Array<T_numtype,N_rank>(r0, storage) 
    151         , initialized(true) 
    152       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     119        , initialized(true) { } 
    153120 
    154121      CArray(Range r0, Range r1, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    155122        : Array<T_numtype,N_rank>(r0, r1, storage) 
    156         , initialized(true) 
    157       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     123        , initialized(true) { } 
    158124 
    159125      CArray(Range r0, Range r1, Range r2, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    160126        : Array<T_numtype,N_rank>(r0, r1, r2, storage) 
    161         , initialized(true) 
    162       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     127        , initialized(true) { } 
    163128 
    164129      CArray(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    165130        : Array<T_numtype,N_rank>(r0, r1, r2, r3, storage) 
    166         , initialized(true) 
    167       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     131        , initialized(true) { } 
    168132 
    169133      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    170134        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, storage) 
    171         , initialized(true) 
    172       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     135        , initialized(true) { } 
    173136 
    174137      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    175138        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, storage) 
    176         , initialized(true) 
    177       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     139        , initialized(true) { } 
    178140 
    179141      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, 
    180142             GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    181143        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, storage) 
    182         , initialized(true) 
    183       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     144        , initialized(true) { } 
    184145 
    185146      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, 
    186147             GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    187148        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, storage) 
    188         , initialized(true) 
    189       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     149        , initialized(true) { } 
    190150 
    191151      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
    192152             Range r6, Range r7, Range r8, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    193153        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, storage) 
    194         , initialized(true) 
    195       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     154        , initialized(true) { } 
    196155 
    197156      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
    198157             Range r6, Range r7, Range r8, Range r9, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    199158        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, storage) 
    200         , initialized(true) 
    201       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     159        , initialized(true) { } 
    202160 
    203161      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, 
    204162             Range r8, Range r9, Range r10, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    205163        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, storage) 
    206         , initialized(true) 
    207       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     164        , initialized(true) {  } 
    208165 
    209166      CArray(const CArray<T_numtype, N_rank>& array) 
    210167        : Array<T_numtype,N_rank>(array) 
    211         , initialized(array.initialized) 
    212       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     168        , initialized(array.initialized) { } 
    213169 
    214170      CArray(const Array<T_numtype, N_rank>& array) 
    215171        : Array<T_numtype,N_rank>(array) 
    216         , initialized(true) 
    217       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     172        , initialized(true) { } 
    218173 
    219174      CArray(const TinyVector<int,N_rank-1>& shape, int lastExtent, const GeneralArrayStorage<N_rank>& storage) 
    220175        : Array<T_numtype,N_rank>(shape, lastExtent, storage) 
    221         , initialized(true) 
    222       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     176        , initialized(true) { } 
    223177 
    224178      CArray(Array<T_numtype, N_rank>& array, Range r0) 
    225179        : Array<T_numtype,N_rank>(array, r0) 
    226         , initialized(true) 
    227       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     180        , initialized(true) { } 
    228181 
    229182      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1) 
    230183        : Array<T_numtype,N_rank>(array, r0, r1) 
    231         , initialized(true) 
    232       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     184        , initialized(true) { } 
    233185 
    234186      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2) 
    235187        : Array<T_numtype,N_rank>( array, r0, r1, r2) 
    236         , initialized(true) 
    237       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     188        , initialized(true) { } 
    238189 
    239190      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3) 
    240191        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3) 
    241         , initialized(true) 
    242       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     192        , initialized(true) { } 
    243193 
    244194      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, 
    245195             Range r3, Range r4) 
    246196        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3,  r4) 
    247         , initialized(true) 
    248       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     197        , initialized(true) {  } 
    249198 
    250199      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, 
    251200             Range r3, Range r4, Range r5) 
    252201        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5) 
    253         , initialized(true) 
    254       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     202        , initialized(true) {  } 
    255203 
    256204      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, 
    257205             Range r4, Range r5, Range r6) 
    258206        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5, r6) 
    259         , initialized(true) 
    260       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     207        , initialized(true) {  } 
    261208 
    262209      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, 
    263210             Range r5, Range r6, Range r7) 
    264211        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7) 
    265         , initialized(true) 
    266       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     212        , initialized(true) {  } 
    267213 
    268214      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
    269215             Range r6, Range r7, Range r8) 
    270216        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8) 
    271         , initialized(true) 
    272       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     217        , initialized(true) {  } 
    273218 
    274219      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
    275220             Range r6, Range r7, Range r8, Range r9) 
    276221        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) 
    277         , initialized(true) 
    278       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     222        , initialized(true) {  } 
    279223 
    280224      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, 
    281225             Range r7, Range r8, Range r9, Range r10) 
    282226        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10) 
    283         , initialized(true) 
    284       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     227        , initialized(true) {  } 
    285228 
    286229      CArray(Array<T_numtype, N_rank>& array, const RectDomain<N_rank>& subdomain) 
    287230        : Array<T_numtype,N_rank>(array, subdomain) 
    288         , initialized(true) 
    289       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     231        , initialized(true) {  } 
    290232 
    291233      CArray(Array<T_numtype, N_rank>& array, const StridedDomain<N_rank>& subdomain) 
    292234        : Array<T_numtype,N_rank>(array, subdomain) 
    293         , initialized(true) 
    294       {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
     235        , initialized(true) {  } 
    295236 
    296237      template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, 
     
    299240        : Array<T_numtype,N_rank>(array, r0,r1, r2, r3, r4, r5, r6, r7, r8, r9, r10) 
    300241        , initialized(true) 
    301       { bool neverTrue ; neverTrue=false ; bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } 
     242      {   } 
    302243 
    303244      virtual ~CArray() {} 
     
    569510      virtual std::vector<T_numtype> getVector(void) { return vector<T_numtype>(this->dataFirst(),this->dataFirst()+this->numElements()) ;} 
    570511      static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); } 
    571        
    572       static int show_TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array ) 
    573       { 
    574         int status ; 
    575         if (array->isEmpty())  
    576         { 
    577           status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; 
    578           if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
    579           else return TV_ttf_format_ok_elide ; 
    580         } 
    581         else  
    582         { 
    583           char tname[128] ; 
    584           char bname[128] = "value_type" ; 
    585 #ifdef __GNUC__ 
    586          size_t size = sizeof(bname) ; 
    587          abi::__cxa_demangle(typeid(T_numtype).name(), bname, &size, &status) ; 
    588          if (status !=0) return TV_ttf_format_raw ; 
    589 #endif 
    590           int dim = array->dimensions() ; 
    591           if (dim==1) snprintf (tname, sizeof(tname), "%s[%d]", bname, array->extent(0)); 
    592           if (dim==2) snprintf (tname, sizeof(tname), "%s[%d][%d]", bname, array->extent(1), array->extent(0)); 
    593           if (dim==3) snprintf (tname, sizeof(tname), "%s[%d][%d][%d]", bname, array->extent(2), array->extent(1), array->extent(3)); 
    594           if (dim==4) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d]", bname, array->extent(0), array->extent(1), array->extent(2), array->extent(3)); 
    595           if (dim==5) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d]", bname, array->extent(4), array->extent(3), array->extent(2), array->extent(1) 
    596                                                                                       ,array->extent(0)); 
    597           if (dim==6) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d]", bname, array->extent(5), array->extent(4), array->extent(3), array->extent(2) 
    598                                                                                       ,array->extent(1),array->extent(0)); 
    599           if (dim==7) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d][%d]", bname, array->extent(6), array->extent(5), array->extent(4), array->extent(3) 
    600                                                                                       ,array->extent(2),array->extent(1),array->extent(0)); 
    601           status = TV_ttf_add_row("array_values", tname, array->dataFirst()) ; 
    602           if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
    603           else return TV_ttf_format_ok ; 
    604         } 
    605       } 
    606        
    607  
    608       static int TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array ) 
    609       { 
    610         return show_TV_ttf_display_type (array) ; 
    611       } 
    612        
     512     
    613513      virtual CBaseType* clone(void) const { return new CArray(*this); } 
    614514 
     
    642542 
    643543  }; 
    644  
    645  
    646 #define macrotyperank(_TYPE_,_RANK_)\ 
    647   template<> int CArray<_TYPE_,_RANK_>::TV_ttf_display_type( const CArray<_TYPE_,_RANK_>* array ) \ 
    648   {\ 
    649     return show_TV_ttf_display_type (array) ;\ 
    650   } 
    651  
    652 #define macrotype(_TYPE_)\ 
    653 macrotyperank(_TYPE_,1)\ 
    654 macrotyperank(_TYPE_,2)\ 
    655 macrotyperank(_TYPE_,3)\ 
    656 macrotyperank(_TYPE_,4)\ 
    657 macrotyperank(_TYPE_,5)\ 
    658 macrotyperank(_TYPE_,6)\ 
    659 macrotyperank(_TYPE_,7) 
    660  
    661 macrotype(double) 
    662 macrotype(int) 
    663 macrotype(bool) 
    664 macrotype(size_t) 
    665 macrotype(float) 
    666 macrotype(string) 
    667  
    668 #undef macrotyperank 
    669 #undef macrotype 
    670544 
    671545 
  • XIOS/dev/dev_trunk_graph/src/attribute_array.hpp

    r2019 r2137  
    6666            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ; 
    6767  
    68  static int show_TV_ttf_display_type ( const CAttributeArray<T_numtype,N_rank>* array ) 
    69       { 
    70         int status ; 
    71         if (array->isEmpty())  
    72         { 
    73           status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; 
    74           if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
    75           else return TV_ttf_format_ok_elide ; 
    76         } 
    77         else  
    78         { 
    79           char tname[128] ; 
    80           char bname[128] = "value_type" ; 
    81 #ifdef __GNUC__ 
    82          size_t size = sizeof(bname) ; 
    83          abi::__cxa_demangle(typeid(T_numtype).name(), bname, &size, &status) ; 
    84          if (status !=0) return TV_ttf_format_raw ; 
    85 #endif 
    86           int dim = array->dimensions() ; 
    87           if (dim==1) snprintf (tname, sizeof(tname), "%s[%d]", bname, array->extent(0)); 
    88           if (dim==2) snprintf (tname, sizeof(tname), "%s[%d][%d]", bname, array->extent(1), array->extent(0)); 
    89           if (dim==3) snprintf (tname, sizeof(tname), "%s[%d][%d][%d]", bname, array->extent(2), array->extent(1), array->extent(3)); 
    90           if (dim==4) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d]", bname, array->extent(0), array->extent(1), array->extent(2), array->extent(3)); 
    91           if (dim==5) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d]", bname, array->extent(4), array->extent(3), array->extent(2), array->extent(1) 
    92                                                                                       ,array->extent(0)); 
    93           if (dim==6) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d]", bname, array->extent(5), array->extent(4), array->extent(3), array->extent(2) 
    94                                                                                       ,array->extent(1),array->extent(0)); 
    95           if (dim==7) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d][%d]", bname, array->extent(6), array->extent(5), array->extent(4), array->extent(3) 
    96                                                                                       ,array->extent(2),array->extent(1),array->extent(0)); 
    97           status = TV_ttf_add_row("array_values", tname, array->dataFirst()) ; 
    98           if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
    99           else return TV_ttf_format_ok ; 
    100         } 
    101       } 
    102        
    103              
    104             static int TV_ttf_display_type ( const  CAttributeArray<T_numtype,N_rank>* array ) 
    105            { 
    106              return CAttributeArray<T_numtype,N_rank>::show_TV_ttf_display_type (array) ; 
    107            } 
    108  
    10968         private : 
    11069          bool isEqual_(const CAttributeArray& attr); 
     
    11978 
    12079 
    121 #define macrotyperank(_TYPE_,_RANK_)\ 
    122   template<> int CAttributeArray<_TYPE_,_RANK_>::TV_ttf_display_type(const CAttributeArray<_TYPE_,_RANK_>* array ) \ 
    123   {\ 
    124     return CAttributeArray<_TYPE_,_RANK_>::show_TV_ttf_display_type (array) ;\ 
    125   } 
    126  
    127 #define macrotype(_TYPE_)\ 
    128 macrotyperank(_TYPE_,1)\ 
    129 macrotyperank(_TYPE_,2)\ 
    130 macrotyperank(_TYPE_,3)\ 
    131 macrotyperank(_TYPE_,4)\ 
    132 macrotyperank(_TYPE_,5)\ 
    133 macrotyperank(_TYPE_,6)\ 
    134 macrotyperank(_TYPE_,7) 
    135  
    136 macrotype(double) 
    137 macrotype(int) 
    138 macrotype(bool) 
    139 macrotype(size_t) 
    140 macrotype(float) 
    141 macrotype(string) 
    142  
    143 #undef macrotyperank 
    144 #undef macrotype 
    14580} // namespace xios 
    14681 
  • XIOS/dev/dev_trunk_graph/src/attribute_array_decl.cpp

    r1158 r2137  
    1919  template class CAttributeArray<StdString,1> ; 
    2020  template class CAttributeArray<StdString,2> ; 
     21 
    2122} 
  • XIOS/dev/dev_trunk_graph/src/attribute_array_impl.hpp

    r2019 r2137  
    1414      CAttributeArray<T_numtype, N_rank>::CAttributeArray(const StdString & id) 
    1515         : CAttribute(id) 
    16       { bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); } 
     16      { } 
    1717 
    1818      template <typename T_numtype, int N_rank> 
     
    2020         : CAttribute(id) 
    2121      { 
    22          bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    2322         this->setValue(value); 
    2423      } 
     
    2827         : CAttribute(id) 
    2928      { 
    30          bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    3129         umap.insert(umap.end(), std::make_pair(id, this)); 
    3230      } 
     
    3735         : CAttribute(id) 
    3836      { 
    39          bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    4037         this->setValue(value); 
    4138         umap.insert(umap.end(), std::make_pair(id, this)); 
  • XIOS/dev/dev_trunk_graph/src/attribute_enum_impl.hpp

    r2026 r2137  
    1010namespace xios 
    1111{ 
    12   /// ////////////////////// Definitions ////////////////////// /// 
     12  /// ////////////////////// Définitions ////////////////////// /// 
    1313  template <class T> 
    1414  CAttributeEnum<T>::CAttributeEnum(const StdString & id) 
  • XIOS/dev/dev_trunk_graph/src/attribute_template.hpp

    r2019 r2137  
    1212#include "buffer_out.hpp" 
    1313#include "type.hpp" 
    14 #include "tv_data_display.h" 
    15  
    16 #ifdef __GNUC__ 
    17 #include <typeinfo> 
    18 #include <cxxabi.h> 
    19 #endif 
    2014 
    2115namespace xios 
     
    4337            CAttributeTemplate(const StdString & id, const ValueType & value, 
    4438                               xios_map<StdString, CAttribute*> & umap); 
     39//            CAttributeTemplate(const CAttribute & attribut) throw (CException); 
     40//            CAttributeTemplate(const CAttribute * const attribut); // Not implemented. 
    4541 
    4642          public : 
     
    4844            /// Accesseur /// 
    4945            ValueType getValue(void) const; 
     46//            ValueType* getRef(void) ; 
    5047 
    5148            /// Mutateurs /// 
     
    7471            virtual StdString toString(void) const { return _toString();} 
    7572            virtual void fromString(const StdString & str) { if (str==resetInheritanceStr) { reset(); _canInherite=false ;}  else _fromString(str);} 
    76  
     73//            virtual CAttributeTemplate* clone() const {} 
     74//            virtual void toBinary  (StdOStream & os) const; 
     75//            virtual void fromBinary(StdIStream & is); 
    7776            virtual StdString dump(void) const { return _dump();} 
    7877            virtual StdString dumpGraph(void) const { return _dumpGraph();} 
     
    8079            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);} 
    8180            virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer); } 
     81//            virtual size_t size(void) const; 
    8282            virtual void generateCInterface(ostream& oss,const string& className) ; 
    8383            virtual void generateFortran2003Interface(ostream& oss,const string& className) ; 
     
    8888            virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ; 
    8989            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ; 
    90  
    91            static int show_TV_ttf_display_type ( const CAttributeTemplate<T>* attr) 
    92            { 
    93              int status ; 
    94              if (attr->isEmpty())  
    95              { 
    96                status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; 
    97                if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
    98                else return TV_ttf_format_ok_elide ; 
    99              } 
    100              else  
    101              { 
    102                char tname[128] ; 
    103                char bname[128] = "ValueType" ; 
    104 #ifdef __GNUC__ 
    105                size_t size = sizeof(bname) ; 
    106                abi::__cxa_demangle(typeid(T).name(), bname, &size, &status) ; 
    107                if (status !=0) return TV_ttf_format_raw ; 
    108 #endif 
    109                snprintf (tname, sizeof(tname), "%s", bname); 
    110                if (typeid(T)==typeid(string)) 
    111                  status = TV_ttf_add_row("values", TV_ttf_type_ascii_string, ((string*)(attr->ptrValue))->c_str() ); 
    112                else status = TV_ttf_add_row("values", tname, attr->ptrValue) ; 
    113                if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; 
    114                else return TV_ttf_format_ok_elide ; 
    115              } 
    116            } 
    117        
    118            static int TV_ttf_display_type ( const CAttributeTemplate<T>* attr ) 
    119            { 
    120              return show_TV_ttf_display_type (attr) ; 
    121            } 
     90//            virtual void generateFortranInterfaceIsDefinedDeclaration_(ostream& oss,const string& className) ; 
     91//            virtual void generateFortranInterfaceIsDefinedBody_(ostream& oss,const string& className) ; 
     92//            virtual void generateFortranInterfaceIsDefinedDeclaration(ostream& oss,const string& className) ; 
    12293 
    12394 
     
    138109      }; // class CAttribute 
    139110 
    140 #define macrotype(_TYPE_)\ 
    141   template<> int CAttributeTemplate<_TYPE_>::TV_ttf_display_type( const CAttributeTemplate<_TYPE_>* attr ) \ 
    142   {\ 
    143     return show_TV_ttf_display_type (attr) ;\ 
    144   } 
    145  
    146 macrotype(double) 
    147 macrotype(int) 
    148 macrotype(bool) 
    149 macrotype(string) 
    150 //macrotype(CDate) 
    151 //macrotype(CDuration) 
    152 #undef macrotype 
    153111 
    154112   template <class T>  void FromBinary(StdIStream & is, T & obj); 
  • XIOS/dev/dev_trunk_graph/src/attribute_template_decl.cpp

    r537 r2137  
    1212  template class CAttributeTemplate<CDate> ; 
    1313  template class CAttributeTemplate<CDuration> ; 
     14 
    1415} 
  • XIOS/dev/dev_trunk_graph/src/attribute_template_impl.hpp

    r2019 r2137  
    2424         this->setValue(value); 
    2525      } 
    26  
     26/* 
     27      template <class T> 
     28         CAttributeTemplate<T>::CAttributeTemplate(const CAttribute & attribut) 
     29         throw (CException) 
     30         : CAttribute(attribut) 
     31      { 
     32         if (!attribut.isEmpty() && !attribut.isType<T>()) 
     33            ERROR("CAttributeTemplate", << "Invalid instantiation !"); 
     34      } 
     35*/ 
    2736      template <class T> 
    2837         CAttributeTemplate<T>::CAttributeTemplate(const StdString & id, 
     
    4251         umap.insert(umap.end(), std::make_pair(id, this)); 
    4352      } 
    44  
     53/* 
     54      template <class T> 
     55      CAttributeTemplate<T>::~CAttributeTemplate(void) 
     56      { 
     57//         this->CType<T>::reset() ; 
     58//         this->clear(); 
     59      } 
     60*/ 
    4561      ///-------------------------------------------------------------- 
    4662      template <class T> 
     
    6985      { 
    7086        return CType<T>::get() ; 
    71       } 
    72  
    73  
     87 
     88/* 
     89        if (SuperClass::isEmpty()) 
     90        { 
     91           ERROR("T CAttributeTemplate<T>::getValue(void) const", 
     92                 << "[ id = " << this->getId() << "]" 
     93                 << " L'attribut est requis mais n'est pas défini !"); 
     94         } 
     95        return (SuperClass::getValue<T>()); 
     96*/ 
     97      } 
     98 
     99/* 
     100      template <class T> 
     101         T* CAttributeTemplate<T>::getRef(void) 
     102      { 
     103         if (SuperClass::isEmpty()) 
     104         { 
     105            ERROR("T CAttributeTemplate<T>::getValue(void) const", 
     106                  << "[ id = " << this->getId() << "]" 
     107                  << " L'attribut est requis mais n'est pas défini !"); 
     108          } 
     109         return (SuperClass::getRef<T>()); 
     110      } 
     111*/ 
    74112 
    75113      template <class T> 
     
    77115      { 
    78116         CType<T>::set(value) ; 
     117//         SuperClass::setValue<T>(value); 
    79118      } 
    80119 
     
    140179      { 
    141180         this->setValue(value); 
     181//         return (this->getValue()); 
    142182         return *this; 
    143183      } 
  • XIOS/dev/dev_trunk_graph/src/buffer_client.cpp

    r2019 r2137  
    77#include "mpi.hpp" 
    88#include "tracer.hpp" 
     9#include "timeline_events.hpp" 
    910 
    1011namespace xios 
     
    200201   
    201202    lockBuffer(); 
     203    count=*bufferCount[current] ; 
     204     
     205    if (resizingBufferStep_ > 0 ) return false ; 
     206 
    202207    if (size > bufferSize) 
    203       ERROR("bool CClientBuffer::isBufferFree(StdSize size)", 
    204             << "The requested size (" << size << " bytes) is too big to fit the buffer (" << bufferSize << " bytes), please increase the client buffer size." << endl); 
     208    { 
     209      // ERROR("bool CClientBuffer::isBufferFree(StdSize size)", 
     210      //      << "The requested size (" << size << " bytes) is too big to fit the buffer (" << bufferSize << " bytes), please increase the client buffer size." << endl); 
     211      resizingBufferStep_=1 ; 
     212      newBufferSize_=size ; 
     213      return false ; 
     214    } 
    205215 
    206216    if (size > maxEventSize) 
     
    214224      if (size > maxRequestSize) maxRequestSize = size; 
    215225    } 
    216  
    217       count=*bufferCount[current] ; 
    218       return (size <= remain()); 
     226     
     227    if (size > remain()) 
     228    { 
     229      if (isGrowableBuffer_) 
     230      { 
     231        resizingBufferStep_ = 1 ; 
     232        newBufferSize_ = (count+size)*growFactor_ ; 
     233      }   
     234      return false ; 
     235    } 
     236    else return true ; 
    219237  } 
    220238 
     
    276294    if (!pending) 
    277295    { 
    278       if (!send) return false ; 
     296      if (!send && resizingBufferStep_==0 ) return false ; 
     297 
    279298      if (count > 0) 
    280299      { 
     
    284303        { 
    285304          MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request); 
     305          if (resizingBufferStep_==3) resizingBufferStep_=0 ; 
    286306          pending = true; 
    287307//          *control[current]=0 ; 
     
    295315          count = 0; 
    296316        } 
    297         else unlockBuffer() ; 
     317        else  
     318        { 
     319          unlockBuffer() ; 
     320        } 
    298321      } 
     322      else 
     323      { 
     324        if (resizingBufferStep_==2) resizeBuffer(newBufferSize_) ; 
     325        if (resizingBufferStep_==1) resizeBufferNotify() ; 
     326      } 
    299327    } 
    300328 
    301329    return pending; 
     330  } 
     331 
     332  void CClientBuffer::resizeBufferNotify(void) 
     333  { 
     334    // notify server of changing buffers size 
     335    lockBuffer() ; 
     336    int size=sizeof(int)+sizeof(size_t) ; 
     337    CBufferOut* bufOut = this->getBuffer(timelineEventNotifyChangeBufferSize, size); 
     338    bufOut->put(size); 
     339    bufOut->put(timelineEventNotifyChangeBufferSize); 
     340    resizingBufferStep_ = 2 ; 
     341    unlockBuffer() ; 
     342  } 
     343 
     344  void CClientBuffer::resizeBuffer(size_t newSize) 
     345  { 
     346    if (hasWindows) 
     347    {  
     348      MPI_Win_detach(windows_[0], bufferHeader[0]) ; 
     349      MPI_Win_detach(windows_[1], bufferHeader[1]) ; 
     350    } 
     351    MPI_Free_mem(bufferHeader[0]) ; 
     352    MPI_Free_mem(bufferHeader[1]) ; 
     353 
     354    bufferSize=newSize ; 
     355    MPI_Alloc_mem(bufferSize+headerSize, MPI_INFO_NULL, &bufferHeader[0]) ; 
     356    MPI_Alloc_mem(bufferSize+headerSize, MPI_INFO_NULL, &bufferHeader[1]) ; 
     357    buffer[0] = bufferHeader[0]+headerSize ; 
     358    buffer[1] = bufferHeader[1]+headerSize ; 
     359    firstTimeLine[0]=(size_t*)bufferHeader[0] ; 
     360    firstTimeLine[1]=(size_t*)bufferHeader[1] ; 
     361    bufferCount[0]=(size_t*)bufferHeader[0] +1 ; 
     362    bufferCount[1]=(size_t*)bufferHeader[1] +1 ; 
     363    control[0]=(size_t*)bufferHeader[0] +2 ; 
     364    control[1]=(size_t*)bufferHeader[1] +2 ; 
     365    finalize[0]=(size_t*)bufferHeader[0] +3 ; 
     366    finalize[1]=(size_t*)bufferHeader[1] +3 ; 
     367 
     368    *firstTimeLine[0]=0 ; 
     369    *firstTimeLine[1]=0 ; 
     370    *bufferCount[0]=0 ; 
     371    *bufferCount[1]=0 ; 
     372    *control[0]=0 ; 
     373    *control[1]=0 ; 
     374    *finalize[0]=0 ; 
     375    *finalize[1]=0 ; 
     376    winState[0]=false ; 
     377    winState[1]=false ; 
     378    current=0 ; 
     379     
     380    if (hasWindows) 
     381    {   
     382     
     383      MPI_Win_attach(windows_[0], bufferHeader[0], bufferSize+headerSize) ; 
     384      MPI_Win_attach(windows_[1], bufferHeader[1], bufferSize+headerSize) ; 
     385           
     386      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, clientRank_, 0, windows_[0]) ; 
     387      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, clientRank_, 0, windows_[1]) ; 
     388 
     389      MPI_Win_unlock(clientRank_, windows_[1]) ; 
     390      MPI_Win_unlock(clientRank_, windows_[0]) ; 
     391    }  
     392 
     393    lockBuffer() ; 
     394  
     395    int size=sizeof(int)+2*sizeof(size_t)+2*sizeof(MPI_AINT) ; 
     396    CBufferOut* bufOut = this->getBuffer(timelineEventChangeBufferSize, size); 
     397    bufOut->put(size); 
     398    bufOut->put(timelineEventChangeBufferSize); 
     399    bufOut->put(newBufferSize_); 
     400    bufOut->put(this->getWinAddress(0)); 
     401    bufOut->put(this->getWinAddress(1)); 
     402 
     403    resizingBufferStep_=3; 
     404    unlockBuffer() ; 
    302405  } 
    303406 
  • XIOS/dev/dev_trunk_graph/src/buffer_client.hpp

    r2019 r2137  
    2929      void infoBuffer(void) ; 
    3030      bool isNotifiedFinalized(void) ; 
     31      void setGrowableBuffer(double growFactor) { growFactor_=growFactor ; isGrowableBuffer_=true ;} 
     32      void fixBufferSize(size_t bufferSize) { newBufferSize_=bufferSize ; isGrowableBuffer_=false ; resizingBufferStep_=1 ;} 
     33      void fixBuffer(void) { isGrowableBuffer_=false ;} 
    3134    private: 
     35       void resizeBuffer(size_t newSize) ; 
     36       void resizeBufferNotify(void) ; 
     37 
     38 
    3239      char* buffer[2]; 
    3340      char* bufferHeader[2]; 
     
    3845      bool winState[2] ; 
    3946      int current; 
     47       
     48      double growFactor_=1.2 ; 
     49      bool isGrowableBuffer_=true ; 
    4050 
     51      int resizingBufferStep_ = 0 ; 
     52      size_t newBufferSize_ ; 
    4153      StdSize count; 
    4254      StdSize maxEventSize; 
    43       const StdSize bufferSize; 
     55      StdSize bufferSize; 
    4456      const StdSize estimatedMaxEventSize; 
    4557 
  • XIOS/dev/dev_trunk_graph/src/buffer_server.cpp

    r2019 r2137  
    1515    end = size; 
    1616    used=0 ; 
    17     buffer = new char[size]; // use MPI_ALLOC_MEM later? 
     17    MPI_Alloc_mem(size, MPI_INFO_NULL, &buffer) ; 
    1818    currentWindows=1 ; 
    1919    if (windows[0]==MPI_WIN_NULL && windows[1]==MPI_WIN_NULL) hasWindows=false ; 
     
    2222  CServerBuffer::~CServerBuffer() 
    2323  { 
    24     delete [] buffer ; 
     24    MPI_Free_mem(buffer) ; 
    2525  } 
    2626 
     
    222222  bool CServerBuffer::getBufferFromClient(size_t timeLine, char*& buffer, size_t& count) 
    223223  { 
    224     if (!hasWindows) return false ; 
     224    if (!hasWindows || resizingBuffer_) return false ; 
    225225 
    226226     
  • XIOS/dev/dev_trunk_graph/src/buffer_server.hpp

    r2019 r2137  
    2626      void unlockBuffer(void) ; 
    2727      void notifyClientFinalize(void) ; 
     28      void notifyBufferResizing(void) { resizingBuffer_=true ;} 
    2829    private: 
    2930      char* buffer; 
     
    3536      std::vector<MPI_Win> windows_ ; 
    3637      std::vector<MPI_Aint> winAddress_ ; 
    37  
     38      bool resizingBuffer_ = false ; 
    3839      int currentWindows ; 
    3940      bool hasWindows ; 
  • XIOS/dev/dev_trunk_graph/src/config/field_attribute.conf

    r2019 r2137  
    4242 
    4343DECLARE_ATTRIBUTE(bool,      build_workflow_graph) 
     44DECLARE_ATTRIBUTE(StdString, build_workflow_graph_start) 
     45DECLARE_ATTRIBUTE(StdString, build_workflow_graph_end) 
  • XIOS/dev/dev_trunk_graph/src/config/interpolate_axis_attribute.conf

    r827 r2137  
    33DECLARE_ATTRIBUTE(int, order) 
    44DECLARE_ATTRIBUTE(StdString, coordinate) 
     5DECLARE_ATTRIBUTE(StdString, coordinate_src) 
     6DECLARE_ATTRIBUTE(StdString, coordinate_dst) 
  • XIOS/dev/dev_trunk_graph/src/context_client.cpp

    r2019 r2137  
    1212#include "cxios.hpp" 
    1313#include "server.hpp" 
     14#include "services.hpp" 
     15#include <boost/functional/hash.hpp> 
     16#include <random> 
     17#include <chrono> 
    1418 
    1519namespace xios 
     
    2529    { 
    2630       
    27       context = parent; 
     31      context_ = parent; 
    2832      intraComm = intraComm_; 
    2933      interComm = interComm_; 
     
    6670      MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf) ; 
    6771 
     72      auto time=chrono::system_clock::now().time_since_epoch().count() ; 
     73      std::default_random_engine rd(time); // not reproducible from a run to another 
     74      std::uniform_int_distribution<size_t> dist; 
     75      hashId_=dist(rd) ; 
     76      MPI_Bcast(&hashId_,1,MPI_SIZE_T,0,intraComm) ; // Bcast to all server of the context 
     77 
    6878      timeLine = 1; 
    6979    } 
     
    124134    { 
    125135      list<int> ranks = event.getRanks(); 
    126       info(100)<<"Event "<<timeLine<<" of context "<<context->getId()<<endl ; 
     136      info(100)<<"Event "<<timeLine<<" of context "<<context_->getId()<<endl ; 
    127137      if (CXios::checkEventSync) 
    128138      { 
     
    154164 
    155165        unlockBuffers(ranks) ; 
    156         info(100)<<"Event "<<timeLine<<" of context "<<context->getId()<<"  sent"<<endl ; 
     166        info(100)<<"Event "<<timeLine<<" of context "<<context_->getId()<<"  sent"<<endl ; 
    157167           
    158168        checkBuffers(ranks); 
     
    161171      if (isAttachedModeEnabled()) // couldBuffer is always true in attached mode 
    162172      { 
    163         waitEvent(ranks); 
    164         CContext::setCurrent(context->getId()); 
     173        while (checkBuffers(ranks)) context_->globalEventLoop() ; 
     174       
     175        CXios::getDaemonsManager()->scheduleContext(hashId_) ; 
     176        while (CXios::getDaemonsManager()->isScheduledContext(hashId_)) context_->globalEventLoop() ; 
    165177      } 
    166178       
     
    177189      while (checkBuffers(ranks)) 
    178190      { 
    179         CXios::getDaemonsManager()->eventLoop() ; 
     191        context_->eventLoop() ; 
    180192      } 
    181193 
     
    256268          for (itBuffer = bufferList.begin(); itBuffer != bufferList.end(); itBuffer++) (*itBuffer)->unlockBuffer(); 
    257269          checkBuffers(); 
    258            
     270/*           
    259271          context->server->listen(); 
    260272 
     
    265277            context->globalEventLoop() ; 
    266278          } 
    267  
    268         } 
     279*/ 
     280           context_->globalEventLoop() ; 
     281        } 
     282 
    269283      } while (!areBuffersFree && !nonBlocking); 
    270284      CTimer::get("Blocking time").suspend(); 
     
    295309   
    296310      CClientBuffer* buffer = buffers[rank] = new CClientBuffer(interComm, Wins, clientRank, rank, mapBufferSize_[rank], maxEventSizes[rank]); 
     311      if (isGrowableBuffer_) buffer->setGrowableBuffer(1.2) ; 
     312      else buffer->fixBuffer() ; 
    297313      // Notify the server 
    298       CBufferOut* bufOut = buffer->getBuffer(0, 3*sizeof(MPI_Aint)); 
    299       MPI_Aint sendBuff[3] ; 
    300       sendBuff[0]=mapBufferSize_[rank]; // Stupid C++ 
    301       sendBuff[1]=buffers[rank]->getWinAddress(0);  
    302       sendBuff[2]=buffers[rank]->getWinAddress(1);  
     314      CBufferOut* bufOut = buffer->getBuffer(0, 4*sizeof(MPI_Aint)); 
     315      MPI_Aint sendBuff[4] ; 
     316      sendBuff[0]=hashId_; 
     317      sendBuff[1]=mapBufferSize_[rank]; 
     318      sendBuff[2]=buffers[rank]->getWinAddress(0);  
     319      sendBuff[3]=buffers[rank]->getWinAddress(1);  
    303320      info(100)<<"CContextClient::newBuffer : rank "<<rank<<" winAdress[0] "<<buffers[rank]->getWinAddress(0)<<" winAdress[1] "<<buffers[rank]->getWinAddress(1)<<endl; 
    304       bufOut->put(sendBuff, 3); // Stupid C++ 
     321      bufOut->put(sendBuff, 4);  
    305322      buffer->checkBuffer(true); 
    306323 
     
    383400    * \param [in] maxEventSize maps the rank of the connected servers to the size of the biggest event 
    384401   */ 
    385    void CContextClient::setBufferSize(const std::map<int,StdSize>& mapSize, const std::map<int,StdSize>& maxEventSize) 
    386    { 
    387      mapBufferSize_ = mapSize; 
    388      maxEventSizes = maxEventSize; 
     402   void CContextClient::setBufferSize(const std::map<int,StdSize>& mapSize) 
     403   { 
     404     for(auto& it : mapSize) {buffers[it.first]->fixBufferSize(std::min(it.second*CXios::bufferSizeFactor*1.01,CXios::maxBufferSize*1.0));} 
    389405   } 
    390406 
     
    463479    for (itMap = itbMap; itMap != iteMap; ++itMap) 
    464480    { 
    465       report(10) << " Memory report : Context <" << context->getId() << "> : client side : memory used for buffer of each connection to server" << endl 
     481      report(10) << " Memory report : Context <" << context_->getId() << "> : client side : memory used for buffer of each connection to server" << endl 
    466482                 << "  +) To server with rank " << itMap->first << " : " << itMap->second << " bytes " << endl; 
    467483      totalBuf += itMap->second; 
    468484    } 
    469     report(0) << " Memory report : Context <" << context->getId() << "> : client side : total memory used for buffer " << totalBuf << " bytes" << endl; 
     485    report(0) << " Memory report : Context <" << context_->getId() << "> : client side : total memory used for buffer " << totalBuf << " bytes" << endl; 
    470486 
    471487  } 
  • XIOS/dev/dev_trunk_graph/src/context_client.hpp

    r2019 r2137  
    6363      void finalize(void); 
    6464 
    65       void setBufferSize(const std::map<int,StdSize>& mapSize, const std::map<int,StdSize>& maxEventSize); 
     65      void setBufferSize(const std::map<int,StdSize>& mapSize); 
    6666 
    6767      int getRemoteSize(void) {return serverSize;} 
     
    7575      /*! get the associated server (dual chanel client/server) */       
    7676      CContextServer* getAssociatedServer(void) { return associatedServer_;} 
    77  
     77      void setGrowableBuffer(void) { isGrowableBuffer_=true;} 
     78      void setFixedBuffer(void) { isGrowableBuffer_=false;} 
    7879    public: 
    79       CContext* context; //!< Context for client 
     80      CContext* context_; //!< Context for client 
    8081 
    8182      size_t timeLine; //!< Timeline of each event 
     
    9899 
    99100      bool pureOneSided ; //!< if true, client will communicated with servers only trough one sided communication. Otherwise the hybrid mode P2P /One sided is used. 
     101 
     102      size_t hashId_ ; //!< hash id on the context client that will be used for context server to identify the remote calling context client. 
    100103 
    101104    private: 
     
    122125      bool isAttached_ ; 
    123126      CContextServer* associatedServer_ ; //!< The server associated to the pair client/server 
    124  
     127      bool isGrowableBuffer_ = true ; 
    125128  }; 
    126129} 
  • XIOS/dev/dev_trunk_graph/src/context_server.cpp

    r2027 r2137  
    2020#include "services.hpp" 
    2121#include "contexts_manager.hpp" 
     22#include "timeline_events.hpp" 
    2223 
    2324#include <boost/functional/hash.hpp> 
     
    5253    CXios::getContextsManager()->getContextInfo(context->getId(), contextInfo, intraComm) ; 
    5354 
    54     //if (contextInfo.serviceType != CServicesManager::CLIENT) // we must have an event scheduler => to be retrieve from the associated services 
    55     //{ 
    56       if (!isAttachedModeEnabled()) eventScheduler_=CXios::getPoolRessource()->getService(contextInfo.serviceId,contextInfo.partitionId)->getEventScheduler() ; 
    57     //} 
     55  //  if (contextInfo.serviceType != CServicesManager::CLIENT) // we must have an event scheduler => to be retrieve from the associated services 
     56  //  { 
     57      //if (!isAttachedModeEnabled()) eventScheduler_=CXios::getPoolRessource()->getService(contextInfo.serviceId,contextInfo.partitionId)->getEventScheduler() ; 
     58      eventScheduler_=CXios::getPoolRessource()->getService(contextInfo.serviceId,contextInfo.partitionId)->getEventScheduler() ; 
     59 
     60  //  } 
    5861 
    5962 
     
    186189    if (it==buffers.end()) // Receive the buffer size and allocate the buffer 
    187190    { 
    188        MPI_Aint recvBuff[3] ; 
    189        MPI_Recv(recvBuff, 3, MPI_AINT, rank, 20, interComm, &status); 
    190        StdSize buffSize = recvBuff[0]; 
     191       MPI_Aint recvBuff[4] ; 
     192       MPI_Recv(recvBuff, 4, MPI_AINT, rank, 20, interComm, &status); 
     193       remoteHashId_ = recvBuff[0] ; 
     194       StdSize buffSize = recvBuff[1]; 
    191195       vector<MPI_Aint> winAdress(2) ; 
    192        winAdress[0]=recvBuff[1] ; winAdress[1]=recvBuff[2] ; 
     196       winAdress[0]=recvBuff[2] ; winAdress[1]=recvBuff[3] ; 
    193197       mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
    194198       it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(windows, winAdress, rank, buffSize)))).first; 
     
    288292      CBufferIn newBuffer(startBuffer,buffer.remain()); 
    289293      newBuffer>>size>>timeLine; 
    290       it=events.find(timeLine); 
    291       if (it==events.end()) it=events.insert(pair<int,CEventServer*>(timeLine,new CEventServer(this))).first; 
    292       it->second->push(rank,buffers[rank],startBuffer,size); 
    293  
     294 
     295      if (timeLine==timelineEventNotifyChangeBufferSize) 
     296      { 
     297        buffers[rank]->notifyBufferResizing() ; 
     298        buffers[rank]->updateCurrentWindows() ; 
     299      }  
     300      else if (timeLine==timelineEventChangeBufferSize) 
     301      { 
     302        size_t newSize ; 
     303        vector<MPI_Aint> winAdress(2) ; 
     304        newBuffer>>newSize>>winAdress[0]>>winAdress[1] ; 
     305        buffers.erase(rank) ; 
     306        buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(windows, winAdress, rank, newSize))); 
     307      } 
     308      else 
     309      { 
     310        it=events.find(timeLine); 
     311        if (it==events.end()) it=events.insert(pair<int,CEventServer*>(timeLine,new CEventServer(this))).first; 
     312        it->second->push(rank,buffers[rank],startBuffer,size); 
     313        if (timeLine>0) lastTimeLine[rank]=timeLine ; 
     314      } 
    294315      buffer.advance(size); 
    295316      count=buffer.remain(); 
    296317    } 
    297  
    298     if (timeLine>0) lastTimeLine[rank]=timeLine ; 
    299318     
    300319    CTimer::get("Process request").suspend(); 
     
    308327//    if (context->isProcessingEvent()) return ; 
    309328    if (isProcessingEvent_) return ; 
     329    if (isAttachedModeEnabled()) 
     330      if (!CXios::getDaemonsManager()->isScheduledContext(remoteHashId_)) return ; 
    310331 
    311332    it=events.find(currentTimeLine); 
     
    316337      if (event->isFull()) 
    317338      { 
    318         if (!scheduled && eventScheduler_) // Skip event scheduling for attached mode and reception on client side 
     339        if (!scheduled && !isAttachedModeEnabled()) // Skip event scheduling for attached mode and reception on client side 
    319340        { 
    320341          eventScheduler_->registerEvent(currentTimeLine,hashId); 
    321342          scheduled=true; 
    322343        } 
    323         else if (!eventScheduler_ || eventScheduler_->queryEvent(currentTimeLine,hashId) ) 
     344        else if (isAttachedModeEnabled() || eventScheduler_->queryEvent(currentTimeLine,hashId) ) 
    324345        { 
    325           MPI_Barrier(intraComm) ; 
     346          MPI_Request req ; 
     347          MPI_Status status ; 
     348 
     349          MPI_Ibarrier(intraComm,&req) ; 
     350          int flag=false ; 
     351          do   
     352          { 
     353            eventScheduler_->checkEvent()  ; 
     354            MPI_Test(&req,&flag,&status) ; 
     355          } while (!flag) ; 
     356 
     357          //MPI_Barrier(intraComm) ; 
    326358         // When using attached mode, synchronise the processes to avoid that differents event be scheduled by differents processes 
    327359         // The best way to properly solve this problem will be to use the event scheduler also in attached mode 
     
    343375         currentTimeLine++; 
    344376         scheduled = false; 
     377         if (isAttachedModeEnabled()) CXios::getDaemonsManager()->unscheduleContext() ; 
    345378        } 
    346379      } 
  • XIOS/dev/dev_trunk_graph/src/context_server.hpp

    r2019 r2137  
    7272      bool isProcessingEvent_ ; 
    7373      CContextClient* associatedClient_ ; 
     74      size_t remoteHashId_; //!< the hash is of the calling context client 
    7475  } ; 
    7576 
  • XIOS/dev/dev_trunk_graph/src/declare_attribute.hpp

    r2019 r2137  
    4343         using CAttributeArray<T_num, T_rank>::operator = ;       \ 
    4444         bool alwaysFalse=false;\ 
    45          name##_attr(void) : CAttributeArray<T_num, T_rank> (#name, *CAttributeMap::Current) {if (alwaysFalse) TV_ttf_display_type(this);} \ 
     45         name##_attr(void) : CAttributeArray<T_num, T_rank> (#name, *CAttributeMap::Current) {} \ 
    4646         virtual bool doSend() const { return helper(__VA_ARGS__); }   \ 
    4747         bool helper(bool returnTrue=true) const { return returnTrue; }   \ 
    48          static int TV_ttf_display_type ( const name##_attr* array )\ 
    49          {\ 
    50            cout<<"TV_ttf_display_type"<<endl ;\ 
    51            return CArray<T_num,T_rank>::TV_ttf_display_type((const CArray<T_num,T_rank>*)array) ;\ 
    52          }\ 
    5348         virtual ~name##_attr(void) {}                            \ 
    5449   } name; 
  • XIOS/dev/dev_trunk_graph/src/distribution/gatherer_connector.hpp

    r2019 r2137  
    151151      void transfer(map<int, CArray<T,1>>& dataIn, CArray<T,1>& dataOut, T missingValue) 
    152152      { 
    153         transfer(1, 1, dataIn, dataout, missingValue) 
     153        transfer(1, 1, dataIn, dataOut, missingValue); 
    154154      } 
    155155       
  • XIOS/dev/dev_trunk_graph/src/distribution/grid_scatterer_connector.hpp

    r2019 r2137  
    4242      }      
    4343 
    44  
     44      const map<int,int>& getTransferedDataSize(void) {return dstSize_;} 
     45      
    4546      template<typename T, int N>  
    4647      void transfer(const CArray<T,N>& input, map<int, CArray<T,1>>& output) 
  • XIOS/dev/dev_trunk_graph/src/distribution/grid_transform_connector.cpp

    r2030 r2137  
    5959        vector<size_t> recvBuff(size) ; 
    6060        MPI_Recv(recvBuff.data(), size, MPI_SIZE_T, status.MPI_SOURCE,0, localComm_,&status) ; 
    61         if(size) 
    62         { 
    63           CArray<size_t,1> arrayTmp(recvBuff.data(), shape(recvBuff.size()), duplicateData) ; 
    64           recvIndex[status.MPI_SOURCE].reference(arrayTmp) ; 
    65         } 
     61        CArray<size_t,1> arrayTmp(recvBuff.data(), shape(recvBuff.size()), duplicateData) ; 
     62        recvIndex[status.MPI_SOURCE].reference(arrayTmp) ; 
    6663        if (recvRankSize_.count(status.MPI_SOURCE)==0) recvRankSize_[status.MPI_SOURCE] = size ;  
    6764        else recvRankSize_[status.MPI_SOURCE] *= size ;  
  • XIOS/dev/dev_trunk_graph/src/distribution/scatterer_connector.hpp

    r2019 r2137  
    5050    void transfer(int sizeT, const CArray<T,n>& dataIn, map<int, CArray<T,1>>& dataOut) 
    5151    { 
    52       transfer(1, sizeT, dataIn, dataOut) 
     52      transfer(1, sizeT, dataIn, dataOut); 
    5353    } 
    5454     
  • XIOS/dev/dev_trunk_graph/src/filter/client_from_client_source_filter.cpp

    r2027 r2137  
    3838    for (auto& subEvent : event.subEvents) (*subEvent.buffer) >> packet->timestamp  ; // better management of time lien later... 
    3939    packet->timestamp = date; 
    40  
     40          
    4141    grid_->getClientFromClientConnector()->transfer(event,packet->data) ; 
    4242 
     
    5555    if (wasDataAlreadyReceived_) isDataLate = lastDateReceived_ + offset_ + freqOp_ <= currentDate ; 
    5656    else isDataLate = CContext::getCurrent()->getCalendar()->getInitDate()+ offset_ <= currentDate ; 
     57    return isDataLate ; 
    5758  } 
    5859 
  • XIOS/dev/dev_trunk_graph/src/filter/client_to_model_store_filter.cpp

    r2019 r2137  
    1919    if (hasMissingValue_) missingValue_  = field->default_value ; 
    2020    detectMissingValues_ = (!field->detect_missing_value.isEmpty() && hasMissingValue_); 
    21      
    2221  } 
    2322 
  • XIOS/dev/dev_trunk_graph/src/filter/client_to_server_store_filter.cpp

    r2027 r2137  
    3030    field_->getSentGrid()->getClientToServerConnector(client_)->transfer(data[0]->data, client_, event, message) ; 
    3131    CTimer::get("Field : send data").suspend(); 
    32    } 
    33    
     32  } 
     33 
    3434  void CClientToServerStoreFilter::buildWorkflowGraph(std::vector<CDataPacketPtr> data) 
    3535  { 
     
    4848    } 
    4949  } 
     50   
     51  CContextClient* CClientToServerStoreFilter::getTransferedDataSize(map<int,int>& size) 
     52  { 
     53    size = field_->getSentGrid()->getClientToServerConnector(client_)->getTransferedDataSize() ; 
     54    return client_ ; 
     55  } 
    5056 
    5157  bool CClientToServerStoreFilter::mustAutoTrigger() const 
  • XIOS/dev/dev_trunk_graph/src/filter/client_to_server_store_filter.hpp

    r2019 r2137  
    2424       */ 
    2525      CClientToServerStoreFilter(CGarbageCollector& gc, CField* field, CContextClient* client); 
     26      /*! 
     27       * Get the size of data transfered by call. Needed for context client buffer size evaluation 
     28       * 
     29       * \param size : map returning the size for each server rank   
     30       * \return the associated context client 
     31       */ 
     32      CContextClient* getTransferedDataSize(map<int,int>& size) ; 
    2633 
    2734      /*! 
  • XIOS/dev/dev_trunk_graph/src/filter/pass_through_filter.cpp

    r2028 r2137  
    6060 
    6161} // namespace xios 
    62  
  • XIOS/dev/dev_trunk_graph/src/filter/server_to_client_store_filter.cpp

    r2019 r2137  
    5050  } 
    5151 
     52  CContextClient* CServerToClientStoreFilter::getTransferedDataSize(map<int,int>& size) 
     53  { 
     54    size = grid_->getServerToClientConnector()->getTransferedDataSize() ; 
     55    return client_ ; 
     56  } 
    5257 
    5358  bool CServerToClientStoreFilter::mustAutoTrigger() const 
  • XIOS/dev/dev_trunk_graph/src/filter/server_to_client_store_filter.hpp

    r2019 r2137  
    2525       */ 
    2626      CServerToClientStoreFilter(CGarbageCollector& gc, CField* field, CContextClient* client); 
     27 
     28      /*! 
     29       * Get the size of data transfered by call. Needed for context client buffer size evaluation 
     30       * 
     31       * \param size : map returning the size for each server rank   
     32       * \return the associated context client 
     33       */ 
     34      CContextClient* getTransferedDataSize(map<int,int>& size) ; 
    2735 
    2836      /*! 
  • XIOS/dev/dev_trunk_graph/src/filter/temporal_filter.cpp

    r2028 r2137  
    2323                        this->samplingOffset.second, this->samplingOffset.timestep) 
    2424    , initDate(initDate) 
     25//    , nextSamplingDate(initDate + (this->samplingOffset + initDate.getRelCalendar().getTimeStep())) 
    2526    , nextSamplingDate(initDate + offsetMonth + ( offsetAllButMonth + initDate.getRelCalendar().getTimeStep())) 
    2627    , nbOperationDates(1) 
    2728    , nbSamplingDates(0) 
     29//    , nextOperationDate(initDate + opFreq + this->samplingOffset) 
    2830    , isFirstOperation(true) 
    2931    , graphCycleCompleted(true) 
     
    7375      { 
    7476        usePacket = (data[0]->date >= nextSamplingDate); 
     77//        outputResult = (data[0]->date + samplingFreq > nextOperationDate); 
    7578        outputResult = (data[0]->date  > initDate + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth); 
    7679        copyLess = (isInstantOperation && usePacket && outputResult); 
     
    110113 
    111114        isFirstOperation = false; 
    112          
     115//        nextOperationDate = initDate + samplingFreq + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth; 
    113116        graphCycleCompleted = true; 
    114       } 
     117     } 
    115118    } 
    116119 
     
    125128  bool CTemporalFilter::isDataExpected(const CDate& date) const 
    126129  { 
     130//    return isOnceOperation ? isFirstOperation : (date >= nextSamplingDate || date + samplingFreq > nextOperationDate); 
    127131    return isOnceOperation ? isFirstOperation : (date >= nextSamplingDate || date > initDate + nbOperationDates*opFreq - samplingFreq + offsetMonth + offsetAllButMonth); 
    128132  } 
  • XIOS/dev/dev_trunk_graph/src/filter/transform_filter.cpp

    r2028 r2137  
    1919    packet->timestamp = data[0]->timestamp; 
    2020    packet->status = data[0]->status; 
    21      
     21 
    2222    if (packet->status == CDataPacket::NO_ERROR)  
    2323    { 
  • XIOS/dev/dev_trunk_graph/src/interface/c/iccontext.cpp

    r1612 r2137  
    6868   CATCH_DUMP_STACK 
    6969 
     70   void cxios_context_get_id(XContextPtr context, char * _id, int _id_len) 
     71   TRY 
     72   { 
     73      string_copy(context->getId(),_id,_id_len); 
     74   } 
     75   CATCH_DUMP_STACK 
     76    
    7077   void cxios_context_set_current(XContextPtr context, bool withswap) 
    7178   TRY 
  • XIOS/dev/dev_trunk_graph/src/interface/c/icdata.cpp

    r2019 r2137  
    412412 
    413413   // ---------------------- Ecriture des données ------------------------------ 
     414    
     415   void cxios_write_data_k80_hdl(CField* field, double* data_k8, int data_Xsize) 
     416   TRY 
     417   { 
     418      CTimer::get("XIOS").resume(); 
     419      CTimer::get("XIOS send field").resume(); 
     420      CContext* context = CContext::getCurrent(); 
     421      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     422        context->eventLoop(); 
     423      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); 
     424      field->setData(data); 
     425      CTimer::get("XIOS send field").suspend(); 
     426      CTimer::get("XIOS").suspend(); 
     427   } 
     428   CATCH_DUMP_STACK 
    414429 
    415430   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     
    418433      std::string fieldid_str; 
    419434      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    420  
    421       CTimer::get("XIOS").resume(); 
    422       CTimer::get("XIOS send field").resume(); 
    423       CContext* context = CContext::getCurrent(); 
    424       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    425         context->eventLoop(); 
    426 //ym        context->checkBuffersAndListen(); 
     435      cxios_write_data_k80_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; 
     436   } 
     437   CATCH_DUMP_STACK 
     438 
     439 
     440 
     441   
     442   void cxios_write_data_k81_hdl(CField* field, double* data_k8, int data_Xsize) 
     443   TRY 
     444   { 
     445      CTimer::get("XIOS").resume(); 
     446      CTimer::get("XIOS send field").resume(); 
     447 
     448      CContext* context = CContext::getCurrent(); 
     449      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     450        context->eventLoop(); 
     451 
    427452      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); 
    428       CField::get(fieldid_str)->setData(data); 
    429       CTimer::get("XIOS send field").suspend(); 
    430       CTimer::get("XIOS").suspend(); 
    431    } 
    432    CATCH_DUMP_STACK 
    433  
     453      field->setData(data); 
     454 
     455      CTimer::get("XIOS send field").suspend(); 
     456      CTimer::get("XIOS").suspend(); 
     457   } 
     458   CATCH_DUMP_STACK 
     459    
    434460   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
    435461   TRY 
     
    437463      std::string fieldid_str; 
    438464      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    439  
    440       CTimer::get("XIOS").resume(); 
    441       CTimer::get("XIOS send field").resume(); 
    442  
    443       CContext* context = CContext::getCurrent(); 
    444       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    445         context->eventLoop(); 
    446 //ym        context->checkBuffersAndListen(); 
    447  
    448       CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); 
    449       CField::get(fieldid_str)->setData(data); 
     465      cxios_write_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; 
     466     
     467   } 
     468   CATCH_DUMP_STACK 
     469 
     470 
     471 
     472   void cxios_write_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize) 
     473   TRY 
     474   { 
     475      CTimer::get("XIOS").resume(); 
     476      CTimer::get("XIOS send field").resume(); 
     477 
     478      CContext* context = CContext::getCurrent(); 
     479      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     480        context->eventLoop(); 
     481 
     482      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); 
     483      field->setData(data); 
    450484 
    451485      CTimer::get("XIOS send field").suspend(); 
     
    459493      std::string fieldid_str; 
    460494      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    461  
    462       CTimer::get("XIOS").resume(); 
    463       CTimer::get("XIOS send field").resume(); 
    464  
    465       CContext* context = CContext::getCurrent(); 
    466       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    467         context->eventLoop(); 
    468 //ym        context->checkBuffersAndListen(); 
    469  
    470       CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); 
    471       CField::get(fieldid_str)->setData(data); 
    472  
    473       CTimer::get("XIOS send field").suspend(); 
    474       CTimer::get("XIOS").suspend(); 
    475    } 
    476    CATCH_DUMP_STACK 
    477  
     495      cxios_write_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ; 
     496   } 
     497   CATCH_DUMP_STACK 
     498 
     499 
     500 
     501 
     502 
     503 
     504   void cxios_write_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     505   TRY 
     506   { 
     507      CTimer::get("XIOS").resume(); 
     508      CTimer::get("XIOS send field").resume(); 
     509 
     510      CContext* context = CContext::getCurrent(); 
     511      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     512        context->eventLoop(); 
     513 
     514      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
     515      field->setData(data); 
     516 
     517      CTimer::get("XIOS send field").suspend(); 
     518      CTimer::get("XIOS").suspend(); 
     519   } 
     520   CATCH_DUMP_STACK 
     521    
    478522   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
    479523   TRY 
     
    481525      std::string fieldid_str; 
    482526      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    483  
    484       CTimer::get("XIOS").resume(); 
    485       CTimer::get("XIOS send field").resume(); 
    486  
    487       CContext* context = CContext::getCurrent(); 
    488       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    489         context->eventLoop(); 
    490 //ym        context->checkBuffersAndListen(); 
    491  
    492       CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
    493       CField::get(fieldid_str)->setData(data); 
     527      cxios_write_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ; 
     528 
     529 
     530   } 
     531   CATCH_DUMP_STACK 
     532 
     533 
     534 
     535 
     536 
     537 
     538   void cxios_write_data_k84_hdl(CField* field, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size) 
     539   TRY 
     540   { 
     541      CTimer::get("XIOS").resume(); 
     542      CTimer::get("XIOS send field").resume(); 
     543 
     544      CContext* context = CContext::getCurrent(); 
     545      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     546        context->eventLoop(); 
     547 
     548      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
     549      field->setData(data); 
    494550 
    495551      CTimer::get("XIOS send field").suspend(); 
     
    506562      CTimer::get("XIOS").resume(); 
    507563      CTimer::get("XIOS send field").resume(); 
    508  
    509       CContext* context = CContext::getCurrent(); 
    510       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    511         context->eventLoop(); 
    512 //ym        context->checkBuffersAndListen(); 
    513  
    514       CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
    515       CField::get(fieldid_str)->setData(data); 
     564      cxios_write_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ; 
     565   } 
     566   CATCH_DUMP_STACK 
     567 
     568 
     569 
     570    
     571 
     572   void cxios_write_data_k85_hdl(CField* field, double* data_k8, 
     573                             int data_0size, int data_1size, int data_2size, 
     574                             int data_3size, int data_4size) 
     575   TRY 
     576   { 
     577      CTimer::get("XIOS").resume(); 
     578      CTimer::get("XIOS send field").resume(); 
     579 
     580      CContext* context = CContext::getCurrent(); 
     581      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     582        context->eventLoop(); 
     583 
     584      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
     585      field->setData(data); 
    516586 
    517587      CTimer::get("XIOS send field").suspend(); 
     
    527597      std::string fieldid_str; 
    528598      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    529  
    530       CTimer::get("XIOS").resume(); 
    531       CTimer::get("XIOS send field").resume(); 
    532  
    533       CContext* context = CContext::getCurrent(); 
    534         context->eventLoop(); 
    535 //ym        context->checkBuffersAndListen(); 
    536  
    537       CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
    538       CField::get(fieldid_str)->setData(data); 
    539  
    540       CTimer::get("XIOS send field").suspend(); 
    541       CTimer::get("XIOS").suspend(); 
    542    } 
    543    CATCH_DUMP_STACK 
    544  
     599      cxios_write_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ; 
     600 
     601   } 
     602   CATCH_DUMP_STACK 
     603 
     604 
     605 
     606   void cxios_write_data_k86_hdl(CField* field, double* data_k8, 
     607                             int data_0size, int data_1size, int data_2size, 
     608                             int data_3size, int data_4size, int data_5size) 
     609   TRY 
     610   { 
     611  
     612      CTimer::get("XIOS").resume(); 
     613      CTimer::get("XIOS send field").resume(); 
     614 
     615      CContext* context = CContext::getCurrent(); 
     616      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     617        context->eventLoop(); 
     618 
     619      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
     620      field->setData(data); 
     621 
     622      CTimer::get("XIOS send field").suspend(); 
     623      CTimer::get("XIOS").suspend(); 
     624   } 
     625   CATCH_DUMP_STACK 
     626    
    545627   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8, 
    546628                             int data_0size, int data_1size, int data_2size, 
     
    550632      std::string fieldid_str; 
    551633      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    552  
    553       CTimer::get("XIOS").resume(); 
    554       CTimer::get("XIOS send field").resume(); 
    555  
    556       CContext* context = CContext::getCurrent(); 
    557       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    558         context->eventLoop(); 
    559 //        context->checkBuffersAndListen(); 
    560  
    561       CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
    562       CField::get(fieldid_str)->setData(data); 
    563  
    564       CTimer::get("XIOS send field").suspend(); 
    565       CTimer::get("XIOS").suspend(); 
    566    } 
    567    CATCH_DUMP_STACK 
    568  
     634      cxios_write_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; 
     635 
     636  } 
     637   CATCH_DUMP_STACK 
     638    
     639 
     640 
     641 
     642   void cxios_write_data_k87_hdl(CField* field, double* data_k8, 
     643                             int data_0size, int data_1size, int data_2size, 
     644                             int data_3size, int data_4size, int data_5size, 
     645                             int data_6size) 
     646   TRY 
     647   { 
     648      CTimer::get("XIOS").resume(); 
     649      CTimer::get("XIOS send field").resume(); 
     650 
     651      CContext* context = CContext::getCurrent(); 
     652      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     653        context->eventLoop(); 
     654 
     655      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); 
     656      field->setData(data); 
     657 
     658      CTimer::get("XIOS send field").suspend(); 
     659      CTimer::get("XIOS").suspend(); 
     660   } 
     661   CATCH_DUMP_STACK 
     662    
    569663   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
    570664                             int data_0size, int data_1size, int data_2size, 
     
    575669      std::string fieldid_str; 
    576670      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    577  
    578       CTimer::get("XIOS").resume(); 
    579       CTimer::get("XIOS send field").resume(); 
    580  
    581       CContext* context = CContext::getCurrent(); 
    582       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    583         context->eventLoop(); 
    584 //        context->checkBuffersAndListen(); 
    585  
    586       CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); 
    587       CField::get(fieldid_str)->setData(data); 
    588  
    589       CTimer::get("XIOS send field").suspend(); 
    590       CTimer::get("XIOS").suspend(); 
    591    } 
    592    CATCH_DUMP_STACK 
    593  
    594    void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
    595    TRY 
    596    { 
    597       std::string fieldid_str; 
    598       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    599  
    600       CTimer::get("XIOS").resume(); 
    601       CTimer::get("XIOS send field").resume(); 
    602       CContext* context = CContext::getCurrent(); 
    603       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    604         context->eventLoop(); 
    605 //ym        context->checkBuffersAndListen(); 
     671      cxios_write_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; 
     672   } 
     673   CATCH_DUMP_STACK 
     674    
     675 
     676 
     677 
     678 
     679   void cxios_write_data_k40_hdl(CField* field, float* data_k4, int data_Xsize) 
     680   TRY 
     681   { 
     682      CTimer::get("XIOS").resume(); 
     683      CTimer::get("XIOS send field").resume(); 
     684      CContext* context = CContext::getCurrent(); 
     685      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     686        context->eventLoop(); 
    606687 
    607688      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); 
    608689      CArray<double, 1> data(data_Xsize) ; 
    609690      data = data_tmp; 
    610       CField::get(fieldid_str)->setData(data); 
    611       CTimer::get("XIOS send field").suspend(); 
    612       CTimer::get("XIOS").suspend(); 
    613    } 
    614    CATCH_DUMP_STACK 
    615  
    616    void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
    617    TRY 
    618    { 
    619       std::string fieldid_str; 
    620       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    621  
    622       CTimer::get("XIOS").resume(); 
    623       CTimer::get("XIOS send field").resume(); 
    624  
    625       CContext* context = CContext::getCurrent(); 
    626       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    627         context->eventLoop(); 
    628 //ym        context->checkBuffersAndListen(); 
     691      field->setData(data); 
     692      CTimer::get("XIOS send field").suspend(); 
     693      CTimer::get("XIOS").suspend(); 
     694   } 
     695   CATCH_DUMP_STACK 
     696 
     697   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     698   TRY 
     699   { 
     700      std::string fieldid_str; 
     701      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     702      cxios_write_data_k40_hdl(CField::get(fieldid_str), data_k4, data_Xsize); 
     703 
     704   } 
     705   CATCH_DUMP_STACK 
     706    
     707    
     708   void cxios_write_data_k41_hdl(CField* field, float* data_k4, int data_Xsize) 
     709   TRY 
     710   { 
     711      CTimer::get("XIOS").resume(); 
     712      CTimer::get("XIOS send field").resume(); 
     713 
     714      CContext* context = CContext::getCurrent(); 
     715      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     716        context->eventLoop(); 
    629717 
    630718      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); 
    631719      CArray<double, 1> data(data_Xsize); 
    632720      data = data_tmp; 
    633       CField::get(fieldid_str)->setData(data); 
    634  
    635       CTimer::get("XIOS send field").suspend(); 
    636       CTimer::get("XIOS").suspend(); 
    637    } 
    638    CATCH_DUMP_STACK 
    639  
    640    void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
    641    TRY 
    642    { 
    643       std::string fieldid_str; 
    644       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    645  
    646       CTimer::get("XIOS").resume(); 
    647       CTimer::get("XIOS send field").resume(); 
    648  
    649       CContext* context = CContext::getCurrent(); 
    650       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    651         context->eventLoop(); 
    652 //ym        context->checkBuffersAndListen(); 
     721      field->setData(data); 
     722 
     723      CTimer::get("XIOS send field").suspend(); 
     724      CTimer::get("XIOS").suspend(); 
     725   } 
     726   CATCH_DUMP_STACK 
     727 
     728   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     729   TRY 
     730   { 
     731      std::string fieldid_str; 
     732      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     733      cxios_write_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize); 
     734   } 
     735   CATCH_DUMP_STACK 
     736 
     737 
     738   void cxios_write_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize) 
     739   TRY 
     740   { 
     741      CTimer::get("XIOS").resume(); 
     742      CTimer::get("XIOS send field").resume(); 
     743 
     744      CContext* context = CContext::getCurrent(); 
     745      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     746        context->eventLoop(); 
    653747 
    654748      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData); 
    655749      CArray<double, 2> data(data_Xsize, data_Ysize); 
    656750      data = data_tmp; 
    657       CField::get(fieldid_str)->setData(data); 
    658  
    659       CTimer::get("XIOS send field").suspend(); 
    660       CTimer::get("XIOS").suspend(); 
    661    } 
    662    CATCH_DUMP_STACK 
    663  
    664    void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
    665    TRY 
    666    { 
    667       std::string fieldid_str; 
    668       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    669  
    670       CTimer::get("XIOS").resume(); 
    671       CTimer::get("XIOS send field").resume(); 
    672  
    673       CContext* context = CContext::getCurrent(); 
    674       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    675         context->eventLoop(); 
    676 //ym        context->checkBuffersAndListen(); 
     751      field->setData(data); 
     752 
     753      CTimer::get("XIOS send field").suspend(); 
     754      CTimer::get("XIOS").suspend(); 
     755   } 
     756   CATCH_DUMP_STACK 
     757 
     758   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
     759   TRY 
     760   { 
     761      std::string fieldid_str; 
     762      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     763      cxios_write_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize); 
     764   } 
     765   CATCH_DUMP_STACK 
     766 
     767 
     768 
     769 
     770   void cxios_write_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     771   TRY 
     772   { 
     773      CTimer::get("XIOS").resume(); 
     774      CTimer::get("XIOS send field").resume(); 
     775 
     776      CContext* context = CContext::getCurrent(); 
     777      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     778        context->eventLoop(); 
    677779 
    678780      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
    679781      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize); 
    680782      data = data_tmp; 
    681       CField::get(fieldid_str)->setData(data); 
     783      field->setData(data); 
     784 
     785      CTimer::get("XIOS send field").suspend(); 
     786      CTimer::get("XIOS").suspend(); 
     787    } 
     788   CATCH_DUMP_STACK 
     789    
     790   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     791   TRY 
     792   { 
     793      std::string fieldid_str; 
     794      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     795      cxios_write_data_k43_hdl(CField::get(fieldid_str), data_k4, data_Xsize,data_Ysize, data_Zsize); 
     796    } 
     797   CATCH_DUMP_STACK 
     798    
     799 
     800    
     801   void cxios_write_data_k44_hdl(CField* field, float* data_k4, 
     802                             int data_0size, int data_1size, int data_2size, 
     803                             int data_3size) 
     804   TRY 
     805   { 
     806      CTimer::get("XIOS").resume(); 
     807      CTimer::get("XIOS send field").resume(); 
     808 
     809      CContext* context = CContext::getCurrent(); 
     810      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     811        context->eventLoop(); 
     812 
     813      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
     814      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); 
     815      data = data_tmp; 
     816      field->setData(data); 
    682817 
    683818      CTimer::get("XIOS send field").suspend(); 
     
    693828      std::string fieldid_str; 
    694829      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    695  
    696       CTimer::get("XIOS").resume(); 
    697       CTimer::get("XIOS send field").resume(); 
    698  
    699       CContext* context = CContext::getCurrent(); 
    700       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    701         context->eventLoop(); 
    702 //ym        context->checkBuffersAndListen(); 
    703  
    704       CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
    705       CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); 
     830      cxios_write_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ; 
     831    } 
     832   CATCH_DUMP_STACK 
     833 
     834 
     835 
     836 
     837   void cxios_write_data_k45_hdl(CField* field, float* data_k4, 
     838                             int data_0size, int data_1size, int data_2size, 
     839                             int data_3size, int data_4size) 
     840   TRY 
     841   { 
     842      CTimer::get("XIOS").resume(); 
     843      CTimer::get("XIOS send field").resume(); 
     844 
     845      CContext* context = CContext::getCurrent(); 
     846      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     847        context->eventLoop(); 
     848 
     849      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
     850      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); 
    706851      data = data_tmp; 
    707       CField::get(fieldid_str)->setData(data); 
     852      field->setData(data); 
    708853 
    709854      CTimer::get("XIOS send field").suspend(); 
     
    719864      std::string fieldid_str; 
    720865      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    721  
    722       CTimer::get("XIOS").resume(); 
    723       CTimer::get("XIOS send field").resume(); 
    724  
    725       CContext* context = CContext::getCurrent(); 
    726       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    727         context->eventLoop(); 
    728 //ym        context->checkBuffersAndListen(); 
    729  
    730       CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
    731       CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); 
     866      cxios_write_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ; 
     867    } 
     868   CATCH_DUMP_STACK 
     869 
     870 
     871 
     872   void cxios_write_data_k46_hdl(CField* field, float* data_k4, 
     873                             int data_0size, int data_1size, int data_2size, 
     874                             int data_3size, int data_4size, int data_5size) 
     875   TRY 
     876   { 
     877      CTimer::get("XIOS").resume(); 
     878      CTimer::get("XIOS send field").resume(); 
     879 
     880      CContext* context = CContext::getCurrent(); 
     881      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     882        context->eventLoop(); 
     883 
     884      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
     885      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); 
    732886      data = data_tmp; 
    733       CField::get(fieldid_str)->setData(data); 
     887      field->setData(data); 
    734888 
    735889      CTimer::get("XIOS send field").suspend(); 
     
    745899      std::string fieldid_str; 
    746900      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    747  
    748       CTimer::get("XIOS").resume(); 
    749       CTimer::get("XIOS send field").resume(); 
    750  
    751       CContext* context = CContext::getCurrent(); 
    752       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    753         context->eventLoop(); 
    754 //ym        context->checkBuffersAndListen(); 
    755  
    756       CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
    757       CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); 
    758       data = data_tmp; 
    759       CField::get(fieldid_str)->setData(data); 
    760  
    761       CTimer::get("XIOS send field").suspend(); 
    762       CTimer::get("XIOS").suspend(); 
    763     } 
    764    CATCH_DUMP_STACK 
    765  
    766    void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
     901      cxios_write_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; 
     902    } 
     903   CATCH_DUMP_STACK 
     904 
     905 
     906   void cxios_write_data_k47_hdl(CField* field, float* data_k4, 
    767907                             int data_0size, int data_1size, int data_2size, 
    768908                             int data_3size, int data_4size, int data_5size, 
     
    770910   TRY 
    771911   { 
    772       std::string fieldid_str; 
    773       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    774  
    775       CTimer::get("XIOS").resume(); 
    776       CTimer::get("XIOS send field").resume(); 
    777  
    778       CContext* context = CContext::getCurrent(); 
    779       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    780         context->eventLoop(); 
    781 //ym        context->checkBuffersAndListen(); 
     912      CTimer::get("XIOS").resume(); 
     913      CTimer::get("XIOS send field").resume(); 
     914 
     915      CContext* context = CContext::getCurrent(); 
     916      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     917        context->eventLoop(); 
    782918 
    783919      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); 
    784920      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size); 
    785921      data = data_tmp; 
    786       CField::get(fieldid_str)->setData(data); 
    787  
    788       CTimer::get("XIOS send field").suspend(); 
    789       CTimer::get("XIOS").suspend(); 
    790     } 
    791    CATCH_DUMP_STACK 
     922      field->setData(data); 
     923 
     924      CTimer::get("XIOS send field").suspend(); 
     925      CTimer::get("XIOS").suspend(); 
     926    } 
     927   CATCH_DUMP_STACK 
     928 
     929  void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
     930                             int data_0size, int data_1size, int data_2size, 
     931                             int data_3size, int data_4size, int data_5size, 
     932                             int data_6size) 
     933   TRY 
     934   { 
     935      std::string fieldid_str; 
     936      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     937      cxios_write_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; 
     938    } 
     939   CATCH_DUMP_STACK 
     940 
    792941 
    793942   // ---------------------- Lecture des données ------------------------------ 
    794943 
     944   void cxios_read_data_k80_hdl(CField* field, double* data_k8, int data_Xsize) 
     945   TRY 
     946   { 
     947      CTimer::get("XIOS").resume(); 
     948      CTimer::get("XIOS recv field").resume(); 
     949 
     950      CContext* context = CContext::getCurrent(); 
     951      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     952        context->eventLoop(); 
     953 
     954      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); 
     955      field->getData(data); 
     956 
     957      CTimer::get("XIOS recv field").suspend(); 
     958      CTimer::get("XIOS").suspend(); 
     959   } 
     960   CATCH_DUMP_STACK 
     961 
    795962   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
    796963   TRY 
     
    798965      std::string fieldid_str; 
    799966      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    800  
    801       CTimer::get("XIOS").resume(); 
    802       CTimer::get("XIOS recv field").resume(); 
    803  
    804       CContext* context = CContext::getCurrent(); 
    805       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    806         context->eventLoop(); 
    807 //ym        context->checkBuffersAndListen(); 
     967      cxios_read_data_k80_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; 
     968   } 
     969   CATCH_DUMP_STACK 
     970    
     971    
     972   void cxios_read_data_k81_hdl(CField* field, double* data_k8, int data_Xsize) 
     973   TRY 
     974   { 
     975      CTimer::get("XIOS").resume(); 
     976      CTimer::get("XIOS recv field").resume(); 
     977 
     978      CContext* context = CContext::getCurrent(); 
     979      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     980        context->eventLoop(); 
    808981 
    809982      CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); 
    810       CField::get(fieldid_str)->getData(data); 
     983      field->getData(data); 
    811984 
    812985      CTimer::get("XIOS recv field").suspend(); 
     
    820993      std::string fieldid_str; 
    821994      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    822  
    823       CTimer::get("XIOS").resume(); 
    824       CTimer::get("XIOS recv field").resume(); 
    825  
    826       CContext* context = CContext::getCurrent(); 
    827       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    828         context->eventLoop(); 
    829 //ym        context->checkBuffersAndListen(); 
    830  
    831       CArray<double, 1> data(data_k8, shape(data_Xsize), neverDeleteData); 
    832       CField::get(fieldid_str)->getData(data); 
     995      cxios_read_data_k81_hdl(CField::get(fieldid_str), data_k8, data_Xsize) ; 
     996   } 
     997   CATCH_DUMP_STACK 
     998 
     999   void cxios_read_data_k82_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize) 
     1000   TRY 
     1001   { 
     1002      CTimer::get("XIOS").resume(); 
     1003      CTimer::get("XIOS recv field").resume(); 
     1004 
     1005      CContext* context = CContext::getCurrent(); 
     1006      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1007        context->eventLoop(); 
     1008 
     1009      CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); 
     1010      field->getData(data); 
    8331011 
    8341012      CTimer::get("XIOS recv field").suspend(); 
     
    8421020      std::string fieldid_str; 
    8431021      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    844  
    845       CTimer::get("XIOS").resume(); 
    846       CTimer::get("XIOS recv field").resume(); 
    847  
    848       CContext* context = CContext::getCurrent(); 
    849       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    850         context->eventLoop(); 
    851 //ym        context->checkBuffersAndListen(); 
    852  
    853       CArray<double, 2>data(data_k8, shape(data_Xsize, data_Ysize), neverDeleteData); 
    854       CField::get(fieldid_str)->getData(data); 
    855  
    856       CTimer::get("XIOS recv field").suspend(); 
    857       CTimer::get("XIOS").suspend(); 
    858    } 
    859    CATCH_DUMP_STACK 
     1022      cxios_read_data_k82_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize) ; 
     1023   } 
     1024   CATCH_DUMP_STACK 
     1025 
     1026 
     1027   void cxios_read_data_k83_hdl(CField* field, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     1028   TRY 
     1029   { 
     1030      CTimer::get("XIOS").resume(); 
     1031      CTimer::get("XIOS recv field").resume(); 
     1032 
     1033      CContext* context = CContext::getCurrent(); 
     1034      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1035        context->eventLoop(); 
     1036 
     1037      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
     1038      field->getData(data); 
     1039 
     1040      CTimer::get("XIOS recv field").suspend(); 
     1041      CTimer::get("XIOS").suspend(); 
     1042   } 
     1043   CATCH_DUMP_STACK 
     1044 
    8601045 
    8611046   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     
    8641049      std::string fieldid_str; 
    8651050      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    866  
    867       CTimer::get("XIOS").resume(); 
    868       CTimer::get("XIOS recv field").resume(); 
    869  
    870       CContext* context = CContext::getCurrent(); 
    871       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    872         context->eventLoop(); 
    873 //ym        context->checkBuffersAndListen(); 
    874  
    875       CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
    876       CField::get(fieldid_str)->getData(data); 
     1051      cxios_read_data_k83_hdl(CField::get(fieldid_str), data_k8, data_Xsize, data_Ysize, data_Zsize) ; 
     1052   } 
     1053   CATCH_DUMP_STACK 
     1054 
     1055   void cxios_read_data_k84_hdl(CField* field, double* data_k8, 
     1056                            int data_0size, int data_1size, int data_2size, 
     1057                            int data_3size) 
     1058   TRY 
     1059   { 
     1060      CTimer::get("XIOS").resume(); 
     1061      CTimer::get("XIOS recv field").resume(); 
     1062 
     1063      CContext* context = CContext::getCurrent(); 
     1064      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1065        context->eventLoop(); 
     1066 
     1067      CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
     1068      field->getData(data); 
    8771069 
    8781070      CTimer::get("XIOS recv field").suspend(); 
     
    8881080      std::string fieldid_str; 
    8891081      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    890  
    891       CTimer::get("XIOS").resume(); 
    892       CTimer::get("XIOS recv field").resume(); 
    893  
    894       CContext* context = CContext::getCurrent(); 
    895       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    896         context->eventLoop(); 
    897 //ym        context->checkBuffersAndListen(); 
    898  
    899       CArray<double, 4>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
    900       CField::get(fieldid_str)->getData(data); 
     1082      cxios_read_data_k84_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size) ; 
     1083   } 
     1084   CATCH_DUMP_STACK 
     1085 
     1086   void cxios_read_data_k85_hdl(CField* field, double* data_k8, 
     1087                            int data_0size, int data_1size, int data_2size, 
     1088                            int data_3size, int data_4size) 
     1089   TRY 
     1090   { 
     1091      CTimer::get("XIOS").resume(); 
     1092      CTimer::get("XIOS recv field").resume(); 
     1093 
     1094      CContext* context = CContext::getCurrent(); 
     1095      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1096        context->eventLoop(); 
     1097 
     1098      CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
     1099      field->getData(data); 
    9011100 
    9021101      CTimer::get("XIOS recv field").suspend(); 
     
    9121111      std::string fieldid_str; 
    9131112      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    914  
    915       CTimer::get("XIOS").resume(); 
    916       CTimer::get("XIOS recv field").resume(); 
    917  
    918       CContext* context = CContext::getCurrent(); 
    919       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    920         context->eventLoop(); 
    921 //ym        context->checkBuffersAndListen(); 
    922  
    923       CArray<double, 5>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
    924       CField::get(fieldid_str)->getData(data); 
     1113      cxios_read_data_k85_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size) ; 
     1114   } 
     1115   CATCH_DUMP_STACK 
     1116 
     1117   void cxios_read_data_k86_hdl(CField* field, double* data_k8, 
     1118                            int data_0size, int data_1size, int data_2size, 
     1119                            int data_3size, int data_4size, int data_5size) 
     1120   TRY 
     1121   { 
     1122      CTimer::get("XIOS").resume(); 
     1123      CTimer::get("XIOS recv field").resume(); 
     1124 
     1125      CContext* context = CContext::getCurrent(); 
     1126      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1127        context->eventLoop(); 
     1128 
     1129      CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
     1130      field->getData(data); 
    9251131 
    9261132      CTimer::get("XIOS recv field").suspend(); 
     
    9361142      std::string fieldid_str; 
    9371143      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    938  
    939       CTimer::get("XIOS").resume(); 
    940       CTimer::get("XIOS recv field").resume(); 
    941  
    942       CContext* context = CContext::getCurrent(); 
    943       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    944         context->eventLoop(); 
    945 //ym        context->checkBuffersAndListen(); 
    946  
    947       CArray<double, 6>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
    948       CField::get(fieldid_str)->getData(data); 
    949  
    950       CTimer::get("XIOS recv field").suspend(); 
    951       CTimer::get("XIOS").suspend(); 
    952    } 
    953    CATCH_DUMP_STACK 
    954  
    955    void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
     1144      cxios_read_data_k86_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; 
     1145   } 
     1146   CATCH_DUMP_STACK 
     1147 
     1148   void cxios_read_data_k87_hdl(CField* field, double* data_k8, 
    9561149                            int data_0size, int data_1size, int data_2size, 
    9571150                            int data_3size, int data_4size, int data_5size, 
     
    9591152   TRY 
    9601153   { 
    961       std::string fieldid_str; 
    962       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    963  
    964       CTimer::get("XIOS").resume(); 
    965       CTimer::get("XIOS recv field").resume(); 
    966  
    967       CContext* context = CContext::getCurrent(); 
    968       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    969         context->eventLoop(); 
    970 //ym        context->checkBuffersAndListen(); 
     1154      CTimer::get("XIOS").resume(); 
     1155      CTimer::get("XIOS recv field").resume(); 
     1156 
     1157      CContext* context = CContext::getCurrent(); 
     1158      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1159        context->eventLoop(); 
    9711160 
    9721161      CArray<double, 7>data(data_k8, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); 
    973       CField::get(fieldid_str)->getData(data); 
    974  
    975       CTimer::get("XIOS recv field").suspend(); 
    976       CTimer::get("XIOS").suspend(); 
    977    } 
    978    CATCH_DUMP_STACK 
    979  
    980    void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
    981    TRY 
    982    { 
    983       std::string fieldid_str; 
    984       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    985  
    986       CTimer::get("XIOS").resume(); 
    987       CTimer::get("XIOS recv field").resume(); 
    988  
    989       CContext* context = CContext::getCurrent(); 
    990       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    991         context->eventLoop(); 
    992 //ym        context->checkBuffersAndListen(); 
     1162      field->getData(data); 
     1163 
     1164      CTimer::get("XIOS recv field").suspend(); 
     1165      CTimer::get("XIOS").suspend(); 
     1166   } 
     1167   CATCH_DUMP_STACK 
     1168 
     1169   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
     1170                            int data_0size, int data_1size, int data_2size, 
     1171                            int data_3size, int data_4size, int data_5size, 
     1172                            int data_6size) 
     1173   TRY 
     1174   { 
     1175      std::string fieldid_str; 
     1176      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1177      cxios_read_data_k87_hdl(CField::get(fieldid_str), data_k8, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; 
     1178   } 
     1179   CATCH_DUMP_STACK 
     1180 
     1181 
     1182 
     1183 
     1184 
     1185 
     1186   void cxios_read_data_k40_hdl(CField* field, float* data_k4, int data_Xsize) 
     1187   TRY 
     1188   { 
     1189      CTimer::get("XIOS").resume(); 
     1190      CTimer::get("XIOS recv field").resume(); 
     1191 
     1192      CContext* context = CContext::getCurrent(); 
     1193      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1194        context->eventLoop(); 
    9931195 
    9941196      CArray<double, 1> data(data_Xsize); 
    995       CField::get(fieldid_str)->getData(data); 
     1197      field->getData(data); 
    9961198      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); 
    9971199      data_tmp = data; 
     
    10021204   CATCH_DUMP_STACK 
    10031205 
    1004    void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
    1005    TRY 
    1006    { 
    1007       std::string fieldid_str; 
    1008       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1009  
    1010       CTimer::get("XIOS").resume(); 
    1011       CTimer::get("XIOS recv field").resume(); 
    1012  
    1013       CContext* context = CContext::getCurrent(); 
    1014       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1015         context->eventLoop(); 
    1016 //ym        context->checkBuffersAndListen(); 
     1206   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     1207   TRY 
     1208   { 
     1209      std::string fieldid_str; 
     1210      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1211      cxios_read_data_k40_hdl(CField::get(fieldid_str), data_k4, data_Xsize) ; 
     1212   } 
     1213   CATCH_DUMP_STACK 
     1214 
     1215 
     1216 
     1217   void cxios_read_data_k41_hdl(CField* field, float* data_k4, int data_Xsize) 
     1218   TRY 
     1219   { 
     1220      CTimer::get("XIOS").resume(); 
     1221      CTimer::get("XIOS recv field").resume(); 
     1222 
     1223      CContext* context = CContext::getCurrent(); 
     1224      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1225        context->eventLoop(); 
    10171226 
    10181227      CArray<double, 1> data(data_Xsize); 
    1019       CField::get(fieldid_str)->getData(data); 
     1228      field->getData(data); 
    10201229      CArray<float, 1> data_tmp(data_k4, shape(data_Xsize), neverDeleteData); 
    10211230      data_tmp = data; 
     
    10261235   CATCH_DUMP_STACK 
    10271236 
    1028    void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
    1029    TRY 
    1030    { 
    1031       std::string fieldid_str; 
    1032       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1033  
    1034       CTimer::get("XIOS").resume(); 
    1035       CTimer::get("XIOS recv field").resume(); 
    1036  
    1037       CContext* context = CContext::getCurrent(); 
    1038       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1039         context->eventLoop(); 
    1040 //ym        context->checkBuffersAndListen(); 
     1237   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     1238   TRY 
     1239   { 
     1240      std::string fieldid_str; 
     1241      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1242      cxios_read_data_k41_hdl(CField::get(fieldid_str), data_k4, data_Xsize) ; 
     1243   } 
     1244   CATCH_DUMP_STACK 
     1245 
     1246 
     1247 
     1248 
     1249   void cxios_read_data_k42_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize) 
     1250   TRY 
     1251   { 
     1252      CTimer::get("XIOS").resume(); 
     1253      CTimer::get("XIOS recv field").resume(); 
     1254 
     1255      CContext* context = CContext::getCurrent(); 
     1256      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1257        context->eventLoop(); 
    10411258 
    10421259      CArray<double, 2> data(data_Xsize, data_Ysize); 
    1043       CField::get(fieldid_str)->getData(data); 
     1260      field->getData(data); 
    10441261      CArray<float, 2> data_tmp(data_k4, shape(data_Xsize, data_Ysize), neverDeleteData); 
    10451262      data_tmp = data; 
     
    10501267   CATCH_DUMP_STACK 
    10511268 
    1052    void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
    1053    TRY 
    1054    { 
    1055       std::string fieldid_str; 
    1056       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1057  
    1058       CTimer::get("XIOS").resume(); 
    1059       CTimer::get("XIOS recv field").resume(); 
    1060  
    1061       CContext* context = CContext::getCurrent(); 
    1062       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1063         context->eventLoop(); 
    1064 //ym        context->checkBuffersAndListen(); 
     1269   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
     1270   TRY 
     1271   { 
     1272      std::string fieldid_str; 
     1273      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1274      cxios_read_data_k42_hdl(CField::get(fieldid_str), data_k4, data_Xsize, data_Ysize) ; 
     1275   } 
     1276   CATCH_DUMP_STACK 
     1277 
     1278 
     1279 
     1280   void cxios_read_data_k43_hdl(CField* field, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     1281   TRY 
     1282   { 
     1283      CTimer::get("XIOS").resume(); 
     1284      CTimer::get("XIOS recv field").resume(); 
     1285 
     1286      CContext* context = CContext::getCurrent(); 
     1287      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1288        context->eventLoop(); 
    10651289 
    10661290      CArray<double, 3> data(data_Xsize, data_Ysize, data_Zsize); 
    1067       CField::get(fieldid_str)->getData(data); 
     1291      field->getData(data); 
    10681292      CArray<float, 3> data_tmp(data_k4, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
    10691293      data_tmp = data; 
     
    10741298   CATCH_DUMP_STACK 
    10751299 
    1076    void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4, 
     1300   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     1301   TRY 
     1302   { 
     1303      std::string fieldid_str; 
     1304      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1305      cxios_read_data_k43_hdl(CField::get(fieldid_str), data_k4,data_Xsize, data_Ysize, data_Zsize) ; 
     1306    } 
     1307   CATCH_DUMP_STACK 
     1308 
     1309 
     1310   void cxios_read_data_k44_hdl(CField* field, float* data_k4, 
    10771311                            int data_0size, int data_1size, int data_2size, 
    10781312                            int data_3size) 
    10791313   TRY 
    10801314   { 
    1081       std::string fieldid_str; 
    1082       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1083  
    1084       CTimer::get("XIOS").resume(); 
    1085       CTimer::get("XIOS recv field").resume(); 
    1086  
    1087       CContext* context = CContext::getCurrent(); 
    1088       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1089         context->eventLoop(); 
    1090 //ym        context->checkBuffersAndListen(); 
     1315      CTimer::get("XIOS").resume(); 
     1316      CTimer::get("XIOS recv field").resume(); 
     1317 
     1318      CContext* context = CContext::getCurrent(); 
     1319      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1320        context->eventLoop(); 
    10911321 
    10921322      CArray<double, 4> data(data_0size, data_1size, data_2size, data_3size); 
    1093       CField::get(fieldid_str)->getData(data); 
     1323      field->getData(data); 
    10941324      CArray<float, 4> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size), neverDeleteData); 
    10951325      data_tmp = data; 
     
    11001330   CATCH_DUMP_STACK 
    11011331 
    1102    void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4, 
     1332   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4, 
     1333                            int data_0size, int data_1size, int data_2size, 
     1334                            int data_3size) 
     1335   TRY 
     1336   { 
     1337      std::string fieldid_str; 
     1338      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1339      cxios_read_data_k44_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size) ; 
     1340    } 
     1341   CATCH_DUMP_STACK 
     1342 
     1343 
     1344 
     1345   void cxios_read_data_k45_hdl(CField* field, float* data_k4, 
    11031346                            int data_0size, int data_1size, int data_2size, 
    11041347                            int data_3size, int data_4size) 
    11051348   TRY 
    11061349   { 
    1107       std::string fieldid_str; 
    1108       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1109  
    1110       CTimer::get("XIOS").resume(); 
    1111       CTimer::get("XIOS recv field").resume(); 
    1112  
    1113       CContext* context = CContext::getCurrent(); 
    1114       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1115         context->eventLoop(); 
    1116 //ym        context->checkBuffersAndListen(); 
     1350      CTimer::get("XIOS").resume(); 
     1351      CTimer::get("XIOS recv field").resume(); 
     1352 
     1353      CContext* context = CContext::getCurrent(); 
     1354      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1355        context->eventLoop(); 
    11171356 
    11181357      CArray<double, 5> data(data_0size, data_1size, data_2size, data_3size, data_4size); 
    1119       CField::get(fieldid_str)->getData(data); 
     1358      field->getData(data); 
    11201359      CArray<float, 5> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size), neverDeleteData); 
    11211360      data_tmp = data; 
     
    11261365   CATCH_DUMP_STACK 
    11271366 
    1128    void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4, 
     1367   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4, 
     1368                            int data_0size, int data_1size, int data_2size, 
     1369                            int data_3size, int data_4size) 
     1370   TRY 
     1371   { 
     1372      std::string fieldid_str; 
     1373      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1374      cxios_read_data_k45_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size) ; 
     1375    } 
     1376   CATCH_DUMP_STACK 
     1377 
     1378 
     1379   void cxios_read_data_k46_hdl(CField* field, float* data_k4, 
    11291380                            int data_0size, int data_1size, int data_2size, 
    11301381                            int data_3size, int data_4size, int data_5size) 
    11311382   TRY 
    11321383   { 
    1133       std::string fieldid_str; 
    1134       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1135  
    1136       CTimer::get("XIOS").resume(); 
    1137       CTimer::get("XIOS recv field").resume(); 
    1138  
    1139       CContext* context = CContext::getCurrent(); 
    1140       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1141         context->eventLoop(); 
    1142 //ym        context->checkBuffersAndListen(); 
     1384      CTimer::get("XIOS").resume(); 
     1385      CTimer::get("XIOS recv field").resume(); 
     1386 
     1387      CContext* context = CContext::getCurrent(); 
     1388      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1389        context->eventLoop(); 
    11431390 
    11441391      CArray<double, 6> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size); 
    1145       CField::get(fieldid_str)->getData(data); 
     1392      field->getData(data); 
    11461393      CArray<float, 6> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size), neverDeleteData); 
    11471394      data_tmp = data; 
     
    11521399   CATCH_DUMP_STACK 
    11531400 
    1154    void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
     1401   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4, 
     1402                            int data_0size, int data_1size, int data_2size, 
     1403                            int data_3size, int data_4size, int data_5size) 
     1404   TRY 
     1405   { 
     1406      std::string fieldid_str; 
     1407      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1408      cxios_read_data_k46_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size) ; 
     1409    } 
     1410   CATCH_DUMP_STACK 
     1411 
     1412 
     1413 
     1414   void cxios_read_data_k47_hdl(CField* field, float* data_k4, 
    11551415                            int data_0size, int data_1size, int data_2size, 
    11561416                            int data_3size, int data_4size, int data_5size, 
     
    11581418   TRY 
    11591419   { 
    1160       std::string fieldid_str; 
    1161       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
    1162  
    1163       CTimer::get("XIOS").resume(); 
    1164       CTimer::get("XIOS recv field").resume(); 
    1165  
    1166       CContext* context = CContext::getCurrent(); 
    1167       if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    1168         context->eventLoop(); 
    1169 //ym        context->checkBuffersAndListen(); 
     1420      CTimer::get("XIOS").resume(); 
     1421      CTimer::get("XIOS recv field").resume(); 
     1422 
     1423      CContext* context = CContext::getCurrent(); 
     1424      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
     1425        context->eventLoop(); 
    11701426 
    11711427      CArray<double, 7> data(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size); 
    1172       CField::get(fieldid_str)->getData(data); 
     1428      field->getData(data); 
    11731429      CArray<float, 7> data_tmp(data_k4, shape(data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size), neverDeleteData); 
    11741430      data_tmp = data; 
     
    11781434    } 
    11791435   CATCH_DUMP_STACK 
     1436  
     1437   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
     1438                            int data_0size, int data_1size, int data_2size, 
     1439                            int data_3size, int data_4size, int data_5size, 
     1440                            int data_6size) 
     1441   TRY 
     1442   { 
     1443      std::string fieldid_str; 
     1444      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     1445      cxios_read_data_k47_hdl(CField::get(fieldid_str), data_k4, data_0size, data_1size, data_2size, data_3size, data_4size, data_5size, data_6size) ; 
     1446    } 
     1447   CATCH_DUMP_STACK 
    11801448} // extern "C" 
  • XIOS/dev/dev_trunk_graph/src/interface/fortran/context_interface.f90

    r545 r2137  
    1616      END SUBROUTINE cxios_context_get_current 
    1717 
     18      SUBROUTINE cxios_context_get_id(context, idt, idt_size) BIND(C) 
     19         import C_CHAR, C_INTPTR_T, C_INT 
     20         INTEGER (kind = C_INTPTR_T) :: context 
     21         CHARACTER(kind = C_CHAR)    , DIMENSION(*) :: idt 
     22         INTEGER  (kind = C_INT)     , VALUE        :: idt_size 
     23     END SUBROUTINE cxios_context_get_id 
     24 
    1825      SUBROUTINE cxios_context_set_current(context, withswap) BIND(C) 
    1926         import C_BOOL, C_INT, C_INTPTR_T 
  • XIOS/dev/dev_trunk_graph/src/interface/fortran/icontext.F90

    r947 r2137  
    1717   END INTERFACE xios(set_current_context) 
    1818 
     19   INTERFACE xios(get_current_context) 
     20      MODULE PROCEDURE xios(get_current_context_hdl), xios(get_current_context_id) 
     21   END INTERFACE xios(get_current_context) 
     22 
    1923   CONTAINS ! Fonctions disponibles pour les utilisateurs. 
    2024 
     
    2731   END SUBROUTINE xios(get_context_handle) 
    2832 
    29    SUBROUTINE xios(get_current_context)(context) 
     33   SUBROUTINE xios(get_current_context_hdl)(context) 
    3034      IMPLICIT NONE 
    3135 
    32       TYPE(txios(context)), INTENT(IN) :: context 
     36      TYPE(txios(context)), INTENT(OUT) :: context 
    3337 
    3438      CALL cxios_context_get_current(context%daddr) 
    3539 
    36    END SUBROUTINE xios(get_current_context) 
     40   END SUBROUTINE xios(get_current_context_hdl) 
    3741 
     42   SUBROUTINE xios(get_current_context_id)(idt) 
     43      IMPLICIT NONE 
     44      CHARACTER(len = *) , INTENT(OUT) :: idt 
     45      TYPE(txios(context)) :: context 
     46 
     47      CALL cxios_context_get_current(context%daddr) 
     48      CALL cxios_context_get_id(context%daddr, idt, len(idt)) 
     49 
     50   END SUBROUTINE xios(get_current_context_id) 
     51    
    3852   SUBROUTINE xios(set_current_context_hdl)(context, withswap) 
    3953      IMPLICIT NONE 
  • XIOS/dev/dev_trunk_graph/src/interface/fortran/idata.F90

    r1590 r2137  
    44   USE, INTRINSIC :: ISO_C_BINDING 
    55   USE ICONTEXT 
     6   USE IFIELD 
    67 
    78   INTERFACE ! Ne pas appeler directement/Interface FORTRAN 2003 <-> C99 
     
    5253      END SUBROUTINE cxios_solve_inheritance 
    5354 
     55      SUBROUTINE cxios_write_data_k80_hdl(field_hdl, data_k8, data_Xsize) BIND(C) 
     56         USE ISO_C_BINDING 
     57         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     58         REAL     (kind = C_DOUBLE)               :: data_k8 
     59         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     60      END SUBROUTINE cxios_write_data_k80_hdl 
     61 
    5462      SUBROUTINE cxios_write_data_k80(fieldid, fieldid_size, data_k8, data_Xsize) BIND(C) 
    5563         USE ISO_C_BINDING 
     
    6068      END SUBROUTINE cxios_write_data_k80 
    6169 
     70      SUBROUTINE cxios_write_data_k81_hdl(field_hdl, data_k8, data_Xsize) BIND(C) 
     71         USE ISO_C_BINDING 
     72         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     73         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     74         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     75      END SUBROUTINE cxios_write_data_k81_hdl 
     76 
    6277      SUBROUTINE cxios_write_data_k81(fieldid, fieldid_size, data_k8, data_Xsize) BIND(C) 
    6378         USE ISO_C_BINDING 
     
    6782         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
    6883      END SUBROUTINE cxios_write_data_k81 
     84 
     85      SUBROUTINE cxios_write_data_k82_hdl(field_hdl, data_k8, data_Xsize, data_Ysize) BIND(C) 
     86         USE ISO_C_BINDING 
     87         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     88         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     89         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize 
     90      END SUBROUTINE cxios_write_data_k82_hdl 
    6991 
    7092      SUBROUTINE cxios_write_data_k82(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize) BIND(C) 
     
    7698      END SUBROUTINE cxios_write_data_k82 
    7799 
     100      SUBROUTINE cxios_write_data_k83_hdl(field_hdl, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
     101         USE ISO_C_BINDING 
     102         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     103         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     104         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize 
     105      END SUBROUTINE cxios_write_data_k83_hdl 
     106 
    78107      SUBROUTINE cxios_write_data_k83(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
    79108         USE ISO_C_BINDING 
     
    84113      END SUBROUTINE cxios_write_data_k83 
    85114 
     115      SUBROUTINE cxios_write_data_k84_hdl(field_hdl, data_k8, & 
     116                                      data_0size, data_1size, data_2size, & 
     117                                      data_3size) BIND(C) 
     118         USE ISO_C_BINDING 
     119         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     120         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     121         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     122         INTEGER  (kind = C_INT)   , VALUE        :: data_3size 
     123      END SUBROUTINE cxios_write_data_k84_hdl 
     124 
    86125      SUBROUTINE cxios_write_data_k84(fieldid, fieldid_size, data_k8, & 
    87126                                      data_0size, data_1size, data_2size, & 
     
    95134      END SUBROUTINE cxios_write_data_k84 
    96135 
     136      SUBROUTINE cxios_write_data_k85_hdl(field_hdl, data_k8, & 
     137                                      data_0size, data_1size, data_2size, & 
     138                                      data_3size, data_4size) BIND(C) 
     139         USE ISO_C_BINDING 
     140         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     141         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     142         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     143         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size 
     144      END SUBROUTINE cxios_write_data_k85_hdl 
     145 
    97146      SUBROUTINE cxios_write_data_k85(fieldid, fieldid_size, data_k8, & 
    98147                                      data_0size, data_1size, data_2size, & 
     
    106155      END SUBROUTINE cxios_write_data_k85 
    107156 
     157      SUBROUTINE cxios_write_data_k86_hdl(field_hdl, data_k8, & 
     158                                      data_0size, data_1size, data_2size, & 
     159                                      data_3size, data_4size, data_5size) BIND(C) 
     160         USE ISO_C_BINDING 
     161         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     162         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     163         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     164         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     165      END SUBROUTINE cxios_write_data_k86_hdl 
     166 
    108167      SUBROUTINE cxios_write_data_k86(fieldid, fieldid_size, data_k8, & 
    109168                                      data_0size, data_1size, data_2size, & 
     
    117176      END SUBROUTINE cxios_write_data_k86 
    118177 
    119       SUBROUTINE cxios_write_data_k87(fieldid, fieldid_size, data_k8, & 
     178      SUBROUTINE cxios_write_data_k87_hdl(field_hdl, data_k8, & 
    120179                                      data_0size, data_1size, data_2size, & 
    121180                                      data_3size, data_4size, data_5size, & 
    122181                                      data_6size) BIND(C) 
    123182         USE ISO_C_BINDING 
     183         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     184         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     185         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     186         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     187         INTEGER  (kind = C_INT)   , VALUE        :: data_6size 
     188      END SUBROUTINE cxios_write_data_k87_hdl 
     189 
     190      SUBROUTINE cxios_write_data_k87(fieldid, fieldid_size, data_k8, & 
     191                                      data_0size, data_1size, data_2size, & 
     192                                      data_3size, data_4size, data_5size, & 
     193                                      data_6size) BIND(C) 
     194         USE ISO_C_BINDING 
    124195         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid 
    125196         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     
    130201      END SUBROUTINE cxios_write_data_k87 
    131202 
     203      SUBROUTINE cxios_write_data_k40_hdl(field_hdl, data_k4, data_Xsize) BIND(C) 
     204         USE ISO_C_BINDING 
     205         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     206         REAL     (kind = C_FLOAT)                :: data_k4 
     207         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     208      END SUBROUTINE cxios_write_data_k40_hdl 
     209 
    132210      SUBROUTINE cxios_write_data_k40(fieldid, fieldid_size, data_k4, data_Xsize) BIND(C) 
    133211         USE ISO_C_BINDING 
     
    138216      END SUBROUTINE cxios_write_data_k40 
    139217 
     218      SUBROUTINE cxios_write_data_k41_hdl(field_hdl, data_k4, data_Xsize) BIND(C) 
     219         USE ISO_C_BINDING 
     220         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     221         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     222         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     223      END SUBROUTINE cxios_write_data_k41_hdl 
     224 
    140225      SUBROUTINE cxios_write_data_k41(fieldid, fieldid_size, data_k4, data_Xsize) BIND(C) 
    141226         USE ISO_C_BINDING 
     
    146231      END SUBROUTINE cxios_write_data_k41 
    147232 
     233      SUBROUTINE cxios_write_data_k42_hdl(field_hdl, data_k4, data_Xsize, data_Ysize) BIND(C) 
     234         USE ISO_C_BINDING 
     235         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     236         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     237         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize 
     238      END SUBROUTINE cxios_write_data_k42_hdl 
     239  
    148240      SUBROUTINE cxios_write_data_k42(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize) BIND(C) 
    149241         USE ISO_C_BINDING 
     
    154246      END SUBROUTINE cxios_write_data_k42 
    155247 
     248      SUBROUTINE cxios_write_data_k43_hdl(field_hdl, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
     249         USE ISO_C_BINDING 
     250         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     251         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     252         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize 
     253      END SUBROUTINE cxios_write_data_k43_hdl 
     254 
    156255      SUBROUTINE cxios_write_data_k43(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
    157256         USE ISO_C_BINDING 
     
    162261      END SUBROUTINE cxios_write_data_k43 
    163262 
     263      SUBROUTINE cxios_write_data_k44_hdl(field_hdl, data_k4, & 
     264                                      data_0size, data_1size, data_2size, & 
     265                                      data_3size) BIND(C) 
     266         USE ISO_C_BINDING 
     267         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     268         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     269         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     270         INTEGER  (kind = C_INT)   , VALUE        :: data_3size 
     271      END SUBROUTINE cxios_write_data_k44_hdl 
     272 
    164273      SUBROUTINE cxios_write_data_k44(fieldid, fieldid_size, data_k4, & 
    165274                                      data_0size, data_1size, data_2size, & 
     
    173282      END SUBROUTINE cxios_write_data_k44 
    174283 
     284      SUBROUTINE cxios_write_data_k45_hdl(field_hdl, data_k4, & 
     285                                      data_0size, data_1size, data_2size, & 
     286                                      data_3size, data_4size) BIND(C) 
     287         USE ISO_C_BINDING 
     288         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     289         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     290         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     291         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size 
     292      END SUBROUTINE cxios_write_data_k45_hdl 
     293 
    175294      SUBROUTINE cxios_write_data_k45(fieldid, fieldid_size, data_k4, & 
    176295                                      data_0size, data_1size, data_2size, & 
     
    184303      END SUBROUTINE cxios_write_data_k45 
    185304 
     305      SUBROUTINE cxios_write_data_k46_hdl(field_hdl, data_k4, & 
     306                                      data_0size, data_1size, data_2size, & 
     307                                      data_3size, data_4size, data_5size) BIND(C) 
     308         USE ISO_C_BINDING 
     309         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     310         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     311         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     312         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     313      END SUBROUTINE cxios_write_data_k46_hdl 
     314  
    186315      SUBROUTINE cxios_write_data_k46(fieldid, fieldid_size, data_k4, & 
    187316                                      data_0size, data_1size, data_2size, & 
     
    195324      END SUBROUTINE cxios_write_data_k46 
    196325 
    197       SUBROUTINE cxios_write_data_k47(fieldid, fieldid_size, data_k4, & 
     326      SUBROUTINE cxios_write_data_k47_hdl(field_hdl, data_k4, & 
    198327                                      data_0size, data_1size, data_2size, & 
    199328                                      data_3size, data_4size, data_5size, & 
    200329                                      data_6size) BIND(C) 
    201330         USE ISO_C_BINDING 
     331         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     332         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     333         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     334         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     335         INTEGER  (kind = C_INT)   , VALUE        :: data_6size 
     336      END SUBROUTINE cxios_write_data_k47_hdl 
     337 
     338      SUBROUTINE cxios_write_data_k47(fieldid, fieldid_size, data_k4, & 
     339                                      data_0size, data_1size, data_2size, & 
     340                                      data_3size, data_4size, data_5size, & 
     341                                      data_6size) BIND(C) 
     342         USE ISO_C_BINDING 
    202343         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid 
    203344         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     
    208349      END SUBROUTINE cxios_write_data_k47 
    209350 
     351 
    210352      ! Read data 
     353      SUBROUTINE cxios_read_data_k80_hdl(field_hdl, data_k8, data_Xsize) BIND(C) 
     354         USE ISO_C_BINDING 
     355         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     356         REAL     (kind = C_DOUBLE)               :: data_k8 
     357         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     358      END SUBROUTINE cxios_read_data_k80_hdl 
     359 
    211360      SUBROUTINE cxios_read_data_k80(fieldid, fieldid_size, data_k8, data_Xsize) BIND(C) 
    212361         USE ISO_C_BINDING 
     
    217366      END SUBROUTINE cxios_read_data_k80 
    218367 
     368      SUBROUTINE cxios_read_data_k81_hdl(field_hdl, data_k8, data_Xsize) BIND(C) 
     369         USE ISO_C_BINDING 
     370         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     371         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     372         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     373      END SUBROUTINE cxios_read_data_k81_hdl 
     374 
    219375      SUBROUTINE cxios_read_data_k81(fieldid, fieldid_size, data_k8, data_Xsize) BIND(C) 
    220376         USE ISO_C_BINDING 
     
    224380         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
    225381      END SUBROUTINE cxios_read_data_k81 
     382 
     383      SUBROUTINE cxios_read_data_k82_hdl(field_hdl, data_k8, data_Xsize, data_Ysize) BIND(C) 
     384         USE ISO_C_BINDING 
     385         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     386         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     387         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize 
     388      END SUBROUTINE cxios_read_data_k82_hdl 
    226389 
    227390      SUBROUTINE cxios_read_data_k82(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize) BIND(C) 
     
    233396      END SUBROUTINE cxios_read_data_k82 
    234397 
    235       SUBROUTINE cxios_read_data_k83(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
     398      SUBROUTINE cxios_read_data_k83_hdl(field_hdl, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
     399         USE ISO_C_BINDING 
     400         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     401         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     402         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize 
     403      END SUBROUTINE cxios_read_data_k83_hdl 
     404 
     405       SUBROUTINE cxios_read_data_k83(fieldid, fieldid_size, data_k8, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
    236406         USE ISO_C_BINDING 
    237407         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid 
     
    241411      END SUBROUTINE cxios_read_data_k83 
    242412 
    243       SUBROUTINE cxios_read_data_k84(fieldid, fieldid_size, data_k8, & 
     413     SUBROUTINE cxios_read_data_k84_hdl(field_hdl, data_k8, & 
     414                                      data_0size, data_1size, data_2size, & 
     415                                      data_3size) BIND(C) 
     416         USE ISO_C_BINDING 
     417         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     418         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     419         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     420         INTEGER  (kind = C_INT)   , VALUE        :: data_3size 
     421      END SUBROUTINE cxios_read_data_k84_hdl 
     422 
     423     SUBROUTINE cxios_read_data_k84(fieldid, fieldid_size, data_k8, & 
    244424                                      data_0size, data_1size, data_2size, & 
    245425                                      data_3size) BIND(C) 
     
    252432      END SUBROUTINE cxios_read_data_k84 
    253433 
     434      SUBROUTINE cxios_read_data_k85_hdl(field_hdl, data_k8, & 
     435                                      data_0size, data_1size, data_2size, & 
     436                                      data_3size, data_4size) BIND(C) 
     437         USE ISO_C_BINDING 
     438         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     439         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     440         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     441         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size 
     442      END SUBROUTINE cxios_read_data_k85_hdl 
     443 
    254444      SUBROUTINE cxios_read_data_k85(fieldid, fieldid_size, data_k8, & 
    255445                                      data_0size, data_1size, data_2size, & 
     
    263453      END SUBROUTINE cxios_read_data_k85 
    264454 
     455      SUBROUTINE cxios_read_data_k86_hdl(field_hdl, data_k8, & 
     456                                      data_0size, data_1size, data_2size, & 
     457                                      data_3size, data_4size, data_5size) BIND(C) 
     458         USE ISO_C_BINDING 
     459         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     460         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     461         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     462         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     463      END SUBROUTINE cxios_read_data_k86_hdl 
     464  
    265465      SUBROUTINE cxios_read_data_k86(fieldid, fieldid_size, data_k8, & 
    266466                                      data_0size, data_1size, data_2size, & 
     
    274474      END SUBROUTINE cxios_read_data_k86 
    275475 
    276       SUBROUTINE cxios_read_data_k87(fieldid, fieldid_size, data_k8, & 
     476      SUBROUTINE cxios_read_data_k87_hdl(field_hdl, data_k8, & 
    277477                                      data_0size, data_1size, data_2size, & 
    278478                                      data_3size, data_4size, data_5size, & 
    279479                                      data_6size) BIND(C) 
    280480         USE ISO_C_BINDING 
     481         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     482         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     483         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     484         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     485         INTEGER  (kind = C_INT)   , VALUE        :: data_6size 
     486      END SUBROUTINE cxios_read_data_k87_hdl 
     487 
     488      SUBROUTINE cxios_read_data_k87(fieldid, fieldid_size, data_k8, & 
     489                                      data_0size, data_1size, data_2size, & 
     490                                      data_3size, data_4size, data_5size, & 
     491                                      data_6size) BIND(C) 
     492         USE ISO_C_BINDING 
    281493         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: fieldid 
    282494         REAL     (kind = C_DOUBLE), DIMENSION(*) :: data_k8 
     
    287499      END SUBROUTINE cxios_read_data_k87 
    288500 
     501      SUBROUTINE cxios_read_data_k40_hdl(field_hdl, data_k4, data_Xsize) BIND(C) 
     502         USE ISO_C_BINDING 
     503         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     504         REAL     (kind = C_FLOAT)                :: data_k4 
     505         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     506      END SUBROUTINE cxios_read_data_k40_hdl 
     507 
    289508      SUBROUTINE cxios_read_data_k40(fieldid, fieldid_size, data_k4, data_Xsize) BIND(C) 
    290509         USE ISO_C_BINDING 
     
    295514      END SUBROUTINE cxios_read_data_k40 
    296515 
     516      SUBROUTINE cxios_read_data_k41_hdl(field_hdl, data_k4, data_Xsize) BIND(C) 
     517         USE ISO_C_BINDING 
     518         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     519         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     520         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
     521      END SUBROUTINE cxios_read_data_k41_hdl 
     522 
    297523      SUBROUTINE cxios_read_data_k41(fieldid, fieldid_size, data_k4, data_Xsize) BIND(C) 
    298524         USE ISO_C_BINDING 
     
    302528         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize 
    303529      END SUBROUTINE cxios_read_data_k41 
     530 
     531      SUBROUTINE cxios_read_data_k42_hdl(field_hdl, data_k4, data_Xsize, data_Ysize) BIND(C) 
     532         USE ISO_C_BINDING 
     533         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     534         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     535         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize 
     536      END SUBROUTINE cxios_read_data_k42_hdl 
    304537 
    305538      SUBROUTINE cxios_read_data_k42(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize) BIND(C) 
     
    311544      END SUBROUTINE cxios_read_data_k42 
    312545 
     546      SUBROUTINE cxios_read_data_k43_hdl(field_hdl, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
     547         USE ISO_C_BINDING 
     548         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     549         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     550         INTEGER  (kind = C_INT)   , VALUE        :: data_Xsize, data_Ysize, data_Zsize 
     551      END SUBROUTINE cxios_read_data_k43_hdl 
     552 
    313553      SUBROUTINE cxios_read_data_k43(fieldid, fieldid_size, data_k4, data_Xsize, data_Ysize, data_Zsize) BIND(C) 
    314554         USE ISO_C_BINDING 
     
    319559      END SUBROUTINE cxios_read_data_k43 
    320560 
     561      SUBROUTINE cxios_read_data_k44_hdl(field_hdl, data_k4, & 
     562                                      data_0size, data_1size, data_2size, & 
     563                                      data_3size) BIND(C) 
     564         USE ISO_C_BINDING 
     565         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     566         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     567         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     568         INTEGER  (kind = C_INT)   , VALUE        :: data_3size 
     569      END SUBROUTINE cxios_read_data_k44_hdl 
     570  
    321571      SUBROUTINE cxios_read_data_k44(fieldid, fieldid_size, data_k4, & 
    322572                                      data_0size, data_1size, data_2size, & 
     
    330580      END SUBROUTINE cxios_read_data_k44 
    331581 
     582      SUBROUTINE cxios_read_data_k45_hdl(field_hdl, data_k4, & 
     583                                      data_0size, data_1size, data_2size, & 
     584                                      data_3size, data_4size) BIND(C) 
     585         USE ISO_C_BINDING 
     586         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     587         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     588         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     589         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size 
     590      END SUBROUTINE cxios_read_data_k45_hdl 
     591 
    332592      SUBROUTINE cxios_read_data_k45(fieldid, fieldid_size, data_k4, & 
    333593                                      data_0size, data_1size, data_2size, & 
     
    341601      END SUBROUTINE cxios_read_data_k45 
    342602 
     603      SUBROUTINE cxios_read_data_k46_hdl(field_hdl, data_k4, & 
     604                                      data_0size, data_1size, data_2size, & 
     605                                      data_3size, data_4size, data_5size) BIND(C) 
     606         USE ISO_C_BINDING 
     607         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     608         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     609         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     610         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     611      END SUBROUTINE cxios_read_data_k46_hdl 
     612  
    343613      SUBROUTINE cxios_read_data_k46(fieldid, fieldid_size, data_k4, & 
    344614                                      data_0size, data_1size, data_2size, & 
     
    351621         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
    352622      END SUBROUTINE cxios_read_data_k46 
     623 
     624      SUBROUTINE cxios_read_data_k47_hdl(field_hdl, data_k4, & 
     625                                      data_0size, data_1size, data_2size, & 
     626                                      data_3size, data_4size, data_5size, & 
     627                                      data_6size) BIND(C) 
     628         USE ISO_C_BINDING 
     629         INTEGER  (kind = C_INTPTR_T), VALUE      :: field_hdl 
     630         REAL     (kind = C_FLOAT) , DIMENSION(*) :: data_k4 
     631         INTEGER  (kind = C_INT)   , VALUE        :: data_0size, data_1size, data_2size 
     632         INTEGER  (kind = C_INT)   , VALUE        :: data_3size, data_4size, data_5size 
     633         INTEGER  (kind = C_INT)   , VALUE        :: data_6size 
     634      END SUBROUTINE cxios_read_data_k47_hdl 
    353635 
    354636      SUBROUTINE cxios_read_data_k47(fieldid, fieldid_size, data_k4, & 
     
    394676         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
    395677         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
    396          LOGICAL  (kind = 4)                      :: data_logic 
     678         LOGICAL  (kind = C_BOOL)                 :: data_logic 
    397679         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
    398680      END SUBROUTINE cxios_get_variable_data_logic 
     
    436718         CHARACTER(kind = C_CHAR)  , DIMENSION(*) :: vardid 
    437719         INTEGER  (kind = C_INT)   , VALUE        :: varid_size 
    438          LOGICAL  (kind = 4)       , VALUE        :: data_logic 
     720         LOGICAL  (kind = C_BOOL)       , VALUE   :: data_logic 
    439721         LOGICAL  (kind = C_BOOL)                 :: is_var_existed 
    440722      END SUBROUTINE cxios_set_variable_data_logic 
     
    534816 
    535817   ! Send field functions 
     818   SUBROUTINE xios(send_field_r8_0d_hdl)(field_hdl, data_k8) 
     819   IMPLICIT NONE 
     820      TYPE(txios(field))              :: field_hdl 
     821      REAL     (kind = 8), INTENT(IN) :: data_k8 
     822      CALL cxios_write_data_k80_hdl(field_hdl%daddr, data_k8, 1) 
     823   END SUBROUTINE xios(send_field_r8_0d_hdl) 
     824 
    536825   SUBROUTINE xios(send_field_r8_0d)(fieldid, data_k8) 
    537826   IMPLICIT NONE 
     
    541830   END SUBROUTINE xios(send_field_r8_0d) 
    542831 
     832   SUBROUTINE xios(send_field_r8_1d_hdl)(field_hdl, data1d_k8) 
     833   IMPLICIT NONE 
     834      TYPE(txios(field))              :: field_hdl 
     835      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data1d_k8(:) 
     836      CALL cxios_write_data_k81_hdl(field_hdl%daddr, data1d_k8, size(data1d_k8, 1)) 
     837   END SUBROUTINE xios(send_field_r8_1d_hdl) 
     838 
    543839   SUBROUTINE xios(send_field_r8_1d)(fieldid, data1d_k8) 
    544840   IMPLICIT NONE 
     
    548844   END SUBROUTINE xios(send_field_r8_1d) 
    549845 
     846   SUBROUTINE  xios(send_field_r8_2d_hdl)(field_hdl, data2d_k8) 
     847   IMPLICIT NONE 
     848      TYPE(txios(field))              :: field_hdl 
     849      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data2d_k8(:,:) 
     850      CALL cxios_write_data_k82_hdl(field_hdl%daddr, data2d_k8, size(data2d_k8, 1), size(data2d_k8, 2)) 
     851   END SUBROUTINE  xios(send_field_r8_2d_hdl) 
     852 
    550853   SUBROUTINE  xios(send_field_r8_2d)(fieldid, data2d_k8) 
    551854   IMPLICIT NONE 
     
    555858   END SUBROUTINE  xios(send_field_r8_2d) 
    556859 
     860   SUBROUTINE  xios(send_field_r8_3d_hdl)(field_hdl, data3d_k8) 
     861   IMPLICIT NONE 
     862      TYPE(txios(field))              :: field_hdl 
     863      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data3d_k8(:,:,:) 
     864      CALL cxios_write_data_k83_hdl(field_hdl%daddr, data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3)) 
     865   END SUBROUTINE  xios(send_field_r8_3d_hdl) 
     866 
    557867   SUBROUTINE  xios(send_field_r8_3d)(fieldid, data3d_k8) 
    558868   IMPLICIT NONE 
     
    561871      CALL cxios_write_data_k83(fieldid, len(fieldid), data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3)) 
    562872   END SUBROUTINE  xios(send_field_r8_3d) 
     873 
     874   SUBROUTINE  xios(send_field_r8_4d_hdl)(field_hdl, data4d_k8) 
     875   IMPLICIT NONE 
     876      TYPE(txios(field))              :: field_hdl 
     877      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data4d_k8(:,:,:,:) 
     878      CALL cxios_write_data_k84_hdl(field_hdl%daddr, data4d_k8, & 
     879                                size(data4d_k8, 1), size(data4d_k8, 2), size(data4d_k8, 3), & 
     880                                size(data4d_k8, 4)) 
     881   END SUBROUTINE  xios(send_field_r8_4d_hdl) 
    563882 
    564883   SUBROUTINE  xios(send_field_r8_4d)(fieldid, data4d_k8) 
     
    571890   END SUBROUTINE  xios(send_field_r8_4d) 
    572891 
     892   SUBROUTINE  xios(send_field_r8_5d_hdl)(field_hdl, data5d_k8) 
     893   IMPLICIT NONE 
     894      TYPE(txios(field))              :: field_hdl 
     895      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data5d_k8(:,:,:,:,:) 
     896      CALL cxios_write_data_k85_hdl(field_hdl%daddr, data5d_k8, & 
     897                                size(data5d_k8, 1), size(data5d_k8, 2), size(data5d_k8, 3), & 
     898                                size(data5d_k8, 4), size(data5d_k8, 5)) 
     899   END SUBROUTINE  xios(send_field_r8_5d_hdl) 
     900 
    573901   SUBROUTINE  xios(send_field_r8_5d)(fieldid, data5d_k8) 
    574902   IMPLICIT NONE 
     
    580908   END SUBROUTINE  xios(send_field_r8_5d) 
    581909 
     910   SUBROUTINE  xios(send_field_r8_6d_hdl)(field_hdl, data6d_k8) 
     911   IMPLICIT NONE 
     912      TYPE(txios(field))              :: field_hdl 
     913      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data6d_k8(:,:,:,:,:,:) 
     914      CALL cxios_write_data_k86_hdl(field_hdl%daddr, data6d_k8, & 
     915                                size(data6d_k8, 1), size(data6d_k8, 2), size(data6d_k8, 3), & 
     916                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6)) 
     917   END SUBROUTINE  xios(send_field_r8_6d_hdl) 
     918 
    582919   SUBROUTINE  xios(send_field_r8_6d)(fieldid, data6d_k8) 
    583920   IMPLICIT NONE 
     
    588925                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6)) 
    589926   END SUBROUTINE  xios(send_field_r8_6d) 
     927 
     928   SUBROUTINE  xios(send_field_r8_7d_hdl)(field_hdl, data7d_k8) 
     929   IMPLICIT NONE 
     930      TYPE(txios(field))              :: field_hdl 
     931      REAL     (kind = 8), DIMENSION(*), INTENT(IN) :: data7d_k8(:,:,:,:,:,:,:) 
     932      CALL cxios_write_data_k87_hdl(field_hdl%daddr, data7d_k8, & 
     933                                size(data7d_k8, 1), size(data7d_k8, 2), size(data7d_k8, 3), & 
     934                                size(data7d_k8, 4), size(data7d_k8, 5), size(data7d_k8, 6), & 
     935                                size(data7d_k8, 7)) 
     936   END SUBROUTINE  xios(send_field_r8_7d_hdl) 
    590937 
    591938   SUBROUTINE  xios(send_field_r8_7d)(fieldid, data7d_k8) 
     
    599946   END SUBROUTINE  xios(send_field_r8_7d) 
    600947 
     948   SUBROUTINE xios(send_field_r4_0d_hdl)(field_hdl, data_k4) 
     949   IMPLICIT NONE 
     950      TYPE(txios(field))              :: field_hdl 
     951      REAL     (kind = 4), INTENT(IN) :: data_k4 
     952      CALL cxios_write_data_k40_hdl(field_hdl%daddr, data_k4, 1) 
     953   END SUBROUTINE xios(send_field_r4_0d_hdl) 
     954 
    601955   SUBROUTINE xios(send_field_r4_0d)(fieldid, data_k4) 
    602956   IMPLICIT NONE 
     
    606960   END SUBROUTINE xios(send_field_r4_0d) 
    607961 
     962   SUBROUTINE xios(send_field_r4_1d_hdl)(field_hdl, data1d_k4) 
     963   IMPLICIT NONE 
     964      TYPE(txios(field))              :: field_hdl 
     965      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data1d_k4(:) 
     966      CALL cxios_write_data_k41_hdl(field_hdl%daddr, data1d_k4, size(data1d_k4, 1)) 
     967   END SUBROUTINE xios(send_field_r4_1d_hdl) 
     968 
    608969   SUBROUTINE xios(send_field_r4_1d)(fieldid, data1d_k4) 
    609970   IMPLICIT NONE 
     
    613974   END SUBROUTINE xios(send_field_r4_1d) 
    614975 
     976   SUBROUTINE xios(send_field_r4_2d_hdl)(field_hdl, data2d_k4) 
     977   IMPLICIT NONE 
     978      TYPE(txios(field))              :: field_hdl 
     979      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data2d_k4(:,:) 
     980      CALL cxios_write_data_k42_hdl(field_hdl%daddr, data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2)) 
     981   END SUBROUTINE xios(send_field_r4_2d_hdl) 
     982 
    615983   SUBROUTINE xios(send_field_r4_2d)(fieldid, data2d_k4) 
    616984   IMPLICIT NONE 
     
    620988   END SUBROUTINE xios(send_field_r4_2d) 
    621989 
     990   SUBROUTINE xios(send_field_r4_3d_hdl)(field_hdl, data3d_k4) 
     991   IMPLICIT NONE 
     992      TYPE(txios(field))              :: field_hdl 
     993      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data3d_k4(:,:,:) 
     994      CALL cxios_write_data_k43_hdl(field_hdl%daddr, data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3)) 
     995   END SUBROUTINE xios(send_field_r4_3d_hdl) 
     996 
    622997   SUBROUTINE xios(send_field_r4_3d)(fieldid, data3d_k4) 
    623998   IMPLICIT NONE 
     
    6271002   END SUBROUTINE xios(send_field_r4_3d) 
    6281003 
     1004   SUBROUTINE  xios(send_field_r4_4d_hdl)(field_hdl, data4d_k4) 
     1005   IMPLICIT NONE 
     1006      TYPE(txios(field))              :: field_hdl 
     1007      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data4d_k4(:,:,:,:) 
     1008      CALL cxios_write_data_k44_hdl(field_hdl%daddr, data4d_k4, & 
     1009                                size(data4d_k4, 1), size(data4d_k4, 2), size(data4d_k4, 3), & 
     1010                                size(data4d_k4, 4)) 
     1011   END SUBROUTINE  xios(send_field_r4_4d_hdl) 
     1012    
    6291013   SUBROUTINE  xios(send_field_r4_4d)(fieldid, data4d_k4) 
    6301014   IMPLICIT NONE 
     
    6361020   END SUBROUTINE  xios(send_field_r4_4d) 
    6371021 
     1022   SUBROUTINE  xios(send_field_r4_5d_hdl)(field_hdl, data5d_k4) 
     1023   IMPLICIT NONE 
     1024      TYPE(txios(field))              :: field_hdl 
     1025      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data5d_k4(:,:,:,:,:) 
     1026      CALL cxios_write_data_k45_hdl(field_hdl%daddr, data5d_k4, & 
     1027                                size(data5d_k4, 1), size(data5d_k4, 2), size(data5d_k4, 3), & 
     1028                                size(data5d_k4, 4), size(data5d_k4, 5)) 
     1029   END SUBROUTINE  xios(send_field_r4_5d_hdl) 
     1030 
    6381031   SUBROUTINE  xios(send_field_r4_5d)(fieldid, data5d_k4) 
    6391032   IMPLICIT NONE 
     
    6451038   END SUBROUTINE  xios(send_field_r4_5d) 
    6461039 
     1040   SUBROUTINE  xios(send_field_r4_6d_hdl)(field_hdl, data6d_k4) 
     1041   IMPLICIT NONE 
     1042      TYPE(txios(field))              :: field_hdl 
     1043      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data6d_k4(:,:,:,:,:,:) 
     1044      CALL cxios_write_data_k46_hdl(field_hdl%daddr, data6d_k4, & 
     1045                                size(data6d_k4, 1), size(data6d_k4, 2), size(data6d_k4, 3), & 
     1046                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6)) 
     1047   END SUBROUTINE  xios(send_field_r4_6d_hdl) 
     1048    
    6471049   SUBROUTINE  xios(send_field_r4_6d)(fieldid, data6d_k4) 
    6481050   IMPLICIT NONE 
     
    6541056   END SUBROUTINE  xios(send_field_r4_6d) 
    6551057 
     1058   SUBROUTINE  xios(send_field_r4_7d_hdl)(field_hdl, data7d_k4) 
     1059   IMPLICIT NONE 
     1060      TYPE(txios(field))              :: field_hdl 
     1061      REAL     (kind = 4), DIMENSION(*), INTENT(IN) :: data7d_k4(:,:,:,:,:,:,:) 
     1062      CALL cxios_write_data_k47_hdl(field_hdl%daddr, data7d_k4, & 
     1063                                size(data7d_k4, 1), size(data7d_k4, 2), size(data7d_k4, 3), & 
     1064                                size(data7d_k4, 4), size(data7d_k4, 5), size(data7d_k4, 6), & 
     1065                                size(data7d_k4, 7)) 
     1066   END SUBROUTINE  xios(send_field_r4_7d_hdl) 
     1067    
    6561068   SUBROUTINE  xios(send_field_r4_7d)(fieldid, data7d_k4) 
    6571069   IMPLICIT NONE 
     
    6651077 
    6661078   ! Receive field functions 
     1079   SUBROUTINE xios(recv_field_r8_0d_hdl)(field_hdl, data0d_k8) 
     1080   IMPLICIT NONE 
     1081      TYPE(txios(field))              :: field_hdl 
     1082      REAL     (kind = 8)              , INTENT(OUT):: data0d_k8 
     1083      CALL cxios_read_data_k80_hdl(field_hdl%daddr, data0d_k8, 1) 
     1084   END SUBROUTINE xios(recv_field_r8_0d_hdl) 
     1085 
    6671086   SUBROUTINE xios(recv_field_r8_0d)(fieldid, data0d_k8) 
    6681087   IMPLICIT NONE 
     
    6721091   END SUBROUTINE xios(recv_field_r8_0d) 
    6731092 
     1093   SUBROUTINE xios(recv_field_r8_1d_hdl)(field_hdl, data1d_k8) 
     1094   IMPLICIT NONE 
     1095      TYPE(txios(field))              :: field_hdl 
     1096      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data1d_k8(:) 
     1097      CALL cxios_read_data_k81_hdl(field_hdl%daddr, data1d_k8, size(data1d_k8, 1)) 
     1098   END SUBROUTINE xios(recv_field_r8_1d_hdl) 
     1099 
    6741100   SUBROUTINE xios(recv_field_r8_1d)(fieldid, data1d_k8) 
    6751101   IMPLICIT NONE 
     
    6791105   END SUBROUTINE xios(recv_field_r8_1d) 
    6801106 
     1107   SUBROUTINE  xios(recv_field_r8_2d_hdl)(field_hdl, data2d_k8) 
     1108   IMPLICIT NONE 
     1109      TYPE(txios(field))              :: field_hdl 
     1110      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data2d_k8(:,:) 
     1111      CALL cxios_read_data_k82_hdl(field_hdl%daddr, data2d_k8, size(data2d_k8, 1), size(data2d_k8, 2)) 
     1112   END SUBROUTINE  xios(recv_field_r8_2d_hdl) 
     1113 
    6811114   SUBROUTINE  xios(recv_field_r8_2d)(fieldid, data2d_k8) 
    6821115   IMPLICIT NONE 
     
    6861119   END SUBROUTINE  xios(recv_field_r8_2d) 
    6871120 
     1121   SUBROUTINE  xios(recv_field_r8_3d_hdl)(field_hdl, data3d_k8) 
     1122   IMPLICIT NONE 
     1123      TYPE(txios(field))              :: field_hdl 
     1124      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data3d_k8(:,:,:) 
     1125      CALL cxios_read_data_k83_hdl(field_hdl%daddr, data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3)) 
     1126   END SUBROUTINE  xios(recv_field_r8_3d_hdl) 
     1127 
    6881128   SUBROUTINE  xios(recv_field_r8_3d)(fieldid, data3d_k8) 
    6891129   IMPLICIT NONE 
     
    6921132      CALL cxios_read_data_k83(fieldid, len(fieldid), data3d_k8, size(data3d_k8, 1), size(data3d_k8, 2), size(data3d_k8, 3)) 
    6931133   END SUBROUTINE  xios(recv_field_r8_3d) 
     1134 
     1135   SUBROUTINE  xios(recv_field_r8_4d_hdl)(field_hdl, data4d_k8) 
     1136   IMPLICIT NONE 
     1137      TYPE(txios(field))              :: field_hdl 
     1138      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data4d_k8(:,:,:,:) 
     1139      CALL cxios_read_data_k84_hdl(field_hdl%daddr, data4d_k8, & 
     1140                                size(data4d_k8, 1), size(data4d_k8, 2), size(data4d_k8, 3), & 
     1141                                size(data4d_k8, 4)) 
     1142   END SUBROUTINE  xios(recv_field_r8_4d_hdl) 
    6941143 
    6951144   SUBROUTINE  xios(recv_field_r8_4d)(fieldid, data4d_k8) 
     
    7021151   END SUBROUTINE  xios(recv_field_r8_4d) 
    7031152 
     1153   SUBROUTINE  xios(recv_field_r8_5d_hdl)(field_hdl, data5d_k8) 
     1154   IMPLICIT NONE 
     1155      TYPE(txios(field))              :: field_hdl 
     1156      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data5d_k8(:,:,:,:,:) 
     1157      CALL cxios_read_data_k85_hdl(field_hdl%daddr, data5d_k8, & 
     1158                                size(data5d_k8, 1), size(data5d_k8, 2), size(data5d_k8, 3), & 
     1159                                size(data5d_k8, 4), size(data5d_k8, 5)) 
     1160   END SUBROUTINE  xios(recv_field_r8_5d_hdl) 
     1161 
    7041162   SUBROUTINE  xios(recv_field_r8_5d)(fieldid, data5d_k8) 
    7051163   IMPLICIT NONE 
     
    7111169   END SUBROUTINE  xios(recv_field_r8_5d) 
    7121170 
     1171   SUBROUTINE  xios(recv_field_r8_6d_hdl)(field_hdl, data6d_k8) 
     1172   IMPLICIT NONE 
     1173      TYPE(txios(field))              :: field_hdl 
     1174      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data6d_k8(:,:,:,:,:,:) 
     1175      CALL cxios_read_data_k86_hdl(field_hdl%daddr, data6d_k8, & 
     1176                                size(data6d_k8, 1), size(data6d_k8, 2), size(data6d_k8, 3), & 
     1177                                size(data6d_k8, 4), size(data6d_k8, 5), size(data6d_k8, 6)) 
     1178   END SUBROUTINE  xios(recv_field_r8_6d_hdl) 
     1179 
    7131180   SUBROUTINE  xios(recv_field_r8_6d)(fieldid, data6d_k8) 
    7141181   IMPLICIT NONE 
     
    7201187   END SUBROUTINE  xios(recv_field_r8_6d) 
    7211188 
    722    SUBROUTINE  xios(recv_field_r8_7d)(fieldid, data7d_k8) 
     1189  SUBROUTINE  xios(recv_field_r8_7d_hdl)(field_hdl, data7d_k8) 
     1190   IMPLICIT NONE 
     1191      TYPE(txios(field))              :: field_hdl 
     1192      REAL     (kind = 8), DIMENSION(*), INTENT(OUT) :: data7d_k8(:,:,:,:,:,:,:) 
     1193      CALL cxios_read_data_k87_hdl(field_hdl%daddr, data7d_k8, & 
     1194                                size(data7d_k8, 1), size(data7d_k8, 2), size(data7d_k8, 3), & 
     1195                                size(data7d_k8, 4), size(data7d_k8, 5), size(data7d_k8, 6), & 
     1196                                size(data7d_k8, 7)) 
     1197   END SUBROUTINE  xios(recv_field_r8_7d_hdl) 
     1198 
     1199  SUBROUTINE  xios(recv_field_r8_7d)(fieldid, data7d_k8) 
    7231200   IMPLICIT NONE 
    7241201      CHARACTER(len = *)               , INTENT(IN) :: fieldid 
     
    7301207   END SUBROUTINE  xios(recv_field_r8_7d) 
    7311208 
     1209   SUBROUTINE xios(recv_field_r4_0d_hdl)(field_hdl, data0d_k4) 
     1210   IMPLICIT NONE 
     1211      TYPE(txios(field))              :: field_hdl 
     1212      REAL     (kind = 4)              , INTENT(OUT):: data0d_k4 
     1213      CALL cxios_read_data_k40_hdl(field_hdl%daddr, data0d_k4, 1) 
     1214   END SUBROUTINE xios(recv_field_r4_0d_hdl) 
     1215 
    7321216   SUBROUTINE xios(recv_field_r4_0d)(fieldid, data0d_k4) 
    7331217   IMPLICIT NONE 
     
    7371221   END SUBROUTINE xios(recv_field_r4_0d) 
    7381222 
     1223   SUBROUTINE xios(recv_field_r4_1d_hdl)(field_hdl, data1d_k4) 
     1224   IMPLICIT NONE 
     1225      TYPE(txios(field))              :: field_hdl 
     1226      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data1d_k4(:) 
     1227      CALL cxios_read_data_k41_hdl(field_hdl%daddr, data1d_k4, size(data1d_k4, 1)) 
     1228   END SUBROUTINE xios(recv_field_r4_1d_hdl) 
     1229 
    7391230   SUBROUTINE xios(recv_field_r4_1d)(fieldid, data1d_k4) 
    7401231   IMPLICIT NONE 
     
    7441235   END SUBROUTINE xios(recv_field_r4_1d) 
    7451236 
     1237   SUBROUTINE xios(recv_field_r4_2d_hdl)(field_hdl, data2d_k4) 
     1238   IMPLICIT NONE 
     1239      TYPE(txios(field))              :: field_hdl 
     1240      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data2d_k4(:,:) 
     1241      CALL cxios_read_data_k42_hdl(field_hdl%daddr, data2d_k4, size(data2d_k4, 1), size(data2d_k4, 2)) 
     1242   END SUBROUTINE xios(recv_field_r4_2d_hdl) 
     1243 
    7461244   SUBROUTINE xios(recv_field_r4_2d)(fieldid, data2d_k4) 
    7471245   IMPLICIT NONE 
     
    7511249   END SUBROUTINE xios(recv_field_r4_2d) 
    7521250 
     1251   SUBROUTINE xios(recv_field_r4_3d_hdl)(field_hdl, data3d_k4) 
     1252   IMPLICIT NONE 
     1253      TYPE(txios(field))              :: field_hdl 
     1254      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data3d_k4(:,:,:) 
     1255      CALL cxios_read_data_k43_hdl(field_hdl%daddr, data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3)) 
     1256   END SUBROUTINE xios(recv_field_r4_3d_hdl) 
     1257 
    7531258   SUBROUTINE xios(recv_field_r4_3d)(fieldid, data3d_k4) 
    7541259   IMPLICIT NONE 
     
    7571262      CALL cxios_read_data_k43(fieldid, len(fieldid), data3d_k4, size(data3d_k4, 1), size(data3d_k4, 2), size(data3d_k4, 3)) 
    7581263   END SUBROUTINE xios(recv_field_r4_3d) 
     1264 
     1265   SUBROUTINE  xios(recv_field_r4_4d_hdl)(field_hdl, data4d_k4) 
     1266   IMPLICIT NONE 
     1267      TYPE(txios(field))              :: field_hdl 
     1268      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data4d_k4(:,:,:,:) 
     1269      CALL cxios_read_data_k44_hdl(field_hdl%daddr, data4d_k4, & 
     1270                                size(data4d_k4, 1), size(data4d_k4, 2), size(data4d_k4, 3), & 
     1271                                size(data4d_k4, 4)) 
     1272   END SUBROUTINE  xios(recv_field_r4_4d_hdl) 
    7591273 
    7601274   SUBROUTINE  xios(recv_field_r4_4d)(fieldid, data4d_k4) 
     
    7671281   END SUBROUTINE  xios(recv_field_r4_4d) 
    7681282 
     1283   SUBROUTINE  xios(recv_field_r4_5d_hdl)(field_hdl, data5d_k4) 
     1284   IMPLICIT NONE 
     1285      TYPE(txios(field))              :: field_hdl 
     1286      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data5d_k4(:,:,:,:,:) 
     1287      CALL cxios_read_data_k45_hdl(field_hdl%daddr, data5d_k4, & 
     1288                                size(data5d_k4, 1), size(data5d_k4, 2), size(data5d_k4, 3), & 
     1289                                size(data5d_k4, 4), size(data5d_k4, 5)) 
     1290   END SUBROUTINE  xios(recv_field_r4_5d_hdl) 
     1291 
    7691292   SUBROUTINE  xios(recv_field_r4_5d)(fieldid, data5d_k4) 
    7701293   IMPLICIT NONE 
     
    7761299   END SUBROUTINE  xios(recv_field_r4_5d) 
    7771300 
     1301   SUBROUTINE  xios(recv_field_r4_6d_hdl)(field_hdl, data6d_k4) 
     1302   IMPLICIT NONE 
     1303      TYPE(txios(field))              :: field_hdl 
     1304      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data6d_k4(:,:,:,:,:,:) 
     1305      CALL cxios_read_data_k46_hdl(field_hdl%daddr, data6d_k4, & 
     1306                                size(data6d_k4, 1), size(data6d_k4, 2), size(data6d_k4, 3), & 
     1307                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6)) 
     1308   END SUBROUTINE  xios(recv_field_r4_6d_hdl) 
     1309 
    7781310   SUBROUTINE  xios(recv_field_r4_6d)(fieldid, data6d_k4) 
    7791311   IMPLICIT NONE 
     
    7841316                                size(data6d_k4, 4), size(data6d_k4, 5), size(data6d_k4, 6)) 
    7851317   END SUBROUTINE  xios(recv_field_r4_6d) 
     1318 
     1319   SUBROUTINE  xios(recv_field_r4_7d_hdl)(field_hdl, data7d_k4) 
     1320   IMPLICIT NONE 
     1321      TYPE(txios(field))              :: field_hdl 
     1322      REAL     (kind = 4), DIMENSION(*), INTENT(OUT) :: data7d_k4(:,:,:,:,:,:,:) 
     1323      CALL cxios_read_data_k47_hdl(field_hdl%daddr, data7d_k4, & 
     1324                                size(data7d_k4, 1), size(data7d_k4, 2), size(data7d_k4, 3), & 
     1325                                size(data7d_k4, 4), size(data7d_k4, 5), size(data7d_k4, 6), & 
     1326                                size(data7d_k4, 7)) 
     1327   END SUBROUTINE  xios(recv_field_r4_7d_hdl) 
    7861328 
    7871329   SUBROUTINE  xios(recv_field_r4_7d)(fieldid, data7d_k4) 
     
    7971339   ! Get variable functions 
    7981340   LOGICAL FUNCTION xios(getVar_k8)(varId, data_k8) 
    799    IMPLICIT NONE 
    800       LOGICAL  (kind = 1)                           :: val 
     1341   USE ISO_C_BINDING 
     1342   IMPLICIT NONE 
     1343      LOGICAL  (kind = C_BOOL)                      :: val 
    8011344      CHARACTER(len = *)               , INTENT(IN) :: varId 
    8021345      REAL     (kind = 8)              , INTENT(OUT):: data_k8 
     
    8081351 
    8091352   LOGICAL FUNCTION xios(getVar_k4)(varId, data_k4) 
    810    IMPLICIT NONE 
    811       LOGICAL  (kind = 1)                           :: val 
     1353   USE ISO_C_BINDING 
     1354   IMPLICIT NONE 
     1355      LOGICAL  (kind = C_BOOL)                      :: val 
    8121356      CHARACTER(len = *)               , INTENT(IN) :: varId 
    8131357      REAL     (kind = 4)              , INTENT(OUT):: data_k4 
     
    8191363 
    8201364   LOGICAL FUNCTION xios(getVar_int)(varId, data_int) 
    821    IMPLICIT NONE 
    822       LOGICAL  (kind = 1)                           :: val 
     1365   USE ISO_C_BINDING 
     1366   IMPLICIT NONE 
     1367      LOGICAL  (kind = C_BOOL)                      :: val 
    8231368      CHARACTER(len = *)               , INTENT(IN) :: varId 
    8241369      INTEGER                          , INTENT(OUT):: data_int 
     
    8301375 
    8311376   LOGICAL FUNCTION xios(getVar_logic)(varId, data_logic) 
    832    IMPLICIT NONE 
    833       LOGICAL  (kind = 1)                           :: val 
     1377   USE ISO_C_BINDING 
     1378   IMPLICIT NONE 
     1379      LOGICAL  (kind = C_BOOL)                      :: val 
    8341380      CHARACTER(len  = *)              , INTENT(IN) :: varId 
    835       LOGICAL  (kind = 4)              , INTENT(OUT):: data_logic 
    836  
    837       CALL cxios_get_variable_data_logic(varId, len(varId), data_logic, val) 
    838  
     1381      LOGICAL  ,INTENT(OUT)                         :: data_logic 
     1382      LOGICAL (C_BOOL)                              :: data_tmp 
     1383 
     1384      CALL cxios_get_variable_data_logic(varId, len(varId), data_tmp, val) 
    8391385      xios(getVar_logic) = val 
     1386      IF (val) data_logic = data_tmp 
    8401387   END FUNCTION xios(getVar_logic) 
    8411388 
    8421389   LOGICAL FUNCTION xios(getVar_char)(varId, data_char) 
    843    IMPLICIT NONE 
    844       LOGICAL  (kind = 1)                           :: val 
     1390   USE ISO_C_BINDING 
     1391   IMPLICIT NONE 
     1392      LOGICAL  (kind = C_BOOL)                      :: val 
    8451393      CHARACTER(len  = *)              , INTENT(IN) :: varId 
    8461394      CHARACTER(len  = *)              , INTENT(OUT):: data_char 
     
    8531401   ! Set variable functions 
    8541402   LOGICAL FUNCTION xios(setVar_k8)(varId, data_k8) 
    855    IMPLICIT NONE 
    856       LOGICAL  (kind = 1)                           :: val 
     1403   USE ISO_C_BINDING 
     1404   IMPLICIT NONE 
     1405      LOGICAL  (kind = C_BOOL)                      :: val 
    8571406      CHARACTER(len = *)               , INTENT(IN) :: varId 
    8581407      REAL     (kind = 8)              , INTENT(IN) :: data_k8 
     
    8641413 
    8651414   LOGICAL FUNCTION xios(setVar_k4)(varId, data_k4) 
    866    IMPLICIT NONE 
    867       LOGICAL  (kind = 1)                           :: val 
     1415   USE ISO_C_BINDING 
     1416   IMPLICIT NONE 
     1417      LOGICAL  (kind = C_BOOL)                      :: val 
    8681418      CHARACTER(len = *)               , INTENT(IN) :: varId 
    8691419      REAL     (kind = 4)              , INTENT(IN) :: data_k4 
     
    8751425 
    8761426   LOGICAL FUNCTION xios(setVar_int)(varId, data_int) 
    877    IMPLICIT NONE 
    878       LOGICAL  (kind = 1)                           :: val 
     1427   USE ISO_C_BINDING 
     1428   IMPLICIT NONE 
     1429      LOGICAL  (kind = C_BOOL)                           :: val 
    8791430      CHARACTER(len = *)               , INTENT(IN) :: varId 
    8801431      INTEGER                          , INTENT(IN) :: data_int 
     
    8861437 
    8871438   LOGICAL FUNCTION xios(setVar_logic)(varId, data_logic) 
    888    IMPLICIT NONE 
    889       LOGICAL  (kind = 1)                           :: val 
     1439   USE ISO_C_BINDING 
     1440   IMPLICIT NONE 
     1441      LOGICAL(kind = C_BOOL)                        :: val 
    8901442      CHARACTER(len  = *)              , INTENT(IN) :: varId 
    891       LOGICAL  (kind = 4)              , INTENT(IN) :: data_logic 
    892  
    893       CALL cxios_set_variable_data_logic(varId, len(varId), data_logic, val) 
     1443      LOGICAL                          , INTENT(IN) :: data_logic 
     1444      LOGICAL  (kind = C_BOOL)                      :: data_tmp 
     1445 
     1446      data_tmp = data_logic 
     1447      CALL cxios_set_variable_data_logic(varId, len(varId), data_tmp, val) 
    8941448 
    8951449      xios(setVar_logic) = val 
     
    8971451 
    8981452   LOGICAL FUNCTION xios(setVar_char)(varId, data_char) 
    899    IMPLICIT NONE 
    900       LOGICAL  (kind = 1)                           :: val 
     1453   USE ISO_C_BINDING 
     1454   IMPLICIT NONE 
     1455      LOGICAL  (kind = C_BOOL)                      :: val 
    9011456      CHARACTER(len  = *)              , INTENT(IN) :: varId 
    9021457      CHARACTER(len  = *)              , INTENT(IN) :: data_char 
  • XIOS/dev/dev_trunk_graph/src/interface/fortran/ixios_interfaces.F90

    r981 r2137  
    1111                  xios(send_field_r4_0d), xios(send_field_r4_1d), xios(send_field_r4_2d), xios(send_field_r4_3d), & 
    1212                  xios(send_field_r4_4d), xios(send_field_r4_5d), xios(send_field_r4_6d), xios(send_field_r4_7d), & 
     13                  xios(send_field_r8_0d_hdl), xios(send_field_r8_1d_hdl), xios(send_field_r8_2d_hdl), xios(send_field_r8_3d_hdl), & 
     14                  xios(send_field_r8_4d_hdl), xios(send_field_r8_5d_hdl), xios(send_field_r8_6d_hdl), xios(send_field_r8_7d_hdl), & 
     15                  xios(send_field_r4_0d_hdl), xios(send_field_r4_1d_hdl), xios(send_field_r4_2d_hdl), xios(send_field_r4_3d_hdl), & 
     16                  xios(send_field_r4_4d_hdl), xios(send_field_r4_5d_hdl), xios(send_field_r4_6d_hdl), xios(send_field_r4_7d_hdl), & 
    1317                  xios(recv_field_r8_0d), xios(recv_field_r8_1d), xios(recv_field_r8_2d), xios(recv_field_r8_3d), & 
    1418                  xios(recv_field_r8_4d), xios(recv_field_r8_5d), xios(recv_field_r8_6d), xios(recv_field_r8_7d), & 
    1519                  xios(recv_field_r4_0d), xios(recv_field_r4_1d), xios(recv_field_r4_2d), xios(recv_field_r4_3d), & 
    1620                  xios(recv_field_r4_4d), xios(recv_field_r4_5d), xios(recv_field_r4_6d), xios(recv_field_r4_7d), & 
     21                  xios(recv_field_r8_0d_hdl), xios(recv_field_r8_1d_hdl), xios(recv_field_r8_2d_hdl), xios(recv_field_r8_3d_hdl), & 
     22                  xios(recv_field_r8_4d_hdl), xios(recv_field_r8_5d_hdl), xios(recv_field_r8_6d_hdl), xios(recv_field_r8_7d_hdl), & 
     23                  xios(recv_field_r4_0d_hdl), xios(recv_field_r4_1d_hdl), xios(recv_field_r4_2d_hdl), xios(recv_field_r4_3d_hdl), & 
     24                  xios(recv_field_r4_4d_hdl), xios(recv_field_r4_5d_hdl), xios(recv_field_r4_6d_hdl), xios(recv_field_r4_7d_hdl), & 
    1725                  xios(getVar_k8), xios(getVar_k4), xios(getVar_int), xios(getVar_logic), xios(getVar_char),      & 
    1826                  xios(setVar_k8), xios(setVar_k4), xios(setVar_int), xios(setVar_logic), xios(setVar_char) 
     
    239247                   xios(send_field_r8_4d), xios(send_field_r8_5d), xios(send_field_r8_6d), xios(send_field_r8_7d), & 
    240248                   xios(send_field_r4_0d), xios(send_field_r4_1d), xios(send_field_r4_2d), xios(send_field_r4_3d), & 
    241                    xios(send_field_r4_4d), xios(send_field_r4_5d), xios(send_field_r4_6d), xios(send_field_r4_7d) 
     249                   xios(send_field_r4_4d), xios(send_field_r4_5d), xios(send_field_r4_6d), xios(send_field_r4_7d), & 
     250                   xios(send_field_r8_0d_hdl), xios(send_field_r8_1d_hdl), xios(send_field_r8_2d_hdl), xios(send_field_r8_3d_hdl), & 
     251                   xios(send_field_r8_4d_hdl), xios(send_field_r8_5d_hdl), xios(send_field_r8_6d_hdl), xios(send_field_r8_7d_hdl), & 
     252                   xios(send_field_r4_0d_hdl), xios(send_field_r4_1d_hdl), xios(send_field_r4_2d_hdl), xios(send_field_r4_3d_hdl), & 
     253                   xios(send_field_r4_4d_hdl), xios(send_field_r4_5d_hdl), xios(send_field_r4_6d_hdl), xios(send_field_r4_7d_hdl) 
    242254END INTERFACE xios(send_field) 
    243255 
     
    246258                   xios(recv_field_r8_4d), xios(recv_field_r8_5d), xios(recv_field_r8_6d), xios(recv_field_r8_7d), & 
    247259                   xios(recv_field_r4_0d), xios(recv_field_r4_1d), xios(recv_field_r4_2d), xios(recv_field_r4_3d), & 
    248                    xios(recv_field_r4_4d), xios(recv_field_r4_5d), xios(recv_field_r4_6d), xios(recv_field_r4_7d) 
     260                   xios(recv_field_r4_4d), xios(recv_field_r4_5d), xios(recv_field_r4_6d), xios(recv_field_r4_7d), & 
     261                   xios(recv_field_r8_0d_hdl), xios(recv_field_r8_1d_hdl), xios(recv_field_r8_2d_hdl), xios(recv_field_r8_3d_hdl), & 
     262                   xios(recv_field_r8_4d_hdl), xios(recv_field_r8_5d_hdl), xios(recv_field_r8_6d_hdl), xios(recv_field_r8_7d_hdl), & 
     263                   xios(recv_field_r4_0d_hdl), xios(recv_field_r4_1d_hdl), xios(recv_field_r4_2d_hdl), xios(recv_field_r4_3d_hdl), & 
     264                   xios(recv_field_r4_4d_hdl), xios(recv_field_r4_5d_hdl), xios(recv_field_r4_6d_hdl), xios(recv_field_r4_7d_hdl) 
    249265END INTERFACE xios(recv_field) 
    250266 
  • XIOS/dev/dev_trunk_graph/src/manager/daemons_manager.hpp

    r2019 r2137  
    11#ifndef __DAEMONS_MANAGER_HPP__ 
    22#define __DAEMONS_MANAGER_HPP__ 
     3#include <cstddef> 
    34 
    45namespace xios 
     
    1617    bool servicesEventLoop(void) ; 
    1718     
     19    void scheduleContext(size_t hashId) { scheduledContext_=hashId ;} //!< for attached mode, give the hand to the associated context server 
     20    bool isScheduledContext(size_t hashId) { return scheduledContext_==hashId ;} //!< for attached mode, return true if context server is sceduled 
     21    void unscheduleContext(void) { scheduledContext_=0 ;} //!< for attached mode : unschedule context 
     22 
    1823    private: 
    1924    bool isServer_ ; 
     25    size_t scheduledContext_ = 0 ; //!< Hash id of the next scehduled context for attached mode 
    2026  } ; 
    2127} 
  • XIOS/dev/dev_trunk_graph/src/manager/server_context.hpp

    r2019 r2137  
    3333    void freeComm(void) ; 
    3434    bool isAttachedMode(void) { return isAttachedMode_ ;} 
     35    CService* getParentService(void) {return parentService_ ; } 
     36 
    3537    private: 
    3638    void createIntercomm(void) ; 
  • XIOS/dev/dev_trunk_graph/src/manager/services.hpp

    r2019 r2137  
    3737    int getType(void) {return type_;} 
    3838    int getNbPartitions(void) {return nbPartitions_;} 
    39  
     39     
    4040    private: 
    4141    void sendNotification(int rank) ; 
  • XIOS/dev/dev_trunk_graph/src/mpi_tools.cpp

    r2019 r2137  
    2727  } 
    2828 
     29  template<> 
     30  MPI_Datatype MPI_GetType<char>(void) { return MPI_CHAR ;} 
     31 
     32  template<> 
     33  MPI_Datatype MPI_GetType<short int>(void) { return MPI_SHORT ;} 
     34 
     35  template<> 
     36  MPI_Datatype MPI_GetType<int>(void) { return MPI_INT ;} 
     37 
     38  template<> 
     39  MPI_Datatype MPI_GetType<size_t>(void) { return MPI_SIZE_T ;} 
     40 
     41  template<> 
     42  MPI_Datatype MPI_GetType<float>(void) { return MPI_FLOAT ;} 
     43 
     44  template<> 
     45  MPI_Datatype MPI_GetType<double>(void) { return MPI_DOUBLE ;} 
     46 
     47  template<> 
     48  MPI_Datatype MPI_GetType<long double>(void) { return MPI_LONG_DOUBLE ;} 
     49 
    2950} 
  • XIOS/dev/dev_trunk_graph/src/mpi_tools.hpp

    r2019 r2137  
    1313 
    1414  template<> 
    15   MPI_Datatype MPI_GetType<char>(void) { return MPI_CHAR ;} 
     15  MPI_Datatype MPI_GetType<char>(void); 
    1616 
    1717  template<> 
    18   MPI_Datatype MPI_GetType<short int>(void) { return MPI_SHORT ;} 
     18  MPI_Datatype MPI_GetType<short int>(void); 
    1919 
    2020  template<> 
    21   MPI_Datatype MPI_GetType<int>(void) { return MPI_INT ;} 
     21  MPI_Datatype MPI_GetType<int>(void); 
    2222 
    2323  template<> 
    24   MPI_Datatype MPI_GetType<size_t>(void) { return MPI_SIZE_T ;} 
     24  MPI_Datatype MPI_GetType<size_t>(void); 
    2525 
    2626  template<> 
    27   MPI_Datatype MPI_GetType<float>(void) { return MPI_FLOAT ;} 
     27  MPI_Datatype MPI_GetType<float>(void); 
    2828 
    2929  template<> 
    30   MPI_Datatype MPI_GetType<double>(void) { return MPI_DOUBLE ;} 
     30  MPI_Datatype MPI_GetType<double>(void); 
    3131 
    3232  template<> 
    33   MPI_Datatype MPI_GetType<long double>(void) { return MPI_LONG_DOUBLE ;} 
     33  MPI_Datatype MPI_GetType<long double>(void); 
    3434 
    3535 
  • XIOS/dev/dev_trunk_graph/src/node/axis.cpp

    r2027 r2137  
    451451 
    452452    } 
    453    
     453 
    454454  string CAxis::getCouplingAlias(const string& fieldId, int posInGrid) 
    455455  { 
  • XIOS/dev/dev_trunk_graph/src/node/axis.hpp

    r2027 r2137  
    176176         void makeAliasForCoupling(const string& fieldId, int posInGrid) ; 
    177177         string getCouplingAlias(const string& fieldId, int posInGrid) ; 
    178  
    179178 
    180179      private: 
  • XIOS/dev/dev_trunk_graph/src/node/context.cpp

    r2027 r2137  
    7373 
    7474   //---------------------------------------------------------------- 
    75    void CContext::initEventScheduler(void) 
    76    { 
    77      SRegisterContextInfo contextInfo ; 
    78      CXios::getContextsManager()->getContextInfo(this->getId(), contextInfo, getIntraComm()) ; 
    79  
    80      eventScheduler_=CXios::getPoolRessource()->getService(contextInfo.serviceId,contextInfo.partitionId)->getEventScheduler() ; 
     75 
     76  void CContext::initEventScheduler(void) 
     77  { 
     78    SRegisterContextInfo contextInfo ; 
     79    CXios::getContextsManager()->getContextInfo(this->getId(), contextInfo, getIntraComm()) ; 
     80 
     81    eventScheduler_=CXios::getPoolRessource()->getService(contextInfo.serviceId,contextInfo.partitionId)->getEventScheduler() ; 
    8182  
    82      // generate unique hash for server 
    83      auto time=chrono::system_clock::now().time_since_epoch().count() ; 
    84      std::default_random_engine rd(time); // not reproducible from a run to another 
    85      std::uniform_int_distribution<size_t> dist; 
    86      hashId_=dist(rd) ; 
    87      MPI_Bcast(&hashId_,1,MPI_SIZE_T,0,getIntraComm()) ; // Bcast to all server of the context 
    88    } 
    89   
     83    // generate unique hash for server 
     84    auto time=chrono::system_clock::now().time_since_epoch().count() ; 
     85    std::default_random_engine rd(time); // not reproducible from a run to another 
     86    std::uniform_int_distribution<size_t> dist; 
     87    hashId_=dist(rd) ; 
     88    MPI_Bcast(&hashId_,1,MPI_SIZE_T,0,getIntraComm()) ; // Bcast to all server of the context 
     89  } 
    9090   /*! 
    9191   \brief Get context group (context root) 
     
    291291   ///--------------------------------------------------------------- 
    292292 
    293  
    294    void CContext::setClientServerBuffer(vector<CField*>& fields, bool bufferForWriting) 
    295    TRY 
    296    { 
    297       // Estimated minimum event size for small events (20 is an arbitrary constant just for safety) 
    298      const size_t minEventSize = CEventClient::headerSize + 20 * sizeof(int); 
    299       // Ensure there is at least some room for 20 of such events in the buffers 
    300      size_t minBufferSize = std::max(CXios::minBufferSize, 20 * minEventSize); 
    301  
    302 #define DECLARE_NODE(Name_, name_)    \ 
    303      if (minBufferSize < sizeof(C##Name_##Definition)) minBufferSize = sizeof(C##Name_##Definition); 
    304 #define DECLARE_NODE_PAR(Name_, name_) 
    305 #include "node_type.conf" 
    306 #undef DECLARE_NODE 
    307 #undef DECLARE_NODE_PAR 
    308  
    309  
    310      map<CContextClient*,map<int,size_t>> dataSize ; 
    311      map<CContextClient*,map<int,size_t>> maxEventSize ; 
    312      map<CContextClient*,map<int,size_t>> attributesSize ;   
    313  
    314      for(auto field : fields) 
    315      { 
    316        field->setContextClientDataBufferSize(dataSize, maxEventSize, bufferForWriting) ; 
    317        field->setContextClientAttributesBufferSize(attributesSize, maxEventSize, bufferForWriting) ; 
    318      } 
    319       
    320  
    321      for(auto& it : attributesSize) 
    322      { 
    323        auto contextClient = it.first ; 
    324        auto& contextDataSize =  dataSize[contextClient] ; 
    325        auto& contextAttributesSize =  attributesSize[contextClient] ; 
    326        auto& contextMaxEventSize =  maxEventSize[contextClient] ; 
    327     
    328        for (auto& it : contextAttributesSize) 
    329        { 
    330          auto serverRank=it.first ; 
    331          auto& buffer = contextAttributesSize[serverRank] ; 
    332          if (contextDataSize[serverRank] > buffer) buffer=contextDataSize[serverRank] ; 
    333          buffer *= CXios::bufferSizeFactor; 
    334          if (buffer < minBufferSize) buffer = minBufferSize; 
    335          if (buffer > CXios::maxBufferSize ) buffer = CXios::maxBufferSize; 
    336        } 
    337  
    338        // Leaders will have to send some control events so ensure there is some room for those in the buffers 
    339        if (contextClient->isServerLeader()) 
    340          for(auto& rank : contextClient->getRanksServerLeader()) 
    341            if (!contextAttributesSize.count(rank)) 
    342            { 
    343              contextAttributesSize[rank] = minBufferSize; 
    344              contextMaxEventSize[rank] = minEventSize; 
    345            } 
    346        
    347        contextClient->setBufferSize(contextAttributesSize, contextMaxEventSize);     
    348      } 
    349    } 
    350    CATCH_DUMP_ATTR 
    351  
    352  
    353     /*! 
    354     Sets client buffers. 
    355     \param [in] contextClient 
    356     \param [in] bufferForWriting True if buffers are used for sending data for writing 
    357     This flag is only true for client and server-1 for communication with server-2 
    358   */ 
    359   // ym obsolete to be removed 
    360    void CContext::setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting) 
    361    TRY 
    362    { 
    363       // Estimated minimum event size for small events (20 is an arbitrary constant just for safety) 
    364      const size_t minEventSize = CEventClient::headerSize + 20 * sizeof(int); 
    365  
    366       // Ensure there is at least some room for 20 of such events in the buffers 
    367       size_t minBufferSize = std::max(CXios::minBufferSize, 20 * minEventSize); 
    368  
    369 #define DECLARE_NODE(Name_, name_)    \ 
    370      if (minBufferSize < sizeof(C##Name_##Definition)) minBufferSize = sizeof(C##Name_##Definition); 
    371 #define DECLARE_NODE_PAR(Name_, name_) 
    372 #include "node_type.conf" 
    373 #undef DECLARE_NODE 
    374 #undef DECLARE_NODE_PAR 
    375  
    376      // Compute the buffer sizes needed to send the attributes and data corresponding to fields 
    377      std::map<int, StdSize> maxEventSize; 
    378      std::map<int, StdSize> bufferSize = getAttributesBufferSize(maxEventSize, contextClient, bufferForWriting); 
    379      std::map<int, StdSize> dataBufferSize = getDataBufferSize(maxEventSize, contextClient, bufferForWriting); 
    380  
    381      std::map<int, StdSize>::iterator it, ite = dataBufferSize.end(); 
    382      for (it = dataBufferSize.begin(); it != ite; ++it) 
    383        if (it->second > bufferSize[it->first]) bufferSize[it->first] = it->second; 
    384  
    385      // Apply the buffer size factor, check that we are above the minimum buffer size and below the maximum size 
    386      ite = bufferSize.end(); 
    387      for (it = bufferSize.begin(); it != ite; ++it) 
    388      { 
    389        it->second *= CXios::bufferSizeFactor; 
    390        if (it->second < minBufferSize) it->second = minBufferSize; 
    391        if (it->second > CXios::maxBufferSize) it->second = CXios::maxBufferSize; 
    392      } 
    393  
    394      // Leaders will have to send some control events so ensure there is some room for those in the buffers 
    395      if (contextClient->isServerLeader()) 
    396      { 
    397        const std::list<int>& ranks = contextClient->getRanksServerLeader(); 
    398        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    399        { 
    400          if (!bufferSize.count(*itRank)) 
    401          { 
    402            bufferSize[*itRank] = minBufferSize; 
    403            maxEventSize[*itRank] = minEventSize; 
    404          } 
    405        } 
    406      } 
    407      contextClient->setBufferSize(bufferSize, maxEventSize); 
    408    } 
    409    CATCH_DUMP_ATTR 
    410293 
    411294 /*! 
     
    716599  CATCH_DUMP_ATTR 
    717600 
    718     
    719   bool CContext::eventLoop(bool enableEventsProcessing) 
     601  void CContext::globalEventLoop(void) 
    720602  { 
    721     bool finished=true;  
    722     bool out;  
     603    lockContext() ; 
     604    CXios::getDaemonsManager()->eventLoop() ; 
     605    unlockContext() ; 
     606    setCurrent(getId()) ; 
     607  } 
     608 
     609  bool CContext::scheduledEventLoop(bool enableEventsProcessing)  
     610  { 
     611    bool out, finished;  
    723612    size_t timeLine=timeLine_ ; 
    724613    if (serviceType_==CServicesManager::CLIENT) 
     
    730619    do 
    731620    {  
    732       if (client!=nullptr && !finalized) client->checkBuffers(); 
    733      
    734       for (int i = 0; i < clientPrimServer.size(); ++i) 
    735       { 
    736         if (!finalized) clientPrimServer[i]->checkBuffers(); 
    737         if (!finalized) finished &= serverPrimServer[i]->eventLoop(enableEventsProcessing); 
    738       } 
    739  
    740       for (auto couplerOut : couplerOutClient_) 
    741         if (!finalized) couplerOut.second->checkBuffers(); 
    742      
    743       for (auto couplerIn : couplerInClient_) 
    744         if (!finalized) couplerIn.second->checkBuffers(); 
    745      
    746       for (auto couplerOut : couplerOutServer_) 
    747         if (!finalized) couplerOut.second->eventLoop(enableEventsProcessing); 
    748  
    749       for (auto couplerIn : couplerInServer_) 
    750         if (!finalized) couplerIn.second->eventLoop(enableEventsProcessing); 
    751      
    752       if (server!=nullptr) if (!finalized) finished &= server->eventLoop(enableEventsProcessing); 
    753    
     621      finished=eventLoop(enableEventsProcessing) ; 
    754622      if (serviceType_==CServicesManager::CLIENT) out = eventScheduler_->queryEvent(timeLine,hashId_) ; 
    755623      else out=true ; 
    756624    }  while(!out) ; 
     625     
     626    return finished ; 
     627  } 
     628 
     629  bool CContext::eventLoop(bool enableEventsProcessing) 
     630  { 
     631    bool  finished;  
     632    if (isLockedContext()) return ; 
     633     
     634    setCurrent(getId()) ; 
     635 
     636    if (client!=nullptr && !finalized) client->checkBuffers(); 
     637     
     638    for (int i = 0; i < clientPrimServer.size(); ++i) 
     639    { 
     640      if (!finalized) clientPrimServer[i]->checkBuffers(); 
     641      if (!finalized) finished &= serverPrimServer[i]->eventLoop(enableEventsProcessing); 
     642    } 
     643 
     644    for (auto couplerOut : couplerOutClient_) 
     645      if (!finalized) couplerOut.second->checkBuffers(); 
     646     
     647    for (auto couplerIn : couplerInClient_) 
     648      if (!finalized) couplerIn.second->checkBuffers(); 
     649     
     650    for (auto couplerOut : couplerOutServer_) 
     651      if (!finalized) couplerOut.second->eventLoop(enableEventsProcessing); 
     652 
     653    for (auto couplerIn : couplerInServer_) 
     654      if (!finalized) couplerIn.second->eventLoop(enableEventsProcessing); 
     655     
     656    if (server!=nullptr) if (!finalized) finished &= server->eventLoop(enableEventsProcessing); 
     657    setCurrent(getId()) ; 
    757658    return finalized && finished ; 
    758659  } 
     
    784685        couplerOutClient_[fullContextId] = client ; 
    785686        couplerOutServer_[fullContextId] = server ; 
    786  
    787 /* 
    788       // for now, we don't now which beffer size must be used for client coupler 
    789       // It will be evaluated later. Fix a constant size for now... 
    790       // set to 10Mb for development 
    791        map<int,size_t> bufferSize, maxEventSize ; 
    792        for(int i=0;i<client->getRemoteSize();i++) 
    793        { 
    794          bufferSize[i]=10000000 ; 
    795          maxEventSize[i]=10000000 ; 
    796        } 
    797  
    798        client->setBufferSize(bufferSize, maxEventSize);     
    799 */ 
    800687      } 
    801688    } 
     
    819706       MPI_Comm_free(&interComm) ; 
    820707 
    821        map<int,size_t> bufferSize, maxEventSize ; 
    822        for(int i=0;i<client->getRemoteSize();i++) 
    823        { 
    824          bufferSize[i]=10000000 ; 
    825          maxEventSize[i]=10000000 ; 
    826        } 
    827  
    828        client->setBufferSize(bufferSize, maxEventSize);     
    829708       couplerInClient_[fullContextId] = client ; 
    830709       couplerInServer_[fullContextId] = server ;         
     
    832711  } 
    833712   
    834   void CContext::globalEventLoop(void) 
    835   { 
    836     CXios::getDaemonsManager()->eventLoop() ; 
    837     setCurrent(getId()) ; 
    838   } 
    839  
    840  
    841713   void CContext::finalize(void) 
    842714   TRY 
     
    1023895 
    1024896    bool workflowGraphIsCompleted ; 
    1025  
     897     
    1026898    bool first=true ; 
     899    
    1027900    do 
    1028901    { 
     
    1032905        workflowGraphIsCompleted &= endWorkflowField->buildWorkflowGraph(garbageCollector) ; 
    1033906      } 
    1034  
     907    
    1035908      for(auto couplerIn : enabledCouplerIn) couplerIn->assignContext() ; 
    1036909      for(auto field : couplerInField) field->makeGridAliasForCoupling(); 
     
    1045918        // connect to couplerOut -> to do 
    1046919      } 
    1047       if (first) setClientServerBuffer(couplerOutField, true) ; // set buffer context --> to check 
    1048     
     920 
    1049921      bool couplersReady ; 
    1050922      do  
     
    1057929          couplersReady &= ready ; 
    1058930        } 
    1059         this->eventLoop() ; 
     931        this->scheduledEventLoop() ; 
     932 
    1060933      } while (!couplersReady) ; 
    1061  
     934       
    1062935      first=false ; 
    1063       this->eventLoop() ; 
     936      this->scheduledEventLoop() ; 
     937 
    1064938    } while (!workflowGraphIsCompleted) ; 
     939 
    1065940 
    1066941    for( auto field : couplerInField) couplerInFields_.push_back(field) ; 
     
    1087962        field->connectToFileServer(garbageCollector) ; // connect the field to server filter 
    1088963      } 
    1089       setClientServerBuffer(fileOutField, true) ; // set buffer context --> to review 
    1090964      for(auto field : fileOutField) field->sendFieldToFileServer() ; 
    1091965    } 
     
    11931067      ok = true ; 
    11941068      for(auto& couplerOutClient : couplerOutClient_) ok &= isCouplerInCloseDefinition(couplerOutClient.second) ; 
    1195       this->eventLoop() ;  
     1069      this->scheduledEventLoop() ; 
    11961070    } while (!ok) ; 
     1071 
     1072    // Now evaluate the size of the context client buffers 
     1073    map<CContextClient*,map<int,size_t>> fieldBufferEvaluation ; 
     1074    for(auto field : fileOutField) field->evaluateBufferSize(fieldBufferEvaluation, CXios::isOptPerformance) ; // output to server 
     1075    for(auto field : couplerOutField) field->evaluateBufferSize(fieldBufferEvaluation, CXios::isOptPerformance) ; // output to coupler 
     1076    for(auto field : fieldModelIn) field->evaluateBufferSize(fieldBufferEvaluation, CXios::isOptPerformance) ; // server to client (for io servers) 
     1077     
     1078    // fix size for each context client 
     1079    for(auto& it : fieldBufferEvaluation) it.first->setBufferSize(it.second) ; 
     1080 
    11971081 
    11981082     CTimer::get("Context : close definition").suspend() ; 
  • XIOS/dev/dev_trunk_graph/src/node/context.hpp

    r2027 r2137  
    1515#include "server_context.hpp" 
    1616#include "event_scheduler.hpp" 
     17 
    1718 
    1819namespace xios 
     
    108109         // Put sever or client into loop state 
    109110         bool eventLoop(bool enableEventsProcessing=true); 
     111         bool scheduledEventLoop(bool enableEventsProcessing=true) ;  
    110112         void globalEventLoop(void); 
    111113 
     
    148150         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false); 
    149151         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false); 
    150          void setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting = false); // old interface to be removed 
    151          void setClientServerBuffer(vector<CField*>& fields, bool bufferForWriting) ;  
    152152 
    153153         // Distribute files (in write mode) among secondary-server pools according to the estimated data flux 
     
    355355         string contextId_ ; //!< context client id for the servers. For clients this is same as getId()  
    356356         bool isProcessingEvent_ ; 
     357    private:      
    357358         CServerContext* parentServerContext_ ; 
    358  
     359    public: 
     360         CServerContext* getParentServerContext(void) { return parentServerContext_; } 
     361    private:  
     362      bool lockedContext_=false; 
     363    public:  
     364        void lockContext(void) {lockedContext_=true; } 
     365        void unlockContext(void) {lockedContext_=true; } 
     366        bool isLockedContext(void) { return lockedContext_;} 
    359367      public: // Some function maybe removed in the near future 
    360368        // virtual void toBinary  (StdOStream & os) const; 
  • XIOS/dev/dev_trunk_graph/src/node/domain.cpp

    r2027 r2137  
    805805        nj = 1; 
    806806        jbegin = 0; 
    807         if (!i_index.isEmpty()) ni = i_index.numElements(); 
    808         j_index.resize(ni); 
    809         for(int i=0;i<ni;++i) j_index(i)=0; 
    810  
    811         if (!area.isEmpty()) 
    812           area.transposeSelf(1, 0); 
     807        if (!i_index.isEmpty())  
     808        { 
     809          ni = i_index.numElements(); 
     810          j_index.resize(ni); 
     811          for(int i=0;i<ni;++i) j_index(i)=0; 
     812        } 
     813         
     814 
     815        if (!area.isEmpty()) area.transposeSelf(1, 0); // => to be checked why is it transposed 
    813816     } 
    814817 
     
    17801783   } 
    17811784 
     1785 
    17821786  string CDomain::getCouplingAlias(const string& fieldId, int posInGrid) 
    17831787  { 
     
    18081812  void CDomain::makeAliasForCoupling(const string& fieldId, int posInGrid) 
    18091813  { 
    1810      const string domainId = getCouplingAlias(fieldId, posInGrid); 
     1814    const string domainId = getCouplingAlias(fieldId, posInGrid); 
    18111815    this->createAlias(domainId) ; 
    18121816  } 
  • XIOS/dev/dev_trunk_graph/src/node/domain.hpp

    r2027 r2137  
    241241        void makeAliasForCoupling(const string& fieldId, int posInGrid) ; 
    242242        string getCouplingAlias(const string& fieldId, int posInGrid) ; 
    243  
    244243       private: 
    245244 
  • XIOS/dev/dev_trunk_graph/src/node/extract_domain_to_axis.cpp

    r2019 r2137  
    6767    { 
    6868      case direction_attr::jDir: 
    69         if (axis_n_glo != domain_ni_glo) 
     69        if (axis_n_glo != domain_nj_glo) 
    7070          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    71             << "Extract domain along j, axis destination should have n_glo equal to ni_glo of domain source" 
    72             << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl 
     71            << "Extract domain along j, axis destination should have n_glo equal to nj_glo of domain source" 
     72            << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl 
    7373            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
    74         if ((position < 0) || (position > domain_ni_glo)) 
     74        if ((position < 0) || (position >= domain_ni_glo)) 
    7575        ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    76           << "Extract domain along j, position should be inside 0 and ni_glo of domain source" 
    77           << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl 
     76          << "Extract domain along j, position should be inside 0 and ni_glo-1 of domain source" 
     77          << "Domain source " <<domainSrc->getId() << " has ni_glo " << domain_ni_glo << std::endl 
    7878          << "Axis destination " << axisDst->getId() << std::endl 
    7979          << "Position " << position); 
     
    8181 
    8282      case direction_attr::iDir: 
    83         if (axis_n_glo != domain_nj_glo) 
     83        if (axis_n_glo != domain_ni_glo) 
    8484          ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    85             << "Extract domain along i, axis destination should have n_glo equal to nj_glo of domain source" 
    86             << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl 
     85            << "Extract domain along i, axis destination should have n_glo equal to ni_glo of domain source" 
     86            << "Domain source " <<domainSrc->getId() << " has ni_glo " << domain_ni_glo << std::endl 
    8787            << "Axis destination " << axisDst->getId() << " has n_glo " << axis_n_glo); 
    88         if ((position < 0) || (position > domain_nj_glo)) 
     88        if ((position < 0) || (position >= domain_nj_glo)) 
    8989        ERROR("CExtractDomainToAxis::checkValid(CAxis* axisDst, CDomain* domainSrc)", 
    90           << "Extract domain along i, position should be inside 0 and nj_glo of domain source" 
    91           << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_ni_glo << std::endl 
     90          << "Extract domain along i, position should be inside 0 and nj_glo-1 of domain source" 
     91          << "Domain source " <<domainSrc->getId() << " has nj_glo " << domain_nj_glo << std::endl 
    9292          << "Axis destination " << axisDst->getId() << std::endl 
    9393          << "Position " << position); 
  • XIOS/dev/dev_trunk_graph/src/node/field.cpp

    r2027 r2137  
    383383  CATCH_DUMP_ATTR 
    384384 
     385   
    385386  //---------------------------------------------------------------- 
    386387 
     
    497498  CATCH_DUMP_ATTR 
    498499 
     500  bool CField::evaluateBufferSize(map<CContextClient*,map<int,size_t>>& evaluateBuffer, bool isOptPerformance) 
     501  { 
     502    CContextClient* client=nullptr ; 
     503 
     504    for(int i=0;i<2;i++) 
     505    { 
     506      map<int,int> dataSize ; 
     507      if (i==0  && clientToServerStoreFilter_) client = clientToServerStoreFilter_-> getTransferedDataSize(dataSize) ; 
     508      if (i==1  && serverToClientStoreFilter_) client = serverToClientStoreFilter_-> getTransferedDataSize(dataSize) ; 
     509 
     510      if (client!=nullptr) 
     511      { 
     512        map<int,size_t> bufferSize ; 
     513    
     514        if (evaluateBuffer.count(client)!=0) bufferSize = evaluateBuffer[client] ; 
     515        if (isOptPerformance) 
     516        { 
     517          for(auto& it : dataSize)  
     518          { 
     519            if (bufferSize.count(it.first)==0) bufferSize[it.first]=it.second ; 
     520            else bufferSize[it.first]+=it.second ; 
     521          } 
     522        } 
     523        else 
     524        { 
     525          for(auto& it : dataSize)  
     526          { 
     527            if (bufferSize.count(it.first)==0) bufferSize[it.first]=it.second ; 
     528            else bufferSize[it.first]=std::max(bufferSize[it.first],(size_t)it.second) ; 
     529          } 
     530        } 
     531        evaluateBuffer[client] = bufferSize ; 
     532        client=nullptr ; 
     533      } 
     534    } 
     535    if (client==nullptr) return false ; 
     536    else return true; 
     537  }   
    499538 
    500539 
     
    550589    bool buildGraph_ = !build_workflow_graph.isEmpty() && build_workflow_graph == true ; 
    551590    std::cout<<"field id="<<this->getId()<<" build_workflow_graph="<<buildGraph_<<std::endl; 
    552  
    553     if (!inputFilter)  
    554     { 
    555       inputFilter = std::shared_ptr<CPassThroughFilter>(new CPassThroughFilter(gc));  
    556       /*if(buildGraph_) 
    557       { 
    558         std::cout<<"============== field "<<this->getId()<<" calls a pass through filter ============== "<<inputFilter<<" ***** "<<CXios::isClient<<std::endl; 
    559         inputFilter->graphEnabled = true; 
    560         inputFilter->graphPackage = new CGraphPackage; 
    561         inputFilter->graphPackage->inFields.push_back(this); 
    562       }*/ 
    563     } 
     591    if (!inputFilter) inputFilter = std::shared_ptr<CPassThroughFilter>(new CPassThroughFilter(gc));  
    564592      
    565593    if (hasDirectFieldReference()) 
    566594    { 
    567        
    568595      CField* fieldRef = getDirectFieldReference(); 
     596 
     597      //------ build_workflow_graph start 
    569598      if(buildGraph_) 
    570599      { 
     
    580609       
    581610      if(buildGraph_) this->build_workflow_graph.set(build_workflow_graph); 
     611      //------ build_workflow_graph end 
     612 
    582613      bool ret=fieldRef->buildWorkflowGraph(gc);  
    583614      if (!ret) return false ; // workflow graph cannot be built at this stage 
     
    612643      { 
    613644        grid->solveElementsRefInheritance() ; 
    614         
    615         // new 
    616          
    617645        std::pair<std::shared_ptr<CFilter>, std::shared_ptr<CFilter> > filters = grid->buildTransformationGraph(gc, false,  gridSrc, detectMissingValues, defaultValue, newGrid, buildGraph_, this) ; 
    618646        lastFilter->connectOutput(filters.first, 0); 
    619         /*if(buildGraph_) 
    620         { 
    621           std::cout<<"============== field "<<this->getId()<<" calls a transformation filter 1 ============== "<<lastFilter<<" _ "<<filters.first<<" ***** "<<CXios::isClient<<std::endl; 
    622           filters.first->graphEnabled=true; 
    623           filters.first->graphPackage = new CGraphPackage; 
    624           filters.first->graphPackage->inFields.push_back(this); 
    625         }*/ 
    626647        lastFilter = filters.second; 
    627648        gridSrc = newGrid ; 
    628  
    629         // end new 
    630649      } 
    631650 
     
    658677         grid_ = newGrid ; 
    659678         grid_ref=grid_->getId() ; // for server  
     679         //grid_->completeGrid(); // grid generation, to be checked 
    660680         if (fileIn_->isClientSide()) fileIn_->readFieldAttributesValues(this); 
    661681         grid_->checkElementsAttributes() ; 
     682//         grid_->solveDomainAxisBaseRef(); 
    662683         // probably in future tag grid incomplete if coming from a reading 
    663684         instantDataFilter=inputFilter ; 
     
    927948   * \return the output pin corresponding to a self reference 
    928949   */ 
     950 
     951/* old version 
     952  std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc) 
     953  TRY 
     954  { 
     955    if (instantDataFilter || !hasExpression()) 
     956      ERROR("COutputPin* CField::getSelfReference(CGarbageCollector& gc)", 
     957            "Impossible to add a self reference to a field which has already been parsed or which does not have an expression."); 
     958 
     959    if (!selfReferenceFilter) 
     960    { 
     961      const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
     962      const double defaultValue  = detectMissingValues ? default_value : (!default_value.isEmpty() ? default_value : 0.0); 
     963 
     964      if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read) 
     965      { 
     966        if (!serverSourceFilter) 
     967        { 
     968          checkTimeAttributes(); 
     969          serverSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid_, true, false, freq_offset, true, 
     970                                                              detectMissingValues, defaultValue)); 
     971         } 
     972 
     973        selfReferenceFilter = serverSourceFilter; 
     974      } 
     975      else if (!field_ref.isEmpty()) 
     976      { 
     977        CField* fieldRef = CField::get(field_ref); 
     978        fieldRef->buildFilterGraph(gc, false); 
     979        selfReferenceFilter = fieldRef->getInstantDataFilter(); 
     980      } 
     981      else 
     982      { 
     983        if (!clientSourceFilter) 
     984        { 
     985          if (check_if_active.isEmpty()) check_if_active = false; 
     986          clientSourceFilter = std::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid_, true, true, NoneDu, false, 
     987                                                                                detectMissingValues, defaultValue)); 
     988        } 
     989 
     990        selfReferenceFilter = clientSourceFilter; 
     991      } 
     992    } 
     993 
     994    return selfReferenceFilter; 
     995  } 
     996  CATCH_DUMP_ATTR 
     997*/ 
    929998  std::shared_ptr<COutputPin> CField::getSelfReference(CGarbageCollector& gc) 
    930999  TRY 
     
    10301099  CATCH_DUMP_ATTR 
    10311100 
     1101/* old version    
     1102  std::shared_ptr<COutputPin> CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq) 
     1103  TRY 
     1104  { 
     1105    if (instantDataFilter || !hasExpression()) 
     1106      ERROR("COutputPin* CField::getSelfTemporalDataFilter(CGarbageCollector& gc)", 
     1107            "Impossible to add a self reference to a field which has already been parsed or which does not have an expression."); 
     1108 
     1109    if (!selfReferenceFilter) getSelfReference(gc) ; 
     1110 
     1111    if (serverSourceFilter || clientSourceFilter) 
     1112    { 
     1113      if (operation.isEmpty()) 
     1114        ERROR("void CField::getSelfTemporalDataFilter(CGarbageCollector& gc, CDuration outFreq)", 
     1115              << "An operation must be defined for field \"" << getId() << "\"."); 
     1116 
     1117      checkTimeAttributes(&outFreq); 
     1118 
     1119      const bool detectMissingValues = (!detect_missing_value.isEmpty() && detect_missing_value == true); 
     1120      std::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
     1121                                                                          CContext::getCurrent()->getCalendar()->getInitDate(), 
     1122                                                                          freq_op, freq_offset, outFreq, detectMissingValues)); 
     1123 
     1124      selfReferenceFilter->connectOutput(temporalFilter, 0); 
     1125      return temporalFilter ; 
     1126    } 
     1127    else if (!field_ref.isEmpty()) 
     1128    { 
     1129      CField* fieldRef = CField::get(field_ref); 
     1130      fieldRef->buildFilterGraph(gc, false);  
     1131      return fieldRef->getTemporalDataFilter(gc, outFreq) ; 
     1132    } 
     1133  } 
     1134  CATCH_DUMP_ATTR 
     1135*/ 
    10321136 
    10331137  //---------------------------------------------------------------- 
     
    13551459   CATCH_DUMP_ATTR 
    13561460 
    1357  
    1358    bool CField::isGridCompleted(void) 
    1359    TRY 
    1360    {  
    1361      bool isFullCompleted ; 
    1362      MPI_Allreduce(&isGridCompleted_,&isFullCompleted,1,MPI_C_BOOL, MPI_LAND, CContext::getCurrent()->getIntraComm() ) ; 
    1363      if ( (isGridCompleted_==false && isFullCompleted==true) ) ERROR("bool CField::isGridCompleted(void)",<< "incoherecy in MPI_AllReduce") ; 
    1364      return isFullCompleted ;  
    1365    } 
    1366    CATCH_DUMP_ATTR 
    1367  
     1461  bool CField::isGridCompleted(void) 
     1462  TRY 
     1463  {  
     1464    bool isFullCompleted ; 
     1465    MPI_Allreduce(&isGridCompleted_,&isFullCompleted,1,MPI_C_BOOL, MPI_LAND, CContext::getCurrent()->getIntraComm() ) ; 
     1466    if ( (isGridCompleted_==false && isFullCompleted==true) ) ERROR("bool CField::isGridCompleted(void)",<< "incoherecy in MPI_AllReduce") ; 
     1467    return isFullCompleted ;  
     1468  } 
     1469  CATCH_DUMP_ATTR 
    13681470 
    13691471  void CField::sendAddAllVariables(CContextClient* client) 
  • XIOS/dev/dev_trunk_graph/src/node/field.hpp

    r2028 r2137  
    110110         // Grid data buffer size for each connection of contextclient 
    111111         std::map<int, StdSize> getGridDataBufferSize(CContextClient* client, bool bufferForWriting = false); 
    112  
     112          
     113         // evaluation the size of the buffer for the field 
     114         bool evaluateBufferSize(map<CContextClient*,map<int,size_t>>& evaluateBuffer, bool isOptPerformance) ; 
    113115       public: 
    114116          void makeGridAliasForCoupling(void) ; 
     
    236238          bool isGridCompleted_ = true ; 
    237239      public: 
    238           bool isGridCompleted() ;  
     240          bool isGridCompleted()  ;  
    239241          void setGridCompleted(void) { isGridCompleted_= true; } 
    240242          void unsetGridCompleted(void) { isGridCompleted_ = false ;} 
  • XIOS/dev/dev_trunk_graph/src/node/grid.cpp

    r2027 r2137  
    12101210  } 
    12111211 
     1212 
    12121213  void CGrid::sendGridToCouplerOut(CContextClient* client, const string& fieldId) 
    12131214  { 
     
    12171218    distributeGridToServer(client,fieldId) ; 
    12181219  } 
     1220 
    12191221 
    12201222  void CGrid::distributeGridToServer(CContextClient* client, const string& fieldId) 
     
    13121314    CMessage message ; 
    13131315    if (isCoupling) message<<getCouplingAlias(fieldId) ; 
    1314     else message<<getId() ; 
     1316    else message<<getId() ;  
    13151317    gridScattererConnector.transfer(maskOut, client, event, message) ; 
    13161318    for(auto& it : scattererConnectors) delete it ; 
     
    13421344    clientFromServerConnector_[client] = new CGridGathererConnector(clientFromServerConnectors) ; 
    13431345 
    1344  
    1345   } 
     1346  } 
     1347 
    13461348 
    13471349  void CGrid::recvMask(CEventServer& event) 
     
    13941396  } 
    13951397 
    1396  
    13971398  string CGrid::getCouplingAlias(const string& fieldId) 
    13981399  { 
    13991400    return "_grid_of_"+fieldId; 
    14001401  } 
    1401  
    14021402 
    14031403  void CGrid::makeAliasForCoupling(const string& fieldId) 
     
    16501650    std::shared_ptr<CFilter> inputFilter = std::shared_ptr<CPassThroughFilter>(new CPassThroughFilter(gc)); 
    16511651    std::shared_ptr<CFilter> outputFilter = inputFilter ; 
    1652     cout<<"***************CGrid::buildTransformationGraph Pass through filter ***************"<<transformationGoing<<field->getId()<<endl; 
    1653     /*inputFilter->graphEnabled = true; 
    1654     inputFilter->graphPackage = new CGraphPackage; 
    1655     inputFilter->graphPackage->inFields.push_back(field); 
    1656 */ 
     1652 
     1653 
    16571654    string newId ; 
    16581655    if (gridSrc!=nullptr) newId = gridSrc->getId() + " --> " + this->getId()  ; 
     
    16671664    else   
    16681665    { 
    1669       StdString role = CXios::isClient? "Client ": "Server "; 
    1670       cout<<role<<"Create new grid : "<<newId<<endl ; 
     1666      cout<<"Create new grid : "<<newId<<endl ; 
    16711667      newGrid = CGrid::create(newId) ; 
    16721668      isNewGrid = true ; 
     
    17151711        else if (srcElement.type==TYPE_AXIS)   tmpGridSrc->addAxis(srcElement.axis->getId()) ; 
    17161712        else if (srcElement.type==TYPE_SCALAR) tmpGridSrc->addScalar(srcElement.scalar->getId()) ; 
    1717         tmpGridSrc->checkElementsAttributes() ; 
     1713        // WARNING -> suppress checkElement attribute ? What append ? 
     1714        // tmpGridSrc->checkElementsAttributes() ; 
    17181715        CGrid* tmpGridDst=CGrid::create(); // destination Grid 
    17191716        map<int,int> posInGrid={{0,0}} ; 
     
    19561953          auxField->getInstantDataFilter()->connectOutput(transformFilter,i) ; 
    19571954          i++ ; 
    1958            
    19591955        } 
    19601956        outputFilter = transformFilter ; 
  • XIOS/dev/dev_trunk_graph/src/node/grid.hpp

    r2027 r2137  
    336336 
    337337      private: 
    338         CGridLocalConnector* workflowToModelConnector_ ; 
     338        CGridLocalConnector* workflowToModelConnector_ = nullptr; 
    339339      public: 
    340340        void computeWorkflowToModelConnector(void) ; 
  • XIOS/dev/dev_trunk_graph/src/node/interpolate_axis.cpp

    r2019 r2137  
    6060    } 
    6161 
     62    if (!this->coordinate.isEmpty() && (!this->coordinate_src.isEmpty() || !this->coordinate_dst.isEmpty())) 
     63    { 
     64       ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)", 
     65               << "<coordinate> is incompatible with <coordinate_src> or <coordinate_dst> attributes. <coordinate> attribute is present only for backward" 
     66               << "compatibility and is now declared obsolete") ; 
     67    } 
    6268 
    6369    if (!this->coordinate.isEmpty()) 
    6470    { 
    65       StdString coordinate = this->coordinate.getValue(); 
    6671      if (!CField::has(coordinate)) 
    6772        ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)", 
    6873               << "Coordinate field whose id " << coordinate << "does not exist " 
     74               << "Please define one"); 
     75    } 
     76 
     77    if (!this->coordinate_src.isEmpty()) 
     78    { 
     79      if (!CField::has(coordinate_src)) 
     80        ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)", 
     81               << "Coordinate field whose id " << coordinate_src << "does not exist " 
     82               << "Please define one"); 
     83    } 
     84 
     85    if (!this->coordinate_dst.isEmpty()) 
     86    { 
     87      if (!CField::has(coordinate_dst)) 
     88        ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)", 
     89               << "Coordinate field whose id " << coordinate_dst << "does not exist " 
    6990               << "Please define one"); 
    7091    } 
     
    7495  { 
    7596    std::vector<StdString> auxInputs; 
     97     
     98    if (!this->coordinate.isEmpty() && (!this->coordinate_src.isEmpty() || !this->coordinate_dst.isEmpty())) 
     99    { 
     100       ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()", 
     101               << "<coordinate> is incompatible with <coordinate_src> or <coordinate_dst> attributes. <coordinate> attribute is present only for backward" 
     102               << "compatibility and is now declared obsolete") ; 
     103    } 
     104 
    76105    if (!this->coordinate.isEmpty()) 
    77106    { 
    78107      StdString coordinate = this->coordinate.getValue(); 
    79108      if (!CField::has(coordinate)) 
    80         ERROR("CInterpolateAxis::checkValid(CAxis* axisSrc)", 
     109        ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()", 
     110               << "Coordinate field whose id " << coordinate << "does not exist " 
     111               << "Please define one"); 
     112      auxInputs.push_back(coordinate); 
     113    } 
     114 
     115    if (!this->coordinate_src.isEmpty()) 
     116    { 
     117      StdString coordinate = this->coordinate_src.getValue(); 
     118      if (!CField::has(coordinate)) 
     119        ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()", 
     120               << "Coordinate field whose id " << coordinate << "does not exist " 
     121               << "Please define one"); 
     122      auxInputs.push_back(coordinate); 
     123    } 
     124 
     125    if (!this->coordinate_dst.isEmpty()) 
     126    { 
     127      StdString coordinate = this->coordinate_dst.getValue(); 
     128      if (!CField::has(coordinate)) 
     129        ERROR("std::vector<StdString> CInterpolateAxis::checkAuxInputs_()", 
    81130               << "Coordinate field whose id " << coordinate << "does not exist " 
    82131               << "Please define one"); 
     
    97146                                                        std::map<int, int>& elementPositionInGridDst2DomainPosition) 
    98147  { 
    99     if (!coordinate.isEmpty())  return CAxisAlgorithmInterpolateCoordinate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
    100                                       elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
    101                                       elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     148    if (!coordinate.isEmpty() || !coordinate_src.isEmpty() || !coordinate_dst.isEmpty())  
     149       return CAxisAlgorithmInterpolateCoordinate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
     150              elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
     151              elementPositionInGridDst2ScalarPosition, elementPositionInGridDst2AxisPosition, elementPositionInGridDst2DomainPosition); 
     152     
    102153    else return CAxisAlgorithmInterpolate::create(isSource, gridDst,  gridSrc, this, elementPositionInGrid,  
    103154                elementPositionInGridSrc2ScalarPosition, elementPositionInGridSrc2AxisPosition, elementPositionInGridSrc2DomainPosition, 
  • XIOS/dev/dev_trunk_graph/src/node/scalar.cpp

    r2027 r2137  
    201201    this->sendAllAttributesToServer(client, scalarId); 
    202202