Changeset 2019


Ignore:
Timestamp:
01/22/21 12:00:29 (8 months ago)
Author:
yushan
Message:

Graph intermedia commit to a tmp branch

Location:
XIOS/dev/dev_trunk_graph/src
Files:
179 added
7 deleted
187 edited

Legend:

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

    r1612 r2019  
    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 
    914#include <cmath> 
    1015 
    1116using namespace blitz; 
    1217BZ_DECLARE_FUNCTION(round) 
     18 
     19namespace xios 
     20{ 
     21  template <typename T_numtype,int N_rank> 
     22  class CArray ; 
     23 
     24 template <typename T_numtype,int N_rank> 
     25 int TV_ttf_display_type ( const CArray<T_numtype, N_rank>* array ) ; 
     26} 
     27 
     28template <typename T_numtype,int N_rank> 
     29int TV_ttf_display_type ( const xios::CArray<T_numtype, N_rank>* array ) ; 
    1330 
    1431namespace xios 
     
    1936    private: 
    2037      bool initialized; 
    21  
     38      void inc_symbol(void) 
     39      { 
     40        TV_ttf_display_type(this); 
     41      } 
    2242    public: 
    2343      typedef typename Array<T_numtype,N_rank>::T_default_storage T_default_storage; 
     
    2747        : Array<T_numtype,N_rank>(expr) 
    2848        , initialized(true) 
    29       {} 
     49      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } 
    3050 
    3151      CArray(GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    3252        : Array<T_numtype,N_rank>(storage) 
    3353        , initialized(false) 
    34       {} 
     54      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    3555 
    3656      explicit CArray(int length0, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    3757        : Array<T_numtype,N_rank>(length0, storage) 
    3858        , initialized(true) 
    39       {} 
     59      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    4060 
    4161      CArray(int length0, int length1, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    4262        : Array<T_numtype,N_rank>(length0, length1, storage) 
    4363        , initialized(true) 
    44       {} 
     64      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    4565 
    4666      CArray(int length0, int length1, int length2, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    4767        : Array<T_numtype,N_rank>(length0, length1, length2, storage) 
    4868        , initialized(true) 
    49       {} 
     69      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    5070 
    5171      CArray(int length0, int length1, int length2, int length3, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    5272        : Array<T_numtype,N_rank>(length0, length1, length2, length3, storage) 
    5373        , initialized(true) 
    54       {} 
     74      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    5575 
    5676      CArray(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    5777        : Array<T_numtype,N_rank>(length0,length1, length2, length3, length4, storage) 
    5878        , initialized(true) 
    59       {} 
     79      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    6080 
    6181      CArray(int length0, int length1, int length2, int length3, int length4, int length5, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    6282        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, storage) 
    6383        , initialized(true) 
    64       {} 
     84      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    6585 
    6686      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    6787        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, storage) 
    6888        , initialized(true) 
    69       {} 
     89      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    7090 
    7191      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7, 
     
    7393        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, storage) 
    7494        , initialized(true) 
    75       {} 
     95      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    7696 
    7797      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, 
     
    7999       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, storage) 
    80100       , initialized(true) 
    81       {} 
     101      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    82102 
    83103      CArray(int length0, int length1, int length2, int length3, int length4, 
     
    85105        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, storage) 
    86106        , initialized(true) 
    87       {} 
     107      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    88108 
    89109      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, 
     
    91111       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, length10, storage) 
    92112       , initialized(true) 
    93       {} 
     113      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    94114 
    95115      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    96116        : Array<T_numtype,N_rank>(dataFirst, shape, storage) 
    97117        , initialized(true) 
    98       {} 
     118      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    99119 
    100120      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride, 
     
    102122        : Array<T_numtype,N_rank>(dataFirst, shape, stride, storage) 
    103123        , initialized(true) 
    104       {} 
     124      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    105125 
    106126      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, preexistingMemoryPolicy deletionPolicy, 
     
    108128        : Array<T_numtype,N_rank>(dataFirst, shape, deletionPolicy, storage) 
    109129        , initialized(true) 
    110       {} 
     130      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    111131 
    112132      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride, 
     
    114134        : Array<T_numtype,N_rank>(dataFirst, shape, stride, deletionPolicy, storage) 
    115135        , initialized(true) 
    116       {} 
     136      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    117137 
    118138      CArray(const TinyVector<int, N_rank>& extent, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    119139        : Array<T_numtype,N_rank>(extent, storage) 
    120140        , initialized(true) 
    121       {} 
     141      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    122142 
    123143      CArray(const TinyVector<int, N_rank>& lbounds, const TinyVector<int, N_rank>& extent, 
     
    125145        : Array<T_numtype,N_rank>(lbounds, extent, storage) 
    126146        , initialized(true) 
    127       {} 
     147      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    128148 
    129149      CArray(Range r0, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    130150        : Array<T_numtype,N_rank>(r0, storage) 
    131151        , initialized(true) 
    132       {} 
     152      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    133153 
    134154      CArray(Range r0, Range r1, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    135155        : Array<T_numtype,N_rank>(r0, r1, storage) 
    136156        , initialized(true) 
    137       {} 
     157      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    138158 
    139159      CArray(Range r0, Range r1, Range r2, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    140160        : Array<T_numtype,N_rank>(r0, r1, r2, storage) 
    141161        , initialized(true) 
    142       {} 
     162      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    143163 
    144164      CArray(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    145165        : Array<T_numtype,N_rank>(r0, r1, r2, r3, storage) 
    146166        , initialized(true) 
    147       {} 
     167      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    148168 
    149169      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    150170        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, storage) 
    151171        , initialized(true) 
    152       {} 
     172      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    153173 
    154174      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, GeneralArrayStorage<N_rank> storage = T_default_storage()) 
    155175        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, storage) 
    156176        , initialized(true) 
    157       {} 
     177      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    158178 
    159179      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, 
     
    161181        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, storage) 
    162182        , initialized(true) 
    163       {} 
     183      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    164184 
    165185      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, 
     
    167187        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, storage) 
    168188        , initialized(true) 
    169       {} 
     189      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    170190 
    171191      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    173193        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, storage) 
    174194        , initialized(true) 
    175       {} 
     195      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    176196 
    177197      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    179199        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, storage) 
    180200        , initialized(true) 
    181       {} 
     201      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    182202 
    183203      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7, 
     
    185205        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, storage) 
    186206        , initialized(true) 
    187       {} 
     207      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    188208 
    189209      CArray(const CArray<T_numtype, N_rank>& array) 
    190210        : Array<T_numtype,N_rank>(array) 
    191211        , initialized(array.initialized) 
    192       {} 
     212      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    193213 
    194214      CArray(const Array<T_numtype, N_rank>& array) 
    195215        : Array<T_numtype,N_rank>(array) 
    196216        , initialized(true) 
    197       {} 
     217      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    198218 
    199219      CArray(const TinyVector<int,N_rank-1>& shape, int lastExtent, const GeneralArrayStorage<N_rank>& storage) 
    200220        : Array<T_numtype,N_rank>(shape, lastExtent, storage) 
    201221        , initialized(true) 
    202       {} 
     222      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    203223 
    204224      CArray(Array<T_numtype, N_rank>& array, Range r0) 
    205225        : Array<T_numtype,N_rank>(array, r0) 
    206226        , initialized(true) 
    207       {} 
     227      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    208228 
    209229      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1) 
    210230        : Array<T_numtype,N_rank>(array, r0, r1) 
    211231        , initialized(true) 
    212       {} 
     232      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    213233 
    214234      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2) 
    215235        : Array<T_numtype,N_rank>( array, r0, r1, r2) 
    216236        , initialized(true) 
    217       {} 
     237      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    218238 
    219239      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3) 
    220240        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3) 
    221241        , initialized(true) 
    222       {} 
     242      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    223243 
    224244      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, 
     
    226246        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3,  r4) 
    227247        , initialized(true) 
    228       {} 
     248      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    229249 
    230250      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, 
     
    232252        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5) 
    233253        , initialized(true) 
    234       {} 
     254      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    235255 
    236256      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, 
     
    238258        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5, r6) 
    239259        , initialized(true) 
    240       {} 
     260      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    241261 
    242262      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, 
     
    244264        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7) 
    245265        , initialized(true) 
    246       {} 
     266      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    247267 
    248268      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    250270        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8) 
    251271        , initialized(true) 
    252       {} 
     272      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    253273 
    254274      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, 
     
    256276        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9) 
    257277        , initialized(true) 
    258       {} 
     278      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    259279 
    260280      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, 
     
    262282        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10) 
    263283        , initialized(true) 
    264       {} 
     284      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    265285 
    266286      CArray(Array<T_numtype, N_rank>& array, const RectDomain<N_rank>& subdomain) 
    267287        : Array<T_numtype,N_rank>(array, subdomain) 
    268288        , initialized(true) 
    269       {} 
     289      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    270290 
    271291      CArray(Array<T_numtype, N_rank>& array, const StridedDomain<N_rank>& subdomain) 
    272292        : Array<T_numtype,N_rank>(array, subdomain) 
    273293        , initialized(true) 
    274       {} 
     294      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} 
    275295 
    276296      template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, 
     
    279299        : Array<T_numtype,N_rank>(array, r0,r1, r2, r3, r4, r5, r6, r7, r8, r9, r10) 
    280300        , initialized(true) 
    281       {} 
     301      { bool neverTrue ; neverTrue=false ; bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } 
    282302 
    283303      virtual ~CArray() {} 
     
    547567      virtual bool isEmpty(void) const { return !initialized; } 
    548568      virtual size_t size(void) const { return size(this->numElements()); } 
     569      virtual std::vector<T_numtype> getVector(void) { return vector<T_numtype>(this->dataFirst(),this->dataFirst()+this->numElements()) ;} 
    549570      static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); } 
    550  
     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       
    551613      virtual CBaseType* clone(void) const { return new CArray(*this); } 
    552614 
     
    578640        return ret; 
    579641      } 
     642 
    580643  }; 
     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_)\ 
     653macrotyperank(_TYPE_,1)\ 
     654macrotyperank(_TYPE_,2)\ 
     655macrotyperank(_TYPE_,3)\ 
     656macrotyperank(_TYPE_,4)\ 
     657macrotyperank(_TYPE_,5)\ 
     658macrotyperank(_TYPE_,6)\ 
     659macrotyperank(_TYPE_,7) 
     660 
     661macrotype(double) 
     662macrotype(int) 
     663macrotype(bool) 
     664macrotype(size_t) 
     665macrotype(float) 
     666macrotype(string) 
     667 
     668#undef macrotyperank 
     669#undef macrotype 
     670 
    581671 
    582672 
  • XIOS/dev/dev_trunk_graph/src/attribute.hpp

    r1686 r2019  
    4242            virtual void fromString(const StdString & str) = 0; 
    4343            virtual StdString dump(void) const = 0; 
    44             virtual StdString dump4graph(void) const = 0; 
     44            virtual StdString dumpGraph(void) const = 0; 
    4545            virtual bool isEqual(const CAttribute& ) = 0; 
    4646 
  • XIOS/dev/dev_trunk_graph/src/attribute_array.hpp

    r1686 r2019  
    2121      { 
    2222        public : 
    23  
    24            using CArray<T_numtype,N_rank>::operator = ; 
     23            using CArray<T_numtype,N_rank>::operator = ; 
    2524 
    2625            /// Constructeurs /// 
     
    5655            virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer); } 
    5756            virtual string dump(void) const { return _dump();} 
    58             virtual string dump4graph(void) const { return _dump4graph();} 
     57            virtual string dumpGraph(void) const { return _dumpGraph();} 
    5958 
    6059            virtual void generateCInterface(ostream& oss,const string& className) ; 
     
    6665            virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ; 
    6766            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ; 
     67  
     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           } 
    68108 
    69109         private : 
     
    72112          StdString _toString(void) const; 
    73113          StdString _dump(void) const; 
    74           StdString _dump4graph(void) const; 
     114          StdString _dumpGraph(void) const; 
    75115          void _fromString(const StdString & str); 
    76116          bool _toBuffer  (CBufferOut& buffer) const; 
    77117          bool _fromBuffer(CBufferIn& buffer) ; 
    78118      }; // class CAttributeEnum 
     119 
     120 
     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_)\ 
     128macrotyperank(_TYPE_,1)\ 
     129macrotyperank(_TYPE_,2)\ 
     130macrotyperank(_TYPE_,3)\ 
     131macrotyperank(_TYPE_,4)\ 
     132macrotyperank(_TYPE_,5)\ 
     133macrotyperank(_TYPE_,6)\ 
     134macrotyperank(_TYPE_,7) 
     135 
     136macrotype(double) 
     137macrotype(int) 
     138macrotype(bool) 
     139macrotype(size_t) 
     140macrotype(float) 
     141macrotype(string) 
     142 
     143#undef macrotyperank 
     144#undef macrotype 
    79145} // namespace xios 
    80146 
  • XIOS/dev/dev_trunk_graph/src/attribute_array_impl.hpp

    r1686 r2019  
    1414      CAttributeArray<T_numtype, N_rank>::CAttributeArray(const StdString & id) 
    1515         : CAttribute(id) 
    16       { /* Ne rien faire de plus */ } 
     16      { bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); } 
    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); 
    2223         this->setValue(value); 
    2324      } 
     
    2728         : CAttribute(id) 
    2829      { 
     30         bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    2931         umap.insert(umap.end(), std::make_pair(id, this)); 
    3032      } 
     
    3537         : CAttribute(id) 
    3638      { 
     39         bool alwaysFalse ; alwaysFalse=false ; if (alwaysFalse) TV_ttf_display_type(this); 
    3740         this->setValue(value); 
    3841         umap.insert(umap.end(), std::make_pair(id, this)); 
     
    137140      return (oss.str()); 
    138141    } 
    139  
    140     template <typename T_numtype, int N_rank> 
    141     StdString CAttributeArray<T_numtype,N_rank>::_dump4graph(void) const 
     142     
     143    template <typename T_numtype, int N_rank> 
     144    StdString CAttributeArray<T_numtype,N_rank>::_dumpGraph(void) const 
    142145    { 
    143146      StdOStringStream oss; 
  • XIOS/dev/dev_trunk_graph/src/attribute_enum.hpp

    r1686 r2019  
    6363            virtual void fromString(const StdString & str) { if (str==resetInheritanceStr) { reset(); _canInherite=false ;}  else _fromString(str);} 
    6464            virtual StdString dump(void) const { return _toString();} 
    65             virtual StdString dump4graph(void) const { return _dump4graph();} 
     65            virtual StdString dumpGraph(void) const { return _dumpGraph();} 
    6666 
    6767            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);}  
     
    8080          bool isEqual_(const CAttributeEnum& attr ); 
    8181          StdString _toString(void) const; 
    82           StdString _dump4graph(void) const; 
    8382          void _fromString(const StdString & str); 
    8483          bool _toBuffer  (CBufferOut& buffer) const; 
    8584          bool _fromBuffer(CBufferIn& buffer) ; 
    8685          CEnum<T> inheritedValue ; 
     86          StdString _dumpGraph(void) const; 
    8787      }; // class CAttributeEnum     
    8888    
  • XIOS/dev/dev_trunk_graph/src/attribute_enum_impl.hpp

    r1686 r2019  
    1010namespace xios 
    1111{ 
    12   /// ////////////////////// Définitions ////////////////////// /// 
     12  /// ////////////////////// Dfinitions ////////////////////// /// 
    1313  template <class T> 
    1414  CAttributeEnum<T>::CAttributeEnum(const StdString & id) 
     
    149149  } 
    150150 
    151 template <class T> 
    152   StdString CAttributeEnum<T>::_dump4graph(void) const 
     151  template <class T> 
     152  void CAttributeEnum<T>::_fromString(const StdString & str) 
     153  { 
     154    CEnum<T>::fromString(str); 
     155  } 
     156 
     157  template <class T> 
     158  bool CAttributeEnum<T>::_toBuffer (CBufferOut& buffer) const 
     159  { 
     160     return CEnum<T>::toBuffer(buffer); 
     161  } 
     162 
     163  template <class T> 
     164  bool CAttributeEnum<T>::_fromBuffer(CBufferIn& buffer) 
     165  { 
     166    return CEnum<T>::fromBuffer(buffer); 
     167  } 
     168 
     169  template <typename T> 
     170  void CAttributeEnum<T>::generateCInterface(ostream& oss,const string& className) 
     171  { 
     172    CInterface::AttributeCInterface<CEnumBase>(oss, className, this->getName()); 
     173  } 
     174 
     175  template <typename T> 
     176  void CAttributeEnum<T>::generateFortran2003Interface(ostream& oss,const string& className) 
     177  { 
     178    CInterface::AttributeFortran2003Interface<string>(oss, className, this->getName()); 
     179  } 
     180 
     181  template <typename T> 
     182  void CAttributeEnum<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
     183  { 
     184    CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()+"_"); 
     185  } 
     186 
     187  template <typename T> 
     188  void CAttributeEnum<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
     189  { 
     190    CInterface::AttributeFortranInterfaceBody<string>(oss, className, this->getName()); 
     191  } 
     192 
     193  template <typename T> 
     194  void CAttributeEnum<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
     195  { 
     196    CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()); 
     197  } 
     198 
     199  template <typename T> 
     200  void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
     201  { 
     202    CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()+"_"); 
     203  } 
     204 
     205  template <typename T> 
     206  void CAttributeEnum<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
     207  { 
     208    CInterface::AttributeFortranInterfaceGetBody<string>(oss, className, this->getName()); 
     209  } 
     210 
     211  template <typename T> 
     212  void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
     213  { 
     214    CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()); 
     215  } 
     216   
     217  template <class T> 
     218  StdString CAttributeEnum<T>::_dumpGraph(void) const 
    153219  { 
    154220     StdOStringStream oss; 
     
    157223     return (oss.str()); 
    158224  } 
    159  
    160   template <class T> 
    161   void CAttributeEnum<T>::_fromString(const StdString & str) 
    162   { 
    163     CEnum<T>::fromString(str); 
    164   } 
    165  
    166   template <class T> 
    167   bool CAttributeEnum<T>::_toBuffer (CBufferOut& buffer) const 
    168   { 
    169      return CEnum<T>::toBuffer(buffer); 
    170   } 
    171  
    172   template <class T> 
    173   bool CAttributeEnum<T>::_fromBuffer(CBufferIn& buffer) 
    174   { 
    175     return CEnum<T>::fromBuffer(buffer); 
    176   } 
    177  
    178   template <typename T> 
    179   void CAttributeEnum<T>::generateCInterface(ostream& oss,const string& className) 
    180   { 
    181     CInterface::AttributeCInterface<CEnumBase>(oss, className, this->getName()); 
    182   } 
    183  
    184   template <typename T> 
    185   void CAttributeEnum<T>::generateFortran2003Interface(ostream& oss,const string& className) 
    186   { 
    187     CInterface::AttributeFortran2003Interface<string>(oss, className, this->getName()); 
    188   } 
    189  
    190   template <typename T> 
    191   void CAttributeEnum<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
    192   { 
    193     CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()+"_"); 
    194   } 
    195  
    196   template <typename T> 
    197   void CAttributeEnum<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
    198   { 
    199     CInterface::AttributeFortranInterfaceBody<string>(oss, className, this->getName()); 
    200   } 
    201  
    202   template <typename T> 
    203   void CAttributeEnum<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
    204   { 
    205     CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()); 
    206   } 
    207  
    208   template <typename T> 
    209   void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
    210   { 
    211     CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()+"_"); 
    212   } 
    213  
    214   template <typename T> 
    215   void CAttributeEnum<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
    216   { 
    217     CInterface::AttributeFortranInterfaceGetBody<string>(oss, className, this->getName()); 
    218   } 
    219  
    220   template <typename T> 
    221   void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
    222   { 
    223     CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()); 
    224   } 
    225225} // namespace xios 
    226226 
  • XIOS/dev/dev_trunk_graph/src/attribute_map.cpp

    r1686 r2019  
    5959      } 
    6060 
    61  
    62  
    63       StdString CAttributeMap::record4graphXiosAttributes(void) const 
     61      ///-------------------------------------------------------------- 
     62      /*! 
     63        Record all non-empty attributes of an object (used only for field) for graph 
     64      */ 
     65      StdString CAttributeMap::recordXiosAttributes(void) const 
    6466      { 
    6567        int maxNbChar = 250; 
     
    7476            if (str.length() < maxNbChar) 
    7577            { 
    76               str.append(att.second->dump4graph()); 
     78              str.append(att.second->dumpGraph()); 
    7779              str.append(" "); 
    7880            } 
  • XIOS/dev/dev_trunk_graph/src/attribute_map.hpp

    r1686 r2019  
    3939            void clearAllAttributes(void); 
    4040            StdString dumpXiosAttributes(void) const; 
    41             StdString record4graphXiosAttributes(void) const; 
     41            StdString recordXiosAttributes(void) const; 
    4242 
    4343            void clearAttribute(const StdString& key); 
  • XIOS/dev/dev_trunk_graph/src/attribute_template.hpp

    r1686 r2019  
    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 
    1420 
    1521namespace xios 
     
    2026    The class implements attribute of some basic types 
    2127  */ 
    22       template <class T> 
     28       template <class T> 
    2329         class CAttributeTemplate : public CAttribute, public CType<T> 
    2430      { 
     
    3743            CAttributeTemplate(const StdString & id, const ValueType & value, 
    3844                               xios_map<StdString, CAttribute*> & umap); 
    39 //            CAttributeTemplate(const CAttribute & attribut) throw (CException); 
    40 //            CAttributeTemplate(const CAttribute * const attribut); // Not implemented. 
    4145 
    4246          public : 
     
    4448            /// Accesseur /// 
    4549            ValueType getValue(void) const; 
    46 //            ValueType* getRef(void) ; 
    4750 
    4851            /// Mutateurs /// 
     
    7174            virtual StdString toString(void) const { return _toString();} 
    7275            virtual void fromString(const StdString & str) { if (str==resetInheritanceStr) { reset(); _canInherite=false ;}  else _fromString(str);} 
    73 //            virtual CAttributeTemplate* clone() const {} 
    74 //            virtual void toBinary  (StdOStream & os) const; 
    75 //            virtual void fromBinary(StdIStream & is); 
     76 
    7677            virtual StdString dump(void) const { return _dump();} 
    77             virtual StdString dump4graph(void) const { return _dump4graph();} 
     78            virtual StdString dumpGraph(void) const { return _dumpGraph();} 
    7879 
    7980            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);} 
    8081            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 //            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) ; 
     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           } 
    93122 
    94123 
     
    101130          StdString _toString(void) const; 
    102131          StdString _dump(void) const; 
    103           StdString _dump4graph(void) const; 
     132          StdString _dumpGraph(void) const; 
    104133          void _fromString(const StdString & str); 
    105134          bool _toBuffer  (CBufferOut& buffer) const; 
     
    109138      }; // class CAttribute 
    110139 
     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 
     146macrotype(double) 
     147macrotype(int) 
     148macrotype(bool) 
     149macrotype(string) 
     150//macrotype(CDate) 
     151//macrotype(CDuration) 
     152#undef macrotype 
    111153 
    112154   template <class T>  void FromBinary(StdIStream & is, T & obj); 
     155 
    113156 
    114157} // namespace xios 
  • XIOS/dev/dev_trunk_graph/src/attribute_template_impl.hpp

    r1686 r2019  
    2424         this->setValue(value); 
    2525      } 
    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 */ 
     26 
    3627      template <class T> 
    3728         CAttributeTemplate<T>::CAttributeTemplate(const StdString & id, 
     
    5142         umap.insert(umap.end(), std::make_pair(id, this)); 
    5243      } 
    53 /* 
    54       template <class T> 
    55       CAttributeTemplate<T>::~CAttributeTemplate(void) 
    56       { 
    57 //         this->CType<T>::reset() ; 
    58 //         this->clear(); 
    59       } 
    60 */ 
     44 
    6145      ///-------------------------------------------------------------- 
    6246      template <class T> 
     
    8569      { 
    8670        return CType<T>::get() ; 
    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 */ 
     71      } 
     72 
     73 
    11274 
    11375      template <class T> 
     
    11577      { 
    11678         CType<T>::set(value) ; 
    117 //         SuperClass::setValue<T>(value); 
    11879      } 
    11980 
     
    179140      { 
    180141         this->setValue(value); 
    181 //         return (this->getValue()); 
    182142         return *this; 
    183143      } 
     
    210170         return (oss.str()); 
    211171      } 
    212  
    213       template <class T> 
    214          StdString CAttributeTemplate<T>::_dump4graph(void) const 
     172       
     173      template <class T> 
     174         StdString CAttributeTemplate<T>::_dumpGraph(void) const 
    215175      { 
    216176         StdOStringStream oss; 
  • XIOS/dev/dev_trunk_graph/src/buffer_client.cpp

    r1227 r2019  
    1212  size_t CClientBuffer::maxRequestSize = 0; 
    1313 
    14   CClientBuffer::CClientBuffer(MPI_Comm interComm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents) 
     14  CClientBuffer::CClientBuffer(MPI_Comm interComm, vector<MPI_Win>& windows, int clientRank, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize) 
    1515    : interComm(interComm) 
     16    , clientRank_(clientRank) 
    1617    , serverRank(serverRank) 
    1718    , bufferSize(bufferSize) 
     
    2021    , current(0) 
    2122    , count(0) 
    22     , bufferedEvents(0) 
    23     , maxBufferedEvents(maxBufferedEvents) 
    2423    , pending(false) 
    25   { 
    26     buffer[0] = new char[bufferSize]; // transform it with MPI_ALLOC_MEM later 
    27     buffer[1] = new char[bufferSize]; 
     24    , hasWindows(false)  
     25    , windows_(windows) 
     26  { 
     27    if (windows[0]==MPI_WIN_NULL && windows[1]==MPI_WIN_NULL) hasWindows=false ; 
     28    else hasWindows=true ; 
     29 
     30      MPI_Alloc_mem(bufferSize+headerSize, MPI_INFO_NULL, &bufferHeader[0]) ; 
     31      MPI_Alloc_mem(bufferSize+headerSize, MPI_INFO_NULL, &bufferHeader[1]) ; 
     32      buffer[0] = bufferHeader[0]+headerSize ; 
     33      buffer[1] = bufferHeader[1]+headerSize ; 
     34      firstTimeLine[0]=(size_t*)bufferHeader[0] ; 
     35      firstTimeLine[1]=(size_t*)bufferHeader[1] ; 
     36      bufferCount[0]=(size_t*)bufferHeader[0] +1 ; 
     37      bufferCount[1]=(size_t*)bufferHeader[1] +1 ; 
     38      control[0]=(size_t*)bufferHeader[0] +2 ; 
     39      control[1]=(size_t*)bufferHeader[1] +2 ; 
     40      finalize[0]=(size_t*)bufferHeader[0] +3 ; 
     41      finalize[1]=(size_t*)bufferHeader[1] +3 ; 
     42 
     43      *firstTimeLine[0]=0 ; 
     44      *firstTimeLine[1]=0 ; 
     45      *bufferCount[0]=0 ; 
     46      *bufferCount[1]=0 ; 
     47      *control[0]=0 ; 
     48      *control[1]=0 ; 
     49      *finalize[0]=0 ; 
     50      *finalize[1]=0 ; 
     51      winState[0]=false ; 
     52      winState[1]=false ; 
     53 
     54 
     55    if (hasWindows) 
     56    {   
     57     
     58      MPI_Win_attach(windows_[0], bufferHeader[0], bufferSize+headerSize) ; 
     59      MPI_Win_attach(windows_[1], bufferHeader[1], bufferSize+headerSize) ; 
     60     
     61      MPI_Group group ; 
     62      int groupSize,groupRank ; 
     63      MPI_Win_get_group(windows_[0], &group) ; 
     64      MPI_Group_size(group, &groupSize) ; 
     65      MPI_Group_rank(group, &groupRank) ; 
     66      if (groupRank!=clientRank_) ERROR("CClientBuffer::CClientBuffer",<< " ClientRank != groupRank "<<clientRank_<<" "<<groupRank); 
     67 
     68      MPI_Win_get_group(windows_[1], &group) ; 
     69      MPI_Group_size(group, &groupSize) ; 
     70      MPI_Group_rank(group, &groupRank) ; 
     71      if (groupRank!=clientRank_) ERROR("CClientBuffer::CClientBuffer",<< " ClientRank != groupRank "<<clientRank_<<" "<<groupRank); 
     72 
     73      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, clientRank_, 0, windows_[0]) ; 
     74      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, clientRank_, 0, windows_[1]) ; 
     75 
     76      MPI_Win_unlock(clientRank_, windows_[1]) ; 
     77      MPI_Win_unlock(clientRank_, windows_[0]) ; 
     78    }  
    2879    retBuffer = new CBufferOut(buffer[current], bufferSize); 
    29     info(10) << "CClientBuffer: allocated 2 x " << bufferSize << " bytes for server " << serverRank << " with a maximum of " << maxBufferedEvents << " buffered events" << endl; 
     80    info(10) << "CClientBuffer: allocated 2 x " << bufferSize << " bytes for server " << serverRank << endl; 
     81  } 
     82 
     83  MPI_Aint CClientBuffer::getWinAddress(int i) 
     84  { 
     85     MPI_Aint address ; 
     86      
     87     if (hasWindows) MPI_Get_address(bufferHeader[i], &address) ; 
     88     else address=0 ; 
     89 
     90     return address ; 
    3091  } 
    3192 
    3293  CClientBuffer::~CClientBuffer() 
    3394  { 
    34    delete [] buffer[0]; 
    35    delete [] buffer[1]; 
    36    delete retBuffer; 
     95     //freeWindows() ; 
     96     if (hasWindows) 
     97     { 
     98       MPI_Win_detach(windows_[0],bufferHeader[0]); 
     99       MPI_Win_detach(windows_[1],bufferHeader[1]); 
     100       MPI_Free_mem(bufferHeader[0]) ; 
     101       MPI_Free_mem(bufferHeader[1]) ; 
     102     } 
     103     delete retBuffer; 
     104  } 
     105 
     106/*  void CClientBuffer::createWindows(MPI_Comm oneSidedComm) 
     107  { 
     108    MPI_Barrier(oneSidedComm) ; 
     109    MPI_Win_create(bufferHeader[0], bufferSize+headerSize, 1, MPI_INFO_NULL, oneSidedComm, &(windows[0])) ; 
     110    MPI_Win_create(bufferHeader[1], bufferSize+headerSize, 1, MPI_INFO_NULL, oneSidedComm, &(windows[1])) ; 
     111 
     112    MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, windows[0]) ; 
     113    *firstTimeLine[0]=0 ; 
     114    *bufferCount[0]=0 ; 
     115    *control[0]=0 ; 
     116    MPI_Win_unlock(0, windows[0]) ; 
     117 
     118    MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, windows[1]) ; 
     119    *firstTimeLine[1]=0 ; 
     120    *bufferCount[1]=0 ; 
     121    *control[1]=0 ; 
     122    MPI_Win_unlock(0, windows[1]) ; 
     123    winState[0]=false ; 
     124    winState[1]=false ; 
     125    MPI_Barrier(oneSidedComm) ; 
     126    hasWindows=true ; 
     127  } 
     128*/ 
     129 
     130/*   
     131  void CClientBuffer::freeWindows() 
     132  { 
     133    if (hasWindows) 
     134    { 
     135      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, windows_[0]) ; 
     136      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, windows_[1]) ; 
     137      *control[0]=2 ; 
     138      *control[1]=2 ; 
     139      MPI_Win_unlock(0, windows_[1]) ; 
     140      MPI_Win_unlock(0, windows_[0]) ; 
     141       
     142      MPI_Win_free(&windows_[0]) ; 
     143      MPI_Win_free(&windows_[1]) ; 
     144      hasWindows=false ; 
     145    } 
     146  } 
     147*/  
     148  void CClientBuffer::lockBuffer(void) 
     149  { 
     150    if (hasWindows) 
     151    { 
     152   //   MPI_Win_lock(MPI_LOCK_EXCLUSIVE, clientRank_, 0, windows_[current]) ; 
     153      long long int lock=1 ; 
     154      long long int zero=0, one=1 ; 
     155      
     156      MPI_Win_lock(MPI_LOCK_EXCLUSIVE,clientRank_, 0, windows_[current]) ; 
     157      
     158      while(lock!=0) 
     159      { 
     160        MPI_Compare_and_swap(&one, &zero, &lock, MPI_LONG_LONG_INT, clientRank_, MPI_Aint_add(getWinAddress(current),2*sizeof(size_t)), 
     161                             windows_[current]) ; 
     162        MPI_Win_flush(clientRank_, windows_[current]) ; 
     163      } 
     164 
     165//      info(100)<<"Buffer locked "<<&windows_<<"  "<<current<<endl ; 
     166      winState[current]=true ; 
     167    } 
     168  } 
     169 
     170  void CClientBuffer::unlockBuffer(void) 
     171  { 
     172    if (hasWindows) 
     173    { 
     174      long long int lock=1 ; 
     175      long long int zero=0, one=1 ; 
     176 
     177      MPI_Compare_and_swap(&zero, &one, &lock, MPI_LONG_LONG_INT, clientRank_, MPI_Aint_add(getWinAddress(current),2*sizeof(size_t)), 
     178                             windows_[current]) ; 
     179      MPI_Win_unlock(clientRank_, windows_[current]) ; 
     180 
     181 //     info(100)<<"Buffer unlocked "<<&windows_<<"  "<<current<<endl ; 
     182      winState[current]=false ; 
     183    } 
    37184  } 
    38185 
     
    44191  bool CClientBuffer::isBufferFree(StdSize size) 
    45192  { 
     193//    bool loop=true ; 
     194//    while (loop)  
     195//    { 
     196//      lockBuffer(); 
     197//      if (*control[current]==0) loop=false ; // attemp to read from server ? 
     198//      else unlockBuffer() ; 
     199//    } 
     200   
     201    lockBuffer(); 
    46202    if (size > bufferSize) 
    47203      ERROR("bool CClientBuffer::isBufferFree(StdSize size)", 
     
    59215    } 
    60216 
    61  
    62     return (size <= remain() && bufferedEvents < maxBufferedEvents); 
    63   } 
    64  
    65  
    66   CBufferOut* CClientBuffer::getBuffer(StdSize size) 
     217      count=*bufferCount[current] ; 
     218      return (size <= remain()); 
     219  } 
     220 
     221 
     222  CBufferOut* CClientBuffer::getBuffer(size_t timeLine, StdSize size) 
    67223  { 
    68224    if (size <= remain()) 
     
    70226      retBuffer->realloc(buffer[current] + count, size); 
    71227      count += size; 
    72       bufferedEvents++; 
     228      if (*firstTimeLine[current]==0) *firstTimeLine[current]=timeLine ; 
     229      *bufferCount[current]=count ; 
     230/*      info(50)<<"CClientBuffer::getBuffer "<<" clientRank_ "<<clientRank_<<" serverRank "<<serverRank <<" current "<<current 
     231              <<" size "<<size<<" timeLine "<< timeLine <<" firstTimeLine "<<*firstTimeLine[current]<<" count "<<*bufferCount[current]<<endl ; 
     232      if (!winState[current]) info(40)<<"CClientBuffer::getBuffer "<<" Windows Not Locked... "<<" clientRank_ "<<clientRank_<<" serverRank "<<serverRank <<" current "<<current 
     233              <<" size "<<size<<" timeLine "<< timeLine <<" firstTimeLine "<<*firstTimeLine[current]<<" count "<<*bufferCount[current]<<endl ;*/ 
    73234      return retBuffer; 
    74235    } 
     
    81242  } 
    82243 
    83   bool CClientBuffer::checkBuffer(void) 
     244  void CClientBuffer::infoBuffer(void) 
     245  { 
     246       
     247      char checksum=0 ; 
     248      for(size_t i=0;i<*bufferCount[current];i++) checksum=checksum+buffer[current][i] ; 
     249  
     250      char checksumFirst=0 ; 
     251      for(size_t i=5; i<10 && i<*bufferCount[current] ;i++) checksumFirst=checksumFirst+buffer[current][i] ; 
     252  
     253      char checksumLast=0 ; 
     254      for(size_t i=(*bufferCount[current]<10)?0:*bufferCount[current]-10; i<*bufferCount[current] ; i++) checksumLast=checksumLast+buffer[current][i] ; 
     255  
     256      info(45)<<"CClientBuffer::infoBuffer "<<" clientRank_ "<<clientRank_<<" serverRank "<<serverRank <<" current "<<current<<" WinState "<<winState[current] 
     257              <<" firstTimeLine "<<*firstTimeLine[current]<<" count "<<*bufferCount[current]<<" checksum "<<(int)checksum<<" " 
     258              <<(int)buffer[current][0]<<" "<<(int)buffer[current][1]<<" "<<(int)buffer[current][2]<<" "<<(int)buffer[current][3]<<" "<<(int)buffer[current][4]<<" "<<(int)buffer[current][5]<<" " 
     259              <<(int)buffer[current][6]<<" "<<(int)buffer[current][7]<<" "<<(int)buffer[current][8]<<" "<<(int)buffer[current][9]<<" "<<(int)buffer[current][10]<<" "<<(int)buffer[current][11]<<endl ; 
     260 
     261  } 
     262 
     263  bool CClientBuffer::checkBuffer(bool send) 
    84264  { 
    85265    MPI_Status status; 
     
    96276    if (!pending) 
    97277    { 
     278      if (!send) return false ; 
    98279      if (count > 0) 
    99280      { 
    100         MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request); 
    101         pending = true; 
    102         if (current == 1) current = 0; 
    103         else current = 1; 
    104         count = 0; 
    105         bufferedEvents = 0; 
     281        lockBuffer() ; 
     282 //       if (*control[current]==0 && bufferCount[current] > 0) 
     283        if (*bufferCount[current] > 0) 
     284        { 
     285          MPI_Issend(buffer[current], count, MPI_CHAR, serverRank, 20, interComm, &request); 
     286          pending = true; 
     287//          *control[current]=0 ; 
     288          *firstTimeLine[current]=0 ; 
     289          *bufferCount[current]=0 ; 
     290 
     291           unlockBuffer() ; 
     292 
     293          if (current == 1) current = 0; 
     294          else current = 1; 
     295          count = 0; 
     296        } 
     297        else unlockBuffer() ; 
    106298      } 
    107299    } 
     
    112304  bool CClientBuffer::hasPendingRequest(void) 
    113305  { 
     306    
     307    lockBuffer() ; 
     308    count=*bufferCount[current] ; 
     309    unlockBuffer() ; 
     310 
    114311    return (pending || count > 0); 
    115312  } 
     313 
     314  bool CClientBuffer::isNotifiedFinalized(void) 
     315  { 
     316    
     317    bool ret ; 
     318    lockBuffer() ; 
     319    ret=*finalize[current] == 1 ? true : false ; 
     320    unlockBuffer() ; 
     321 
     322    return ret; 
     323  } 
     324 
    116325} 
  • XIOS/dev/dev_trunk_graph/src/buffer_client.hpp

    r1227 r2019  
    1414      static size_t maxRequestSize; 
    1515 
    16       CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
     16      CClientBuffer(MPI_Comm intercomm, vector<MPI_Win>& windows, int clientRank, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize); 
    1717      ~CClientBuffer(); 
    18  
     18//      void createWindows(MPI_Comm oneSidedComm) ; 
     19      void freeWindows(void) ; 
     20      void lockBuffer(void) ; 
     21      void unlockBuffer(void) ; 
     22       
    1923      bool isBufferFree(StdSize size); 
    20       CBufferOut* getBuffer(StdSize size); 
    21       bool checkBuffer(void); 
     24      CBufferOut* getBuffer(size_t timeLine, StdSize size); 
     25      bool checkBuffer(bool send=false); 
    2226      bool hasPendingRequest(void); 
    2327      StdSize remain(void); 
    24  
     28      MPI_Aint getWinAddress(int numWindows) ; 
     29      void infoBuffer(void) ; 
     30      bool isNotifiedFinalized(void) ; 
    2531    private: 
    2632      char* buffer[2]; 
    27  
     33      char* bufferHeader[2]; 
     34      size_t* firstTimeLine[2] ; 
     35      size_t* bufferCount[2] ; 
     36      size_t* control[2] ; 
     37      size_t* finalize[2] ; 
     38      bool winState[2] ; 
    2839      int current; 
    2940 
    3041      StdSize count; 
    31       StdSize bufferedEvents; 
    3242      StdSize maxEventSize; 
    33       const StdSize maxBufferedEvents; 
    3443      const StdSize bufferSize; 
    3544      const StdSize estimatedMaxEventSize; 
     
    3746 
    3847      const int serverRank; 
     48      const int clientRank_; 
    3949      bool pending; 
    4050 
     
    4353      CBufferOut* retBuffer; 
    4454      const MPI_Comm interComm; 
     55      std::vector<MPI_Win> windows_ ; 
     56      bool hasWindows ; 
     57      static const int headerSize=4*sizeof(size_t); 
    4558  }; 
    4659} 
  • XIOS/dev/dev_trunk_graph/src/buffer_decl.cpp

    r501 r2019  
    1717  macro(short) 
    1818  macro(long) 
     19  macro(longlong) 
    1920  macro(uint) 
    2021  macro(ushort) 
    2122  macro(ulong) 
     23  macro(ulonglong) 
    2224  macro(float) 
    2325  macro(double) 
  • XIOS/dev/dev_trunk_graph/src/buffer_impl.hpp

    r501 r2019  
    1010    template <> bool CBuffer::put<short>(const short& data) { return put_template(data) ; }   
    1111    template <> bool CBuffer::put<long>(const long& data)  { return put_template(data) ; }   
     12    template <> bool CBuffer::put<longlong>(const longlong& data)  { return put_template(data) ; }   
    1213    template <> bool CBuffer::put<uint>(const uint& data)  { return put_template(data) ; }   
    1314    template <> bool CBuffer::put<ushort>(const ushort& data) { return put_template(data) ; }   
    1415    template <> bool CBuffer::put<ulong>(const ulong& data) { return put_template(data) ; }   
     16    template <> bool CBuffer::put<ulonglong>(const ulonglong& data) { return put_template(data) ; }   
    1517    template <> bool CBuffer::put<float>(const float& data) { return put_template(data) ; }   
    1618    template <> bool CBuffer::put<double>(const double& data) { return put_template(data) ; }   
     
    2123    template <> bool CBuffer::put<short>(const short* data, size_t n) { return put_template(data,n) ; }   
    2224    template <> bool CBuffer::put<long>(const long* data, size_t n)  { return put_template(data,n) ; }   
     25    template <> bool CBuffer::put<longlong>(const longlong* data, size_t n)  { return put_template(data,n) ; }   
    2326    template <> bool CBuffer::put<uint>(const uint* data, size_t n)  { return put_template(data,n) ; }   
    2427    template <> bool CBuffer::put<ushort>(const ushort* data, size_t n) { return put_template(data,n) ; }   
    2528    template <> bool CBuffer::put<ulong>(const ulong* data, size_t n) { return put_template(data,n) ; }   
     29    template <> bool CBuffer::put<ulonglong>(const ulonglong* data, size_t n) { return put_template(data,n) ; }   
    2630    template <> bool CBuffer::put<float>(const float* data, size_t n) { return put_template(data,n) ; }   
    2731    template <> bool CBuffer::put<double>(const double* data, size_t n) { return put_template(data,n) ; }   
     
    3337    template <> bool CBuffer::put_ptr<short>(const short*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3438    template <> bool CBuffer::put_ptr<long>(const long*& data, size_t n)  { return put_ptr_template(data,n) ; }   
     39    template <> bool CBuffer::put_ptr<longlong>(const longlong*& data, size_t n)  { return put_ptr_template(data,n) ; }   
    3540    template <> bool CBuffer::put_ptr<uint>(const uint*& data, size_t n)  { return put_ptr_template(data,n) ; }   
    3641    template <> bool CBuffer::put_ptr<ushort>(const ushort*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3742    template <> bool CBuffer::put_ptr<ulong>(const ulong*& data, size_t n) { return put_ptr_template(data,n) ; }   
     43    template <> bool CBuffer::put_ptr<ulonglong>(const ulonglong*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3844    template <> bool CBuffer::put_ptr<float>(const float*& data, size_t n) { return put_ptr_template(data,n) ; }   
    3945    template <> bool CBuffer::put_ptr<double>(const double*& data, size_t n) { return put_ptr_template(data,n) ; }   
     
    4652    template <> bool CBuffer::get<short>(short& data) { return get_template(data) ; }   
    4753    template <> bool CBuffer::get<long>(long& data)  { return get_template(data) ; }   
     54    template <> bool CBuffer::get<longlong>(longlong& data)  { return get_template(data) ; }   
    4855    template <> bool CBuffer::get<uint>(uint& data)  { return get_template(data) ; }   
    4956    template <> bool CBuffer::get<ushort>(ushort& data) { return get_template(data) ; }   
    5057    template <> bool CBuffer::get<ulong>(ulong& data) { return get_template(data) ; }   
     58    template <> bool CBuffer::get<ulonglong>(ulonglong& data) { return get_template(data) ; }   
    5159    template <> bool CBuffer::get<float>(float& data) { return get_template(data) ; }   
    5260    template <> bool CBuffer::get<double>(double& data) { return get_template(data) ; }   
     
    5765    template <> bool CBuffer::get<short>(short* data, size_t n) { return get_template(data,n) ; }   
    5866    template <> bool CBuffer::get<long>(long* data, size_t n)  { return get_template(data,n) ; }   
     67    template <> bool CBuffer::get<longlong>(longlong* data, size_t n)  { return get_template(data,n) ; }   
    5968    template <> bool CBuffer::get<uint>(uint* data, size_t n)  { return get_template(data,n) ; }   
    6069    template <> bool CBuffer::get<ushort>(ushort* data, size_t n) { return get_template(data,n) ; }   
    6170    template <> bool CBuffer::get<ulong>(ulong* data, size_t n) { return get_template(data,n) ; }   
     71    template <> bool CBuffer::get<ulonglong>(ulonglong* data, size_t n) { return get_template(data,n) ; }   
    6272    template <> bool CBuffer::get<float>(float* data, size_t n) { return get_template(data,n) ; }   
    6373    template <> bool CBuffer::get<double>(double* data, size_t n) { return get_template(data,n) ; }   
     
    6878    template <> bool CBuffer::get_ptr<short>(short*& data, size_t n) { return get_ptr_template(data,n) ; }   
    6979    template <> bool CBuffer::get_ptr<long>(long*& data, size_t n)  { return get_ptr_template(data,n) ; }   
     80    template <> bool CBuffer::get_ptr<longlong>(longlong*& data, size_t n)  { return get_ptr_template(data,n) ; }   
    7081    template <> bool CBuffer::get_ptr<uint>(uint*& data, size_t n)  { return get_ptr_template(data,n) ; }   
    7182    template <> bool CBuffer::get_ptr<ushort>(ushort*& data, size_t n) { return get_ptr_template(data,n) ; }   
    7283    template <> bool CBuffer::get_ptr<ulong>(ulong*& data, size_t n) { return get_ptr_template(data,n) ; }   
     84    template <> bool CBuffer::get_ptr<ulonglong>(ulonglong*& data, size_t n) { return get_ptr_template(data,n) ; }   
    7385    template <> bool CBuffer::get_ptr<float>(float*& data, size_t n) { return get_ptr_template(data,n) ; }   
    7486    template <> bool CBuffer::get_ptr<double>(double*& data, size_t n) { return get_ptr_template(data,n) ; }   
  • XIOS/dev/dev_trunk_graph/src/buffer_in_decl.cpp

    r501 r2019  
    1414  macro(short) 
    1515  macro(long) 
     16  macro(longlong) 
    1617  macro(uint) 
    1718  macro(ushort) 
    1819  macro(ulong) 
     20  macro(ulonglong) 
    1921  macro(float) 
    2022  macro(double) 
  • XIOS/dev/dev_trunk_graph/src/buffer_in_impl.hpp

    r501 r2019  
    1212    template <> bool CBufferIn::get<short>(short& data) { return get_template(data) ; }   
    1313    template <> bool CBufferIn::get<long>(long& data)  { return get_template(data) ; }   
     14    template <> bool CBufferIn::get<longlong>(longlong& data)  { return get_template(data) ; }   
    1415    template <> bool CBufferIn::get<uint>(uint& data)  { return get_template(data) ; }   
    1516    template <> bool CBufferIn::get<ushort>(ushort& data) { return get_template(data) ; }   
    1617    template <> bool CBufferIn::get<ulong>(ulong& data) { return get_template(data) ; }   
     18    template <> bool CBufferIn::get<ulonglong>(ulonglong& data) { return get_template(data) ; }   
    1719    template <> bool CBufferIn::get<float>(float& data) { return get_template(data) ; }   
    1820    template <> bool CBufferIn::get<double>(double& data) { return get_template(data) ; }   
     
    2426    template <> bool CBufferIn::get<short>(short* data, size_t n) { return get_template(data,n) ; }   
    2527    template <> bool CBufferIn::get<long>(long* data, size_t n)  { return get_template(data,n) ; }   
     28    template <> bool CBufferIn::get<longlong>(longlong* data, size_t n)  { return get_template(data,n) ; }   
    2629    template <> bool CBufferIn::get<uint>(uint* data, size_t n)  { return get_template(data,n) ; }   
    2730    template <> bool CBufferIn::get<ushort>(ushort* data, size_t n) { return get_template(data,n) ; }   
    2831    template <> bool CBufferIn::get<ulong>(ulong* data, size_t n) { return get_template(data,n) ; }   
     32    template <> bool CBufferIn::get<ulonglong>(ulonglong* data, size_t n) { return get_template(data,n) ; }   
    2933    template <> bool CBufferIn::get<float>(float* data, size_t n) { return get_template(data,n) ; }   
    3034    template <> bool CBufferIn::get<double>(double* data, size_t n) { return get_template(data,n) ; }   
     
    3640    template <> bool CBufferIn::advance<short>(size_t n) { return advance_template<short>(n) ; }   
    3741    template <> bool CBufferIn::advance<long>(size_t n)  { return advance_template<long>(n) ; }   
     42    template <> bool CBufferIn::advance<longlong>(size_t n)  { return advance_template<longlong>(n) ; }   
    3843    template <> bool CBufferIn::advance<uint>(size_t n)  { return advance_template<uint>(n) ; }   
    3944    template <> bool CBufferIn::advance<ushort>(size_t n) { return advance_template<ushort>(n) ; }   
    4045    template <> bool CBufferIn::advance<ulong>(size_t n) { return advance_template<ulong>(n) ; }   
     46    template <> bool CBufferIn::advance<ulonglong>(size_t n) { return advance_template<ulonglong>(n) ; }   
    4147    template <> bool CBufferIn::advance<float>(size_t n) { return advance_template<float>(n) ; }   
    4248    template <> bool CBufferIn::advance<double>(size_t n) { return advance_template<double>(n) ; }   
  • XIOS/dev/dev_trunk_graph/src/buffer_out_decl.cpp

    r501 r2019  
    1515  macro(short) 
    1616  macro(long) 
     17  macro(longlong) 
    1718  macro(uint) 
    1819  macro(ushort) 
    1920  macro(ulong) 
     21  macro(ulonglong) 
    2022  macro(float) 
    2123  macro(double) 
  • XIOS/dev/dev_trunk_graph/src/buffer_out_impl.hpp

    r501 r2019  
    1111    template <> bool CBufferOut::put<short>(const short& data) { return put_template(data) ; }   
    1212    template <> bool CBufferOut::put<long>(const long& data)  { return put_template(data) ; }   
     13    template <> bool CBufferOut::put<longlong>(const longlong& data)  { return put_template(data) ; }   
    1314    template <> bool CBufferOut::put<uint>(const uint& data)  { return put_template(data) ; }   
    1415    template <> bool CBufferOut::put<ushort>(const ushort& data) { return put_template(data) ; }   
    1516    template <> bool CBufferOut::put<ulong>(const ulong& data) { return put_template(data) ; }   
     17    template <> bool CBufferOut::put<ulonglong>(const ulonglong& data) { return put_template(data) ; }   
    1618    template <> bool CBufferOut::put<float>(const float& data) { return put_template(data) ; }   
    1719    template <> bool CBufferOut::put<double>(const double& data) { return put_template(data) ; }   
     
    2325    template <> bool CBufferOut::put<short>(const short* data, size_t n) { return put_template(data,n) ; }   
    2426    template <> bool CBufferOut::put<long>(const long* data, size_t n)  { return put_template(data,n) ; }   
     27    template <> bool CBufferOut::put<longlong>(const longlong* data, size_t n)  { return put_template(data,n) ; }   
    2528    template <> bool CBufferOut::put<uint>(const uint* data, size_t n)  { return put_template(data,n) ; }   
    2629    template <> bool CBufferOut::put<ushort>(const ushort* data, size_t n) { return put_template(data,n) ; }   
    2730    template <> bool CBufferOut::put<ulong>(const ulong* data, size_t n) { return put_template(data,n) ; }   
     31    template <> bool CBufferOut::put<ulonglong>(const ulonglong* data, size_t n) { return put_template(data,n) ; }   
    2832    template <> bool CBufferOut::put<float>(const float* data, size_t n) { return put_template(data,n) ; }   
    2933    template <> bool CBufferOut::put<double>(const double* data, size_t n) { return put_template(data,n) ; }   
     
    3640    template <> bool CBufferOut::advance<short>(size_t n) { return advance_template<short>(n) ; }   
    3741    template <> bool CBufferOut::advance<long>(size_t n)  { return advance_template<long>(n) ; }   
     42    template <> bool CBufferOut::advance<longlong>(size_t n)  { return advance_template<longlong>(n) ; }   
    3843    template <> bool CBufferOut::advance<uint>(size_t n)  { return advance_template<uint>(n) ; }   
    3944    template <> bool CBufferOut::advance<ushort>(size_t n) { return advance_template<ushort>(n) ; }   
    4045    template <> bool CBufferOut::advance<ulong>(size_t n) { return advance_template<ulong>(n) ; }   
     46    template <> bool CBufferOut::advance<ulonglong>(size_t n) { return advance_template<ulonglong>(n) ; }   
    4147    template <> bool CBufferOut::advance<float>(size_t n) { return advance_template<float>(n) ; }   
    4248    template <> bool CBufferOut::advance<double>(size_t n) { return advance_template<double>(n) ; }   
  • XIOS/dev/dev_trunk_graph/src/buffer_server.cpp

    r885 r2019  
    77{ 
    88 
    9   CServerBuffer::CServerBuffer(StdSize buffSize) 
     9  CServerBuffer::CServerBuffer(vector<MPI_Win>& windows, vector<MPI_Aint>& winAddress, int windowsRank, StdSize buffSize)  
     10  : hasWindows(true), windows_(windows), windowsRank_(windowsRank), winAddress_(winAddress) 
    1011  { 
    1112    size = 3 * buffSize; 
     
    1314    current = 1; 
    1415    end = size; 
     16    used=0 ; 
    1517    buffer = new char[size]; // use MPI_ALLOC_MEM later? 
     18    currentWindows=1 ; 
     19    if (windows[0]==MPI_WIN_NULL && windows[1]==MPI_WIN_NULL) hasWindows=false ; 
    1620  } 
    1721 
     
    2125  } 
    2226 
     27  void CServerBuffer::updateCurrentWindows(void) 
     28  { 
     29    if (currentWindows==0) currentWindows=1 ; 
     30    else currentWindows=0 ; 
     31  } 
     32 
     33/* 
     34  void CServerBuffer::createWindows(MPI_Comm oneSidedComm) 
     35  { 
     36    MPI_Barrier(oneSidedComm) ; 
     37    MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, oneSidedComm, &(windows[0])) ; 
     38    MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, oneSidedComm, &(windows[1])) ; 
     39    hasWindows=true ; 
     40    updateCurrentWindows() ; 
     41    MPI_Barrier(oneSidedComm) ; 
     42  } 
     43*/ 
     44 
     45/* 
     46  bool CServerBuffer::freeWindows() 
     47  { 
     48    if (hasWindows) 
     49    { 
     50      size_t header[3] ; 
     51      size_t& control=header[2] ; 
     52      MPI_Win_lock(MPI_LOCK_EXCLUSIVE,0,0,windows_[0]) ; 
     53      MPI_Get(&control, 1, MPI_LONG_LONG_INT, windowsRank , 2*sizeof(size_t), 1, MPI_LONG_LONG_INT,windows[0]) ; 
     54      MPI_Win_unlock(0,windows[0]) ; 
     55      if (control==2)  // ok for free windows 
     56      { 
     57        MPI_Win_free( &(windows[0])) ; 
     58        MPI_Win_free( &(windows[1])) ; 
     59        hasWindows=false ; 
     60        return true ; 
     61      } 
     62      else return false ; 
     63    } 
     64    else return true ; 
     65  } 
     66*/ 
    2367 
    2468  bool CServerBuffer::isBufferFree(size_t count) 
     
    72116  } 
    73117 
     118  bool CServerBuffer::isBufferEmpty(void) 
     119  { 
     120    if (used==0) return true ; 
     121    else return false; 
     122  } 
    74123 
    75124  void* CServerBuffer::getBuffer(size_t count) 
     
    128177    } 
    129178 
     179    used+=count ; 
    130180    return ret ; 
    131181  } 
     
    167217      } 
    168218    } 
    169   } 
    170  
     219    used-=count ; 
     220  } 
     221 
     222  bool CServerBuffer::getBufferFromClient(size_t timeLine, char*& buffer, size_t& count) 
     223  { 
     224    if (!hasWindows) return false ; 
     225 
     226     
     227    size_t header[3] ; 
     228    size_t& clientTimeline=header[0] ; 
     229    size_t& clientCount=header[1] ; 
     230    size_t& control=header[2] ; 
     231    bool ok=false ; 
     232     
     233    MPI_Group group ; 
     234    int groupSize,groupRank ; 
     235    MPI_Win_get_group(windows_[currentWindows], &group) ; 
     236    MPI_Group_size(group, &groupSize) ; 
     237    MPI_Group_rank(group, &groupRank) ; 
     238     
     239    lockBuffer();  
     240 
     241// lock is acquired 
     242 
     243    MPI_Get(&clientTimeline, 1, MPI_LONG_LONG_INT, windowsRank_ , MPI_Aint_add(winAddress_[currentWindows],0), 1, MPI_LONG_LONG_INT,windows_[currentWindows]) ; 
     244    MPI_Get(&clientCount, 1, MPI_LONG_LONG_INT, windowsRank_ , MPI_Aint_add(winAddress_[currentWindows],sizeof(size_t)), 1, MPI_LONG_LONG_INT,windows_[currentWindows]) ; 
     245    MPI_Win_flush(windowsRank_, windows_[currentWindows]) ; 
     246 
     247//    control=1 ; 
     248//    MPI_Put(&control, 1, MPI_LONG_LONG_INT, windowsRank_ , MPI_Aint_add(winAddress_[currentWindows],2*sizeof(size_t)), 1, MPI_LONG_LONG_INT,windows_[currentWindows]) ; 
     249    
     250//    MPI_Win_unlock(windowsRank_, windows_[currentWindows]) ; 
     251    MPI_Win_flush(windowsRank_, windows_[currentWindows]) ; 
     252//    info(100)<<"getBufferFromClient : windowsRank "<<windowsRank_<<" timeline "<<timeLine<<" clientTimeline "<<clientTimeline<<" clientCount "<<clientCount<<endl ; 
     253    if (timeLine==clientTimeline) 
     254    { 
     255//      info(50)<<"getBufferFromClient timeLine==clientTimeLine: windowsRank "<<windowsRank_<<" timeline "<<timeLine<<" clientTimeline "<<clientTimeline<<" clientCount "<<clientCount<<endl ; 
     256  
     257//      MPI_Win_lock(MPI_LOCK_EXCLUSIVE,windowsRank_,0,windows_[currentWindows]) ; 
     258      buffer=(char*)getBuffer(clientCount) ; 
     259      count=clientCount ; 
     260      MPI_Get(buffer, clientCount, MPI_CHAR, windowsRank_, MPI_Aint_add(winAddress_[currentWindows],4*sizeof(size_t)) , clientCount, MPI_CHAR, windows_[currentWindows]) ; 
     261      clientTimeline = 0 ; 
     262      clientCount = 0 ; 
     263//      control=0 ; 
     264      MPI_Put(&header[0], 2, MPI_LONG_LONG_INT, windowsRank_, MPI_Aint_add(winAddress_[currentWindows],0) , 2, MPI_LONG_LONG_INT,windows_[currentWindows]) ; 
     265 
     266// release lock 
     267     unlockBuffer() ; 
     268 
     269      ok=true ; 
     270      char checksum=0 ; 
     271      for(size_t i=0;i<count;i++) checksum=checksum+buffer[i] ; 
     272      char checksumFirst=0 ; 
     273      for(size_t i=5; i<10 && i<count ;i++) checksumFirst=checksumFirst+buffer[i] ; 
     274      char checksumLast=0 ; 
     275      for(size_t i=(count<10)?0:count-10; i<count ; i++) checksumLast=checksumLast+buffer[i] ; 
     276       
     277      info(40)<<"getBufferFromClient timeLine==clientTimeLine: windowsRank "<<windowsRank_<<" timeline "<<timeLine<<" clientTimeline " 
     278              <<clientTimeline<<" clientCount "<<count<<" checksum "<<(int)checksum<<" " 
     279              <<(int)buffer[0]<<" "<<(int)buffer[1]<<" "<<(int)buffer[2]<<" "<<(int)buffer[3]<<" "<<(int)buffer[4]<<" "<<(int)buffer[5]<<" "  
     280              <<(int)buffer[6]<<" "<<(int)buffer[7]<<" "<<(int)buffer[8]<<" "<<(int)buffer[9]<<" "<<(int)buffer[10]<<" "<<(int)buffer[11]<<endl ; 
     281 
     282    } 
     283    else 
     284    { 
     285      //MPI_Win_lock(MPI_LOCK_EXCLUSIVE,windowsRank_,0,windows_[currentWindows]) ; 
     286      //control=0 ; 
     287      //MPI_Put(&control, 1, MPI_LONG_LONG_INT, windowsRank_ , MPI_Aint_add(winAddress_[currentWindows],2*sizeof(size_t)), 1, MPI_LONG_LONG_INT,windows_[currentWindows]) ; 
     288  
     289 // release lock 
     290      unlockBuffer() ; 
     291    } 
     292 
     293    if (ok) return true ; 
     294 
     295    return false ; 
     296  } 
     297   
     298  void CServerBuffer::lockBuffer(void) 
     299  { 
     300    if (!hasWindows) return ; 
     301 
     302    long long int lock=1 ; 
     303    long long int zero=0, one=1 ; 
     304//    control=1 ; 
     305    MPI_Win_lock(MPI_LOCK_EXCLUSIVE,windowsRank_,0,windows_[currentWindows]) ; 
     306    while(lock!=0) 
     307    { 
     308      MPI_Compare_and_swap(&one, &zero, &lock, MPI_LONG_LONG_INT, windowsRank_, MPI_Aint_add(winAddress_[currentWindows],2*sizeof(size_t)), 
     309                           windows_[currentWindows]) ; 
     310      MPI_Win_flush(windowsRank_, windows_[currentWindows]) ; 
     311    } 
     312  } 
     313 
     314  void CServerBuffer::unlockBuffer(void) 
     315  { 
     316    if (!hasWindows) return ; 
     317    long long int lock=1 ; 
     318    long long int zero=0, one=1 ; 
     319     
     320    MPI_Compare_and_swap(&zero, &one, &lock, MPI_LONG_LONG_INT, windowsRank_, MPI_Aint_add(winAddress_[currentWindows],2*sizeof(size_t)), 
     321                          windows_[currentWindows]) ; 
     322    MPI_Win_flush(windowsRank_, windows_[currentWindows]) ;  
     323    MPI_Win_unlock(windowsRank_,windows_[currentWindows]) ; 
     324  } 
     325   
     326  void CServerBuffer::notifyClientFinalize(void) 
     327  { 
     328    if (!hasWindows) return ; 
     329    size_t finalize=1 ; 
     330    lockBuffer();  
     331// lock is acquired 
     332    MPI_Put(&finalize, 1, MPI_LONG_LONG_INT, windowsRank_ , MPI_Aint_add(winAddress_[currentWindows],3*sizeof(size_t)), 1, MPI_LONG_LONG_INT,windows_[currentWindows]) ; 
     333    unlockBuffer() ; 
     334  } 
    171335} 
  • XIOS/dev/dev_trunk_graph/src/buffer_server.hpp

    r717 r2019  
    1212  { 
    1313    public: 
    14       CServerBuffer(StdSize bufSize) ; 
     14      CServerBuffer(vector<MPI_Win>& windows, vector<MPI_Aint>& winAddress, int windowsRank, StdSize bufSize) ; 
    1515      ~CServerBuffer() ; 
    1616 
     
    1818      void* getBuffer(size_t count) ; 
    1919      void freeBuffer(size_t count) ; 
    20  
     20      void createWindows(MPI_Comm oneSidedComm) ; 
     21      bool freeWindows(void) ; 
     22      bool getBufferFromClient(size_t timeLine, char* & buffer, size_t& count) ; 
     23      bool isBufferEmpty(void) ; 
     24      void updateCurrentWindows(void) ; 
     25      void lockBuffer(void) ; 
     26      void unlockBuffer(void) ; 
     27      void notifyClientFinalize(void) ; 
    2128    private: 
    2229      char* buffer; 
     
    2532      size_t end; 
    2633      size_t size; 
     34      size_t used ;  // count of element occupied 
     35      std::vector<MPI_Win> windows_ ; 
     36      std::vector<MPI_Aint> winAddress_ ; 
     37 
     38      int currentWindows ; 
     39      bool hasWindows ; 
     40      int windowsRank_ ; 
    2741  }; 
    2842} 
  • XIOS/dev/dev_trunk_graph/src/client.cpp

    r1590 r2019  
    1212#include "buffer_client.hpp" 
    1313#include "string_tools.hpp" 
     14#include "ressources_manager.hpp" 
     15#include "services_manager.hpp" 
     16#include <functional> 
     17#include <cstdio> 
     18#include "workflow_graph.hpp" 
    1419 
    1520namespace xios 
    1621{ 
    1722 
     23    const double serverPublishDefaultTimeout=10; 
     24 
    1825    MPI_Comm CClient::intraComm ; 
    1926    MPI_Comm CClient::interComm ; 
     27    MPI_Comm CClient::clientsComm_ ; 
     28 
    2029    std::list<MPI_Comm> CClient::contextInterComms; 
    2130    int CClient::serverLeader ; 
     
    2433    StdOFStream CClient::m_infoStream; 
    2534    StdOFStream CClient::m_errorStream; 
     35    CPoolRessource* CClient::poolRessource_=nullptr ; 
     36 
    2637    MPI_Comm& CClient::getInterComm(void)   { return (interComm); } 
    2738      
     
    3748    void CClient::initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
    3849    { 
     50     
     51       MPI_Comm clientComm ; 
     52      // initialize MPI if not initialized 
    3953      int initialized ; 
    4054      MPI_Initialized(&initialized) ; 
    4155      if (initialized) is_MPI_Initialized=true ; 
    4256      else is_MPI_Initialized=false ; 
    43       int rank ; 
    44  
    45 // don't use OASIS 
    46       if (!CXios::usingOasis) 
    47       { 
    48 // localComm isn't given 
    49         if (localComm == MPI_COMM_NULL) 
    50         { 
     57       
     58      MPI_Comm globalComm=CXios::getGlobalComm() ; 
     59 
     60      ///////////////////////////////////////// 
     61      ///////////// PART 1 //////////////////// 
     62      ///////////////////////////////////////// 
     63       
     64 
     65      // localComm isn't given 
     66      if (localComm == MPI_COMM_NULL) 
     67      { 
     68           
     69        // don't use OASIS 
     70        if (!CXios::usingOasis) 
     71        { 
     72 
    5173          if (!is_MPI_Initialized) 
    5274          { 
     
    5476          } 
    5577          CTimer::get("XIOS").resume() ; 
    56           CTimer::get("XIOS init/finalize").resume() ; 
    57           boost::hash<string> hashString ; 
    58  
    59           unsigned long hashClient=hashString(codeId) ; 
    60           unsigned long hashServer=hashString(CXios::xiosCodeId) ; 
    61           unsigned long* hashAll ; 
    62           int size ; 
    63           int myColor ; 
    64           int i,c ; 
    65           MPI_Comm newComm ; 
    66  
    67           MPI_Comm_size(CXios::globalComm,&size) ; 
    68           MPI_Comm_rank(CXios::globalComm,&rank_); 
    69  
    70           hashAll=new unsigned long[size] ; 
    71  
    72           MPI_Allgather(&hashClient,1,MPI_LONG,hashAll,1,MPI_LONG,CXios::globalComm) ; 
    73  
    74           map<unsigned long, int> colors ; 
    75           map<unsigned long, int> leaders ; 
    76  
    77           for(i=0,c=0;i<size;i++) 
     78          CTimer::get("XIOS init/finalize",false).resume() ; 
     79           
     80          // split the global communicator 
     81          // get hash from all model to attribute a unique color (int) and then split to get client communicator 
     82          // every mpi process of globalComm (MPI_COMM_WORLD) must participate 
     83 
     84          int commRank, commSize ; 
     85          MPI_Comm_rank(globalComm,&commRank) ; 
     86          MPI_Comm_size(globalComm,&commSize) ; 
     87 
     88          std::hash<string> hashString ; 
     89          size_t hashClient=hashString(codeId) ; 
     90           
     91          size_t* hashAll = new size_t[commSize] ; 
     92          MPI_Allgather(&hashClient,1,MPI_UNSIGNED_LONG,hashAll,1,MPI_LONG,globalComm) ; 
     93           
     94          int color=0 ; 
     95          set<size_t> listHash ; 
     96          for(int i=0 ; i<=commRank ; i++)  
     97            if (listHash.count(hashAll[i])==0) 
     98            { 
     99              listHash.insert(hashAll[i]) ; 
     100              color=color+1 ; 
     101            } 
     102          delete[] hashAll ; 
     103 
     104          MPI_Comm_split(globalComm, color, commRank, &clientComm) ; 
     105        } 
     106        else // using oasis to split communicator 
     107        { 
     108          if (!is_MPI_Initialized) oasis_init(codeId) ; 
     109          oasis_get_localcomm(clientComm) ; 
     110        } 
     111      } 
     112      else // localComm is given 
     113      { 
     114        MPI_Comm_dup(localComm,&clientComm) ; 
     115      } 
     116       
     117      
     118      ///////////////////////////////////////// 
     119      ///////////// PART 2 //////////////////// 
     120      ///////////////////////////////////////// 
     121       
     122 
     123      // Create the XIOS communicator for every process which is related 
     124      // to XIOS, as well on client side as on server side 
     125       
     126      MPI_Comm xiosGlobalComm ; 
     127      string strIds=CXios::getin<string>("clients_code_id","") ; 
     128      vector<string> clientsCodeId=splitRegex(strIds,"\\s*,\\s*") ; 
     129      if (strIds.empty()) 
     130      { 
     131         // no code Ids given, suppose XIOS initialisation is global             
     132         int commRank, commGlobalRank, serverLeader, clientLeader,serverRemoteLeader,clientRemoteLeader ; 
     133         MPI_Comm splitComm,interComm ; 
     134         MPI_Comm_rank(globalComm,&commGlobalRank) ; 
     135         MPI_Comm_split(globalComm, 0, commGlobalRank, &splitComm) ; 
     136         int splitCommSize, globalCommSize ; 
     137         
     138         MPI_Comm_size(splitComm,&splitCommSize) ; 
     139         MPI_Comm_size(globalComm,&globalCommSize) ; 
     140         if (splitCommSize==globalCommSize) // no server 
     141         { 
     142           MPI_Comm_dup(globalComm,&xiosGlobalComm) ; 
     143           CXios::setXiosComm(xiosGlobalComm) ; 
     144         } 
     145         else 
     146         { 
     147           MPI_Comm_rank(splitComm,&commRank) ; 
     148           if (commRank==0) clientLeader=commGlobalRank ; 
     149           else clientLeader=0 ; 
     150           serverLeader=0 ; 
     151           MPI_Allreduce(&clientLeader,&clientRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ; 
     152           MPI_Allreduce(&serverLeader,&serverRemoteLeader,1,MPI_INT,MPI_SUM,globalComm) ; 
     153           MPI_Intercomm_create(splitComm, 0, globalComm, serverRemoteLeader,1341,&interComm) ; 
     154           MPI_Intercomm_merge(interComm,true,&xiosGlobalComm) ; 
     155           CXios::setXiosComm(xiosGlobalComm) ; 
     156         } 
     157      } 
     158      else 
     159      { 
     160 
     161        xiosGlobalCommByFileExchange(clientComm, codeId) ; 
     162       
     163      } 
     164 
     165      int commRank ; 
     166      MPI_Comm_rank(CXios::getXiosComm(), &commRank) ; 
     167      MPI_Comm_split(CXios::getXiosComm(),false,commRank, &clientsComm_) ; 
     168       
     169      // is using server or not ? 
     170      int xiosCommSize, clientsCommSize ;  
     171      MPI_Comm_size(CXios::getXiosComm(), &xiosCommSize) ; 
     172      MPI_Comm_size(clientsComm_, &clientsCommSize) ; 
     173      if (xiosCommSize==clientsCommSize) CXios::setUsingServer() ; 
     174      else CXios::setNotUsingServer() ; 
     175 
     176 
     177      CXios::setGlobalRegistry(new CRegistry(clientsComm_)) ; 
     178      ///////////////////////////////////////// 
     179      ///////////// PART 3 //////////////////// 
     180      ///////////////////////////////////////// 
     181      
     182      CXios::launchDaemonsManager(false) ; 
     183      poolRessource_ = new CPoolRessource(clientComm, codeId) ; 
     184 
     185      ///////////////////////////////////////// 
     186      ///////////// PART 4 //////////////////// 
     187      /////////////////////////////////////////       
     188       
     189      returnComm = clientComm ; 
     190    } 
     191 
     192 
     193    void CClient::xiosGlobalCommByFileExchange(MPI_Comm clientComm, const string& codeId) 
     194    { 
     195  
     196      MPI_Comm globalComm=CXios::getGlobalComm() ; 
     197      MPI_Comm xiosGlobalComm ; 
     198 
     199      string strIds=CXios::getin<string>("clients_code_id","") ; 
     200      vector<string> clientsCodeId=splitRegex(strIds,"\\s*,\\s*") ; 
     201 
     202      int commRank, globalRank, clientRank, serverRank ; 
     203      MPI_Comm_rank(clientComm, &commRank) ; 
     204      MPI_Comm_rank(globalComm, &globalRank) ; 
     205      string clientFileName("__xios_publisher::"+codeId+"__to_remove__") ; 
     206            
     207      int error ; 
     208 
     209      if (commRank==0) // if root process publish name 
     210      {   
     211        std::ofstream ofs (clientFileName, std::ofstream::out); 
     212        ofs<<globalRank ; 
     213        ofs.close(); 
     214         
     215  // get server root rank 
     216 
     217        std::ifstream ifs ; 
     218        string fileName=("__xios_publisher::"+CXios::xiosCodeId+"__to_remove__") ; 
     219       
     220        double timeout = CXios::getin<double>("server_puplish_timeout",serverPublishDefaultTimeout) ; 
     221        double time ; 
     222           
     223        do 
     224        { 
     225          CTimer::get("server_publish_timeout").resume() ;   
     226          ifs.clear() ; 
     227          ifs.open(fileName, std::ifstream::in) ; 
     228          CTimer::get("server_publish_timeout").suspend() ; 
     229        } while (ifs.fail() && CTimer::get("server_publish_timeout").getCumulatedTime()<timeout) ; 
     230         
     231        if (CTimer::get("server_publish_timeout").getCumulatedTime()>=timeout || ifs.fail()) 
     232        { 
     233          ifs.clear() ; 
     234          ifs.close() ; 
     235          ifs.clear() ; 
     236          error=true ;             
     237        } 
     238        else  
     239        { 
     240          ifs>>serverRank ; 
     241          ifs.close() ; 
     242          error=false ; 
     243        }  
     244 
     245      }  
     246       
     247      MPI_Bcast(&error,1,MPI_INT,0,clientComm) ; 
     248       
     249      if (error==false)  // you have a server 
     250      { 
     251        MPI_Comm intraComm ; 
     252        MPI_Comm_dup(clientComm,&intraComm) ; 
     253        MPI_Comm interComm ; 
     254         
     255        int pos=0 ; 
     256        for(int i=0 ; codeId!=clientsCodeId[i]; i++) pos=pos+1 ; 
     257 
     258        bool high=true ; 
     259        for(int i=pos ; i<clientsCodeId.size(); i++) 
     260        {   
     261          MPI_Intercomm_create(intraComm, 0, globalComm, serverRank, 3141, &interComm); 
     262          MPI_Comm_free(&intraComm) ; 
     263          MPI_Intercomm_merge(interComm,high, &intraComm ) ; 
     264          high=false ; 
     265        } 
     266        xiosGlobalComm=intraComm ; 
     267      } 
     268      else  // no server detected 
     269      { 
     270        vector<int> clientsRank(clientsCodeId.size()) ; 
     271         
     272        if (commRank==0) 
     273        {   
     274          for(int i=0;i<clientsRank.size();i++) 
    78275          { 
    79             if (colors.find(hashAll[i])==colors.end()) 
     276            std::ifstream ifs ; 
     277            string fileName=("__xios_publisher::"+clientsCodeId[i]+"__to_remove__") ; 
     278            do 
    80279            { 
    81               colors[hashAll[i]] =c ; 
    82               leaders[hashAll[i]]=i ; 
    83               c++ ; 
     280              ifs.clear() ; 
     281              ifs.open(fileName, std::ifstream::in) ; 
     282            } while (ifs.fail()) ; 
     283            ifs>>clientsRank[i] ; 
     284            ifs.close() ; 
     285          } 
     286        } 
     287          
     288        int client ; 
     289        MPI_Comm intraComm ; 
     290        MPI_Comm_dup(clientComm,&intraComm) ; 
     291        MPI_Comm interComm ; 
     292         
     293        int pos=0 ; 
     294        for(int i=0 ; codeId!=clientsCodeId[i]; i++) pos=pos+1 ; 
     295         
     296        bool high=true ; 
     297        for(int i=pos+1 ; i<clientsCodeId.size(); i++) 
     298        {   
     299          if (codeId==clientsCodeId[0])   // first model play the server rule 
     300          {           
     301            MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[i], 3141, &interComm); 
     302            MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
     303          } 
     304          else 
     305          {           
     306            MPI_Intercomm_create(intraComm, 0, globalComm, clientsRank[0], 3141, &interComm); 
     307            MPI_Intercomm_merge(interComm,high, &intraComm ) ; 
     308            high=false ; 
     309          } 
     310        } 
     311        xiosGlobalComm=intraComm ; 
     312      } 
     313 
     314      MPI_Barrier(xiosGlobalComm); 
     315      if (commRank==0) std::remove(clientFileName.c_str()) ;          
     316      MPI_Barrier(xiosGlobalComm); 
     317   
     318      CXios::setXiosComm(xiosGlobalComm) ; 
     319 
     320      MPI_Comm commUnfree ; 
     321      MPI_Comm_dup(clientComm, &commUnfree ) ; 
     322  
     323    } 
     324 
     325// to check on other architecture 
     326    void CClient::xiosGlobalCommByPublishing(MPI_Comm clientComm, const string& codeId) 
     327    { 
     328 
     329      // untested. need to be developped an a true MPI compliant library 
     330 
     331/* 
     332        // try to discover other client/server 
     333        // do you have a xios server ? 
     334        char portName[MPI_MAX_PORT_NAME]; 
     335        int ierr ; 
     336        int commRank ; 
     337        MPI_Comm_rank(clientComm,&commRank) ; 
     338 
     339        MPI_Barrier(globalComm) ; 
     340        if (commRank==0) 
     341        { 
     342              
     343          MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN ); 
     344          const char* serviceName=CXios::xiosCodeId.c_str() ; 
     345          ierr=MPI_Lookup_name(CXios::xiosCodeId.c_str(), MPI_INFO_NULL, portName); 
     346          MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL ); 
     347        } 
     348        ierr=MPI_SUCCESS ; 
     349        MPI_Bcast(&ierr,1,MPI_INT,0,clientComm) ; 
     350 
     351        if (ierr==MPI_SUCCESS) // you have a server 
     352        {   
     353          MPI_Comm intraComm=clientComm ; 
     354          MPI_Comm interComm ; 
     355          for(int i=0 ; i<clientsCodeId.size(); i++) 
     356          {   
     357            MPI_Comm_connect(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
     358            MPI_Intercomm_merge(interComm, true, &intraComm ) ; 
     359          } 
     360          xiosGlobalComm=intraComm ; 
     361        } 
     362        else  // you don't have any server 
     363        { 
     364          if (codeId==clientsCodeId[0]) // first code will publish his name 
     365          { 
     366 
     367            if (commRank==0) // if root process publish name 
     368            {   
     369              MPI_Open_port(MPI_INFO_NULL, portName); 
     370              MPI_Publish_name(CXios::xiosCodeId.c_str(), MPI_INFO_NULL, portName); 
     371            } 
     372 
     373            MPI_Comm intraComm=clientComm ; 
     374            MPI_Comm interComm ; 
     375            for(int i=0 ; i<clientsCodeId.size()-1; i++) 
     376            {   
     377              MPI_Comm_accept(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
     378              MPI_Intercomm_merge(interComm,false, &intraComm ) ; 
    84379            } 
    85380          } 
    86  
    87           // Verify whether we are on server mode or not 
    88           CXios::setNotUsingServer(); 
    89           for (i=0; i < size; ++i) 
     381          else  // other clients are connecting to the first one 
    90382          { 
    91             if (hashServer == hashAll[i]) 
     383            if (commRank==0) 
    92384            { 
    93               CXios::setUsingServer(); 
    94               break; 
     385 
     386              MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN ); 
     387              ierr=MPI_Lookup_name(CXios::xiosCodeId.c_str(), MPI_INFO_NULL, portName); 
     388              MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL ); 
     389             } 
     390 
     391            MPI_Bcast(&ierr,1,MPI_INT,0,clientComm) ; 
     392 
     393            if (ierr==MPI_SUCCESS) // you can connect 
     394            {   
     395              MPI_Comm intraComm=clientComm ; 
     396              MPI_Comm interComm ; 
     397              for(int i=0 ; i<clientsCodeId.size()-1; i++) 
     398              {   
     399                MPI_Comm_connect(portName, MPI_INFO_NULL, 0, intraComm, &interComm); 
     400                MPI_Intercomm_merge(interComm, true, &intraComm ) ; 
     401              } 
     402              xiosGlobalComm=intraComm ; 
    95403            } 
    96404          } 
    97  
    98           myColor=colors[hashClient]; 
    99           MPI_Comm_split(CXios::globalComm,myColor,rank_,&intraComm) ; 
    100  
    101           if (CXios::usingServer) 
    102           { 
    103             int clientLeader=leaders[hashClient] ; 
    104             serverLeader=leaders[hashServer] ; 
    105             int intraCommSize, intraCommRank ; 
    106             MPI_Comm_size(intraComm,&intraCommSize) ; 
    107             MPI_Comm_rank(intraComm,&intraCommRank) ; 
    108             info(50)<<"intercommCreate::client "<<rank_<<" intraCommSize : "<<intraCommSize 
    109                    <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ; 
    110              MPI_Intercomm_create(intraComm, 0, CXios::globalComm, serverLeader, 0, &interComm) ; 
    111              //rank_ = intraCommRank; 
    112           } 
    113           else 
    114           { 
    115             MPI_Comm_dup(intraComm,&interComm) ; 
    116           } 
    117           delete [] hashAll ; 
    118         } 
    119         // localComm argument is given 
    120         else 
    121         { 
    122           if (CXios::usingServer) 
    123           { 
    124             //ERROR("void CClient::initialize(const string& codeId,MPI_Comm& localComm,MPI_Comm& returnComm)", << " giving a local communictor is not compatible with using server mode") ; 
    125           } 
    126           else 
    127           { 
    128             MPI_Comm_dup(localComm,&intraComm) ; 
    129             MPI_Comm_dup(intraComm,&interComm) ; 
    130           } 
    131         } 
    132       } 
    133       // using OASIS 
    134       else 
    135       { 
    136         // localComm isn't given 
    137         if (localComm == MPI_COMM_NULL) 
    138         { 
    139           if (!is_MPI_Initialized) oasis_init(codeId) ; 
    140           oasis_get_localcomm(localComm) ; 
    141         } 
    142         MPI_Comm_dup(localComm,&intraComm) ; 
    143  
    144         CTimer::get("XIOS").resume() ; 
    145         CTimer::get("XIOS init/finalize").resume() ; 
    146  
    147         if (CXios::usingServer) 
    148         { 
    149           MPI_Status status ; 
    150           MPI_Comm_rank(intraComm,&rank_) ; 
    151  
    152           oasis_get_intercomm(interComm,CXios::xiosCodeId) ; 
    153           if (rank_==0) MPI_Recv(&serverLeader,1, MPI_INT, 0, 0, interComm, &status) ; 
    154           MPI_Bcast(&serverLeader,1,MPI_INT,0,intraComm) ; 
    155         } 
    156         else MPI_Comm_dup(intraComm,&interComm) ; 
    157       } 
    158  
    159       MPI_Comm_dup(intraComm,&returnComm) ; 
    160     } 
     405        }   
     406      */ 
     407    } 
     408 
    161409 
    162410///--------------------------------------------------------------- 
     
    170418    void CClient::registerContext(const string& id, MPI_Comm contextComm) 
    171419    { 
    172       CContext::setCurrent(id) ; 
    173       CContext* context=CContext::create(id); 
    174       StdString idServer(id); 
    175       idServer += "_server"; 
    176  
    177       if (CXios::isServer && !context->hasServer) 
    178       // Attached mode 
    179       { 
    180         MPI_Comm contextInterComm ; 
    181         MPI_Comm_dup(contextComm,&contextInterComm) ; 
    182         CContext* contextServer = CContext::create(idServer); 
    183  
    184         // Firstly, initialize context on client side 
    185         context->initClient(contextComm,contextInterComm, contextServer); 
    186  
    187         // Secondly, initialize context on server side 
    188         contextServer->initServer(contextComm,contextInterComm, context); 
    189  
    190         // Finally, we should return current context to context client 
    191         CContext::setCurrent(id); 
    192  
    193         contextInterComms.push_back(contextInterComm); 
    194       } 
    195       else 
    196       { 
    197         int size,rank,globalRank ; 
    198         size_t message_size ; 
    199         int leaderRank ; 
    200         MPI_Comm contextInterComm ; 
    201  
    202         MPI_Comm_size(contextComm,&size) ; 
    203         MPI_Comm_rank(contextComm,&rank) ; 
    204         MPI_Comm_rank(CXios::globalComm,&globalRank) ; 
    205         if (rank!=0) globalRank=0 ; 
    206  
    207         CMessage msg ; 
    208         msg<<idServer<<size<<globalRank ; 
    209 //        msg<<id<<size<<globalRank ; 
    210  
    211         int messageSize=msg.size() ; 
    212         char * buff = new char[messageSize] ; 
    213         CBufferOut buffer((void*)buff,messageSize) ; 
    214         buffer<<msg ; 
    215  
    216         MPI_Send((void*)buff,buffer.count(),MPI_CHAR,serverLeader,1,CXios::globalComm) ; 
    217  
    218         MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ; 
    219         info(10)<<"Register new Context : "<<id<<endl ; 
    220         MPI_Comm inter ; 
    221         MPI_Intercomm_merge(contextInterComm,0,&inter) ; 
    222         MPI_Barrier(inter) ; 
    223  
    224         context->initClient(contextComm,contextInterComm) ; 
    225  
    226         contextInterComms.push_back(contextInterComm); 
    227         MPI_Comm_free(&inter); 
    228         delete [] buff ; 
    229  
    230       } 
    231     } 
     420      int commRank, commSize ; 
     421      MPI_Comm_rank(contextComm,&commRank) ; 
     422      MPI_Comm_size(contextComm,&commSize) ; 
     423 
     424      getPoolRessource()->createService(contextComm, id, 0, CServicesManager::CLIENT, 1) ; 
     425      getPoolRessource()->createService(contextComm, CXios::defaultServerId, 0, CServicesManager::IO_SERVER, 1) ; 
     426 
     427      if (commRank==0) while (!CXios::getServicesManager()->hasService(getPoolRessource()->getId(), id, 0)) { CXios::getDaemonsManager()->eventLoop();} 
     428 
     429      if (commRank==0) CXios::getContextsManager()->createServerContext(getPoolRessource()->getId(), id, 0, id) ; 
     430      int type=CServicesManager::CLIENT ; 
     431      string name = CXios::getContextsManager()->getServerContextName(getPoolRessource()->getId(), id, 0, type, id) ; 
     432      while (!CXios::getContextsManager()->hasContext(name, contextComm) ) 
     433      { 
     434        CXios::getDaemonsManager()->eventLoop() ; 
     435      } 
     436 
     437    } 
     438 
     439 
    232440 
    233441/*! 
     
    260468    } 
    261469 
    262  
    263470    void CClient::finalize(void) 
    264471    { 
    265       int rank ; 
    266       int msg=0 ; 
    267  
    268       MPI_Comm_rank(intraComm,&rank) ; 
    269   
    270       if (!CXios::isServer) 
    271       { 
    272         MPI_Comm_rank(intraComm,&rank) ; 
    273         if (rank==0) 
    274         { 
    275           MPI_Send(&msg,1,MPI_INT,0,0,interComm) ; 
    276         } 
    277       } 
    278  
    279       for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
    280         MPI_Comm_free(&(*it)); 
    281       MPI_Comm_free(&interComm); 
    282       MPI_Comm_free(&intraComm); 
    283  
    284       CTimer::get("XIOS init/finalize").suspend() ; 
     472      
     473      MPI_Barrier(clientsComm_) ; 
     474      int commRank ; 
     475      MPI_Comm_rank(clientsComm_, &commRank) ; 
     476      if (commRank==0) CXios::getRessourcesManager()->finalize() ; 
     477       
     478      auto globalRegistry=CXios::getGlobalRegistry() ; 
     479      globalRegistry->hierarchicalGatherRegistry() ; 
     480 
     481      if (commRank==0) 
     482      { 
     483        info(80)<<"Write data base Registry"<<endl<<globalRegistry->toString()<<endl ; 
     484        globalRegistry->toFile("xios_registry.bin") ; 
     485      } 
     486      delete globalRegistry ; 
     487 
     488      CTimer::get("XIOS init/finalize",false).suspend() ; 
    285489      CTimer::get("XIOS").suspend() ; 
     490       
     491      CXios::finalizeDaemonsManager() ; 
    286492 
    287493      if (!is_MPI_Initialized) 
     
    301507      report(0)<< " Memory report : increasing it by a factor will increase performance, depending of the volume of data wrote in file at each time step of the file"<<endl ; 
    302508      report(100)<<CTimer::getAllCumulatedTime()<<endl ; 
    303    } 
     509     
     510      CWorkflowGraph::drawWorkFlowGraph_client(); 
     511    } 
     512     
    304513 
    305514    /*! 
     
    325534      int size = 0; 
    326535      int rank; 
    327       MPI_Comm_size(CXios::globalComm, &size); 
     536      MPI_Comm_size(CXios::getGlobalComm(), &size); 
     537      MPI_Comm_rank(CXios::getGlobalComm(),&rank); 
    328538      while (size) 
    329539      { 
     
    332542      } 
    333543 
    334       if (CXios::usingOasis) 
    335       { 
    336         MPI_Comm_rank(CXios::globalComm,&rank); 
    337         fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << rank << ext; 
    338       } 
    339       else 
    340         fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << getRank() << ext; 
    341  
     544      fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << rank << ext; 
    342545 
    343546      fb->open(fileNameClient.str().c_str(), std::ios::out); 
  • XIOS/dev/dev_trunk_graph/src/client.hpp

    r1590 r2019  
    77namespace xios 
    88{ 
     9    class CPoolRessource ; 
    910    class CClient 
    1011    { 
    1112      public: 
    1213        static void initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm); 
     14        static void xiosGlobalCommByFileExchange(MPI_Comm clientComm, const string& codeId) ; 
     15        static void xiosGlobalCommByPublishing(MPI_Comm clientComm, const string& codeId) ; 
    1316        static void finalize(void); 
    1417        static void registerContext(const string& id, MPI_Comm contextComm); 
    15         static void callOasisEnddef(void) ; 
    16  
     18        static void registerContext_old(const string& id, MPI_Comm contextComm); 
     19        static void callOasisEnddef(void) ;  
     20         
    1721        static MPI_Comm intraComm; 
    1822        static MPI_Comm interComm; 
     
    2024        static int serverLeader; 
    2125        static bool is_MPI_Initialized ; 
     26        static MPI_Comm clientsComm_ ; 
    2227 
    2328        static MPI_Comm& getInterComm(); 
     
    3944        //! Close the error log file if it opens 
    4045        static void closeErrorStream(); 
     46        static CPoolRessource* getPoolRessource(void) { return poolRessource_ ; } 
    4147 
    4248      protected: 
     
    4652 
    4753        static void openStream(const StdString& fileName, const StdString& ext, std::filebuf* fb); 
     54        static CPoolRessource* poolRessource_ ; 
    4855    }; 
    4956} 
  • XIOS/dev/dev_trunk_graph/src/config/axis_attribute.conf

    r1493 r2019  
    2222 
    2323/* LOCAL */ 
    24 DECLARE_ARRAY(double , 1   , value) 
    25 DECLARE_ATTRIBUTE(StdString, axis_ref) 
     24DECLARE_ARRAY(double , 1   , value, false) 
     25DECLARE_ATTRIBUTE(StdString, axis_ref, false) 
    2626 
    27 DECLARE_ARRAY(int    ,1    , index) 
     27DECLARE_ARRAY(int    ,1    , index, false) 
    2828 
    2929/* LOCAL */ 
    30 DECLARE_ATTRIBUTE(int,       data_n) 
    31 DECLARE_ATTRIBUTE(int,       data_begin) 
    32 DECLARE_ARRAY(int    ,   1 , data_index) 
     30DECLARE_ATTRIBUTE(int,       data_n, false) 
     31DECLARE_ATTRIBUTE(int,       data_begin, false) 
     32DECLARE_ARRAY(int    ,   1 , data_index, false) 
    3333 
    3434/*LOCAL */ 
    35 DECLARE_ATTRIBUTE(int,       begin) 
    36 DECLARE_ATTRIBUTE(int,       n) 
     35DECLARE_ATTRIBUTE(int,       begin, false) 
     36DECLARE_ATTRIBUTE(int,       n, false) 
    3737 
    3838/* LOCAL */ 
    39 DECLARE_ARRAY(bool, 1 , mask) 
    40 DECLARE_ARRAY(double, 2 , bounds) 
     39DECLARE_ARRAY(bool, 1 , mask, false) 
     40DECLARE_ARRAY(double, 2 , bounds, false) 
    4141DECLARE_ATTRIBUTE(int,       prec) 
    42 DECLARE_ARRAY(StdString    ,1    , label) 
     42DECLARE_ARRAY(StdString    ,1    , label, false) 
  • XIOS/dev/dev_trunk_graph/src/config/context_attribute.conf

    r549 r2019  
    11DECLARE_ATTRIBUTE(StdString, output_dir) 
     2DECLARE_ATTRIBUTE(bool, attached_mode) 
  • XIOS/dev/dev_trunk_graph/src/config/domain_attribute.conf

    r1634 r2019  
    5757DECLARE_ARRAY(double, 3, bounds_lat_2d, false) 
    5858 
    59 DECLARE_ARRAY(double, 2, area) 
     59DECLARE_ARRAY(double, 2, area, false) 
    6060DECLARE_ATTRIBUTE(double, radius) 
    6161 
    6262DECLARE_ENUM4(type,rectilinear,curvilinear,unstructured, gaussian) 
    63 DECLARE_ATTRIBUTE(StdString, domain_ref) 
     63DECLARE_ATTRIBUTE(StdString, domain_ref, false) 
    6464DECLARE_ATTRIBUTE(int,       prec) 
  • XIOS/dev/dev_trunk_graph/src/config/field_attribute.conf

    r1686 r2019  
    2424DECLARE_ATTRIBUTE(StdString, scalar_ref, false) 
    2525DECLARE_ATTRIBUTE(StdString, grid_ref) 
    26 DECLARE_ATTRIBUTE(StdString, field_ref) 
     26DECLARE_ATTRIBUTE(StdString, field_ref, false) 
    2727DECLARE_ATTRIBUTE(StdString, grid_path) 
    2828 
     
    4141DECLARE_ENUM4(cell_methods_mode,  overwrite, prefix, suffix, none) 
    4242 
    43  
    4443DECLARE_ATTRIBUTE(bool,      build_workflow_graph) 
    45 DECLARE_ATTRIBUTE(CDuration, build_workflow_graph_start) 
    46 DECLARE_ATTRIBUTE(CDuration, build_workflow_graph_end) 
  • XIOS/dev/dev_trunk_graph/src/config/node_type.conf

    r1558 r2019  
    1414   DECLARE_NODE(File  , file  ) 
    1515#endif //__XIOS_CFile__ 
     16 
     17#ifdef __XIOS_CCouplerIn__ 
     18   DECLARE_NODE(CouplerIn  , coupler_in  ) 
     19#endif //__XIOS_CCouplerIn__ 
     20 
     21#ifdef __XIOS_CCouplerOut__ 
     22   DECLARE_NODE(CouplerOut  , coupler_out  ) 
     23#endif //__XIOS_CCouplerOut__ 
     24 
    1625 
    1726#ifdef __XIOS_CGrid__ 
  • XIOS/dev/dev_trunk_graph/src/config/scalar_attribute.conf

    r1493 r2019  
    88 
    99/* LOCAL and GLOBAL*/ 
     10DECLARE_ATTRIBUTE(bool, mask, false) 
    1011DECLARE_ATTRIBUTE(double, value) 
    1112DECLARE_ATTRIBUTE(StdString, bounds_name) 
    1213DECLARE_ARRAY(double, 1 , bounds) 
     14 
    1315 
    1416DECLARE_ATTRIBUTE(StdString, scalar_ref) 
  • XIOS/dev/dev_trunk_graph/src/context_client.cpp

    r1634 r2019  
    2222    */ 
    2323    CContextClient::CContextClient(CContext* parent, MPI_Comm intraComm_, MPI_Comm interComm_, CContext* cxtSer) 
    24      : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4) 
    25     { 
     24     : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4), associatedServer_(nullptr) 
     25    { 
     26       
    2627      context = parent; 
    2728      intraComm = intraComm_; 
     
    3233      int flag; 
    3334      MPI_Comm_test_inter(interComm, &flag); 
     35      if (flag) isAttached_=false ; 
     36      else  isAttached_=true ; 
     37 
     38      pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test) 
     39      if (isAttachedModeEnabled()) pureOneSided=false ; // no one sided in attach mode 
     40       
     41 
     42 
    3443      if (flag) MPI_Comm_remote_size(interComm, &serverSize); 
    3544      else  MPI_Comm_size(interComm, &serverSize); 
     
    3746      computeLeader(clientRank, clientSize, serverSize, ranksServerLeader, ranksServerNotLeader); 
    3847 
    39       timeLine = 0; 
     48      if (flag) MPI_Intercomm_merge(interComm_,false,&interCommMerged) ; 
     49       
     50      if (!isAttachedModeEnabled()) 
     51      {   
     52        windows.resize(serverSize) ; 
     53        MPI_Comm winComm ; 
     54        for(int rank=0; rank<serverSize; rank++) 
     55        { 
     56          windows[rank].resize(2) ; 
     57          MPI_Comm_split(interCommMerged, rank, clientRank, &winComm); 
     58          int myRank ; 
     59          MPI_Comm_rank(winComm,&myRank); 
     60          MPI_Win_create_dynamic(MPI_INFO_NULL, winComm, &windows[rank][0]); 
     61          MPI_Win_create_dynamic(MPI_INFO_NULL, winComm, &windows[rank][1]); 
     62          MPI_Comm_free(&winComm) ; 
     63        } 
     64      } 
     65 
     66      MPI_Comm_split(intraComm_,clientRank,clientRank, &commSelf) ; 
     67 
     68      timeLine = 1; 
    4069    } 
    4170 
     
    116145        list<int> sizes = event.getSizes(); 
    117146 
    118         // We force the getBuffers call to be non-blocking on classical servers 
     147         // We force the getBuffers call to be non-blocking on classical servers 
    119148        list<CBufferOut*> buffList; 
    120         bool couldBuffer = getBuffers(ranks, sizes, buffList, (!CXios::isClient && (CServer::serverLevel == 0) )); 
    121 //        bool couldBuffer = getBuffers(ranks, sizes, buffList, CXios::isServer ); 
    122  
    123         if (couldBuffer) 
    124         { 
    125           event.send(timeLine, sizes, buffList); 
    126           info(100)<<"Event "<<timeLine<<" of context "<<context->getId()<<"  sent"<<endl ; 
    127  
    128           checkBuffers(ranks); 
    129  
    130           if (isAttachedModeEnabled()) // couldBuffer is always true in attached mode 
    131           { 
    132             waitEvent(ranks); 
    133             CContext::setCurrent(context->getId()); 
    134           } 
    135         } 
    136         else 
    137         { 
    138           tmpBufferedEvent.ranks = ranks; 
    139           tmpBufferedEvent.sizes = sizes; 
    140  
    141           for (list<int>::const_iterator it = sizes.begin(); it != sizes.end(); it++) 
    142             tmpBufferedEvent.buffers.push_back(new CBufferOut(*it)); 
    143           info(100)<<"DEBUG : temporaly event created : timeline "<<timeLine<<endl ; 
    144           event.send(timeLine, tmpBufferedEvent.sizes, tmpBufferedEvent.buffers); 
    145           info(100)<<"Event "<<timeLine<<" of context "<<context->getId()<<"  sent"<<endl ; 
    146         } 
    147       } 
    148  
     149        getBuffers(timeLine, ranks, sizes, buffList) ; 
     150 
     151        event.send(timeLine, sizes, buffList); 
     152        
     153        //for (auto itRank = ranks.begin(); itRank != ranks.end(); itRank++) buffers[*itRank]->infoBuffer() ; 
     154 
     155        unlockBuffers(ranks) ; 
     156        info(100)<<"Event "<<timeLine<<" of context "<<context->getId()<<"  sent"<<endl ; 
     157           
     158        checkBuffers(ranks); 
     159      } 
     160       
     161      if (isAttachedModeEnabled()) // couldBuffer is always true in attached mode 
     162      { 
     163        waitEvent(ranks); 
     164        CContext::setCurrent(context->getId()); 
     165      } 
     166       
    149167      timeLine++; 
    150     } 
    151  
    152     /*! 
    153      * Send the temporarily buffered event (if any). 
    154      * 
    155      * \return true if a temporarily buffered event could be sent, false otherwise  
    156      */ 
    157     bool CContextClient::sendTemporarilyBufferedEvent() 
    158     { 
    159       bool couldSendTmpBufferedEvent = false; 
    160  
    161       if (hasTemporarilyBufferedEvent()) 
    162       { 
    163         list<CBufferOut*> buffList; 
    164         if (getBuffers(tmpBufferedEvent.ranks, tmpBufferedEvent.sizes, buffList, true)) // Non-blocking call 
    165         { 
    166           list<CBufferOut*>::iterator it, itBuffer; 
    167  
    168           for (it = tmpBufferedEvent.buffers.begin(), itBuffer = buffList.begin(); it != tmpBufferedEvent.buffers.end(); it++, itBuffer++) 
    169             (*itBuffer)->put((char*)(*it)->start(), (*it)->count()); 
    170  
    171           info(100)<<"DEBUG : temporaly event sent "<<endl ; 
    172           checkBuffers(tmpBufferedEvent.ranks); 
    173  
    174           tmpBufferedEvent.clear(); 
    175  
    176           couldSendTmpBufferedEvent = true; 
    177         } 
    178       } 
    179  
    180       return couldSendTmpBufferedEvent; 
    181168    } 
    182169 
     
    188175    void CContextClient::waitEvent(list<int>& ranks) 
    189176    { 
     177      while (checkBuffers(ranks)) 
     178      { 
     179        CXios::getDaemonsManager()->eventLoop() ; 
     180      } 
     181 
     182      MPI_Request req ; 
     183      MPI_Status status ; 
     184 
     185      MPI_Ibarrier(intraComm,&req) ; 
     186      int flag=false ; 
     187 
     188      do   
     189      { 
     190        CXios::getDaemonsManager()->eventLoop() ; 
     191        MPI_Test(&req,&flag,&status) ; 
     192      } while (!flag) ; 
     193 
     194 
     195    } 
     196 
     197 
     198    void CContextClient::waitEvent_old(list<int>& ranks) 
     199    { 
    190200      parentServer->server->setPendingEvent(); 
    191201      while (checkBuffers(ranks)) 
     
    205215     * it is explicitly requested to be non-blocking. 
    206216     * 
     217     * 
     218     * \param [in] timeLine time line of the event which will be sent to servers 
    207219     * \param [in] serverList list of rank of connected server 
    208220     * \param [in] sizeList size of message corresponding to each connection 
     
    211223     * \return whether the already allocated buffers could be used 
    212224    */ 
    213     bool CContextClient::getBuffers(const list<int>& serverList, const list<int>& sizeList, list<CBufferOut*>& retBuffers, 
     225    bool CContextClient::getBuffers(const size_t timeLine, const list<int>& serverList, const list<int>& sizeList, list<CBufferOut*>& retBuffers, 
    214226                                    bool nonBlocking /*= false*/) 
    215227    { 
     
    236248        areBuffersFree = true; 
    237249        for (itBuffer = bufferList.begin(), itSize = sizeList.begin(); itBuffer != bufferList.end(); itBuffer++, itSize++) 
     250        { 
    238251          areBuffersFree &= (*itBuffer)->isBufferFree(*itSize); 
     252        } 
    239253 
    240254        if (!areBuffersFree) 
    241255        { 
     256          for (itBuffer = bufferList.begin(); itBuffer != bufferList.end(); itBuffer++) (*itBuffer)->unlockBuffer(); 
    242257          checkBuffers(); 
    243           if (CServer::serverLevel == 0) 
    244             context->server->listen(); 
    245  
    246           else if (CServer::serverLevel == 1) 
     258           
     259          context->server->listen(); 
     260 
     261          if (context->serverPrimServer.size()>0) 
    247262          { 
    248             context->server->listen(); 
    249             for (int i = 0; i < context->serverPrimServer.size(); ++i) 
    250               context->serverPrimServer[i]->listen(); 
    251             CServer::contextEventLoop(false) ; // avoid dead-lock at finalize... 
     263            for (int i = 0; i < context->serverPrimServer.size(); ++i)  context->serverPrimServer[i]->listen(); 
     264 //ym           CServer::contextEventLoop(false) ; // avoid dead-lock at finalize... 
     265            context->globalEventLoop() ; 
    252266          } 
    253267 
    254           else if (CServer::serverLevel == 2) 
    255             context->server->listen(); 
    256  
    257268        } 
    258269      } while (!areBuffersFree && !nonBlocking); 
    259  
    260270      CTimer::get("Blocking time").suspend(); 
    261271 
     
    263273      { 
    264274        for (itBuffer = bufferList.begin(), itSize = sizeList.begin(); itBuffer != bufferList.end(); itBuffer++, itSize++) 
    265           retBuffers.push_back((*itBuffer)->getBuffer(*itSize)); 
    266       } 
    267  
     275          retBuffers.push_back((*itBuffer)->getBuffer(timeLine, *itSize)); 
     276      } 
    268277      return areBuffersFree; 
    269278   } 
     
    281290        maxEventSizes[rank] = CXios::minBufferSize; 
    282291      } 
    283       CClientBuffer* buffer = buffers[rank] = new CClientBuffer(interComm, rank, mapBufferSize_[rank], maxEventSizes[rank], maxBufferedEvents); 
     292       
     293      vector<MPI_Win> Wins(2,MPI_WIN_NULL) ; 
     294      if (!isAttachedModeEnabled()) Wins=windows[rank] ; 
     295   
     296      CClientBuffer* buffer = buffers[rank] = new CClientBuffer(interComm, Wins, clientRank, rank, mapBufferSize_[rank], maxEventSizes[rank]); 
    284297      // Notify the server 
    285       CBufferOut* bufOut = buffer->getBuffer(sizeof(StdSize)); 
    286       bufOut->put(mapBufferSize_[rank]); // Stupid C++ 
    287       buffer->checkBuffer(); 
     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);  
     303      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++ 
     305      buffer->checkBuffer(true); 
     306 
    288307   } 
    289308 
     
    297316      bool pending = false; 
    298317      for (itBuff = buffers.begin(); itBuff != buffers.end(); itBuff++) 
    299         pending |= itBuff->second->checkBuffer(); 
     318        pending |= itBuff->second->checkBuffer(!pureOneSided); 
    300319      return pending; 
    301320   } 
     
    307326      for (itBuff = buffers.begin(); itBuff != buffers.end(); itBuff++) 
    308327      { 
    309           delete itBuff->second; 
     328         delete itBuff->second; 
    310329      } 
    311330      buffers.clear(); 
    312    } 
    313  
     331 
     332/* don't know when release windows 
     333 
     334      if (!isAttachedModeEnabled()) 
     335      {   
     336        for(int rank=0; rank<serverSize; rank++) 
     337        { 
     338          MPI_Win_free(&windows[rank][0]); 
     339          MPI_Win_free(&windows[rank][1]); 
     340        } 
     341      }  
     342*/ 
     343   } 
     344 
     345       
     346  /*! 
     347   Lock the buffers for one sided communications 
     348   \param [in] ranks list rank of server to which client connects to 
     349   */ 
     350   void CContextClient::lockBuffers(list<int>& ranks) 
     351   { 
     352      list<int>::iterator it; 
     353      for (it = ranks.begin(); it != ranks.end(); it++) buffers[*it]->lockBuffer(); 
     354   } 
     355 
     356  /*! 
     357   Unlock the buffers for one sided communications 
     358   \param [in] ranks list rank of server to which client connects to 
     359   */ 
     360   void CContextClient::unlockBuffers(list<int>& ranks) 
     361   { 
     362      list<int>::iterator it; 
     363      for (it = ranks.begin(); it != ranks.end(); it++) buffers[*it]->unlockBuffer(); 
     364   } 
     365       
    314366   /*! 
    315367   Verify state of buffers corresponding to a connection 
     
    321373      list<int>::iterator it; 
    322374      bool pending = false; 
    323       for (it = ranks.begin(); it != ranks.end(); it++) pending |= buffers[*it]->checkBuffer(); 
     375      for (it = ranks.begin(); it != ranks.end(); it++) pending |= buffers[*it]->checkBuffer(!pureOneSided); 
    324376      return pending; 
    325377   } 
     
    335387     mapBufferSize_ = mapSize; 
    336388     maxEventSizes = maxEventSize; 
    337  
    338      // Compute the maximum number of events that can be safely buffered. 
    339      double minBufferSizeEventSizeRatio = std::numeric_limits<double>::max(); 
    340      for (std::map<int,StdSize>::const_iterator it = mapSize.begin(), ite = mapSize.end(); it != ite; ++it) 
    341      { 
    342        double ratio = double(it->second) / maxEventSizes[it->first]; 
    343        if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio; 
    344      } 
    345      MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    346  
    347      if (minBufferSizeEventSizeRatio < 1.0) 
    348      { 
    349        ERROR("void CContextClient::setBufferSize(const std::map<int,StdSize>& mapSize, const std::map<int,StdSize>& maxEventSize)", 
    350              << "The buffer sizes and the maximum events sizes are incoherent."); 
    351      } 
    352      else if (minBufferSizeEventSizeRatio == std::numeric_limits<double>::max()) 
    353        minBufferSizeEventSizeRatio = 1.0; // In this case, maxBufferedEvents will never be used but we want to avoid any floating point exception 
    354  
    355      maxBufferedEvents = size_t(2 * minBufferSizeEventSizeRatio) // there is room for two local buffers on the server 
    356                           + size_t(minBufferSizeEventSizeRatio)  // one local buffer can always be fully used 
    357                           + 1;                                   // the other local buffer might contain only one event 
    358389   } 
    359390 
     
    394425  } 
    395426 
    396   /*! 
    397    * Check if the attached mode is used. 
    398    * 
    399    * \return true if and only if attached mode is used 
    400    */ 
    401   bool CContextClient::isAttachedModeEnabled() const 
    402   { 
    403     return (parentServer != 0); 
    404   } 
    405  
    406427   /*! 
    407428   * Finalize context client and do some reports. Function is non-blocking. 
     
    410431  { 
    411432    map<int,CClientBuffer*>::iterator itBuff; 
     433    std::list<int>::iterator ItServerLeader;  
     434     
    412435    bool stop = false; 
    413436 
     437    int* nbServerConnectionLocal  = new int[serverSize] ; 
     438    int* nbServerConnectionGlobal  = new int[serverSize] ; 
     439    for(int i=0;i<serverSize;++i) nbServerConnectionLocal[i]=0 ; 
     440    for (itBuff = buffers.begin(); itBuff != buffers.end(); itBuff++)  nbServerConnectionLocal[itBuff->first]=1 ; 
     441    for (ItServerLeader = ranksServerLeader.begin(); ItServerLeader != ranksServerLeader.end(); ItServerLeader++)  nbServerConnectionLocal[*ItServerLeader]=1 ; 
     442     
     443    MPI_Allreduce(nbServerConnectionLocal, nbServerConnectionGlobal, serverSize, MPI_INT, MPI_SUM, intraComm); 
     444     
     445    CEventClient event(CContext::GetType(), CContext::EVENT_ID_CONTEXT_FINALIZE); 
     446    CMessage msg; 
     447 
     448    for (int i=0;i<serverSize;++i) if (nbServerConnectionLocal[i]==1) event.push(i, nbServerConnectionGlobal[i], msg) ; 
     449    sendEvent(event); 
     450 
     451    delete[] nbServerConnectionLocal ; 
     452    delete[] nbServerConnectionGlobal ; 
     453 
     454 
    414455    CTimer::get("Blocking time").resume(); 
    415     while (hasTemporarilyBufferedEvent()) 
    416     { 
    417       checkBuffers(); 
    418       sendTemporarilyBufferedEvent(); 
    419     } 
    420     CTimer::get("Blocking time").suspend(); 
    421  
    422     CEventClient event(CContext::GetType(), CContext::EVENT_ID_CONTEXT_FINALIZE); 
    423     if (isServerLeader()) 
    424     { 
    425       CMessage msg; 
    426       const std::list<int>& ranks = getRanksServerLeader(); 
    427       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    428       { 
    429         info(100)<<"DEBUG : Sent context Finalize event to rank "<<*itRank<<endl ; 
    430         event.push(*itRank, 1, msg); 
    431       } 
    432       sendEvent(event); 
    433     } 
    434     else sendEvent(event); 
    435  
    436     CTimer::get("Blocking time").resume(); 
    437 //    while (!stop) 
    438     { 
    439       checkBuffers(); 
    440       if (hasTemporarilyBufferedEvent()) 
    441         sendTemporarilyBufferedEvent(); 
    442  
    443       stop = true; 
    444 //      for (itBuff = buffers.begin(); itBuff != buffers.end(); itBuff++) stop &= !itBuff->second->hasPendingRequest(); 
    445     } 
     456    checkBuffers(); 
    446457    CTimer::get("Blocking time").suspend(); 
    447458 
     
    458469    report(0) << " Memory report : Context <" << context->getId() << "> : client side : total memory used for buffer " << totalBuf << " bytes" << endl; 
    459470 
    460     //releaseBuffers(); // moved to CContext::finalize() 
    461471  } 
    462472 
     
    472482    return pending; 
    473483  } 
    474  
     484   
     485  bool CContextClient::isNotifiedFinalized(void) 
     486  { 
     487    if (isAttachedModeEnabled()) return true ; 
     488 
     489    bool finalized = true; 
     490    map<int,CClientBuffer*>::iterator itBuff; 
     491    for (itBuff = buffers.begin(); itBuff != buffers.end(); itBuff++) 
     492      finalized &= itBuff->second->isNotifiedFinalized(); 
     493    return finalized; 
     494  } 
    475495 
    476496} 
  • XIOS/dev/dev_trunk_graph/src/context_client.hpp

    r1232 r2019  
    1414{ 
    1515  class CContext; 
    16  
     16  class CContextServer ; 
    1717  /*! 
    1818  \class CContextClient 
     
    3131      // Send event to server 
    3232      void sendEvent(CEventClient& event); 
    33       bool sendTemporarilyBufferedEvent(); 
    3433      void waitEvent(list<int>& ranks); 
     34      void waitEvent_old(list<int>& ranks); 
    3535 
    3636      // Functions to set/get buffers 
    37       bool getBuffers(const list<int>& serverList, const list<int>& sizeList, list<CBufferOut*>& retBuffers, bool nonBlocking = false); 
     37      bool getBuffers(const size_t timeLine, const list<int>& serverList, const list<int>& sizeList, list<CBufferOut*>& retBuffers, bool nonBlocking = false); 
    3838      void newBuffer(int rank); 
    3939      bool checkBuffers(list<int>& ranks); 
     
    4747      const std::list<int>& getRanksServerNotLeader(void) const; 
    4848 
    49       bool isAttachedModeEnabled() const; 
    50       bool hasTemporarilyBufferedEvent() const { return !tmpBufferedEvent.isEmpty(); }; 
     49  /*! 
     50   * Check if the attached mode is used. 
     51   * 
     52   * \return true if and only if attached mode is used 
     53   */ 
     54      bool isAttachedModeEnabled() const { return isAttached_ ; }  
    5155 
    5256      static void computeLeader(int clientRank, int clientSize, int serverSize, 
     
    5660      // Close and finalize context client 
    5761//      void closeContext(void);  Never been implemented. 
     62      bool isNotifiedFinalized(void) ; 
    5863      void finalize(void); 
    5964 
    6065      void setBufferSize(const std::map<int,StdSize>& mapSize, const std::map<int,StdSize>& maxEventSize); 
     66 
     67      int getRemoteSize(void) {return serverSize;} 
     68      int getServerSize(void) {return serverSize;} 
     69      MPI_Comm getIntraComm(void)  {return intraComm ;}  
     70      int getIntraCommSize(void) {return clientSize ;} 
     71      int getIntraCommRank(void) {return clientRank ;} 
     72 
     73      /*! set the associated server (dual chanel client/server) */       
     74      void setAssociatedServer(CContextServer* associatedServer) { associatedServer=associatedServer_;} 
     75      /*! get the associated server (dual chanel client/server) */       
     76      CContextServer* getAssociatedServer(void) { return associatedServer_;} 
    6177 
    6278    public: 
     
    7187      int serverSize; //!< Size of server group 
    7288 
    73       MPI_Comm interComm; //!< Communicator of server group 
     89      MPI_Comm interComm; //!< Communicator of server group (interCommunicator) 
     90 
     91      MPI_Comm interCommMerged; //!< Communicator of the client group + server group (intraCommunicator) needed for one sided communication. 
    7492 
    7593      MPI_Comm intraComm; //!< Communicator of client group 
    7694 
     95      MPI_Comm commSelf; //!< Communicator of the client alone. Needed to create a new communicator between 1 proc client and 1 proc server for one sided communication 
     96 
    7797      map<int,CClientBuffer*> buffers; //!< Buffers for connection to servers 
    7898 
     99      bool pureOneSided ; //!< if true, client will communicated with servers only trough one sided communication. Otherwise the hybrid mode P2P /One sided is used. 
     100 
    79101    private: 
     102      void lockBuffers(list<int>& ranks) ; 
     103      void unlockBuffers(list<int>& ranks) ; 
     104       
    80105      //! Mapping of server and buffer size for each connection to server 
    81106      std::map<int,StdSize> mapBufferSize_; 
     
    84109      //! Maximum number of events that can be buffered 
    85110      StdSize maxBufferedEvents; 
    86  
    87       struct { 
    88         std::list<int> ranks, sizes; 
    89         std::list<CBufferOut*> buffers; 
    90  
    91         bool isEmpty() const { return ranks.empty(); }; 
    92         void clear() { 
    93           ranks.clear(); 
    94           sizes.clear(); 
    95  
    96           for (std::list<CBufferOut*>::iterator it = buffers.begin(); it != buffers.end(); it++) 
    97             delete *it; 
    98  
    99           buffers.clear(); 
    100         }; 
    101       } tmpBufferedEvent; //! Event temporarily buffered (used only on the server) 
    102111 
    103112      //! Context for server (Only used in attached mode) 
     
    110119      std::list<int> ranksServerNotLeader; 
    111120 
     121      std::vector<std::vector<MPI_Win> >windows ; //! one sided mpi windows to expose client buffers to servers == windows[nbServers][2] 
     122      bool isAttached_ ; 
     123      CContextServer* associatedServer_ ; //!< The server associated to the pair client/server 
     124 
    112125  }; 
    113126} 
  • XIOS/dev/dev_trunk_graph/src/context_server.cpp

    r1230 r2019  
    1616#include "event_scheduler.hpp" 
    1717#include "server.hpp" 
     18#include "servers_ressource.hpp" 
     19#include "pool_ressource.hpp" 
     20#include "services.hpp" 
     21#include "contexts_manager.hpp" 
     22 
    1823#include <boost/functional/hash.hpp> 
    19  
     24#include <random> 
     25#include <chrono> 
    2026 
    2127 
    2228namespace xios 
    2329{ 
    24  
    25   CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_) 
     30  using namespace std ; 
     31 
     32  CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_)  
     33    : eventScheduler_(nullptr), isProcessingEvent_(false), associatedClient_(nullptr) 
    2634  { 
    2735    context=parent; 
     
    3341    int flag; 
    3442    MPI_Comm_test_inter(interComm,&flag); 
     43 
     44    if (flag) attachedMode=false ; 
     45    else  attachedMode=true ; 
     46     
    3547    if (flag) MPI_Comm_remote_size(interComm,&commSize); 
    3648    else  MPI_Comm_size(interComm,&commSize); 
    3749 
    38     currentTimeLine=0; 
     50    
     51    SRegisterContextInfo contextInfo ; 
     52    CXios::getContextsManager()->getContextInfo(context->getId(), contextInfo, intraComm) ; 
     53 
     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    } 
     58 
     59 
     60    currentTimeLine=1; 
    3961    scheduled=false; 
    4062    finished=false; 
    41     boost::hash<string> hashString; 
    42     if (CServer::serverLevel == 1) 
    43       hashId=hashString(context->getId() + boost::lexical_cast<string>(context->clientPrimServer.size())); 
    44     else 
    45       hashId=hashString(context->getId()); 
    46   } 
    47  
     63 
     64    // generate unique hash for server 
     65    auto time=chrono::system_clock::now().time_since_epoch().count() ; 
     66    std::default_random_engine rd(time); // not reproducible from a run to another 
     67    std::uniform_int_distribution<size_t> dist; 
     68    hashId=dist(rd) ; 
     69    MPI_Bcast(&hashId,1,MPI_SIZE_T,0,intraComm) ; // Bcast to all server of the context 
     70 
     71 
     72    if (!isAttachedModeEnabled()) 
     73    { 
     74      MPI_Intercomm_merge(interComm_,true,&interCommMerged) ; 
     75// create windows for one sided comm 
     76      int interCommMergedRank; 
     77      MPI_Comm winComm ; 
     78      MPI_Comm_rank(intraComm, &interCommMergedRank); 
     79      windows.resize(2) ; 
     80      for(int rank=commSize; rank<commSize+intraCommSize; rank++) 
     81      { 
     82        if (rank==commSize+interCommMergedRank)  
     83        { 
     84          MPI_Comm_split(interCommMerged, interCommMergedRank, rank, &winComm); 
     85          int myRank ; 
     86          MPI_Comm_rank(winComm,&myRank); 
     87          MPI_Win_create_dynamic(MPI_INFO_NULL, winComm, &windows[0]); 
     88          MPI_Win_create_dynamic(MPI_INFO_NULL, winComm, &windows[1]);       
     89        } 
     90        else MPI_Comm_split(interCommMerged, interCommMergedRank, rank, &winComm); 
     91        MPI_Comm_free(&winComm) ; 
     92      } 
     93    } 
     94    else  
     95    { 
     96      windows.resize(2) ; 
     97      windows[0]=MPI_WIN_NULL ; 
     98      windows[1]=MPI_WIN_NULL ; 
     99    } 
     100 
     101 
     102     
     103    MPI_Comm_split(intraComm_,intraCommRank,intraCommRank, &commSelf) ; 
     104    itLastTimeLine=lastTimeLine.begin() ; 
     105 
     106    pureOneSided=CXios::getin<bool>("pure_one_sided",false); // pure one sided communication (for test) 
     107    if (isAttachedModeEnabled()) pureOneSided=false ; // no one sided in attach mode 
     108       
     109  } 
     110 
     111//! Attached mode is used ? 
     112//! \return true if attached mode is used, false otherwise 
     113  bool CContextServer::isAttachedModeEnabled() const 
     114  { 
     115    return attachedMode ; 
     116  } 
     117   
    48118  void CContextServer::setPendingEvent(void) 
    49119  { 
     
    65135    listen(); 
    66136    checkPendingRequest(); 
    67     if (enableEventsProcessing) 
    68       processEvents(); 
     137    if (enableEventsProcessing)  processEvents(); 
    69138    return finished; 
    70139  } 
     
    117186    if (it==buffers.end()) // Receive the buffer size and allocate the buffer 
    118187    { 
    119        StdSize buffSize = 0; 
    120        MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status); 
     188       MPI_Aint recvBuff[3] ; 
     189       MPI_Recv(recvBuff, 3, MPI_AINT, rank, 20, interComm, &status); 
     190       StdSize buffSize = recvBuff[0]; 
     191       vector<MPI_Aint> winAdress(2) ; 
     192       winAdress[0]=recvBuff[1] ; winAdress[1]=recvBuff[2] ; 
    121193       mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
    122        it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first; 
     194       it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(windows, winAdress, rank, buffSize)))).first; 
     195      
     196       lastTimeLine[rank]=0 ; 
     197       itLastTimeLine=lastTimeLine.begin() ; 
     198 
    123199       return true; 
    124200    } 
     
    157233      if (flag==true) 
    158234      { 
     235        buffers[rank]->updateCurrentWindows() ; 
    159236        recvRequest.push_back(rank); 
    160237        MPI_Get_count(&status,MPI_CHAR,&count); 
     
    170247  } 
    171248 
     249  void CContextServer::getBufferFromClient(size_t timeLine) 
     250  { 
     251    if (!isAttachedModeEnabled()) // one sided desactivated in attached mode 
     252    {   
     253      int rank ; 
     254      char *buffer ; 
     255      size_t count ;  
     256 
     257      if (itLastTimeLine==lastTimeLine.end()) itLastTimeLine=lastTimeLine.begin() ; 
     258      for(;itLastTimeLine!=lastTimeLine.end();++itLastTimeLine) 
     259      { 
     260        rank=itLastTimeLine->first ; 
     261        if (itLastTimeLine->second < timeLine &&  pendingRequest.count(rank)==0) 
     262        { 
     263          if (buffers[rank]->getBufferFromClient(timeLine, buffer, count)) 
     264          { 
     265            processRequest(rank, buffer, count); 
     266            break ; 
     267          } 
     268        } 
     269      } 
     270    } 
     271  } 
     272          
     273        
    172274  void CContextServer::processRequest(int rank, char* buff,int count) 
    173275  { 
     
    176278    char* startBuffer,endBuffer; 
    177279    int size, offset; 
    178     size_t timeLine; 
     280    size_t timeLine=0; 
    179281    map<size_t,CEventServer*>::iterator it; 
    180282 
     283     
    181284    CTimer::get("Process request").resume(); 
    182285    while(count>0) 
     
    185288      CBufferIn newBuffer(startBuffer,buffer.remain()); 
    186289      newBuffer>>size>>timeLine; 
    187  
    188290      it=events.find(timeLine); 
    189       if (it==events.end()) it=events.insert(pair<int,CEventServer*>(timeLine,new CEventServer)).first; 
     291      if (it==events.end()) it=events.insert(pair<int,CEventServer*>(timeLine,new CEventServer(this))).first; 
    190292      it->second->push(rank,buffers[rank],startBuffer,size); 
    191293 
     
    193295      count=buffer.remain(); 
    194296    } 
     297 
     298    if (timeLine>0) lastTimeLine[rank]=timeLine ; 
     299     
    195300    CTimer::get("Process request").suspend(); 
    196301  } 
     
    200305    map<size_t,CEventServer*>::iterator it; 
    201306    CEventServer* event; 
     307     
     308//    if (context->isProcessingEvent()) return ; 
     309    if (isProcessingEvent_) return ; 
    202310 
    203311    it=events.find(currentTimeLine); 
     
    208316      if (event->isFull()) 
    209317      { 
    210         if (!scheduled && CServer::eventScheduler) // Skip event scheduling for attached mode and reception on client side 
     318        if (!scheduled && eventScheduler_) // Skip event scheduling for attached mode and reception on client side 
    211319        { 
    212           CServer::eventScheduler->registerEvent(currentTimeLine,hashId); 
     320          eventScheduler_->registerEvent(currentTimeLine,hashId); 
    213321          scheduled=true; 
    214322        } 
    215         else if (!CServer::eventScheduler || CServer::eventScheduler->queryEvent(currentTimeLine,hashId) ) 
     323        else if (!eventScheduler_ || eventScheduler_->queryEvent(currentTimeLine,hashId) ) 
    216324        { 
    217325         // When using attached mode, synchronise the processes to avoid that differents event be scheduled by differents processes 
    218326         // The best way to properly solve this problem will be to use the event scheduler also in attached mode 
    219327         // for now just set up a MPI barrier 
    220          if (!CServer::eventScheduler && CXios::isServer) MPI_Barrier(intraComm) ; 
    221  
     328//ym to be check later 
     329//         if (!eventScheduler_ && CXios::isServer) MPI_Barrier(intraComm) ; 
     330 
     331//         context->setProcessingEvent() ; 
     332         isProcessingEvent_=true ; 
    222333         CTimer::get("Process events").resume(); 
    223334         dispatchEvent(*event); 
    224335         CTimer::get("Process events").suspend(); 
     336         isProcessingEvent_=false ; 
     337//         context->unsetProcessingEvent() ; 
    225338         pendingEvent=false; 
    226339         delete event; 
     
    230343        } 
    231344      } 
    232     } 
     345      else getBufferFromClient(currentTimeLine) ; 
     346    } 
     347    else if (pureOneSided) getBufferFromClient(currentTimeLine) ; // if pure one sided check buffer even if no event recorded at current time line 
    233348  } 
    234349 
     
    237352    map<int,CServerBuffer*>::iterator it; 
    238353    for(it=buffers.begin();it!=buffers.end();++it) delete it->second; 
     354  } 
     355 
     356  void CContextServer::releaseBuffers() 
     357  { 
     358    map<int,CServerBuffer*>::iterator it; 
     359    bool out ; 
     360    do 
     361    { 
     362      out=true ; 
     363      for(it=buffers.begin();it!=buffers.end();++it) 
     364      { 
     365//        out = out && it->second->freeWindows() ; 
     366 
     367      } 
     368    } while (! out) ;  
     369  } 
     370 
     371  void CContextServer::notifyClientsFinalize(void) 
     372  { 
     373    for(auto it=buffers.begin();it!=buffers.end();++it) 
     374    { 
     375      it->second->notifyClientFinalize() ; 
     376    } 
    239377  } 
    240378 
     
    254392      finished=true; 
    255393      info(20)<<" CContextServer: Receive context <"<<context->getId()<<"> finalize."<<endl; 
     394//      releaseBuffers() ; 
     395      notifyClientsFinalize() ; 
    256396      context->finalize(); 
     397 
     398/* don't know where release windows 
     399      MPI_Win_free(&windows[0]) ; 
     400      MPI_Win_free(&windows[1]) ; 
     401*/      
    257402      std::map<int, StdSize>::const_iterator itbMap = mapBufferSize_.begin(), 
    258403                           iteMap = mapBufferSize_.end(), itMap; 
  • XIOS/dev/dev_trunk_graph/src/context_server.hpp

    r1228 r2019  
    55#include "buffer_server.hpp" 
    66#include "mpi.hpp" 
     7#include "event_scheduler.hpp" 
    78 
    89namespace xios 
    910{ 
    1011  class CContext ; 
     12  class CContextClient; 
    1113 
    1214  class CContextServer 
     
    1921    bool listenPendingRequest(MPI_Status& status) ; 
    2022    void checkPendingRequest(void) ; 
     23    void getBufferFromClient(size_t timeLine) ; 
    2124    void processRequest(int rank, char* buff,int count) ; 
    2225    void processEvents(void) ; 
     
    2528    void setPendingEvent(void) ; 
    2629    bool hasPendingEvent(void) ; 
    27  
     30    bool isAttachedModeEnabled() const; 
     31    void releaseBuffers(void) ; 
     32    void notifyClientsFinalize(void) ; 
     33     
    2834    MPI_Comm intraComm ; 
    2935    int intraCommSize ; 
     
    3339    int commSize ; 
    3440 
     41    MPI_Comm interCommMerged; //!< Communicator of the client group + server group (intraCommunicator) needed for one sided communication. 
     42 
     43    MPI_Comm commSelf; //!< Communicator of the server alone. Needed to create a new communicator between 1 proc client and 1 proc server for one sided communication 
     44 
    3545    map<int,CServerBuffer*> buffers ; 
     46    map<int,size_t> lastTimeLine ; //!< last event time line for a processed request 
     47    map<int,size_t>::iterator itLastTimeLine ; //!< iterator on lastTimeLine 
    3648    map<int,MPI_Request> pendingRequest ; 
    3749    map<int,char*> bufferRequest ; 
     
    4456    bool pendingEvent ; 
    4557    bool scheduled  ;    /*!< event of current timeline is alreading scheduled ? */ 
     58    bool attachedMode ;  //! true if attached mode is enabled otherwise false 
     59    bool pureOneSided ; //!< if true, client will communicated with servers only trough one sided communication. Otherwise the hybrid mode P2P /One sided is used. 
     60          
    4661    size_t hashId ; 
     62 
     63    void setAssociatedClient(CContextClient* associatedClient) {associatedClient_=associatedClient ;} 
     64    CContextClient* getAssociatedClient(void) { return associatedClient_ ;} 
    4765 
    4866    ~CContextServer() ; 
     
    5068    private: 
    5169      std::map<int, StdSize> mapBufferSize_; 
     70      vector<MPI_Win> windows ; //! one sided mpi windows to expose client buffers to servers ; No memory will be attached on server side. 
     71      CEventScheduler* eventScheduler_ ; 
     72      bool isProcessingEvent_ ; 
     73      CContextClient* associatedClient_ ; 
    5274  } ; 
    5375 
  • XIOS/dev/dev_trunk_graph/src/cxios.cpp

    r1686 r2019  
    1111#include "memtrack.hpp" 
    1212#include "registry.hpp" 
    13  
    14 #include "graphviz.hpp" 
     13#include "ressources_manager.hpp" 
     14#include "services_manager.hpp" 
     15#include "servers_ressource.hpp" 
    1516 
    1617namespace xios 
     
    2223  string CXios::serverPrmFile="./xios_server1"; 
    2324  string CXios::serverSndFile="./xios_server2"; 
    24  
     25  const string CXios::defaultPoolId="default_pool_id" ; 
     26  const string CXios::defaultServerId="default_server_id" ; 
     27  const string CXios::defaultGathererId="default_gatherer_id" ; 
     28   
    2529  bool CXios::xiosStack = true; 
    2630  bool CXios::systemStack = false; 
     
    2832  bool CXios::isClient ; 
    2933  bool CXios::isServer ; 
     34   
    3035  MPI_Comm CXios::globalComm ; 
     36  MPI_Comm CXios::xiosComm ; 
     37 
    3138  bool CXios::usingOasis ; 
    3239  bool CXios::usingServer = false; 
     
    4350  double CXios::recvFieldTimeout = 300.0; 
    4451  bool CXios::checkEventSync=false ; 
    45   
     52 
     53  CDaemonsManager*    CXios::daemonsManager_=nullptr ; 
     54  CRessourcesManager* CXios::ressourcesManager_=nullptr ; 
     55  CServicesManager*   CXios::servicesManager_=nullptr ; 
     56  CContextsManager*   CXios::contextsManager_=nullptr ; 
     57  CCouplerManager*    CXios::couplerManager_=nullptr ; 
     58 
    4659  //! Parse configuration file and create some objects from it 
    4760  void CXios::initialize() 
     
    109122    isClient = true; 
    110123 
     124    //CClient::initialize(codeId,localComm,returnComm) ; 
    111125    CClient::initialize(codeId,localComm,returnComm) ; 
    112     if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ; 
    113  
     126     
    114127    // If there are no server processes then we are in attached mode 
    115128    // and the clients are also servers 
     
    132145  { 
    133146     CClient::finalize() ; 
    134      if (CClient::getRank()==0) 
    135      { 
    136        info(80)<<"Write data base Registry"<<endl<<globalRegistry->toString()<<endl ; 
    137        globalRegistry->toFile("xios_registry.bin") ; 
    138        delete globalRegistry ; 
    139        CGraphviz::buildWorkflowGraphVisjs_with_info(); 
    140      } 
    141  
     147           
    142148#ifdef XIOS_MEMTRACK 
    143149 
     
    176182    // Initialize all aspects MPI 
    177183    CServer::initialize(); 
    178     if (CServer::getRank()==0 && CServer::serverLevel != 1) globalRegistry = new CRegistry(CServer::intraComm) ; 
    179      
    180     if (printLogs2Files) 
    181     { 
    182       if (CServer::serverLevel == 0) 
    183       { 
    184         CServer::openInfoStream(serverFile); 
    185         CServer::openErrorStream(serverFile); 
    186       } 
    187       else if (CServer::serverLevel == 1) 
    188       { 
    189         CServer::openInfoStream(serverPrmFile); 
    190         CServer::openErrorStream(serverPrmFile); 
    191       } 
    192       else 
    193       { 
    194         CServer::openInfoStream(serverSndFile); 
    195         CServer::openErrorStream(serverSndFile); 
    196       } 
    197     } 
    198     else 
    199     { 
    200       CServer::openInfoStream(); 
    201       CServer::openErrorStream(); 
    202     } 
    203  
    204     // Enter the loop to listen message from Client 
    205     CServer::eventLoop(); 
    206  
    207     // Finalize 
    208     if (CServer::serverLevel == 0) 
    209     { 
    210       if (CServer::getRank()==0) 
    211       { 
    212         info(80)<<"Write data base Registry"<<endl<<globalRegistry->toString()<<endl ; 
    213         globalRegistry->toFile("xios_registry.bin") ; 
    214         delete globalRegistry ; 
    215       } 
    216     } 
    217     else 
    218     { 
    219       // If using two server levels: 
    220       // (1) merge registries on each pool 
    221       // (2) send merged registries to the first pool 
    222       // (3) merge received registries on the first pool 
    223       if (CServer::serverLevel == 2) 
    224       { 
    225         vector<int>& secondaryServerGlobalRanks = CServer::getSecondaryServerGlobalRanks(); 
    226         int firstPoolGlobalRank = secondaryServerGlobalRanks[0]; 
    227         int rankGlobal; 
    228         MPI_Comm_rank(globalComm, &rankGlobal); 
    229  
    230         // Merge registries defined on each pools 
    231         CRegistry globalRegistrySndServers (CServer::intraComm); 
    232  
    233         // All pools (except the first): send globalRegistry to the first pool 
    234         for (int i=1; i<secondaryServerGlobalRanks.size(); i++) 
    235         { 
    236           if (rankGlobal == secondaryServerGlobalRanks[i]) 
    237           { 
    238             globalRegistrySndServers.mergeRegistry(*globalRegistry) ; 
    239             int registrySize = globalRegistrySndServers.size(); 
    240             MPI_Send(&registrySize,1,MPI_LONG,firstPoolGlobalRank,15,CXios::globalComm) ; 
    241             CBufferOut buffer(registrySize) ; 
    242             globalRegistrySndServers.toBuffer(buffer) ; 
    243             MPI_Send(buffer.start(),registrySize,MPI_CHAR,firstPoolGlobalRank,15,CXios::globalComm) ; 
    244           } 
    245         } 
    246  
    247         // First pool: receive globalRegistry of all secondary server pools, merge and write the resultant registry 
    248         if (rankGlobal == firstPoolGlobalRank) 
    249         { 
    250           MPI_Status status; 
    251           char* recvBuff; 
    252  
    253           globalRegistrySndServers.mergeRegistry(*globalRegistry) ; 
    254  
    255           for (int i=1; i< secondaryServerGlobalRanks.size(); i++) 
    256           { 
    257             int rank = secondaryServerGlobalRanks[i]; 
    258             int registrySize = 0; 
    259             MPI_Recv(&registrySize, 1, MPI_LONG, rank, 15, CXios::globalComm, &status); 
    260             recvBuff = new char[registrySize]; 
    261             MPI_Recv(recvBuff, registrySize, MPI_CHAR, rank, 15, CXios::globalComm, &status); 
    262             CBufferIn buffer(recvBuff, registrySize) ; 
    263             CRegistry recvRegistry; 
    264             recvRegistry.fromBuffer(buffer) ; 
    265             globalRegistrySndServers.mergeRegistry(recvRegistry) ; 
    266             delete[] recvBuff; 
    267           } 
    268  
    269           info(80)<<"Write data base Registry"<<endl<<globalRegistrySndServers.toString()<<endl ; 
    270           globalRegistrySndServers.toFile("xios_registry.bin") ; 
    271  
    272         } 
    273       } 
    274       delete globalRegistry; 
    275     } 
    276184    CServer::finalize(); 
    277185 
     
    308216    usingServer = false; 
    309217  } 
     218 
     219  void CXios::launchRessourcesManager(bool isXiosServer) 
     220  { 
     221    ressourcesManager_ = new CRessourcesManager(isXiosServer) ; 
     222  } 
     223 
     224  void CXios::launchCouplerManager(bool isXiosServer) 
     225  { 
     226    couplerManager_ = new CCouplerManager(isXiosServer) ; 
     227  } 
     228 
     229  void CXios::launchServicesManager(bool isXiosServer) 
     230  { 
     231    servicesManager_ = new CServicesManager(isXiosServer) ; 
     232  } 
     233 
     234  void CXios::launchContextsManager(bool isXiosServer) 
     235  { 
     236    contextsManager_ = new CContextsManager(isXiosServer) ; 
     237  } 
     238   
     239  void CXios::launchDaemonsManager(bool isXiosServer) 
     240  { 
     241    daemonsManager_ = new CDaemonsManager(isXiosServer) ; 
     242  } 
     243 
     244   
     245  void CXios::finalizeRessourcesManager() 
     246  { 
     247    delete ressourcesManager_; 
     248  } 
     249 
     250  void CXios::finalizeCouplerManager() 
     251  { 
     252    delete couplerManager_; 
     253  } 
     254 
     255  void CXios::finalizeServicesManager() 
     256  { 
     257    delete servicesManager_  ; 
     258  } 
     259 
     260  void CXios::finalizeContextsManager() 
     261  { 
     262    delete contextsManager_  ; 
     263  } 
     264   
     265  void CXios::finalizeDaemonsManager() 
     266  { 
     267    delete daemonsManager_  ; 
     268  } 
     269   
     270 
     271  CPoolRessource* CXios::getPoolRessource(void) 
     272  { 
     273    if (isClient) return CClient::getPoolRessource() ; 
     274    else if (isServer) return CServer::getServersRessource()->getPoolRessource() ; 
     275  } 
    310276} 
     277 
  • XIOS/dev/dev_trunk_graph/src/cxios.hpp

    r1612 r2019  
    55#include "mpi.hpp" 
    66#include "registry.hpp" 
     7#include "ressources_manager.hpp" 
     8#include "services_manager.hpp" 
     9#include "contexts_manager.hpp" 
     10#include "daemons_manager.hpp" 
     11#include "coupler_manager.hpp" 
    712 
    813namespace xios 
     
    4146 
    4247     static MPI_Comm globalComm ; //!< Global communicator 
     48     static MPI_Comm xiosComm ; //!< Global communicator 
    4349 
    4450     static bool printLogs2Files; //!< Printing out logs into files 
     
    5662     static double recvFieldTimeout; //!< Time to wait for data before issuing an error when receiving a field 
    5763     static bool checkEventSync; //!< For debuuging, check if event are coherent and synchrone on client side 
     64      
     65     static const string defaultPoolId ; 
     66     static const string defaultServerId ; 
     67     static const string defaultGathererId ; 
     68 
     69 
     70     static CRessourcesManager* ressourcesManager_ ; 
     71     static CCouplerManager* couplerManager_ ; 
     72     static CServicesManager* servicesManager_ ; 
     73     static CContextsManager* contextsManager_ ; 
     74     static CDaemonsManager* daemonsManager_ ; 
     75      
    5876 
    5977    public: 
     
    6381     //! Setting xios NOT to use server mode 
    6482     static void setNotUsingServer(); 
     83      
     84     //! is using server mode 
     85     static bool isUsingServer() {return usingServer;} 
    6586 
    6687     //! Initialize server (if any) 
    6788     static  void initServer(); 
     89 
     90     static void launchServicesManager( bool isXiosServer) ; 
     91     static void launchContextsManager(bool isXiosServer) ; 
     92     static void launchDaemonsManager(bool isXiosServer) ; 
     93     static void launchRessourcesManager(bool isXiosServer) ; 
     94     static void launchCouplerManager(bool isXiosServer) ; 
     95     
     96     static void finalizeServicesManager() ; 
     97     static void finalizeContextsManager() ; 
     98     static void finalizeDaemonsManager() ; 
     99     static void finalizeRessourcesManager() ; 
     100     static void finalizeCouplerManager() ; 
     101 
     102     static CRessourcesManager* getRessourcesManager(void) { return ressourcesManager_ ;} 
     103     static CCouplerManager*    getCouplerManager(void) { return couplerManager_ ;} 
     104     static CServicesManager*   getServicesManager(void) { return servicesManager_ ;} 
     105     static CContextsManager*   getContextsManager(void) { return contextsManager_ ;} 
     106     static CDaemonsManager*    getDaemonsManager(void) { return daemonsManager_ ;} 
     107     static CPoolRessource*     getPoolRessource(void) ; 
     108 
     109     static MPI_Comm getGlobalComm(void) { return globalComm ;} 
     110     static MPI_Comm getXiosComm(void) { return xiosComm ;} 
     111     static void setXiosComm(MPI_Comm comm) { xiosComm=comm ;} 
     112     static CRegistry* getGlobalRegistry(void) { return globalRegistry ;} 
     113     static void setGlobalRegistry(CRegistry* registry) { globalRegistry=registry ;} 
    68114 
    69115    private: 
  • XIOS/dev/dev_trunk_graph/src/data_input.cpp

    r775 r2019  
    1919  //---------------------------------------------------------------- 
    2020 
    21   void CDataInput::readFieldData(CField* field) 
     21  void CDataInput::readFieldData(CField* field, int record, CArray<double,1>& data) 
    2222  { 
    23     this->readFieldData_(field); 
     23    this->readFieldData_(field, record, data); 
    2424  } 
    2525 
  • XIOS/dev/dev_trunk_graph/src/data_input.hpp

    r775 r2019  
    1818      /// Read methods /// 
    1919      StdSize getFieldNbRecords(CField* field); 
    20       void readFieldData(CField* field); 
     20      void readFieldData(CField* field, int record, CArray<double,1>& data); 
    2121      void readFieldAttributesMetaData(CField* field); 
    2222      void readFieldAttributesValues(CField* field); 
     
    2727    protected: 
    2828      virtual StdSize getFieldNbRecords_(CField* field) = 0; 
    29       virtual void readFieldData_(CField* field) = 0; 
     29      virtual void readFieldData_(CField* field, int record, CArray<double,1>& data) = 0; 
    3030      virtual void readFieldAttributes_(CField* field, bool readAttributeValues) = 0; 
    3131      virtual void closeFile_(void) = 0; 
  • XIOS/dev/dev_trunk_graph/src/data_output.cpp

    r1612 r2019  
    122122      //---------------------------------------------------------------- 
    123123 
    124       void CDataOutput::writeFieldData(CField* field) 
     124      int CDataOutput::writeFieldData(CField* field, const CArray<double,1>& data, const CDate& lastWrite, const CDate& currentWrite, int nstep) 
    125125      TRY 
    126126      { 
    127 //         CGrid* grid = CGrid::get(field->grid_ref.getValue()); 
    128 //         CDomain* domain = CDomain::get(grid->domain_ref.getValue()); 
    129          this->writeFieldData_(field); 
     127        return this->writeFieldData_(field, data, lastWrite, currentWrite, nstep); 
    130128      } 
    131129      CATCH 
     130 
    132131 
    133132      ///---------------------------------------------------------------- 
  • XIOS/dev/dev_trunk_graph/src/data_output.hpp

    r1542 r2019  
    2828            void writeFieldGrid(CField* field); 
    2929            void writeTimeDimension(void); 
    30             void writeFieldData(CField* field); 
     30            int  writeFieldData(CField* field, const CArray<double,1>& data, const CDate& lastWrite, const CDate& currentWrite, int nstep); 
    3131 
    3232            virtual void definition_start(void) = 0; 
     
    5252            virtual void syncFile_      (void)               = 0; 
    5353            virtual void writeField_    (CField*     field)  = 0; 
    54             virtual void writeFieldData_(CField*     field)  = 0; 
     54            virtual int writeFieldData_ (CField*     field, const CArray<double,1>& data, const CDate& lastWrite, const CDate& currentWrite, int nstep)  = 0; 
    5555            virtual void writeDomain_   (CDomain*    domain) = 0; 
    5656            virtual void writeAxis_     (CAxis*      axis)   = 0; 
  • XIOS/dev/dev_trunk_graph/src/declare_attribute.hpp

    r1229 r2019  
    4242      public :                                                    \ 
    4343         using CAttributeArray<T_num, T_rank>::operator = ;       \ 
    44          name##_attr(void) : CAttributeArray<T_num, T_rank> (#name, *CAttributeMap::Current) {} \ 
     44         bool alwaysFalse=false;\ 
     45         name##_attr(void) : CAttributeArray<T_num, T_rank> (#name, *CAttributeMap::Current) {if (alwaysFalse) TV_ttf_display_type(this);} \ 
    4546         virtual bool doSend() const { return helper(__VA_ARGS__); }   \ 
    4647         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         }\ 
    4753         virtual ~name##_attr(void) {}                            \ 
    4854   } name; 
  • XIOS/dev/dev_trunk_graph/src/declare_ref_func.hpp

    r1361 r2019  
    5151    SuperClassAttribute::setAttributes(refer_ptr, apply);              \ 
    5252  }                                                                    \ 
    53   if (this->hasAttribute("name") && this->name.isEmpty())              \ 
    54     this->name.setValue(this->get##type##OutputName());                \ 
    5553}                                                                      \ 
    5654                                                                       \ 
  • XIOS/dev/dev_trunk_graph/src/event_scheduler.cpp

    r1224 r2019  
    218218          { 
    219219            registerEvent( timeLine,hashId,lev) ; 
     220            recvEvent.erase(itEvent) ; 
    220221          } 
    221222        } 
  • XIOS/dev/dev_trunk_graph/src/event_server.hpp

    r591 r2019  
    88namespace xios 
    99{ 
     10  class CContextServer ; 
    1011 
    1112  class CEventServer 
     
    1718    int nbSender ; 
    1819 
     20    CEventServer(CContextServer* contextServer) : contextServer_(contextServer) {} 
    1921 
    2022    void push(int rank,CServerBuffer* serverBuffer ,char* startBuffer,int size) ; 
    21  
     23    CContextServer* getContextServer(void) { return contextServer_ ;} 
     24     
    2225    struct SSubEvent 
    2326    { 
     
    3235    bool isFull(void) ; 
    3336    ~CEventServer() ;  
     37    private : 
     38 
     39    CContextServer* contextServer_ ; 
    3440  } ; 
    3541 
  • XIOS/dev/dev_trunk_graph/src/filter/binary_arithmetic_filter.cpp

    r1686 r2019  
    11#include "binary_arithmetic_filter.hpp" 
    2 #include "workflow_graph.hpp" 
    3 #include "yacc_var.hpp" 
    4 #include "file.hpp" 
    5  
    62 
    73namespace xios 
     
    117    , op(operatorExpr.getOpScalarField(op)) 
    128    , value(value) 
    13   {  
    14     expression.assign(*yacc_globalInputText_ptr, 0, yacc_globalInputText_ptr->size()-1); 
    15   }; 
    16  
    17   std::tuple<int, int, int> CScalarFieldArithmeticFilter::buildGraph(std::vector<CDataPacketPtr> data) 
    18   { 
    19     bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
    20     // bool building_graph = true; 
    21     int unique_filter_id; 
    22     bool firstround; 
    23  
    24     if(building_graph) 
    25     { 
    26       CWorkflowGraph::allocNodeEdge(); 
    27  
    28       size_t filterhash = std::hash<StdString>{}(expression+to_string(data[0]->timestamp)+this->field->getId()); 
    29  
    30       // first round 
    31       if(CWorkflowGraph::mapHashFilterID_ptr->find(filterhash) == CWorkflowGraph::mapHashFilterID_ptr->end()) 
    32       { 
    33         firstround = true; 
    34         this->filterID = InvalidableObject::filterIdGenerator++; 
    35         int edgeID = InvalidableObject::edgeIdGenerator++; 
    36  
    37         CWorkflowGraph::addNode(this->filterID, "Arithmetic Filter\\n("+expression+")", 3, 1, 0, data[0]); 
    38         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_tag = this->tag; 
    39         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance = data[0]->distance+1; 
    40  
    41  
    42         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes = this->field->record4graphXiosAttributes(); 
    43         if(this->field->file) (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes += "</br>file attributes : </br>" +this->field->file->record4graphXiosAttributes(); 
    44        
    45  
    46         if(CWorkflowGraph::build_begin) 
    47         { 
    48           CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
    49           (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb ++; 
    50  
    51           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
    52         } 
    53         else CWorkflowGraph::build_begin = true; 
    54  
    55         (*CWorkflowGraph::mapHashFilterID_ptr)[filterhash] = this->filterID;  
    56         unique_filter_id = this->filterID; 
    57       } 
    58       // not first round 
    59       else  
    60       { 
    61         firstround=false; 
    62         unique_filter_id = (*CWorkflowGraph::mapHashFilterID_ptr)[filterhash]; 
    63         if(data[0]->src_filterID != unique_filter_id) 
    64         { 
    65           int edgeID = InvalidableObject::edgeIdGenerator++; 
    66           CWorkflowGraph::addEdge(edgeID, unique_filter_id, data[0]);   
    67           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ;  
    68           (*CWorkflowGraph::mapFilters_ptr_with_info)[unique_filter_id].expected_entry_nb ++; 
    69         } 
    70       }   
    71     } 
    72  
    73     return std::make_tuple(building_graph, firstround, unique_filter_id); 
    74   } 
    75  
     9  { /* Nothing to do */ }; 
    7610 
    7711  CDataPacketPtr CScalarFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
     
    8115    packet->timestamp = data[0]->timestamp; 
    8216    packet->status = data[0]->status; 
    83  
    84     std::tuple<int, int, int> graph = buildGraph(data); 
    85  
    86     if(std::get<0>(graph)) packet->src_filterID = std::get<2>(graph); 
    87     if(std::get<0>(graph) && std::get<1>(graph)) packet->distance = data[0]->distance+1; 
    88     if(std::get<0>(graph) && !std::get<1>(graph)) packet->distance = data[0]->distance; 
    89  
    90     packet->field = this->field; 
    9117 
    9218    if (packet->status == CDataPacket::NO_ERROR) 
     
    10026    , op(operatorExpr.getOpFieldScalar(op)) 
    10127    , value(value) 
    102   {  
    103     expression.assign(*yacc_globalInputText_ptr, 0, yacc_globalInputText_ptr->size()-1); 
    104   }; 
    105  
    106   std::tuple<int, int, int> CFieldScalarArithmeticFilter::buildGraph(std::vector<CDataPacketPtr> data) 
    107   { 
    108     bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
    109     // bool building_graph = true; 
    110     int unique_filter_id; 
    111     bool firstround; 
    112  
    113     if(building_graph) 
    114     { 
    115       CWorkflowGraph::allocNodeEdge(); 
    116  
    117       size_t filterhash = std::hash<StdString>{}(expression+to_string(data[0]->timestamp)+this->field->getId()); 
    118  
    119       // first round 
    120       if(CWorkflowGraph::mapHashFilterID_ptr->find(filterhash) == CWorkflowGraph::mapHashFilterID_ptr->end()) 
    121       { 
    122         firstround = true; 
    123         this->filterID = InvalidableObject::filterIdGenerator++; 
    124         int edgeID = InvalidableObject::edgeIdGenerator++; 
    125  
    126         CWorkflowGraph::addNode(this->filterID, "Arithmetic Filter\\n("+expression+")", 3, 1, 0, data[0]); 
    127         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_tag = this->tag; 
    128         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance = data[0]->distance+1; 
    129  
    130  
    131         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes = this->field->record4graphXiosAttributes(); 
    132         if(this->field->file) (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes += "</br>file attributes : </br>" +this->field->file->record4graphXiosAttributes(); 
    133        
    134  
    135         if(CWorkflowGraph::build_begin) 
    136         { 
    137           CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
    138           (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb ++; 
    139  
    140           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
    141         } 
    142         else CWorkflowGraph::build_begin = true; 
    143  
    144         (*CWorkflowGraph::mapHashFilterID_ptr)[filterhash] = this->filterID;  
    145         unique_filter_id = this->filterID; 
    146       } 
    147       // not first round 
    148       else  
    149       { 
    150         firstround=false; 
    151         unique_filter_id = (*CWorkflowGraph::mapHashFilterID_ptr)[filterhash]; 
    152         if(data[0]->src_filterID != unique_filter_id) 
    153         { 
    154           int edgeID = InvalidableObject::edgeIdGenerator++; 
    155           CWorkflowGraph::addEdge(edgeID, unique_filter_id, data[0]);   
    156           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ;  
    157           (*CWorkflowGraph::mapFilters_ptr_with_info)[unique_filter_id].expected_entry_nb ++; 
    158         } 
    159       }   
    160     } 
    161  
    162     return std::make_tuple(building_graph, firstround, unique_filter_id); 
    163   } 
     28  { /* Nothing to do */ }; 
    16429 
    16530  CDataPacketPtr CFieldScalarArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
     
    16934    packet->timestamp = data[0]->timestamp; 
    17035    packet->status = data[0]->status; 
    171  
    172     std::tuple<int, int, int> graph = buildGraph(data); 
    173  
    174     if(std::get<0>(graph)) packet->src_filterID = std::get<2>(graph); 
    175     if(std::get<0>(graph) && std::get<1>(graph)) packet->distance = data[0]->distance+1; 
    176     if(std::get<0>(graph) && !std::get<1>(graph)) packet->distance = data[0]->distance; 
    177  
    178     packet->field = this->field; 
    17936 
    18037    if (packet->status == CDataPacket::NO_ERROR) 
     
    18744    : CFilter(gc, 2, this) 
    18845    , op(operatorExpr.getOpFieldField(op)) 
    189   {  
    190     expression.assign(*yacc_globalInputText_ptr, 0, yacc_globalInputText_ptr->size()-1); 
    191   }; 
    192  
    193   std::tuple<int, int, int> CFieldFieldArithmeticFilter::buildGraph(std::vector<CDataPacketPtr> data) 
    194   { 
    195     bool building_graph = this->tag ? ((data[0]->timestamp >= this->field->field_graph_start && data[0]->timestamp <= this->field->field_graph_end) && (data[0]->timestamp == data[1]->timestamp)) : false; 
    196  
    197     int unique_filter_id; 
    198  
    199     bool firstround; 
    200  
    201     if(building_graph) 
    202     {   
    203       CWorkflowGraph::allocNodeEdge(); 
    204  
    205       // std::cout<<"CFieldFieldArithmeticFilter::apply filter tag = "<<this->tag<<std::endl; 
    206  
    207       size_t filterhash = std::hash<StdString>{}(expression+to_string(data[0]->timestamp)+this->field->getId()); 
    208  
    209       // first round 
    210       if(CWorkflowGraph::mapHashFilterID_ptr->find(filterhash) == CWorkflowGraph::mapHashFilterID_ptr->end()) 
    211       { 
    212         firstround = true; 
    213         this->filterID = InvalidableObject::filterIdGenerator++; 
    214         int edgeID = InvalidableObject::edgeIdGenerator++; 
    215      
    216         CWorkflowGraph::addNode(this->filterID, "Arithmetic Filter\\n("+expression+")", 3, 1, 0, data[0]); 
    217         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes = this->field->record4graphXiosAttributes(); 
    218         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance = data[0]->distance+1; 
    219  
    220         if(this->field->file) (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes += "</br>file attributes : </br>" +this->field->file->record4graphXiosAttributes(); 
    221      
    222         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].filter_tag = this->tag; 
    223         if(CWorkflowGraph::build_begin) 
    224         { 
    225  
    226           CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
    227           (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb ++; 
    228  
    229           edgeID = InvalidableObject::edgeIdGenerator++; 
    230  
    231           CWorkflowGraph::addEdge(edgeID, this->filterID, data[1]); 
    232           (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb ++; 
    233  
    234           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
    235           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
    236         } 
    237         CWorkflowGraph::build_begin = true; 
    238  
    239         (*CWorkflowGraph::mapHashFilterID_ptr)[filterhash] = this->filterID;  
    240         unique_filter_id = this->filterID; 
    241   
    242       } 
    243       // not first round 
    244       else  
    245       { 
    246         firstround = false; 
    247         unique_filter_id = (*CWorkflowGraph::mapHashFilterID_ptr)[filterhash]; 
    248         if(data[0]->src_filterID != unique_filter_id) 
    249         { 
    250           int edgeID = InvalidableObject::edgeIdGenerator++; 
    251           CWorkflowGraph::addEdge(edgeID, unique_filter_id, data[0]);  
    252           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ;  
    253           (*CWorkflowGraph::mapFilters_ptr_with_info)[unique_filter_id].expected_entry_nb ++; 
    254         } 
    255         if(data[1]->src_filterID != unique_filter_id) 
    256         {  
    257           int edgeID = InvalidableObject::edgeIdGenerator++; 
    258           CWorkflowGraph::addEdge(edgeID, unique_filter_id, data[1]);   
    259           (*CWorkflowGraph::mapFilters_ptr_with_info)[data[1]->src_filterID].filter_filled = 0 ; 
    260           (*CWorkflowGraph::mapFilters_ptr_with_info)[unique_filter_id].expected_entry_nb ++; 
    261         } 
    262          
    263       }   
    264     } 
    265  
    266     return std::make_tuple(building_graph, firstround, unique_filter_id); 
    267   } 
     46  { /* Nothing to do */ }; 
    26847 
    26948  CDataPacketPtr CFieldFieldArithmeticFilter::apply(std::vector<CDataPacketPtr> data) 
     
    27251    packet->date = data[0]->date; 
    27352    packet->timestamp = data[0]->timestamp; 
    274  
    275     std::tuple<int, int, int> graph = buildGraph(data); 
    276  
    277     if(std::get<0>(graph)) packet->src_filterID = std::get<2>(graph); 
    278     if(std::get<0>(graph) && std::get<1>(graph)) packet->distance = data[0]->distance+1; 
    279     if(std::get<0>(graph) && !std::get<1>(graph)) packet->distance = data[0]->distance; 
    280      
    281     packet->field = this->field; 
    282      
    28353 
    28454    if (data[0]->status != CDataPacket::NO_ERROR) 
     
    29464    return packet; 
    29565  } 
    296  
    297   StdString CScalarFieldArithmeticFilter::GetName(void)    { return StdString("CScalarFieldArithmeticFilter"); } 
    298   StdString CFieldScalarArithmeticFilter::GetName(void)    { return StdString("CFieldScalarArithmeticFilter"); } 
    299   StdString CFieldFieldArithmeticFilter::GetName(void)     { return StdString("CFieldFieldArithmeticFilter"); } 
    300  
    301  
    30266} // namespace xios 
  • XIOS/dev/dev_trunk_graph/src/filter/binary_arithmetic_filter.hpp

    r1686 r2019  
    66#include "operator_expr.hpp" 
    77#include <unordered_map> 
    8 #include <tuple> 
    98 
    109namespace xios 
     
    2423       */ 
    2524      CScalarFieldArithmeticFilter(CGarbageCollector& gc, const std::string& op, double value); 
    26       StdString virtual GetName(void); 
    27  
    2825 
    2926    protected: 
     
    3835       */ 
    3936      CDataPacketPtr virtual apply(std::vector<CDataPacketPtr> data); 
    40       std::tuple<int, int, int> virtual buildGraph(std::vector<CDataPacketPtr> data); 
    41        
    42  
    4337  }; // class CScalarFieldArithmeticFilter 
    4438 
     
    5751       */ 
    5852      CFieldScalarArithmeticFilter(CGarbageCollector& gc, const std::string& op, double value); 
    59       StdString virtual GetName(void); 
    60  
    6153 
    6254    protected: 
     
    7163       */ 
    7264      CDataPacketPtr virtual apply(std::vector<CDataPacketPtr> data); 
    73       std::tuple<int, int, int> virtual buildGraph(std::vector<CDataPacketPtr> data); 
    7465  }; // class CFieldScalarArithmeticFilter 
    7566 
     
    8778       */ 
    8879      CFieldFieldArithmeticFilter(CGarbageCollector& gc, const std::string& op); 
    89       StdString virtual GetName(void); 
    90  
    9180 
    9281    protected: 
     
    10089       */ 
    10190      CDataPacketPtr virtual apply(std::vector<CDataPacketPtr> data); 
    102       std::tuple<int, int, int> virtual buildGraph(std::vector<CDataPacketPtr> data); 
    10391  }; // class CFieldFieldArithmeticFilter 
    10492} // namespace xios 
  • XIOS/dev/dev_trunk_graph/src/filter/data_packet.hpp

    r1686 r2019  
    66#include "array_new.hpp" 
    77#include "date.hpp" 
     8#include "graph_package.hpp" 
    89 
    910namespace xios 
    1011{ 
    11   class CField; 
    1212  /*! 
    1313   * A packet corresponds to a timestamped array of data. 
     
    2323    }; 
    2424 
     25    CGraphDataPackage * graphPackage; 
     26 
    2527    CArray<double, 1> data; //!< Array containing the data 
    2628    CDate date;             //!< Date associated to the data 
    2729    Time timestamp;         //!< Timestamp of the data 
    2830    StatusCode status;      //!< Status of the packet 
    29     int src_filterID; 
    30     std::vector<int> filterIDoutputs; 
    31     CField *field; 
    32     int distance; 
    33      
     31 
    3432    /*! 
    3533     * Creates a deep copy of the packet. 
     
    3735     * \return a deep copy of the packet 
    3836     */ 
    39     CDataPacket* copy() const { 
     37    CDataPacket* copy() const  
     38    { 
    4039      CDataPacket* p = new CDataPacket; 
    4140      p->data.resize(data.shape()); 
     
    4443      p->timestamp = timestamp; 
    4544      p->status = status; 
     45      p->graphPackage = graphPackage; 
    4646      return p; 
    4747    }; 
     48 
     49 
     50    CDataPacket() : graphPackage(nullptr) {} 
     51 
    4852  }; // struct CDataPacket 
    4953 
  • XIOS/dev/dev_trunk_graph/src/filter/filter.cpp

    r1686 r2019  
    55  CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine) 
    66    : CInputPin(gc, inputSlotsCount) 
    7     , COutputPin(gc, false) 
     7    , COutputPin(gc) 
    88    , engine(engine) 
    99    , inputSlotCount(inputSlotCount) 
    1010  { /* Nothing to do */ } 
    11  
    12   StdString CFilter::GetName(void)    { return StdString("Filter"); } 
    1311 
    1412  void CFilter::onInputReady(std::vector<CDataPacketPtr> data) 
  • XIOS/dev/dev_trunk_graph/src/filter/filter.hpp

    r1686 r2019  
    2525       */ 
    2626      CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine); 
    27  
    28       StdString virtual GetName(void); 
    2927 
    3028      /*! 
     
    6462      bool virtual isDataExpected(const CDate& date) const; 
    6563 
    66        
    67        
    68  
    69       int filterID; 
    70       StdString expression; 
    71  
    7264    protected: 
    7365      IFilterEngine* engine; //!< The filter engine, might be the filter itself 
  • XIOS/dev/dev_trunk_graph/src/filter/garbage_collector.cpp

    r1686 r2019  
    33namespace xios 
    44{ 
    5   int InvalidableObject::filterIdGenerator = 0; 
    6  
    7   int InvalidableObject::edgeIdGenerator = 0; 
    8  
    9   int InvalidableObject::clusterIdGenerator = 0; 
    10    
    115  void CGarbageCollector::registerObject(InvalidableObject* Object, Time timestamp) 
    126  { 
  • XIOS/dev/dev_trunk_graph/src/filter/garbage_collector.hpp

    r1686 r2019  
    2020     */ 
    2121    void virtual invalidate(Time timestamp) = 0; 
    22    
    23      
    24  
    25     static int filterIdGenerator; 
    26  
    27     static int edgeIdGenerator; 
    28  
    29     static int clusterIdGenerator; 
    30  
    31      
    32      
    3322  }; // struct InvalidableObject 
    3423 
  • XIOS/dev/dev_trunk_graph/src/filter/input_pin.cpp

    r1686 r2019  
    33#include "garbage_collector.hpp" 
    44#include "exception.hpp" 
    5 #include "workflow_graph.hpp" 
    65 
    76namespace xios 
     
    1211    , triggers(slotsCount) 
    1312    , hasTriggers(false) 
    14   {  } 
    15  
    16   StdString CInputPin::GetName(void) 
    17   { 
    18     return StdString("Input pin"); 
    19   } 
     13  { /* Nothing to do */ } 
    2014 
    2115  void CInputPin::setInput(size_t inputSlot, CDataPacketPtr packet) 
  • XIOS/dev/dev_trunk_graph/src/filter/input_pin.hpp

    r1686 r2019  
    2626       */ 
    2727      CInputPin(CGarbageCollector& gc, size_t slotsCount); 
    28        
    29       StdString virtual GetName(void); 
    3028 
    3129      /*! 
  • XIOS/dev/dev_trunk_graph/src/filter/output_pin.cpp

    r1686 r2019  
    11#include "output_pin.hpp" 
    22#include "exception.hpp" 
    3 #include "workflow_graph.hpp" 
    43 
    54namespace xios 
     
    76  COutputPin::COutputPin(CGarbageCollector& gc, bool manualTrigger /*= false*/) 
    87    : gc(gc) 
    9     , manualTrigger(manualTrigger) 
    10   {  } 
    11  
    12   StdString COutputPin::GetName(void) 
    13   { 
    14     return StdString("Output pin"); 
    15   } 
     8    , manualTrigger(manualTrigger), graphEnabled(false) 
     9  { /* Nothing to do */ } 
    1610 
    1711  void COutputPin::connectOutput(std::shared_ptr<CInputPin> inputPin, size_t inputSlot) 
     
    107101    outputPackets.erase(outputPackets.begin(), outputPackets.lower_bound(timestamp)); 
    108102  } 
    109  
    110   void COutputPin::setParentFiltersTag() 
    111   { 
    112     for(int i=0; i<parent_filters.size(); i++) 
    113     { 
    114  
    115       if(parent_filters[i]->start_graph<0) parent_filters[i]->start_graph = start_graph; 
    116       else parent_filters[i]->start_graph = min(parent_filters[i]->start_graph, start_graph); 
    117  
    118  
    119       if(parent_filters[i]->end_graph<0) parent_filters[i]->end_graph = end_graph;   
    120       else parent_filters[i]->end_graph = max(parent_filters[i]->end_graph, end_graph); 
    121        
    122        
    123       parent_filters[i]->tag += tag; 
    124       parent_filters[i]->setParentFiltersTag(); 
    125     } 
    126   } 
    127  
    128  
    129  
    130  
    131103} // namespace xios 
  • XIOS/dev/dev_trunk_graph/src/filter/output_pin.hpp

    r1686 r2019  
    44#include "garbage_collector.hpp" 
    55#include "input_pin.hpp" 
    6 #include "duration.hpp" 
     6#include "graph_package.hpp" 
    77 
    88namespace xios 
    99{ 
    10   class CField; 
    11   class CInputPin; 
    12   class CFilter; 
    13   class CDuration; 
    1410  /*! 
    1511   * An output pin handles the connections with downstream filters. 
     
    1814  { 
    1915    public: 
    20       int tag; 
    21       Time start_graph; 
    22       Time end_graph; 
    23       CField *field; 
    24       int distance; 
    25  
    26  
    27  
    28       std::vector< std::shared_ptr<COutputPin> > parent_filters; 
    29  
    3016      /*! 
    3117       * Constructs an ouput pin with manual or automatic trigger 
     
    3723      COutputPin(CGarbageCollector& gc, bool manualTrigger = false); 
    3824 
    39       StdString virtual GetName(void); 
    40        
    4125      /*! 
    4226       * Connects to a specific slot of the input pin of a downstream filter. 
     
    8266       */ 
    8367      void virtual invalidate(Time timestamp); 
    84  
    85       void virtual setParentFiltersTag(); 
    86  
     68      CGraphPackage *graphPackage; 
     69      bool graphEnabled; 
    8770 
    8871    protected: 
  • XIOS/dev/dev_trunk_graph/src/filter/pass_through_filter.cpp

    r1688 r2019  
    11#include "pass_through_filter.hpp" 
    22#include "workflow_graph.hpp" 
    3 #include "field.hpp" 
    4 #include "file.hpp" 
     3#include <algorithm> 
    54 
    65namespace xios 
     
    87  CPassThroughFilter::CPassThroughFilter(CGarbageCollector& gc) 
    98    : CFilter(gc, 1, this) 
    10   {  
    11   } 
    12  
    13   void CPassThroughFilter::buildGraph(std::vector<CDataPacketPtr> data) 
    14   { 
    15     bool building_graph = this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
    16     // bool building_graph = this->tag ? data[0]->timestamp >= this->field->field_graph_start && data[0]->timestamp <= this->field->field_graph_end : false; 
    17  
    18     if(building_graph) 
    19     { 
    20       // std::cout<<"CPassThroughFilter::apply field_id = "<<this->field->getId()<<" start = "<<start_graph<<" end = "<<end_graph<<std::endl; 
    21       this->filterID = InvalidableObject::filterIdGenerator++; 
    22       int edgeID = InvalidableObject::edgeIdGenerator++; 
    23  
    24       CWorkflowGraph::allocNodeEdge(); 
    25  
    26       CWorkflowGraph::addNode(this->filterID, "Pass Through Filter\\n("+data[0]->field->getId()+")", 2, 1, 1, data[0]); 
    27       (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance = data[0]->distance+1; 
    28  
    29       (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes = this->field->record4graphXiosAttributes(); 
    30       if(this->field->file) (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes += "</br>file attributes : </br>" +this->field->file->record4graphXiosAttributes(); 
    31  
    32        
    33       if(CWorkflowGraph::build_begin) 
    34       { 
    35         CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
    36         (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0; 
    37       } 
    38       else CWorkflowGraph::build_begin = true; 
    39        
    40       data[0]->src_filterID=this->filterID; 
    41       data[0]->distance++; 
    42  
    43     } 
    44  
    45     data[0]->field = this->field; 
    46   } 
     9  { /* Nothing to do */ } 
    4710 
    4811  CDataPacketPtr CPassThroughFilter::apply(std::vector<CDataPacketPtr> data) 
    4912  { 
    50     if(CXios::isClient) buildGraph(data); 
     13    buildWorkflowGraph(data); 
    5114    return data[0]; 
    5215  } 
     16 
     17  void CPassThroughFilter::buildWorkflowGraph(std::vector<CDataPacketPtr> data) 
     18  { 
     19    if(this->graphEnabled) 
     20    { 
     21      this->graphPackage->filterId = CWorkflowGraph::getNodeSize(); 
     22       
     23      if(!data[0]->graphPackage)  
     24      { 
     25        data[0]->graphPackage = new CGraphDataPackage; 
     26        data[0]->graphPackage->fromFilter = -1; 
     27      } 
     28           
     29      data[0]->graphPackage->currentField = this->graphPackage->inFields[0]; 
     30      std::rotate(this->graphPackage->inFields.begin(), this->graphPackage->inFields.begin() + 1, this->graphPackage->inFields.end()); 
     31       
     32      CWorkflowGraph::addNode("Pass through filter", 2, false, 1, data[0]); 
     33      CWorkflowGraph::addEdge(data[0]->graphPackage->fromFilter, this->graphPackage->filterId, data[0]); 
     34      data[0]->graphPackage->fromFilter = this->graphPackage->filterId; 
     35         
     36    }  
     37  } 
     38 
     39 
    5340} // namespace xios 
     41 
  • XIOS/dev/dev_trunk_graph/src/filter/pass_through_filter.hpp

    r1686 r2019  
    2020      CPassThroughFilter(CGarbageCollector& gc); 
    2121 
    22       inline StdString GetName(void) {return StdString("Pass through filter");}; 
    23  
    2422    protected: 
    2523      /*! 
     
    3028       */ 
    3129      CDataPacketPtr virtual apply(std::vector<CDataPacketPtr> data); 
    32       void virtual buildGraph(std::vector<CDataPacketPtr> data); 
     30      void buildWorkflowGraph(std::vector<CDataPacketPtr> data); 
     31   
    3332  }; // class CPassThroughFilter 
    3433} // namespace xios 
  • XIOS/dev/dev_trunk_graph/src/filter/temporal_filter.cpp

    r1686 r2019  
    33#include "calendar_util.hpp" 
    44#include "workflow_graph.hpp" 
    5 #include "file.hpp" 
    65 
    76namespace xios 
     
    2726    , nbOperationDates(1) 
    2827    , nbSamplingDates(0) 
    29 //    , nextOperationDate(initDate + opFreq + this->samplingOffset) 
    3028    , isFirstOperation(true) 
    31     , temp_op(opId) 
    3229  { 
    3330  } 
    3431 
    35    
    36  
    37  
    38  
    39   bool CTemporalFilter::buildGraph(std::vector<CDataPacketPtr> data) 
     32  void CTemporalFilter::buildWorkflowGraph(std::vector<CDataPacketPtr> data) 
    4033  { 
    41     bool building_graph=this->tag ? data[0]->timestamp >= this->start_graph && data[0]->timestamp <= this->end_graph : false; 
    42     
    43     if(building_graph) 
     34    if(this->graphEnabled) 
    4435    { 
    45       if(this->filterIDoutputs.size()==0) this->filterID = InvalidableObject::filterIdGenerator++; 
    46       int edgeID = InvalidableObject::edgeIdGenerator++; 
     36      if(!data[0]->graphPackage) data[0]->graphPackage = new CGraphDataPackage; 
     37      data[0]->graphPackage->currentField = this->graphPackage->inFields[0]; 
     38      std::rotate(this->graphPackage->inFields.begin(), this->graphPackage->inFields.begin() + 1, this->graphPackage->inFields.end()); 
    4739       
    48       // std::cout<<"CTemporalFilter::apply filter tag = "<<this->tag<<" start = "<<this->start_graph<<" end = "<<this->end_graph<<std::endl; 
    49  
    50       CWorkflowGraph::allocNodeEdge(); 
    51  
    52       if(this->filterIDoutputs.size()==0) 
    53       { 
    54         CWorkflowGraph::addNode(this->filterID, "Temporal Filter\\n("+this->temp_op+")", 5, 1, 0, data[0]);    
    55         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].transform_type = this->temp_op;    
    56         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].inputs_complete = false ; 
    57         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].clusterID = 1 ; 
    58         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance = (data[0]->distance); 
    59  
    60  
    61         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes = this->field->record4graphXiosAttributes(); 
    62         if(this->field->file) (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].attributes += "</br>file attributes : </br>" +this->field->file->record4graphXiosAttributes(); 
     40      if(this->graphPackage->sourceFilterIds.size()==0) 
     41      {   
     42        this->graphPackage->filterId = CWorkflowGraph::getNodeSize(); 
     43        CWorkflowGraph::addNode("Temporal filter", 3, false, 0, data[0]); 
    6344      } 
    64  
    65       if(CWorkflowGraph::build_begin) 
    66       { 
    67  
    68         CWorkflowGraph::addEdge(edgeID, this->filterID, data[0]); 
    69  
    70         (*CWorkflowGraph::mapFilters_ptr_with_info)[data[0]->src_filterID].filter_filled = 0 ; 
    71         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].expected_entry_nb += 1 ; 
    72         (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance = max(data[0]->distance+1, (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].distance); 
    73       } 
    74  
    75  
    76       this->filterIDoutputs.push_back(data[0]->src_filterID);  
     45       
     46      CWorkflowGraph::addEdge(data[0]->graphPackage->fromFilter, this->graphPackage->filterId, data[0]); 
     47      data[0]->graphPackage->fromFilter = this->graphPackage->filterId; 
     48      this->graphPackage->sourceFilterIds.push_back(data[0]->graphPackage->fromFilter);     
    7749    } 
    7850 
    79     return building_graph; 
    8051  } 
    81  
    82  
    8352  CDataPacketPtr CTemporalFilter::apply(std::vector<CDataPacketPtr> data) 
    8453  { 
    85     bool BG = buildGraph(data); 
    86  
     54    buildWorkflowGraph(data); 
     55   
    8756    CDataPacketPtr packet; 
    8857 
     
    12695          packet->data.resize(tmpData.numElements()); 
    12796          packet->data = tmpData; 
     97          packet->graphPackage = data[0]->graphPackage; 
    12898        } 
    12999        else 
     
    132102        isFirstOperation = false; 
    133103         
    134         packet->field = this->field; 
    135          
    136         if(BG) 
    137         { 
    138           packet->src_filterID=this->filterID; 
    139           packet->distance = data[0]->distance+1; 
    140           this->filterIDoutputs.clear(); 
    141           CWorkflowGraph::build_begin=true; 
    142           (*CWorkflowGraph::mapFilters_ptr_with_info)[this->filterID].inputs_complete =