Ignore:
Timestamp:
11/15/17 12:14:34 (5 years ago)
Author:
yushan
Message:

dev_omp

Location:
XIOS/dev/branch_openmp/src
Files:
149 edited

Legend:

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

    r1134 r1328  
    554554        TinyVector<int,N_rank> vect; 
    555555        size_t ne; 
    556  
     556         
    557557        ret =  buffer.get(numDim); 
    558558        ret &= buffer.get(vect.data(), N_rank); 
  • XIOS/dev/branch_openmp/src/attribute_enum.hpp

    r1134 r1328  
    1414namespace xios 
    1515{ 
    16     /// ////////////////////// Déclarations ////////////////////// /// 
    17     /*! 
    18       \class CAttributeEnum 
    19       This class implements the attribute representing enumeration 
     16      /// ////////////////////// Déclarations ////////////////////// /// 
     17        /*! 
     18        \class CAttributeEnum 
     19        This class implements the attribute representing enumeration 
    2020      */ 
    21     template <class T> 
    22         class CAttributeEnum : public CAttribute, public CEnum<T> 
    23     { 
     21      template <class T> 
     22         class CAttributeEnum : public CAttribute, public CEnum<T> 
     23      { 
    2424        typedef typename T::t_enum T_enum ; 
    2525        public : 
    2626 
    27         /// Constructeurs /// 
    28         explicit CAttributeEnum(const StdString & id); 
    29         CAttributeEnum(const StdString & id, 
    30                 xios_map<StdString, CAttribute*> & umap); 
    31         CAttributeEnum(const StdString & id, const T_enum & value); 
    32         CAttributeEnum(const StdString & id, const T_enum & value, 
    33                 xios_map<StdString, CAttribute*> & umap); 
     27            /// Constructeurs /// 
     28            explicit CAttributeEnum(const StdString & id); 
     29            CAttributeEnum(const StdString & id, 
     30                               xios_map<StdString, CAttribute*> & umap); 
     31            CAttributeEnum(const StdString & id, const T_enum & value); 
     32            CAttributeEnum(const StdString & id, const T_enum & value, 
     33                               xios_map<StdString, CAttribute*> & umap); 
    3434 
    35         /// Accesseur /// 
    36         T_enum getValue(void) const; 
    37         string getStringValue(void) const; 
     35            /// Accesseur /// 
     36            T_enum getValue(void) const; 
     37            string getStringValue(void) const; 
    3838 
    3939 
    40         /// Mutateurs /// 
    41         void setValue(const T_enum & value); 
     40            /// Mutateurs /// 
     41            void setValue(const T_enum & value); 
     42             
     43            void set(const CAttribute& attr) ; 
     44            void set(const CAttributeEnum& attr) ; 
     45            void reset(void); 
     46             
     47            void setInheritedValue(const CAttributeEnum& attr ); 
     48            void setInheritedValue(const CAttribute& attr ); 
     49            T_enum getInheritedValue(void)  const; 
     50            string getInheritedStringValue(void) const; 
     51            bool hasInheritedValue(void) const;           
     52           
     53            bool isEqual(const CAttributeEnum& attr ); 
     54            bool isEqual(const CAttribute& attr ); 
    4255 
    43         void set(const CAttribute& attr) ; 
    44         void set(const CAttributeEnum& attr) ; 
    45         void reset(void); 
     56            /// Destructeur /// 
     57            virtual ~CAttributeEnum(void) { } 
    4658 
    47         void setInheritedValue(const CAttributeEnum& attr ); 
    48         void setInheritedValue(const CAttribute& attr ); 
    49         T_enum getInheritedValue(void)  const; 
    50         string getInheritedStringValue(void) const; 
    51         bool hasInheritedValue(void) const;           
     59            /// Operateur /// 
     60            CAttributeEnum& operator=(const T_enum & value); 
    5261 
    53         bool isEqual(const CAttributeEnum& attr ); 
    54         bool isEqual(const CAttribute& attr ); 
     62            /// Autre /// 
     63            virtual StdString toString(void) const { return _toString();} 
     64            virtual void fromString(const StdString & str) { if (str==resetInheritanceStr) { reset(); _canInherite=false ;}  else _fromString(str);} 
    5565 
    56         /// Destructeur /// 
    57         virtual ~CAttributeEnum(void) { } 
     66            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);}  
     67            virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer); }  
     68             
     69            virtual void generateCInterface(ostream& oss,const string& className) ; 
     70            virtual void generateFortran2003Interface(ostream& oss,const string& className) ; 
     71            virtual void generateFortranInterfaceDeclaration_(ostream& oss,const string& className) ; 
     72            virtual void generateFortranInterfaceBody_(ostream& oss,const string& className) ; 
     73            virtual void generateFortranInterfaceDeclaration(ostream& oss,const string& className) ; 
     74            virtual void generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) ; 
     75            virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ; 
     76            virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ;       
    5877 
    59         /// Operateur /// 
    60         CAttributeEnum& operator=(const T_enum & value); 
    61  
    62         /// Autre /// 
    63         virtual StdString toString(void) const { return _toString();} 
    64         virtual void fromString(const StdString & str) { if (str==resetInheritanceStr) { reset(); _canInherite=false ;}  else _fromString(str);} 
    65  
    66         virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);}  
    67         virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer); }  
    68  
    69         virtual void generateCInterface(ostream& oss,const string& className) ; 
    70         virtual void generateFortran2003Interface(ostream& oss,const string& className) ; 
    71         virtual void generateFortranInterfaceDeclaration_(ostream& oss,const string& className) ; 
    72         virtual void generateFortranInterfaceBody_(ostream& oss,const string& className) ; 
    73         virtual void generateFortranInterfaceDeclaration(ostream& oss,const string& className) ; 
    74         virtual void generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) ; 
    75         virtual void generateFortranInterfaceGetBody_(ostream& oss,const string& className) ; 
    76         virtual void generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) ;       
    77  
    78         private : 
    79         StdString _toString(void) const; 
    80         void _fromString(const StdString & str); 
    81         bool _toBuffer  (CBufferOut& buffer) const; 
    82         bool _fromBuffer(CBufferIn& buffer) ; 
    83         CEnum<T> inheritedValue ; 
    84     }; // class CAttributeEnum     
    85  
     78         private : 
     79          StdString _toString(void) const; 
     80          void _fromString(const StdString & str); 
     81          bool _toBuffer  (CBufferOut& buffer) const; 
     82          bool _fromBuffer(CBufferIn& buffer) ; 
     83          CEnum<T> inheritedValue ; 
     84      }; // class CAttributeEnum     
     85    
    8686} // namespace xios 
    8787 
    8888#endif // __XIOS_ATTRIBUTE_ENUM__ 
    89  
  • XIOS/dev/branch_openmp/src/attribute_enum_impl.hpp

    r1134 r1328  
    1010namespace xios 
    1111{ 
    12   /// ////////////////////// Définitions ////////////////////// /// 
     12  /// ////////////////////// Définitions ////////////////////// /// 
    1313  template <class T> 
    1414  CAttributeEnum<T>::CAttributeEnum(const StdString & id) 
     
    3030     umap.insert(umap.end(), std::make_pair(id, this)); 
    3131  } 
    32   
     32 
    3333  template <class T> 
    3434  CAttributeEnum<T>::CAttributeEnum 
     
    4040     umap.insert(umap.end(), std::make_pair(id, this)); 
    4141  } 
    42   
     42 
    4343  ///-------------------------------------------------------------- 
    4444  template <class T> 
     
    5454     return CEnum<T>::get(); 
    5555  } 
    56   
     56 
    5757  template <class T> 
    5858  string CAttributeEnum<T>::getStringValue(void) const 
    5959  { 
    60     return CEnum<T>::toString(); 
    61   } 
    62  
     60     return CEnum<T>::toString(); 
     61  } 
    6362 
    6463  template <class T> 
     
    7170  void CAttributeEnum<T>::set(const CAttribute& attr) 
    7271  { 
    73      this->set(dynamic_cast<const CAttributeEnum<T>& >(attr)); 
    74   } 
    75     
    76   template <class T> 
     72    this->set(dynamic_cast<const CAttributeEnum<T>& >(attr)); 
     73  } 
     74 
     75 template <class T> 
    7776  void CAttributeEnum<T>::set(const CAttributeEnum& attr) 
    7877  { 
    79      CEnum<T>::set(attr); 
    80   } 
    81   
     78    CEnum<T>::set(attr); 
     79  } 
     80 
    8281  template <class T> 
    8382  void CAttributeEnum<T>::setInheritedValue(const CAttribute& attr) 
    8483  { 
    85      this->setInheritedValue(dynamic_cast<const CAttributeEnum<T>& >(attr)); 
    86   } 
    87    
     84    this->setInheritedValue(dynamic_cast<const CAttributeEnum<T>& >(attr)); 
     85  } 
     86 
    8887  template <class T> 
    8988  void CAttributeEnum<T>::setInheritedValue(const CAttributeEnum& attr) 
    9089  { 
    91      if (this->isEmpty() && _canInherite && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()); 
    92   } 
    93    
     90    if (this->isEmpty() && _canInherite && attr.hasInheritedValue()) inheritedValue.set(attr.getInheritedValue()); 
     91  } 
     92 
    9493  template <class T> 
    9594  typename T::t_enum CAttributeEnum<T>::getInheritedValue(void) const 
    9695  { 
    97      if (this->isEmpty()) return inheritedValue.get(); 
    98      else return getValue(); 
    99   } 
    100  
    101   template <class T> 
    102       string CAttributeEnum<T>::getInheritedStringValue(void) const 
    103       { 
    104           if (this->isEmpty()) return inheritedValue.toString(); 
    105           else return CEnum<T>::toString();; 
    106       } 
    107  
    108   template <class T> 
    109       bool CAttributeEnum<T>::hasInheritedValue(void) const 
    110       { 
    111           return !this->isEmpty() || !inheritedValue.isEmpty(); 
    112       } 
    113  
    114   template <class T> 
    115       bool CAttributeEnum<T>::isEqual(const CAttribute& attr) 
    116       { 
    117           return (this->isEqual(dynamic_cast<const CAttributeEnum<T>& >(attr))); 
    118       } 
    119  
    120   template <class T> 
    121       bool CAttributeEnum<T>::isEqual(const CAttributeEnum& attr) 
    122       { 
    123           return ((dynamic_cast<const CEnum<T>& >(*this)) == (dynamic_cast<const CEnum<T>& >(attr))); 
    124       } 
     96    if (this->isEmpty()) return inheritedValue.get(); 
     97    else return getValue(); 
     98  } 
     99 
     100  template <class T> 
     101  string CAttributeEnum<T>::getInheritedStringValue(void) const 
     102  { 
     103     if (this->isEmpty()) return inheritedValue.toString(); 
     104     else return CEnum<T>::toString();; 
     105  } 
     106 
     107  template <class T> 
     108  bool CAttributeEnum<T>::hasInheritedValue(void) const 
     109  { 
     110    return !this->isEmpty() || !inheritedValue.isEmpty(); 
     111  } 
     112 
     113  template <class T> 
     114  bool CAttributeEnum<T>::isEqual(const CAttribute& attr) 
     115  { 
     116    return (this->isEqual(dynamic_cast<const CAttributeEnum<T>& >(attr))); 
     117  } 
     118 
     119  template <class T> 
     120  bool CAttributeEnum<T>::isEqual(const CAttributeEnum& attr) 
     121  { 
     122    return ((dynamic_cast<const CEnum<T>& >(*this)) == (dynamic_cast<const CEnum<T>& >(attr))); 
     123  } 
    125124 
    126125  //--------------------------------------------------------------- 
    127126 
    128127  template <class T> 
    129       CAttributeEnum<T>& CAttributeEnum<T>::operator=(const T_enum & value) 
    130       { 
    131           this->setValue(value); 
    132           return *this; 
    133       } 
     128  CAttributeEnum<T>& CAttributeEnum<T>::operator=(const T_enum & value) 
     129  { 
     130     this->setValue(value); 
     131     return *this; 
     132  } 
    134133 
    135134  //--------------------------------------------------------------- 
    136135 
    137136  template <class T> 
    138       StdString CAttributeEnum<T>::_toString(void) const 
    139       { 
    140           StdOStringStream oss; 
    141           if (!CEnum<T>::isEmpty() && this->hasId()) 
    142               oss << this->getName() << "=\"" << CEnum<T>::toString() << "\""; 
    143           return (oss.str()); 
    144       } 
    145  
    146   template <class T> 
    147       void CAttributeEnum<T>::_fromString(const StdString & str) 
    148       { 
    149           CEnum<T>::fromString(str); 
    150       } 
    151  
    152   template <class T> 
    153       bool CAttributeEnum<T>::_toBuffer (CBufferOut& buffer) const 
    154       { 
    155           return CEnum<T>::toBuffer(buffer); 
    156       } 
    157  
    158   template <class T> 
    159       bool CAttributeEnum<T>::_fromBuffer(CBufferIn& buffer) 
    160       { 
    161           return CEnum<T>::fromBuffer(buffer); 
    162       } 
    163  
    164   template <typename T> 
    165       void CAttributeEnum<T>::generateCInterface(ostream& oss,const string& className) 
    166       { 
    167           CInterface::AttributeCInterface<CEnumBase>(oss, className, this->getName()); 
    168       } 
    169  
    170   template <typename T> 
    171       void CAttributeEnum<T>::generateFortran2003Interface(ostream& oss,const string& className) 
    172       { 
    173           CInterface::AttributeFortran2003Interface<string>(oss, className, this->getName()); 
    174       } 
    175  
    176   template <typename T> 
    177       void CAttributeEnum<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
    178       { 
    179           CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()+"_"); 
    180       } 
    181  
    182   template <typename T> 
    183       void CAttributeEnum<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
    184       { 
    185           CInterface::AttributeFortranInterfaceBody<string>(oss, className, this->getName()); 
    186       } 
    187  
    188   template <typename T> 
    189       void CAttributeEnum<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
    190       { 
    191           CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()); 
    192       } 
    193  
    194   template <typename T> 
    195       void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
    196       { 
    197           CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()+"_"); 
    198       } 
    199  
    200   template <typename T> 
    201       void CAttributeEnum<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
    202       { 
    203           CInterface::AttributeFortranInterfaceGetBody<string>(oss, className, this->getName()); 
    204       } 
    205  
    206   template <typename T> 
    207       void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
    208       { 
    209           CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()); 
    210       } 
     137  StdString CAttributeEnum<T>::_toString(void) const 
     138  { 
     139     StdOStringStream oss; 
     140     if (!CEnum<T>::isEmpty() && this->hasId()) 
     141        oss << this->getName() << "=\"" << CEnum<T>::toString() << "\""; 
     142     return (oss.str()); 
     143  } 
     144 
     145  template <class T> 
     146  void CAttributeEnum<T>::_fromString(const StdString & str) 
     147  { 
     148    CEnum<T>::fromString(str); 
     149  } 
     150 
     151  template <class T> 
     152  bool CAttributeEnum<T>::_toBuffer (CBufferOut& buffer) const 
     153  { 
     154     return CEnum<T>::toBuffer(buffer); 
     155  } 
     156 
     157  template <class T> 
     158  bool CAttributeEnum<T>::_fromBuffer(CBufferIn& buffer) 
     159  { 
     160    return CEnum<T>::fromBuffer(buffer); 
     161  } 
     162 
     163  template <typename T> 
     164  void CAttributeEnum<T>::generateCInterface(ostream& oss,const string& className) 
     165  { 
     166    CInterface::AttributeCInterface<CEnumBase>(oss, className, this->getName()); 
     167  } 
     168 
     169  template <typename T> 
     170  void CAttributeEnum<T>::generateFortran2003Interface(ostream& oss,const string& className) 
     171  { 
     172    CInterface::AttributeFortran2003Interface<string>(oss, className, this->getName()); 
     173  } 
     174 
     175  template <typename T> 
     176  void CAttributeEnum<T>::generateFortranInterfaceDeclaration_(ostream& oss,const string& className) 
     177  { 
     178    CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()+"_"); 
     179  } 
     180 
     181  template <typename T> 
     182  void CAttributeEnum<T>::generateFortranInterfaceBody_(ostream& oss,const string& className) 
     183  { 
     184    CInterface::AttributeFortranInterfaceBody<string>(oss, className, this->getName()); 
     185  } 
     186 
     187  template <typename T> 
     188  void CAttributeEnum<T>::generateFortranInterfaceDeclaration(ostream& oss,const string& className) 
     189  { 
     190    CInterface::AttributeFortranInterfaceDeclaration<string>(oss, className, this->getName()); 
     191  } 
     192 
     193  template <typename T> 
     194  void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration_(ostream& oss,const string& className) 
     195  { 
     196    CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()+"_"); 
     197  } 
     198 
     199  template <typename T> 
     200  void CAttributeEnum<T>::generateFortranInterfaceGetBody_(ostream& oss,const string& className) 
     201  { 
     202    CInterface::AttributeFortranInterfaceGetBody<string>(oss, className, this->getName()); 
     203  } 
     204 
     205  template <typename T> 
     206  void CAttributeEnum<T>::generateFortranInterfaceGetDeclaration(ostream& oss,const string& className) 
     207  { 
     208    CInterface::AttributeFortranInterfaceGetDeclaration<string>(oss, className, this->getName()); 
     209  } 
    211210} // namespace xios 
    212211 
    213212#endif // __XIOS_ATTRIBUTE_ENUM_IMPL_HPP__ 
    214  
  • XIOS/dev/branch_openmp/src/attribute_map.hpp

    r1134 r1328  
    7676            /// Propriété statique /// 
    7777            static CAttributeMap * Current; 
    78             #pragma omp threadprivate (Current) 
    7978 
    8079      };  // class CAttributeMap 
  • XIOS/dev/branch_openmp/src/buffer_client.cpp

    r1205 r1328  
    77#include "mpi.hpp" 
    88#include "tracer.hpp" 
     9 
     10 
     11using namespace ep_lib; 
    912 
    1013namespace xios 
     
    2730    buffer[1] = new char[bufferSize]; 
    2831    retBuffer = new CBufferOut(buffer[current], bufferSize); 
    29     #pragma omp critical (_output) 
    3032    info(10) << "CClientBuffer: allocated 2 x " << bufferSize << " bytes for server " << serverRank << " with a maximum of " << maxBufferedEvents << " buffered events" << endl; 
    3133  } 
  • XIOS/dev/branch_openmp/src/buffer_client.hpp

    r1205 r1328  
    66#include "mpi.hpp" 
    77#include "cxios.hpp" 
    8 #ifdef _usingEP 
    9 #include "ep_declaration.hpp" 
    10 #endif 
    118 
    129namespace xios 
     
    1613    public: 
    1714      static size_t maxRequestSize; 
    18       #pragma omp threadprivate(maxRequestSize) 
    1915 
    20       CClientBuffer(MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
     16      CClientBuffer(ep_lib::MPI_Comm intercomm, int serverRank, StdSize bufferSize, StdSize estimatedMaxEventSize, StdSize maxBufferedEvents); 
    2117      ~CClientBuffer(); 
    2218 
     
    4036      bool pending; 
    4137 
    42       MPI_Request request; 
     38      ep_lib::MPI_Request request; 
    4339 
    4440      CBufferOut* retBuffer; 
    45       const MPI_Comm interComm; 
     41      const ep_lib::MPI_Comm interComm; 
    4642  }; 
    4743} 
  • XIOS/dev/branch_openmp/src/buffer_server.hpp

    r1134 r1328  
    44#include "xios_spl.hpp" 
    55#include "buffer.hpp" 
    6 #include "mpi_std.hpp" 
     6#include "mpi.hpp" 
    77#include "cxios.hpp" 
    88 
  • XIOS/dev/branch_openmp/src/calendar.cpp

    r1134 r1328  
    117117      const CDate& CCalendar::update(int step) 
    118118      { 
    119         #pragma omp critical (_output) 
    120         info(80)<< "update step : " << step << " timestep " << this->timestep << std::endl; 
     119        info(20) << "update step : " << step << " timestep " << this->timestep << std::endl; 
    121120        return (this->currentDate = this->getInitDate() + step * this->timestep); 
    122121      } 
  • XIOS/dev/branch_openmp/src/client.cpp

    r1205 r1328  
    1111#include "timer.hpp" 
    1212#include "buffer_client.hpp" 
    13 #include "log.hpp" 
    14  
     13using namespace ep_lib; 
    1514 
    1615namespace xios 
    1716{ 
    18     extern int test_omp_rank; 
    19     #pragma omp threadprivate(test_omp_rank) 
    2017 
    2118    MPI_Comm CClient::intraComm ; 
    2219    MPI_Comm CClient::interComm ; 
     20    //std::list<MPI_Comm> CClient::contextInterComms; 
    2321    std::list<MPI_Comm> *CClient::contextInterComms_ptr = 0; 
    2422    int CClient::serverLeader ; 
     
    2826    StdOFStream CClient::m_errorStream; 
    2927 
    30     StdOFStream CClient::array_infoStream[16]; 
    31  
    32     void CClient::initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
     28    void CClient::initialize(const string& codeId,MPI_Comm& localComm,MPI_Comm& returnComm) 
    3329    { 
    3430      int initialized ; 
     
    4137      { 
    4238// localComm doesn't given 
    43  
    4439        if (localComm == MPI_COMM_NULL) 
    4540        { 
    4641          if (!is_MPI_Initialized) 
    4742          { 
    48             //MPI_Init(NULL, NULL); 
    49             int return_level; 
    50             MPI_Init_thread(NULL, NULL, 3, &return_level); 
    51             assert(return_level == 3); 
     43            MPI_Init(NULL, NULL); 
    5244          } 
    5345          CTimer::get("XIOS").resume() ; 
     
    6153          int myColor ; 
    6254          int i,c ; 
    63  
    64           MPI_Comm_size(CXios::globalComm,&size); 
     55          MPI_Comm newComm ; 
     56 
     57          MPI_Comm_size(CXios::globalComm,&size) ; 
    6558          MPI_Comm_rank(CXios::globalComm,&rank); 
    66         
    6759 
    6860          hashAll=new unsigned long[size] ; 
     
    10698            MPI_Comm_size(intraComm,&intraCommSize) ; 
    10799            MPI_Comm_rank(intraComm,&intraCommRank) ; 
    108              
    109             #pragma omp critical(_output) 
    110             { 
    111               info(10)<<"intercommCreate::client "<<test_omp_rank<< " "<< &test_omp_rank <<" intraCommSize : "<<intraCommSize 
    112                  <<" intraCommRank :"<<intraCommRank<<"  serverLeader "<< serverLeader 
    113                  <<" globalComm : "<< &(CXios::globalComm) << endl ;   
    114             } 
    115  
    116              
    117             //test_sendrecv(CXios::globalComm); 
     100            info(50)<<"intercommCreate::client "<<rank<<" intraCommSize : "<<intraCommSize 
     101                 <<" intraCommRank :"<<intraCommRank<<"  clientLeader "<< serverLeader<<endl ; 
    118102            MPI_Intercomm_create(intraComm,0,CXios::globalComm,serverLeader,0,&interComm) ; 
    119  
    120103          } 
    121104          else 
     
    140123      } 
    141124      // using OASIS 
    142       else 
     125/*      else 
    143126      { 
    144127        // localComm doesn't given 
     
    165148        else MPI_Comm_dup(intraComm,&interComm) ; 
    166149      } 
    167  
     150*/ 
    168151      MPI_Comm_dup(intraComm,&returnComm) ; 
    169  
    170152    } 
    171153 
     
    174156    { 
    175157      CContext::setCurrent(id) ; 
    176       CContext* context = CContext::create(id); 
    177  
    178       int tmp_rank; 
    179       MPI_Comm_rank(contextComm,&tmp_rank) ; 
    180        
     158      CContext* context=CContext::create(id); 
    181159      StdString idServer(id); 
    182160      idServer += "_server"; 
     
    185163      { 
    186164        int size,rank,globalRank ; 
    187         //size_t message_size ; 
    188         //int leaderRank ; 
     165        size_t message_size ; 
     166        int leaderRank ; 
    189167        MPI_Comm contextInterComm ; 
    190168 
     
    197175        CMessage msg ; 
    198176        msg<<idServer<<size<<globalRank ; 
    199  
     177//        msg<<id<<size<<globalRank ; 
    200178 
    201179        int messageSize=msg.size() ; 
     
    208186 
    209187        MPI_Intercomm_create(contextComm,0,CXios::globalComm,serverLeader,10+globalRank,&contextInterComm) ; 
    210          
    211         #pragma omp critical(_output) 
    212         info(10)<<" RANK "<< tmp_rank<<" Register new Context : "<<id<<endl ; 
    213  
     188        info(10)<<"Register new Context : "<<id<<endl ; 
    214189 
    215190        MPI_Comm inter ; 
     
    217192        MPI_Barrier(inter) ; 
    218193 
    219          
    220194        context->initClient(contextComm,contextInterComm) ; 
    221195 
    222          
     196        //contextInterComms.push_back(contextInterComm); 
    223197        if(contextInterComms_ptr == NULL) contextInterComms_ptr = new std::list<MPI_Comm>; 
    224198        contextInterComms_ptr->push_back(contextInterComm); 
    225          
    226199        MPI_Comm_free(&inter); 
    227200      } 
     
    240213        // Finally, we should return current context to context client 
    241214        CContext::setCurrent(id); 
    242          
     215 
     216        //contextInterComms.push_back(contextInterComm); 
    243217        if(contextInterComms_ptr == NULL) contextInterComms_ptr = new std::list<MPI_Comm>; 
    244218        contextInterComms_ptr->push_back(contextInterComm); 
    245  
    246219      } 
    247220    } 
     
    253226 
    254227      MPI_Comm_rank(intraComm,&rank) ; 
    255  
     228  
    256229      if (!CXios::isServer) 
    257230      { 
     
    263236      } 
    264237 
    265       for (std::list<MPI_Comm>::iterator it = contextInterComms_ptr->begin(); it != contextInterComms_ptr->end(); ++it) 
     238      //for (std::list<MPI_Comm>::iterator it = contextInterComms.begin(); it != contextInterComms.end(); it++) 
     239      for (std::list<MPI_Comm>::iterator it = contextInterComms_ptr->begin(); it != contextInterComms_ptr->end(); it++) 
    266240        MPI_Comm_free(&(*it)); 
    267        
    268241      MPI_Comm_free(&interComm); 
    269242      MPI_Comm_free(&intraComm); 
     
    274247      if (!is_MPI_Initialized) 
    275248      { 
    276         if (CXios::usingOasis) oasis_finalize(); 
    277         else MPI_Finalize(); 
     249        //if (CXios::usingOasis) oasis_finalize(); 
     250        //else 
     251        MPI_Finalize() ; 
    278252      } 
    279253       
    280       #pragma omp critical (_output) 
    281       info(20) << "Client "<<rank<<" : Client side context is finalized "<< endl ; 
    282  
    283    /*#pragma omp critical (_output) 
    284    { 
     254      info(20) << "Client side context is finalized"<<endl ; 
    285255      report(0) <<" Performance report : Whole time from XIOS init and finalize: "<< CTimer::get("XIOS init/finalize").getCumulatedTime()<<" s"<<endl ; 
    286256      report(0) <<" Performance report : total time spent for XIOS : "<< CTimer::get("XIOS").getCumulatedTime()<<" s"<<endl ; 
     
    292262      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 ; 
    293263      report(100)<<CTimer::getAllCumulatedTime()<<endl ; 
    294    }*/ 
    295     
    296264   } 
    297265 
     
    322290 
    323291      fileNameClient << fileName << "_" << std::setfill('0') << std::setw(numDigit) << getRank() << ext; 
    324        
    325292      fb->open(fileNameClient.str().c_str(), std::ios::out); 
    326293      if (!fb->is_open()) 
    327294        ERROR("void CClient::openStream(const StdString& fileName, const StdString& ext, std::filebuf* fb)", 
    328             << std::endl << "Can not open <" << fileNameClient << "> file to write the client log(s)."); 
     295              << std::endl << "Can not open <" << fileNameClient << "> file to write the client log(s)."); 
    329296    } 
    330297 
     
    337304    void CClient::openInfoStream(const StdString& fileName) 
    338305    { 
    339       //std::filebuf* fb = m_infoStream.rdbuf(); 
    340  
    341       info_FB[omp_get_thread_num()] = array_infoStream[omp_get_thread_num()].rdbuf(); 
    342            
    343       openStream(fileName, ".out", info_FB[omp_get_thread_num()]); 
    344  
    345       info.write2File(info_FB[omp_get_thread_num()]); 
    346       report.write2File(info_FB[omp_get_thread_num()]); 
    347        
     306      std::filebuf* fb = m_infoStream.rdbuf(); 
     307      openStream(fileName, ".out", fb); 
     308 
     309      info.write2File(fb); 
     310      report.write2File(fb); 
    348311    } 
    349312 
  • XIOS/dev/branch_openmp/src/client.hpp

    r1164 r1328  
    1010    { 
    1111      public: 
    12         static void initialize(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm); 
     12        static void initialize(const string& codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm); 
    1313        static void finalize(void); 
    1414        static void registerContext(const string& id, ep_lib::MPI_Comm contextComm); 
    1515 
    16         static MPI_Comm intraComm; 
    17         #pragma omp threadprivate(intraComm) 
    18  
    19         static MPI_Comm interComm; 
    20         #pragma omp threadprivate(interComm) 
    21  
     16        static ep_lib::MPI_Comm intraComm; 
     17        static ep_lib::MPI_Comm interComm; 
    2218        //static std::list<MPI_Comm> contextInterComms; 
    23          
    24         static std::list<MPI_Comm> * contextInterComms_ptr; 
    25         #pragma omp threadprivate(contextInterComms_ptr) 
    26  
     19        static std::list<ep_lib::MPI_Comm> *contextInterComms_ptr; 
    2720        static int serverLeader; 
    28         #pragma omp threadprivate(serverLeader) 
    29  
    3021        static bool is_MPI_Initialized ; 
    31         #pragma omp threadprivate(is_MPI_Initialized) 
    3222 
    3323        //! Get rank of the current process 
     
    5040      protected: 
    5141        static int rank; 
    52         #pragma omp threadprivate(rank) 
    53  
    5442        static StdOFStream m_infoStream; 
    55         #pragma omp threadprivate(m_infoStream)  
    56  
    5743        static StdOFStream m_errorStream; 
    58         #pragma omp threadprivate(m_errorStream) 
    59  
    60         static StdOFStream array_infoStream[16]; 
    6144 
    6245        static void openStream(const StdString& fileName, const StdString& ext, std::filebuf* fb); 
  • XIOS/dev/branch_openmp/src/client_client_dht_template.hpp

    r1134 r1328  
    1313#include "xios_spl.hpp" 
    1414#include "array_new.hpp" 
    15 #include "mpi_std.hpp" 
     15#include "mpi.hpp" 
    1616#include "policy.hpp" 
    1717#include <boost/unordered_map.hpp> 
     
    8787                           const ep_lib::MPI_Comm& clientIntraComm, 
    8888                           std::vector<ep_lib::MPI_Request>& requestSendInfo); 
     89    void sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
     90                           const ep_lib::MPI_Comm& clientIntraComm, 
     91                           ep_lib::MPI_Request* requestSendInfo); 
    8992 
    9093    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
    9194                            const ep_lib::MPI_Comm& clientIntraComm, 
    9295                            std::vector<ep_lib::MPI_Request>& requestRecvInfo); 
     96    void recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
     97                             const ep_lib::MPI_Comm& clientIntraComm, 
     98                             ep_lib::MPI_Request* requestRecvInfo); 
     99                                                         
    93100 
    94101    // Send global index to clients 
     
    96103                            const ep_lib::MPI_Comm& clientIntraComm, 
    97104                            std::vector<ep_lib::MPI_Request>& requestSendIndexGlobal); 
     105    void sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
     106                            const ep_lib::MPI_Comm& clientIntraComm, 
     107                            ep_lib::MPI_Request* requestSendIndexGlobal); 
    98108 
    99109    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
    100110                             const ep_lib::MPI_Comm& clientIntraComm, 
    101111                             std::vector<ep_lib::MPI_Request>& requestRecvIndex); 
     112    void recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
     113                              const ep_lib::MPI_Comm& clientIntraComm, 
     114                              ep_lib::MPI_Request* requestRecvIndex); 
    102115 
    103116    void sendRecvOnReturn(const std::vector<int>& sendNbRank, std::vector<int>& sendNbElements, 
  • XIOS/dev/branch_openmp/src/client_client_dht_template_impl.hpp

    r1209 r1328  
    1010#include "utils.hpp" 
    1111#include "mpi_tag.hpp" 
    12 #ifdef _usingEP 
    13 #include "ep_declaration.hpp" 
    14 #include "ep_lib.hpp" 
    15 #endif 
    16  
    1712 
    1813namespace xios 
     
    2217  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    2318{ 
    24   MPI_Comm_size(clientIntraComm, &nbClient_); 
     19  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
    2520  this->computeMPICommLevel(); 
    2621  int nbLvl = this->getNbLevel(); 
     
    4237  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    4338{ 
    44   MPI_Comm_size(clientIntraComm, &nbClient_); 
     39  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
    4540  this->computeMPICommLevel(); 
    4641  int nbLvl = this->getNbLevel(); 
     
    6762  : H(clientIntraComm), index2InfoMapping_(), indexToInfoMappingLevel_(), nbClient_(0) 
    6863{ 
    69   MPI_Comm_size(clientIntraComm, &nbClient_); 
     64  ep_lib::MPI_Comm_size(clientIntraComm, &nbClient_); 
    7065  this->computeMPICommLevel(); 
    7166  int nbLvl = this->getNbLevel(); 
     
    10499{ 
    105100  int clientRank; 
    106   MPI_Comm_rank(commLevel,&clientRank); 
    107   //ep_lib::MPI_Barrier(commLevel); 
     101  ep_lib::MPI_Comm_rank(commLevel,&clientRank); 
    108102  int groupRankBegin = this->getGroupBegin()[level]; 
    109103  int nbClient = this->getNbInGroup()[level]; 
     
    175169    recvIndexBuff = new unsigned long[recvNbIndexCount]; 
    176170 
    177   int request_size = 0; 
    178  
    179   int currentIndex = 0; 
    180   int nbRecvClient = recvRankClient.size(); 
    181  
    182   int position = 0; 
    183  
    184   for (int idx = 0; idx < nbRecvClient; ++idx) 
     171int request_size = 0; 
     172  for (int idx = 0; idx < recvRankClient.size(); ++idx) 
    185173  { 
    186174    if (0 != recvNbIndexClientCount[idx]) 
    187     { 
    188       request_size++; 
    189     } 
     175      request_size ++; 
    190176  } 
    191177 
    192178  request_size += client2ClientIndex.size(); 
    193179 
    194  
    195180  std::vector<ep_lib::MPI_Request> request(request_size); 
    196  
     181   
    197182  std::vector<int>::iterator itbRecvIndex = recvRankClient.begin(), itRecvIndex, 
    198183                             iteRecvIndex = recvRankClient.end(), 
    199184                           itbRecvNbIndex = recvNbIndexClientCount.begin(), 
    200185                           itRecvNbIndex; 
    201    
    202    
     186  int currentIndex = 0; 
     187  int nbRecvClient = recvRankClient.size(); 
     188  int request_position = 0; 
     189  for (int idx = 0; idx < nbRecvClient; ++idx) 
     190  { 
     191    if (0 != recvNbIndexClientCount[idx]) 
     192      recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
     193      //recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
     194    currentIndex += recvNbIndexClientCount[idx]; 
     195  } 
     196 
    203197  boost::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex, 
    204198                                                iteIndex = client2ClientIndex.end(); 
    205199  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    206   { 
    207     MPI_Isend(itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], MPI_UNSIGNED_LONG, itIndex->first, MPI_DHT_INDEX, commLevel, &request[position]); 
    208     position++; 
     200    sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
    209201    //sendIndexToClients(itIndex->first, (itIndex->second), sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
    210   } 
    211      
    212   for (int idx = 0; idx < nbRecvClient; ++idx) 
    213   { 
    214     if (0 != recvNbIndexClientCount[idx]) 
    215     { 
    216       MPI_Irecv(recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], MPI_UNSIGNED_LONG, 
    217             recvRankClient[idx], MPI_DHT_INDEX, commLevel, &request[position]); 
    218       position++; 
    219       //recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
    220     } 
    221     currentIndex += recvNbIndexClientCount[idx]; 
    222   } 
    223  
    224    
    225   std::vector<ep_lib::MPI_Status> status(request_size); 
    226   MPI_Waitall(request.size(), &request[0], &status[0]); 
    227  
     202 
     203  std::vector<ep_lib::MPI_Status> status(request.size()); 
     204  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]); 
    228205 
    229206  CArray<size_t,1>* tmpGlobalIndex; 
     
    238215    --level; 
    239216    computeIndexInfoMappingLevel(*tmpGlobalIndex, this->internalComm_, level); 
    240        
    241217  } 
    242218  else // Now, we are in the last level where necessary mappings are. 
     
    279255  } 
    280256 
    281   request_size = 0; 
     257int requestOnReturn_size=0; 
    282258  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx) 
    283259  { 
    284260    if (0 != recvNbIndexOnReturn[idx]) 
    285261    { 
    286       request_size += 2; 
     262      requestOnReturn_size += 2; 
    287263    } 
    288264  } 
     
    292268    if (0 != sendNbIndexOnReturn[idx]) 
    293269    { 
    294       request_size += 2; 
    295     } 
    296   } 
    297  
    298   std::vector<ep_lib::MPI_Request> requestOnReturn(request_size); 
     270      requestOnReturn_size += 2; 
     271    } 
     272  } 
     273 
     274  int requestOnReturn_position=0; 
     275 
     276  std::vector<ep_lib::MPI_Request> requestOnReturn(requestOnReturn_size); 
    299277  currentIndex = 0; 
    300   position = 0; 
    301278  for (int idx = 0; idx < recvRankOnReturn.size(); ++idx) 
    302279  { 
     
    304281    { 
    305282      //recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, requestOnReturn); 
    306       MPI_Irecv(recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], MPI_UNSIGNED_LONG, 
    307             recvRankOnReturn[idx], MPI_DHT_INDEX, commLevel, &requestOnReturn[position]); 
    308       position++; 
    309283      //recvInfoFromClients(recvRankOnReturn[idx], 
    310284      //                    recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    311285      //                    recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    312286      //                    commLevel, requestOnReturn); 
    313       MPI_Irecv(recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(),  
    314                 recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), MPI_CHAR, 
    315                 recvRankOnReturn[idx], MPI_DHT_INFO, commLevel, &requestOnReturn[position]); 
    316       position++; 
     287      recvIndexFromClients(recvRankOnReturn[idx], recvIndexBuffOnReturn+currentIndex, recvNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
     288      recvInfoFromClients(recvRankOnReturn[idx], 
     289                          recvInfoBuffOnReturn+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
     290                          recvNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), 
     291                          commLevel, &requestOnReturn[requestOnReturn_position++]); 
    317292    } 
    318293    currentIndex += recvNbIndexOnReturn[idx]; 
     
    349324      //sendIndexToClients(rank, client2ClientIndexOnReturn[rank], 
    350325      //                   sendNbIndexOnReturn[idx], commLevel, requestOnReturn); 
    351       MPI_Isend(client2ClientIndexOnReturn[rank], sendNbIndexOnReturn[idx], MPI_UNSIGNED_LONG, 
    352             rank, MPI_DHT_INDEX, commLevel, &requestOnReturn[position]); 
    353       position++; 
    354326      //sendInfoToClients(rank, client2ClientInfoOnReturn[rank], 
    355327      //                  sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, requestOnReturn); 
    356       MPI_Isend(client2ClientInfoOnReturn[rank], sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), MPI_CHAR, 
    357             rank, MPI_DHT_INFO, commLevel, &requestOnReturn[position]); 
    358       position++; 
     328      sendIndexToClients(rank, client2ClientIndexOnReturn[rank], 
     329                         sendNbIndexOnReturn[idx], commLevel, &requestOnReturn[requestOnReturn_position++]); 
     330      sendInfoToClients(rank, client2ClientInfoOnReturn[rank], 
     331                        sendNbIndexOnReturn[idx]*ProcessDHTElement<InfoType>::typeSize(), commLevel, &requestOnReturn[requestOnReturn_position++]); 
     332       
    359333    } 
    360334    currentIndex += recvNbIndexClientCount[idx]; 
     
    362336 
    363337  std::vector<ep_lib::MPI_Status> statusOnReturn(requestOnReturn.size()); 
    364   MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]); 
     338  ep_lib::MPI_Waitall(requestOnReturn.size(), &requestOnReturn[0], &statusOnReturn[0]); 
    365339 
    366340  Index2VectorInfoTypeMap indexToInfoMapping; 
     
    432406{ 
    433407  int clientRank; 
    434   MPI_Comm_rank(commLevel,&clientRank); 
     408  ep_lib::MPI_Comm_rank(commLevel,&clientRank); 
    435409  computeSendRecvRank(level, clientRank); 
    436   //ep_lib::MPI_Barrier(commLevel); 
    437410 
    438411  int groupRankBegin = this->getGroupBegin()[level]; 
     
    481454    { 
    482455      client2ClientIndex[indexClient + groupRankBegin][sendNbIndexBuff[indexClient]] = it->first;; 
     456  //          ProcessDHTElement<InfoType>::packElement(it->second, client2ClientInfo[indexClient + groupRankBegin], sendNbInfo[indexClient]); 
    483457      ProcessDHTElement<InfoType>::packElement(infoTmp[idx], client2ClientInfo[indexClient + groupRankBegin], sendNbInfo[indexClient]); 
    484458      ++sendNbIndexBuff[indexClient]; 
     
    494468  int recvNbIndexCount = 0; 
    495469  for (int idx = 0; idx < recvNbIndexClientCount.size(); ++idx) 
    496   {  
    497470    recvNbIndexCount += recvNbIndexClientCount[idx]; 
    498   } 
    499471 
    500472  unsigned long* recvIndexBuff; 
     
    509481  // it will send a message to the correct clients. 
    510482  // Contents of the message are index and its corresponding informatioin 
    511   int request_size = 0;   
     483  int request_size = 0; 
     484   for (int idx = 0; idx < recvRankClient.size(); ++idx) 
     485   { 
     486     if (0 != recvNbIndexClientCount[idx]) 
     487     { 
     488       request_size += 2; 
     489     } 
     490   } 
     491  
     492   request_size += client2ClientIndex.size(); 
     493   request_size += client2ClientInfo.size(); 
     494  
     495   std::vector<ep_lib::MPI_Request> request(request_size); 
    512496  int currentIndex = 0; 
    513497  int nbRecvClient = recvRankClient.size(); 
    514   int current_pos = 0;  
    515  
     498  int request_position=0; 
    516499  for (int idx = 0; idx < nbRecvClient; ++idx) 
    517500  { 
    518501    if (0 != recvNbIndexClientCount[idx]) 
    519502    { 
    520       request_size += 2; 
    521     } 
    522     //currentIndex += recvNbIndexClientCount[idx]; 
    523   } 
    524  
    525   request_size += client2ClientIndex.size(); 
    526   request_size += client2ClientInfo.size(); 
    527  
    528  
    529  
    530   std::vector<ep_lib::MPI_Request> request(request_size); 
    531    
    532   //unsigned long* tmp_send_buf_long[client2ClientIndex.size()]; 
    533   //unsigned char* tmp_send_buf_char[client2ClientInfo.size()]; 
    534    
    535   int info_position = 0; 
    536   int index_position = 0; 
    537  
     503      //recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
     504      //recvInfoFromClients(recvRankClient[idx], 
     505      //                    recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
     506      //                    recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
     507      //                    commLevel, request); 
     508        recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, &request[request_position++]); 
     509        recvInfoFromClients(recvRankClient[idx], 
     510                            recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
     511                            recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
     512                            commLevel, &request[request_position++]); 
     513    } 
     514    currentIndex += recvNbIndexClientCount[idx]; 
     515  } 
    538516 
    539517  boost::unordered_map<int, size_t* >::iterator itbIndex = client2ClientIndex.begin(), itIndex, 
    540518                                                iteIndex = client2ClientIndex.end(); 
    541519  for (itIndex = itbIndex; itIndex != iteIndex; ++itIndex) 
    542   { 
     520    sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, &request[request_position++]); 
    543521    //sendIndexToClients(itIndex->first, itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], commLevel, request); 
    544  
    545     //tmp_send_buf_long[index_position] = new unsigned long[sendNbIndexBuff[itIndex->first-groupRankBegin]]; 
    546     //for(int i=0; i<sendNbIndexBuff[itIndex->first-groupRankBegin]; i++) 
    547     //{ 
    548     //  tmp_send_buf_long[index_position][i] = (static_cast<unsigned long * >(itIndex->second))[i]; 
    549     //} 
    550     //MPI_Isend(tmp_send_buf_long[current_pos], sendNbIndexBuff[itIndex->first-groupRankBegin], MPI_UNSIGNED_LONG, 
    551     MPI_Isend(itIndex->second, sendNbIndexBuff[itIndex->first-groupRankBegin], MPI_UNSIGNED_LONG, 
    552               itIndex->first, MPI_DHT_INDEX, commLevel, &request[current_pos]); 
    553     current_pos++;  
    554     index_position++; 
    555  
    556   } 
    557  
    558522  boost::unordered_map<int, unsigned char*>::iterator itbInfo = client2ClientInfo.begin(), itInfo, 
    559523                                                      iteInfo = client2ClientInfo.end(); 
    560524  for (itInfo = itbInfo; itInfo != iteInfo; ++itInfo) 
    561   { 
     525    sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, &request[request_position++]); 
    562526    //sendInfoToClients(itInfo->first, itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], commLevel, request); 
    563527 
    564     //tmp_send_buf_char[info_position] = new unsigned char[sendNbInfo[itInfo->first-groupRankBegin]]; 
    565     //for(int i=0; i<sendNbInfo[itInfo->first-groupRankBegin]; i++) 
    566     //{ 
    567     //  tmp_send_buf_char[info_position][i] = (static_cast<unsigned char * >(itInfo->second))[i]; 
    568     //} 
    569  
    570     MPI_Isend(itInfo->second, sendNbInfo[itInfo->first-groupRankBegin], MPI_CHAR, 
    571               itInfo->first, MPI_DHT_INFO, commLevel, &request[current_pos]); 
    572  
    573     current_pos++; 
    574     info_position++; 
    575   } 
    576    
    577   for (int idx = 0; idx < nbRecvClient; ++idx) 
    578   { 
    579     if (0 != recvNbIndexClientCount[idx]) 
    580     { 
    581       //recvIndexFromClients(recvRankClient[idx], recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], commLevel, request); 
    582       MPI_Irecv(recvIndexBuff+currentIndex, recvNbIndexClientCount[idx], MPI_UNSIGNED_LONG, 
    583                 recvRankClient[idx], MPI_DHT_INDEX, commLevel, &request[current_pos]); 
    584       current_pos++; 
    585        
    586        
    587       MPI_Irecv(recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(),  
    588                 recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(),  
    589                 MPI_CHAR, recvRankClient[idx], MPI_DHT_INFO, commLevel, &request[current_pos]); 
    590        
    591       current_pos++; 
    592        
    593  
    594  
    595       // recvInfoFromClients(recvRankClient[idx], 
    596       //                     recvInfoBuff+currentIndex*ProcessDHTElement<InfoType>::typeSize(), 
    597       //                     recvNbIndexClientCount[idx]*ProcessDHTElement<InfoType>::typeSize(), 
    598       //                     commLevel, request); 
    599     } 
    600     currentIndex += recvNbIndexClientCount[idx]; 
    601   } 
    602  
    603528  std::vector<ep_lib::MPI_Status> status(request.size()); 
    604    
    605   MPI_Waitall(request.size(), &request[0], &status[0]); 
    606    
    607   
    608   //for(int i=0; i<client2ClientInfo.size(); i++) 
    609   //  delete[] tmp_send_buf_char[i]; 
    610  
    611    
    612  
    613   //for(int i=0; i<client2ClientIndex.size(); i++) 
    614   //  delete[] tmp_send_buf_long[i]; 
    615  
     529  ep_lib::MPI_Waitall(request.size(), &request[0], &status[0]); 
    616530 
    617531  Index2VectorInfoTypeMap indexToInfoMapping; 
     
    654568  else 
    655569    index2InfoMapping_.swap(indexToInfoMapping); 
    656    
    657570} 
    658571 
     
    670583                                                       std::vector<ep_lib::MPI_Request>& requestSendIndex) 
    671584{ 
    672   printf("should not call this function sendIndexToClients");   
    673585  ep_lib::MPI_Request request; 
    674586  requestSendIndex.push_back(request); 
    675   MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG, 
     587  ep_lib::MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG, 
    676588            clientDestRank, MPI_DHT_INDEX, clientIntraComm, &(requestSendIndex.back())); 
     589} 
     590 
     591/*! 
     592  Send message containing index to clients 
     593  \param [in] clientDestRank rank of destination client 
     594  \param [in] indices index to send 
     595  \param [in] indiceSize size of index array to send 
     596  \param [in] clientIntraComm communication group of client 
     597  \param [in] requestSendIndex sending request 
     598*/ 
     599template<typename T, typename H> 
     600void CClientClientDHTTemplate<T,H>::sendIndexToClients(int clientDestRank, size_t* indices, size_t indiceSize, 
     601                                                       const ep_lib::MPI_Comm& clientIntraComm, 
     602                                                       ep_lib::MPI_Request* requestSendIndex) 
     603{ 
     604  ep_lib::MPI_Isend(indices, indiceSize, MPI_UNSIGNED_LONG, 
     605            clientDestRank, MPI_DHT_INDEX, clientIntraComm, requestSendIndex); 
    677606} 
    678607 
     
    689618                                                         std::vector<ep_lib::MPI_Request>& requestRecvIndex) 
    690619{ 
    691   printf("should not call this function recvIndexFromClients"); 
    692620  ep_lib::MPI_Request request; 
    693621  requestRecvIndex.push_back(request); 
    694   MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG, 
     622  ep_lib::MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG, 
    695623            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, &(requestRecvIndex.back())); 
     624} 
     625 
     626/*! 
     627  Receive message containing index to clients 
     628  \param [in] clientDestRank rank of destination client 
     629  \param [in] indices index to send 
     630  \param [in] clientIntraComm communication group of client 
     631  \param [in] requestRecvIndex receiving request 
     632*/ 
     633template<typename T, typename H> 
     634void CClientClientDHTTemplate<T,H>::recvIndexFromClients(int clientSrcRank, size_t* indices, size_t indiceSize, 
     635                                                         const ep_lib::MPI_Comm& clientIntraComm, 
     636                                                         ep_lib::MPI_Request *requestRecvIndex) 
     637{ 
     638  ep_lib::MPI_Irecv(indices, indiceSize, MPI_UNSIGNED_LONG, 
     639            clientSrcRank, MPI_DHT_INDEX, clientIntraComm, requestRecvIndex); 
    696640} 
    697641 
     
    709653                                                      std::vector<ep_lib::MPI_Request>& requestSendInfo) 
    710654{ 
    711   printf("should not call this function sendInfoToClients"); 
    712655  ep_lib::MPI_Request request; 
    713656  requestSendInfo.push_back(request); 
    714   MPI_Isend(info, infoSize, MPI_CHAR, 
     657 
     658  ep_lib::MPI_Isend(info, infoSize, MPI_CHAR, 
    715659            clientDestRank, MPI_DHT_INFO, clientIntraComm, &(requestSendInfo.back())); 
     660} 
     661 
     662/*! 
     663  Send message containing information to clients 
     664  \param [in] clientDestRank rank of destination client 
     665  \param [in] info info array to send 
     666  \param [in] infoSize info array size to send 
     667  \param [in] clientIntraComm communication group of client 
     668  \param [in] requestSendInfo sending request 
     669*/ 
     670template<typename T, typename H> 
     671void CClientClientDHTTemplate<T,H>::sendInfoToClients(int clientDestRank, unsigned char* info, int infoSize, 
     672                                                      const ep_lib::MPI_Comm& clientIntraComm, 
     673                                                      ep_lib::MPI_Request *requestSendInfo) 
     674{ 
     675  ep_lib::MPI_Isend(info, infoSize, MPI_CHAR, 
     676            clientDestRank, MPI_DHT_INFO, clientIntraComm, requestSendInfo); 
    716677} 
    717678 
     
    729690                                                        std::vector<ep_lib::MPI_Request>& requestRecvInfo) 
    730691{ 
    731   printf("should not call this function recvInfoFromClients\n"); 
    732692  ep_lib::MPI_Request request; 
    733693  requestRecvInfo.push_back(request); 
    734694 
    735   MPI_Irecv(info, infoSize, MPI_CHAR, 
     695  ep_lib::MPI_Irecv(info, infoSize, MPI_CHAR, 
    736696            clientSrcRank, MPI_DHT_INFO, clientIntraComm, &(requestRecvInfo.back())); 
     697} 
     698 
     699/*! 
     700  Receive message containing information from other clients 
     701  \param [in] clientDestRank rank of destination client 
     702  \param [in] info info array to receive 
     703  \param [in] infoSize info array size to receive 
     704  \param [in] clientIntraComm communication group of client 
     705  \param [in] requestRecvInfo list of receiving request 
     706*/ 
     707template<typename T, typename H> 
     708void CClientClientDHTTemplate<T,H>::recvInfoFromClients(int clientSrcRank, unsigned char* info, int infoSize, 
     709                                                        const ep_lib::MPI_Comm& clientIntraComm, 
     710                                                        ep_lib::MPI_Request* requestRecvInfo) 
     711{ 
     712  ep_lib::MPI_Irecv(info, infoSize, MPI_CHAR, 
     713            clientSrcRank, MPI_DHT_INFO, clientIntraComm, requestRecvInfo); 
    737714} 
    738715 
     
    807784 
    808785  int nRequest = 0; 
    809    
     786  for (int idx = 0; idx < recvNbRank.size(); ++idx) 
     787  { 
     788    ep_lib::MPI_Irecv(&recvNbElements[0]+idx, 1, MPI_INT, 
     789              recvNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
     790    ++nRequest; 
     791  } 
    810792 
    811793  for (int idx = 0; idx < sendNbRank.size(); ++idx) 
    812794  { 
    813     MPI_Isend(&sendNbElements[0]+idx, 1, MPI_INT, 
     795    ep_lib::MPI_Isend(&sendNbElements[0]+idx, 1, MPI_INT, 
    814796              sendNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
    815797    ++nRequest; 
    816798  } 
    817    
    818   for (int idx = 0; idx < recvNbRank.size(); ++idx) 
    819   { 
    820     MPI_Irecv(&recvNbElements[0]+idx, 1, MPI_INT, 
    821               recvNbRank[idx], MPI_DHT_INDEX_1, this->internalComm_, &request[nRequest]); 
    822     ++nRequest; 
    823   } 
    824  
    825   MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]); 
     799 
     800  ep_lib::MPI_Waitall(sendNbRank.size()+recvNbRank.size(), &request[0], &requestStatus[0]); 
    826801} 
    827802 
     
    852827  std::vector<ep_lib::MPI_Request> request(sendBuffSize+recvBuffSize); 
    853828  std::vector<ep_lib::MPI_Status> requestStatus(sendBuffSize+recvBuffSize); 
    854   //ep_lib::MPI_Request request[sendBuffSize+recvBuffSize]; 
    855   //ep_lib::MPI_Status requestStatus[sendBuffSize+recvBuffSize]; 
    856    
    857   int my_rank; 
    858   MPI_Comm_rank(this->internalComm_, &my_rank); 
    859    
     829 
    860830  int nRequest = 0; 
    861831  for (int idx = 0; idx < recvBuffSize; ++idx) 
    862832  { 
    863     MPI_Irecv(&recvBuff[2*idx], 2, MPI_INT, 
     833    ep_lib::MPI_Irecv(&recvBuff[0]+2*idx, 2, MPI_INT, 
    864834              recvRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]); 
    865835    ++nRequest; 
    866836  } 
    867    
    868837 
    869838  for (int idx = 0; idx < sendBuffSize; ++idx) 
     
    873842    sendBuff[idx*2+1] = sendNbElements[offSet]; 
    874843  } 
    875    
    876    
    877844 
    878845  for (int idx = 0; idx < sendBuffSize; ++idx) 
    879846  { 
    880     MPI_Isend(&sendBuff[idx*2], 2, MPI_INT, 
     847    ep_lib::MPI_Isend(&sendBuff[idx*2], 2, MPI_INT, 
    881848              sendRank[idx], MPI_DHT_INDEX_0, this->internalComm_, &request[nRequest]); 
    882849    ++nRequest; 
    883850  } 
    884    
    885    
    886  
    887   //MPI_Barrier(this->internalComm_); 
    888  
    889   MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]); 
    890   //MPI_Waitall(sendBuffSize+recvBuffSize, request, requestStatus); 
    891  
    892    
     851 
     852  ep_lib::MPI_Waitall(sendBuffSize+recvBuffSize, &request[0], &requestStatus[0]); 
    893853  int nbRecvRank = 0, nbRecvElements = 0; 
    894854  recvNbRank.clear(); 
     
    902862    } 
    903863  } 
    904  
    905  
    906    
    907    
    908 } 
    909  
    910 } 
    911  
     864} 
     865 
     866} 
  • XIOS/dev/branch_openmp/src/client_server_mapping.cpp

    r1287 r1328  
    88 */ 
    99#include "client_server_mapping.hpp" 
     10using namespace ep_lib; 
    1011 
    1112namespace xios { 
     
    6465  MPI_Allgather(&nbConnectedServer,1,MPI_INT,recvCount,1,MPI_INT,clientIntraComm) ; 
    6566 
    66    
    67   // for(int i=0; i<nbClient; i++) 
    68   //   printf("MPI_Allgather : recvCount[%d] = %d\n", i, recvCount[i]); 
    69  
    7067  displ[0]=0 ; 
    7168  for(int n=1;n<nbClient;n++) displ[n]=displ[n-1]+recvCount[n-1] ; 
     
    7572 
    7673  MPI_Allgatherv(sendBuff,nbConnectedServer,MPI_INT,recvBuff,recvCount,displ,MPI_INT,clientIntraComm) ; 
    77  
    78   // for(int i=0; i<recvSize; i++) 
    79   //   printf("MPI_Allgatherv : recvBuff[%d] = %d\n", i, recvBuff[i]); 
    80  
    81  
    8274  for(int n=0;n<recvSize;n++) clientRes[recvBuff[n]]++ ; 
    8375 
  • XIOS/dev/branch_openmp/src/client_server_mapping.hpp

    r1134 r1328  
    1414#include "mpi.hpp" 
    1515#include <boost/unordered_map.hpp> 
    16 #ifdef _usingEP 
    17 #include "ep_declaration.hpp" 
    18 #endif 
    19  
    2016 
    2117namespace xios { 
  • XIOS/dev/branch_openmp/src/client_server_mapping_distributed.cpp

    r907 r1328  
    1515#include "context.hpp" 
    1616#include "context_client.hpp" 
     17using namespace ep_lib; 
    1718 
    1819namespace xios 
  • XIOS/dev/branch_openmp/src/context_client.cpp

    r1205 r1328  
    1111#include "timer.hpp" 
    1212#include "cxios.hpp" 
     13using namespace ep_lib; 
    1314 
    1415namespace xios 
     
    2021    \cxtSer [in] cxtSer Pointer to context of server side. (It is only used on case of attached mode) 
    2122    */ 
    22     CContextClient::CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm_, ep_lib::MPI_Comm interComm_, CContext* cxtSer) 
     23    CContextClient::CContextClient(CContext* parent, MPI_Comm intraComm_, MPI_Comm interComm_, CContext* cxtSer) 
    2324     : mapBufferSize_(), parentServer(cxtSer), maxBufferedEvents(4) 
    2425    { 
     
    293294       if (ratio < minBufferSizeEventSizeRatio) minBufferSizeEventSizeRatio = ratio; 
    294295     } 
    295      #ifdef _usingMPI 
    296      MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    297      #elif _usingEP 
     296     //MPI_Allreduce(MPI_IN_PLACE, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    298297     MPI_Allreduce(&minBufferSizeEventSizeRatio, &minBufferSizeEventSizeRatio, 1, MPI_DOUBLE, MPI_MIN, intraComm); 
    299      #endif 
    300       
     298 
    301299     if (minBufferSizeEventSizeRatio < 1.0) 
    302300     { 
     
    402400     for (itMap = itbMap; itMap != iteMap; ++itMap) 
    403401     { 
    404        //report(10) << " Memory report : Context <" << context->getId() << "> : client side : memory used for buffer of each connection to server" << endl 
    405        //           << "  +) To server with rank " << itMap->first << " : " << itMap->second << " bytes " << endl; 
     402       report(10) << " Memory report : Context <" << context->getId() << "> : client side : memory used for buffer of each connection to server" << endl 
     403                  << "  +) To server with rank " << itMap->first << " : " << itMap->second << " bytes " << endl; 
    406404       totalBuf += itMap->second; 
    407405     } 
    408      //report(0) << " Memory report : Context <" << context->getId() << "> : client side : total memory used for buffer " << totalBuf << " bytes" << endl; 
     406     report(0) << " Memory report : Context <" << context->getId() << "> : client side : total memory used for buffer " << totalBuf << " bytes" << endl; 
    409407 
    410408     releaseBuffers(); 
  • XIOS/dev/branch_openmp/src/context_server.cpp

    r1179 r1328  
    1010#include "file.hpp" 
    1111#include "grid.hpp" 
    12 #include "mpi_std.hpp" 
     12#include "mpi.hpp" 
    1313#include "tracer.hpp" 
    1414#include "timer.hpp" 
     
    1818#include <boost/functional/hash.hpp> 
    1919 
    20  
     20using namespace ep_lib; 
    2121 
    2222namespace xios 
    2323{ 
    2424 
    25   CContextServer::CContextServer(CContext* parent, ep_lib::MPI_Comm intraComm_, ep_lib::MPI_Comm interComm_) 
     25  CContextServer::CContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_) 
    2626  { 
    2727    context=parent; 
     
    7272    int count; 
    7373    char * addr; 
    74     ep_lib::MPI_Status status; 
     74    MPI_Status status; 
    7575    map<int,CServerBuffer*>::iterator it; 
    76  
    77     for(rank=0;rank<commSize;rank++) 
    78     { 
     76    bool okLoop; 
     77 
     78    traceOff(); 
     79    MPI_Iprobe(-2, 20,interComm,&flag,&status); 
     80    traceOn(); 
     81 
     82    if (flag==true) 
     83    { 
     84      #ifdef _usingMPI 
     85      rank=status.MPI_SOURCE ; 
     86      #elif _usingEP 
     87      rank=status.ep_src ; 
     88      #endif 
     89      okLoop = true; 
    7990      if (pendingRequest.find(rank)==pendingRequest.end()) 
    80       { 
    81         traceOff(); 
    82         ep_lib::MPI_Iprobe(rank,20,interComm,&flag,&status); 
    83         traceOn(); 
    84         if (flag) 
     91        okLoop = !listenPendingRequest(status) ; 
     92      if (okLoop) 
     93      { 
     94        for(rank=0;rank<commSize;rank++) 
    8595        { 
    86           it=buffers.find(rank); 
    87           if (it==buffers.end()) // Receive the buffer size and allocate the buffer 
     96          if (pendingRequest.find(rank)==pendingRequest.end()) 
    8897          { 
    89             StdSize buffSize = 0; 
    90             ep_lib::MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status); 
    91             mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
    92             it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first; 
    93           } 
    94           else 
    95           { 
    96              
    97             ep_lib::MPI_Get_count(&status,MPI_CHAR,&count); 
    98             if (it->second->isBufferFree(count)) 
    99             { 
    100               addr=(char*)it->second->getBuffer(count); 
    101               ep_lib::MPI_Irecv(addr,count,MPI_CHAR,rank,20,interComm,&pendingRequest[rank]); 
    102               bufferRequest[rank]=addr; 
    103             } 
     98 
     99            traceOff(); 
     100            MPI_Iprobe(rank, 20,interComm,&flag,&status); 
     101            traceOn(); 
     102            if (flag==true) listenPendingRequest(status) ; 
    104103          } 
    105104        } 
     
    108107  } 
    109108 
     109  bool CContextServer::listenPendingRequest(MPI_Status& status) 
     110  { 
     111    int count; 
     112    char * addr; 
     113    map<int,CServerBuffer*>::iterator it; 
     114    #ifdef _usingMPI 
     115    int rank=status.MPI_SOURCE ; 
     116    #elif _usingEP 
     117    int rank=status.ep_src; 
     118    #endif 
     119 
     120    it=buffers.find(rank); 
     121    if (it==buffers.end()) // Receive the buffer size and allocate the buffer 
     122    { 
     123       StdSize buffSize = 0; 
     124       MPI_Recv(&buffSize, 1, MPI_LONG, rank, 20, interComm, &status); 
     125       mapBufferSize_.insert(std::make_pair(rank, buffSize)); 
     126       it=(buffers.insert(pair<int,CServerBuffer*>(rank,new CServerBuffer(buffSize)))).first; 
     127       return true; 
     128    } 
     129    else 
     130    { 
     131      MPI_Get_count(&status,MPI_CHAR,&count); 
     132      if (it->second->isBufferFree(count)) 
     133      { 
     134         addr=(char*)it->second->getBuffer(count); 
     135         MPI_Irecv(addr,count,MPI_CHAR,rank,20,interComm,&pendingRequest[rank]); 
     136         bufferRequest[rank]=addr; 
     137         return true; 
     138      } 
     139      else 
     140        return false; 
     141    } 
     142  } 
     143 
    110144  void CContextServer::checkPendingRequest(void) 
    111145  { 
    112     map<int,ep_lib::MPI_Request>::iterator it; 
     146    map<int,MPI_Request>::iterator it; 
    113147    list<int> recvRequest; 
    114148    list<int>::iterator itRecv; 
     
    116150    int flag; 
    117151    int count; 
    118     ep_lib::MPI_Status status; 
    119  
    120     for(it=pendingRequest.begin();it!=pendingRequest.end();++it) 
     152    MPI_Status status; 
     153 
     154    for(it=pendingRequest.begin();it!=pendingRequest.end();it++) 
    121155    { 
    122156      rank=it->first; 
    123157      traceOff(); 
    124       ep_lib::MPI_Test(& it->second, &flag, &status); 
     158      MPI_Test(& it->second, &flag, &status); 
    125159      traceOn(); 
    126160      if (flag==true) 
    127161      { 
    128162        recvRequest.push_back(rank); 
    129         ep_lib::MPI_Get_count(&status,MPI_CHAR,&count); 
     163        MPI_Get_count(&status,MPI_CHAR,&count); 
    130164        processRequest(rank,bufferRequest[rank],count); 
    131165      } 
     
    220254    { 
    221255      finished=true; 
    222       #pragma omp critical (_output) 
    223256      info(20)<<"Server Side context <"<<context->getId()<<"> finalized"<<endl; 
    224257      std::map<int, StdSize>::const_iterator itbMap = mapBufferSize_.begin(), 
     
    227260      for (itMap = itbMap; itMap != iteMap; ++itMap) 
    228261      { 
    229         //report(10)<< " Memory report : Context <"<<context->getId()<<"> : server side : memory used for buffer of each connection to client" << endl 
    230         //          << "  +) With client of rank " << itMap->first << " : " << itMap->second << " bytes " << endl; 
     262        report(10)<< " Memory report : Context <"<<context->getId()<<"> : server side : memory used for buffer of each connection to client" << endl 
     263                  << "  +) With client of rank " << itMap->first << " : " << itMap->second << " bytes " << endl; 
    231264        totalBuf += itMap->second; 
    232265      } 
    233266      context->finalize(); 
    234       //report(0)<< " Memory report : Context <"<<context->getId()<<"> : server side : total memory used for buffer "<<totalBuf<<" bytes"<<endl; 
     267      report(0)<< " Memory report : Context <"<<context->getId()<<"> : server side : total memory used for buffer "<<totalBuf<<" bytes"<<endl; 
    235268    } 
    236269    else if (event.classId==CContext::GetType()) CContext::dispatchEvent(event); 
  • XIOS/dev/branch_openmp/src/context_server.hpp

    r1134 r1328  
    1717    bool eventLoop(bool enableEventsProcessing = true); 
    1818    void listen(void) ; 
     19    bool listenPendingRequest(ep_lib::MPI_Status& status); 
    1920    void checkPendingRequest(void) ; 
    2021    void processRequest(int rank, char* buff,int count) ; 
  • XIOS/dev/branch_openmp/src/cxios.cpp

    r1205 r1328  
    1111#include "memtrack.hpp" 
    1212#include "registry.hpp" 
     13using namespace ep_lib; 
    1314 
    1415namespace xios 
    1516{ 
    16  
    17   extern int test_omp_rank; 
    18   #pragma omp threadprivate(test_omp_rank) 
    19  
    20   const string CXios::rootFile="./iodef.xml" ; 
    21   const string CXios::xiosCodeId="xios.x" ; 
    22   const string CXios::clientFile="./xios_client"; 
    23   const string CXios::serverFile="./xios_server"; 
    24  
     17  string CXios::rootFile="./iodef.xml" ; 
     18  string CXios::xiosCodeId="xios.x" ; 
     19  string CXios::clientFile="./xios_client"; 
     20  string CXios::serverFile="./xios_server"; 
    2521 
    2622  bool CXios::isClient ; 
    2723  bool CXios::isServer ; 
    28  
    29  
    3024  MPI_Comm CXios::globalComm ; 
    31  
    32    
    3325  bool CXios::usingOasis ; 
    3426  bool CXios::usingServer = false; 
    35  
    36  
    3727  double CXios::bufferSizeFactor = 1.0; 
    3828  const double CXios::defaultBufferSizeFactor = 1.0; 
    3929  StdSize CXios::minBufferSize = 1024 * sizeof(double); 
    40  
    41  
    4230  bool CXios::printLogs2Files; 
    4331  bool CXios::isOptPerformance = true; 
     
    4937  { 
    5038    set_new_handler(noMemory); 
    51      
    52      
    53     #pragma omp critical 
    54     { 
    55       parseFile(rootFile);   
    56     } 
    57     #pragma omp barrier 
     39    parseFile(rootFile); 
    5840    parseXiosConfig(); 
    5941  } 
     
    8769      ERROR("CXios::parseXiosConfig()", "recv_field_timeout cannot be negative."); 
    8870 
    89   
     71    //globalComm=MPI_COMM_WORLD ; 
    9072    int num_ep; 
    9173    if(isClient)   
     
    9375      num_ep = omp_get_num_threads(); 
    9476    } 
    95      
     77         
    9678    if(isServer)  
    9779    {  
    9880      num_ep = omp_get_num_threads(); 
    9981    } 
    100      
     82         
    10183    MPI_Info info; 
    10284    #pragma omp master 
     
    10688      passage = ep_comm;   
    10789    } 
    108      
     90         
    10991    #pragma omp barrier 
    110  
    111        
     92     
     93           
    11294    CXios::globalComm = passage[omp_get_thread_num()]; 
    113  
    114     int tmp_rank; 
    115     MPI_Comm_rank(CXios::globalComm, &tmp_rank); 
    116  
    117      
    118     test_omp_rank = tmp_rank; 
    119      
    12095  } 
    12196 
     
    133108 
    134109    CClient::initialize(codeId,localComm,returnComm) ; 
    135  
    136110    if (CClient::getRank()==0) globalRegistry = new CRegistry(returnComm) ; 
    137111 
     
    142116    if (printLogs2Files) 
    143117    { 
    144       #pragma omp critical 
    145118      CClient::openInfoStream(clientFile); 
    146119      CClient::openErrorStream(clientFile); 
     
    158131     if (CClient::getRank()==0) 
    159132     { 
    160        #pragma omp critical (_output) 
    161133       info(80)<<"Write data base Registry"<<endl<<globalRegistry->toString()<<endl ; 
    162134       globalRegistry->toFile("xios_registry.bin") ; 
     
    184156  void CXios::initServer() 
    185157  { 
    186     int initialized; 
    187     MPI_Initialized(&initialized); 
    188     if (initialized) CServer::is_MPI_Initialized=true ; 
    189     else CServer::is_MPI_Initialized=false ; 
    190        
    191   
    192     if(!CServer::is_MPI_Initialized) 
    193     { 
    194       MPI_Init(NULL, NULL); 
    195     } 
    196        
    197158    set_new_handler(noMemory); 
    198159    std::set<StdString> parseList; 
     
    210171     
    211172    initServer(); 
    212      
    213      
     173 
    214174    // Initialize all aspects MPI 
    215175    CServer::initialize(); 
  • XIOS/dev/branch_openmp/src/cxios.hpp

    r1134 r1328  
    55#include "mpi.hpp" 
    66#include "registry.hpp" 
    7 #include "log.hpp" 
    87 
    98namespace xios 
     
    1514  { 
    1615    public: 
    17       static void initialize(void) ; 
    18       static void initClientSide(const string & codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) ; 
    19       static void initServerSide(void) ; 
    20       static void clientFinalize(void) ; 
    21       static void parseFile(const string& filename) ; 
     16     static void initialize(void) ; 
     17     static void initClientSide(const string & codeId, ep_lib::MPI_Comm& localComm, ep_lib::MPI_Comm& returnComm) ; 
     18     static void initServerSide(void) ; 
     19     static void clientFinalize(void) ; 
     20     static void parseFile(const string& filename) ; 
    2221 
    23       template <typename T> 
    24       static T getin(const string& id,const T& defaultValue) ; 
     22     template <typename T> 
     23     static T getin(const string& id,const T& defaultValue) ; 
    2524 
    26       template <typename T> 
    27       static T getin(const string& id) ; 
     25     template <typename T> 
     26     static T getin(const string& id) ; 
    2827 
    2928    public: 
    30       static const string rootFile; //!< Configuration filename 
    31       static const string xiosCodeId ; //!< Identity for XIOS 
    32       static const string clientFile; //!< Filename template for client 
    33       static const string serverFile; //!< Filename template for server 
     29     static string rootFile ; //!< Configuration filename 
     30     static string xiosCodeId ; //!< Identity for XIOS 
     31     static string clientFile; //!< Filename template for client 
     32     static string serverFile; //!< Filename template for server 
    3433 
    35       static bool isClient ; //!< Check if xios is client 
    36       static bool isServer ; //!< Check if xios is server 
    37       #pragma omp threadprivate(isClient, isServer) 
     34     static bool isClient ; //!< Check if xios is client 
     35     static bool isServer ; //!< Check if xios is server 
    3836 
    39       static MPI_Comm globalComm ; //!< Global communicator 
    40       #pragma omp threadprivate(globalComm) 
     37     static ep_lib::MPI_Comm globalComm ; //!< Global communicator 
    4138 
    42       static bool printLogs2Files; //!< Printing out logs into files 
    43       static bool usingOasis ; //!< Using Oasis 
    44       static bool usingServer ; //!< Using server (server mode) 
    45       static double bufferSizeFactor; //!< Factor used to tune the buffer size 
    46       static const double defaultBufferSizeFactor; //!< Default factor value 
    47       static StdSize minBufferSize; //!< Minimum buffer size 
    48       static bool isOptPerformance; //!< Check if buffer size is for performance (as large as possible) 
    49       #pragma omp threadprivate(printLogs2Files, usingOasis, usingServer, bufferSizeFactor, minBufferSize, isOptPerformance) 
    50        
    51       static CRegistry* globalRegistry ; //!< global registry which is wrote by the root process of the servers 
    52       static double recvFieldTimeout; 
    53       #pragma omp threadprivate(recvFieldTimeout) 
    54        
    55        
     39     static bool printLogs2Files; //!< Printing out logs into files 
     40     static bool usingOasis ; //!< Using Oasis 
     41     static bool usingServer ; //!< Using server (server mode) 
     42     static double bufferSizeFactor; //!< Factor used to tune the buffer size 
     43     static const double defaultBufferSizeFactor; //!< Default factor value 
     44     static StdSize minBufferSize; //!< Minimum buffer size 
     45     static bool isOptPerformance; //!< Check if buffer size is for performance (as large as possible) 
     46     static CRegistry* globalRegistry ; //!< global registry which is wrote by the root process of the servers 
     47     static double recvFieldTimeout; //!< Time to wait for data before issuing an error when receiving a field 
     48 
    5649    public: 
    5750     //! Setting xios to use server mode 
  • XIOS/dev/branch_openmp/src/data_output.cpp

    r1205 r1328  
    44#include "group_template.hpp" 
    55#include "context.hpp" 
    6 //mpi.hpp 
     6 
    77namespace xios 
    88{ 
  • XIOS/dev/branch_openmp/src/data_output.hpp

    r1287 r1328  
    5959            virtual void writeTimeDimension_(void)           = 0; 
    6060            virtual void writeTimeAxis_ (CField*     field, 
    61                                          const boost::shared_ptr<CCalendar> cal) = 0; 
     61                                         const shared_ptr<CCalendar> cal) = 0; 
    6262 
    6363            /// Propriétés protégées /// 
  • XIOS/dev/branch_openmp/src/dht_auto_indexing.cpp

    r1134 r1328  
    88 */ 
    99#include "dht_auto_indexing.hpp" 
     10using namespace ep_lib; 
    1011 
    1112namespace xios 
     
    2223 
    2324  CDHTAutoIndexing::CDHTAutoIndexing(const CArray<size_t,1>& hashValue, 
    24                                      const ep_lib::MPI_Comm& clientIntraComm) 
     25                                     const MPI_Comm& clientIntraComm) 
    2526    : CClientClientDHTTemplate<size_t>(clientIntraComm) 
    2627  { 
     
    5859  */ 
    5960  CDHTAutoIndexing::CDHTAutoIndexing(Index2VectorInfoTypeMap& hashInitMap, 
    60                                      const ep_lib::MPI_Comm& clientIntraComm) 
     61                                     const MPI_Comm& clientIntraComm) 
    6162    : CClientClientDHTTemplate<size_t>(clientIntraComm) 
    6263  { 
  • XIOS/dev/branch_openmp/src/dht_auto_indexing.hpp

    r1134 r1328  
    1212 
    1313#include "client_client_dht_template.hpp" 
    14 #ifdef _usingEP 
    15 #include "ep_declaration.hpp" 
    16 #endif 
    1714 
    1815namespace xios 
  • XIOS/dev/branch_openmp/src/event_scheduler.cpp

    r1134 r1328  
    22#include "xios_spl.hpp" 
    33#include "mpi.hpp" 
     4using namespace ep_lib; 
    45 
    56namespace xios 
     
    132133    while(received) 
    133134    { 
    134       #ifdef _usingEP 
    135       MPI_Iprobe(-1,1,communicator,&received, &status) ; 
    136       #else 
    137       MPI_Iprobe(MPI_ANY_SOURCE,1,communicator,&received, &status) ; 
    138       #endif 
     135      MPI_Iprobe(-2,1,communicator,&received, &status) ; 
    139136      if (received) 
    140137      { 
    141138        recvRequest=new SPendingRequest ; 
    142         #ifdef _usingEP 
    143         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, -1, 1, communicator, &(recvRequest->request)) ; 
    144         #else 
    145         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 1, communicator, &(recvRequest->request)) ; 
    146         #endif 
     139        MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, -2, 1, communicator, &(recvRequest->request)) ; 
    147140        pendingRecvParentRequest.push(recvRequest) ; 
    148141      } 
     
    182175    while(received) 
    183176    { 
    184       #ifdef _usingEP 
    185       MPI_Iprobe(-1,0,communicator,&received, &status) ; 
    186       #else 
    187       MPI_Iprobe(MPI_ANY_SOURCE,0,communicator,&received, &status) ; 
    188       #endif 
     177      MPI_Iprobe(-2,0,communicator,&received, &status) ; 
    189178      if (received) 
    190179      { 
    191180        recvRequest=new SPendingRequest ; 
    192         #ifdef _usingEP 
    193         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, -1, 0, communicator, &recvRequest->request) ; 
    194         #else 
    195         MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, MPI_ANY_SOURCE, 0, communicator, &recvRequest->request) ; 
    196         #endif 
     181        MPI_Irecv(recvRequest->buffer, 3, MPI_UNSIGNED_LONG, -2, 0, communicator, &recvRequest->request) ; 
    197182        pendingRecvChildRequest.push_back(recvRequest) ; 
    198183      } 
  • XIOS/dev/branch_openmp/src/event_scheduler.hpp

    r1134 r1328  
    44#include "xios_spl.hpp" 
    55#include "mpi.hpp" 
    6 #ifdef _usingEP 
    7 #include "ep_declaration.hpp" 
    8 #endif 
    9  
    106 
    117namespace xios 
     
    3026        *  @param[in] comm : MPI communicator du duplicate for internal use 
    3127        */ 
    32        CEventScheduler(const MPI_Comm& comm) ; 
     28       CEventScheduler(const ep_lib::MPI_Comm& comm) ; 
    3329 
    3430 
     
    155151       { 
    156152         size_t buffer[3] ;      /*!< communication buffer : timeLine, hashId, level */ 
    157          MPI_Request request ;   /*!< pending MPI request */  
     153         ep_lib::MPI_Request request ;   /*!< pending MPI request */  
    158154       } ; 
    159155        
    160        MPI_Comm communicator ;  /*!< Internal MPI communicator */  
     156       ep_lib::MPI_Comm communicator ;  /*!< Internal MPI communicator */  
    161157       int mpiRank ;            /*!< Rank in the communicator */ 
    162158       int mpiSize ;            /*!< Size of the communicator */ 
  • XIOS/dev/branch_openmp/src/filter/file_writer_filter.cpp

    r1205 r1328  
    1717  void CFileWriterFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    1818  { 
    19     CDataPacketPtr packet = data[0]; 
    20  
    2119    const bool detectMissingValue = (!field->detect_missing_value.isEmpty() 
    2220                                      && !field->default_value.isEmpty() 
    2321                                      && field->detect_missing_value == true); 
     22 
     23    CArray<double, 1> dataArray = (detectMissingValue) ? data[0]->data.copy() : data[0]->data; 
     24 
    2425    if (detectMissingValue) 
    2526    { 
    2627      const double missingValue = field->default_value; 
    27       const size_t nbData = packet->data.numElements(); 
     28      const size_t nbData = dataArray.numElements(); 
    2829      for (size_t idx = 0; idx < nbData; ++idx) 
    2930      { 
    30         if (NumTraits<double>::isnan(packet->data(idx))) 
    31           packet->data(idx) = missingValue; 
     31        if (NumTraits<double>::isnan(dataArray(idx))) 
     32          dataArray(idx) = missingValue; 
    3233      } 
    3334    } 
    3435 
    35     field->sendUpdateData(packet->data); 
     36    field->sendUpdateData(dataArray); 
    3637  } 
    3738 
  • XIOS/dev/branch_openmp/src/filter/source_filter.cpp

    r1205 r1328  
    9999  void CSourceFilter::signalEndOfStream(CDate date) 
    100100  { 
     101    date = date + offset; // this is a temporary solution, it should be part of a proper temporal filter 
     102 
    101103    CDataPacketPtr packet(new CDataPacket); 
    102104    packet->date = date; 
  • XIOS/dev/branch_openmp/src/filter/spatial_transform_filter.cpp

    r1287 r1328  
     1#include "mpi.hpp" 
    12#include "spatial_transform_filter.hpp" 
    23#include "grid_transformation.hpp" 
    34#include "context.hpp" 
    45#include "context_client.hpp" 
     6using namespace ep_lib; 
    57 
    68namespace xios 
     
    6567  } 
    6668 
     69  //std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > CSpatialTransformFilterEngine::engines; 
    6770  std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > *CSpatialTransformFilterEngine::engines_ptr = 0; 
    6871 
     
    7275      ERROR("CSpatialTransformFilterEngine& CSpatialTransformFilterEngine::get(CGridTransformation* gridTransformation)", 
    7376            "Impossible to get the requested engine, the grid transformation is invalid."); 
    74  
     77     
    7578    if(engines_ptr == NULL) engines_ptr = new std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >; 
    7679 
     80    //std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines.find(gridTransformation); 
    7781    std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> >::iterator it = engines_ptr->find(gridTransformation); 
     82    //if (it == engines.end()) 
    7883    if (it == engines_ptr->end()) 
    7984    { 
    8085      boost::shared_ptr<CSpatialTransformFilterEngine> engine(new CSpatialTransformFilterEngine(gridTransformation)); 
     86      //it = engines.insert(std::make_pair(gridTransformation, engine)).first; 
    8187      it = engines_ptr->insert(std::make_pair(gridTransformation, engine)).first; 
    8288    } 
     
    122128    double defaultValue = std::numeric_limits<double>::quiet_NaN(); 
    123129    if (0 != dataDest.numElements()) ignoreMissingValue = NumTraits<double>::isnan(dataDest(0)); 
    124      
    125     const std::list<CGridTransformation::SendingIndexGridSourceMap> *listLocalIndexSend_ptr = & (gridTransformation->getLocalIndexToSendFromGridSource()); 
    126      
     130 
    127131    const std::list<CGridTransformation::SendingIndexGridSourceMap>& listLocalIndexSend = gridTransformation->getLocalIndexToSendFromGridSource(); 
    128132    const std::list<CGridTransformation::RecvIndexGridDestinationMap>& listLocalIndexToReceive = gridTransformation->getLocalIndexToReceiveOnGridDest(); 
     
    133137    CArray<double,1> dataCurrentDest(dataSrc.copy()); 
    134138 
    135     std::list<CGridTransformation::SendingIndexGridSourceMap>::const_iterator itListSend  = listLocalIndexSend_ptr->begin(), 
    136                                                                               iteListSend = listLocalIndexSend_ptr->end(); 
     139    std::list<CGridTransformation::SendingIndexGridSourceMap>::const_iterator itListSend  = listLocalIndexSend.begin(), 
     140                                                                              iteListSend = listLocalIndexSend.end(); 
    137141    std::list<CGridTransformation::RecvIndexGridDestinationMap>::const_iterator itListRecv = listLocalIndexToReceive.begin(); 
    138142    std::list<size_t>::const_iterator itNbListRecv = listNbLocalIndexToReceive.begin(); 
     
    155159          sendBuff[idxSendBuff] = new double[itSend->second.numElements()]; 
    156160      } 
    157        
    158       const CGridTransformation::RecvIndexGridDestinationMap& localIndexToReceive = *itListRecv; 
    159       CGridTransformation::RecvIndexGridDestinationMap::const_iterator itbRecv = localIndexToReceive.begin(), itRecv, 
    160                                                                        iteRecv = localIndexToReceive.end(); 
    161161 
    162162      idxSendBuff = 0; 
    163       std::vector<ep_lib::MPI_Request> sendRecvRequest(localIndexToSend.size()+localIndexToReceive.size()); 
     163      std::vector<MPI_Request> sendRecvRequest(localIndexToSend.size() + itListRecv->size()); 
    164164      int position = 0; 
    165165      for (itSend = itbSend; itSend != iteSend; ++itSend, ++idxSendBuff) 
     
    172172          sendBuff[idxSendBuff][idx] = dataCurrentSrc(localIndex_p(idx)); 
    173173        } 
    174         MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest[position]); 
    175         position++; 
     174        MPI_Isend(sendBuff[idxSendBuff], countSize, MPI_DOUBLE, destRank, 12, client->intraComm, &sendRecvRequest[position++]); 
    176175      } 
    177176 
    178177      // Receiving data on destination fields 
    179        
     178      const CGridTransformation::RecvIndexGridDestinationMap& localIndexToReceive = *itListRecv; 
     179      CGridTransformation::RecvIndexGridDestinationMap::const_iterator itbRecv = localIndexToReceive.begin(), itRecv, 
     180                                                                       iteRecv = localIndexToReceive.end(); 
    180181      int recvBuffSize = 0; 
    181182      for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) recvBuffSize += itRecv->second.size(); //(recvBuffSize < itRecv->second.size()) 
     
    188189        int srcRank = itRecv->first; 
    189190        int countSize = itRecv->second.size(); 
    190         MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest[position]); 
    191         position++; 
     191        MPI_Irecv(recvBuff + currentBuff, countSize, MPI_DOUBLE, srcRank, 12, client->intraComm, &sendRecvRequest[position++]); 
    192192        currentBuff += countSize; 
    193193      } 
    194       std::vector<ep_lib::MPI_Status> status(sendRecvRequest.size()); 
     194      std::vector<MPI_Status> status(sendRecvRequest.size()); 
    195195      MPI_Waitall(sendRecvRequest.size(), &sendRecvRequest[0], &status[0]); 
    196196 
     
    203203      std::vector<bool> localInitFlag(dataCurrentDest.numElements(), true); 
    204204      currentBuff = 0; 
     205      bool firstPass=true;  
    205206      for (itRecv = itbRecv; itRecv != iteRecv; ++itRecv) 
    206207      { 
     
    211212                         dataCurrentDest, 
    212213                         localInitFlag, 
    213                          ignoreMissingValue); 
     214                         ignoreMissingValue,firstPass); 
    214215 
    215216        currentBuff += countSize; 
     217        firstPass=false ; 
    216218      } 
    217219 
  • XIOS/dev/branch_openmp/src/filter/spatial_transform_filter.hpp

    r1134 r1328  
    33 
    44#include "filter.hpp" 
    5  
    65namespace xios 
    76{ 
     
    106105      //static std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > engines; 
    107106      static std::map<CGridTransformation*, boost::shared_ptr<CSpatialTransformFilterEngine> > *engines_ptr; 
    108       #pragma omp threadprivate(engines_ptr) 
    109        
    110107  }; // class CSpatialTransformFilterEngine 
    111108} // namespace xios 
  • XIOS/dev/branch_openmp/src/filter/store_filter.cpp

    r1205 r1328  
    7878  void CStoreFilter::onInputReady(std::vector<CDataPacketPtr> data) 
    7979  { 
    80     CDataPacketPtr packet = data[0]; 
     80 
     81    CDataPacketPtr packet; 
     82    if (detectMissingValues) 
     83    { 
     84      const size_t nbData = data[0]->data.numElements(); 
     85 
     86      packet = CDataPacketPtr(new CDataPacket); 
     87      packet->date = data[0]->date; 
     88      packet->timestamp = data[0]->timestamp; 
     89      packet->status = data[0]->status; 
     90      packet->data.resize(nbData); 
     91      packet->data = data[0]->data; 
     92 
     93      for (size_t idx = 0; idx < nbData; ++idx) 
     94      { 
     95        if (NumTraits<double>::isnan(packet->data(idx))) 
     96          packet->data(idx) = missingValue; 
     97      } 
     98 
     99    } 
     100 
     101    else 
     102    { 
     103      packet = data[0]; 
     104    } 
    81105 
    82106    packets.insert(std::make_pair(packet->timestamp, packet)); 
     
    85109    gc.registerObject(this, packet->timestamp); 
    86110 
    87     if (detectMissingValues) 
    88     { 
    89       const size_t nbData = packet->data.numElements(); 
    90       for (size_t idx = 0; idx < nbData; ++idx) 
    91       { 
    92         if (NumTraits<double>::isnan(packet->data(idx))) 
    93           packet->data(idx) = missingValue; 
    94       } 
    95     } 
    96111  } 
    97112 
  • XIOS/dev/branch_openmp/src/filter/temporal_filter.cpp

    r1124 r1328  
    1414    , isOnceOperation(functor->timeType() == func::CFunctor::once) 
    1515    , isInstantOperation(functor->timeType() == func::CFunctor::instant) 
    16     // If we can optimize the sampling when dealing with an instant functor we do it 
    17     , samplingFreq((isInstantOperation && samplingFreq == TimeStep && samplingOffset == NoneDu) ? opFreq : samplingFreq) 
    18     , samplingOffset((isInstantOperation && samplingFreq == TimeStep && samplingOffset == NoneDu) ? opFreq - initDate.getRelCalendar().getTimeStep() : samplingOffset) 
     16    , samplingFreq(samplingFreq) 
     17    , samplingOffset(samplingOffset) 
    1918    , opFreq(opFreq) 
    2019    , nextSamplingDate(initDate + this->samplingOffset + initDate.getRelCalendar().getTimeStep()) 
  • XIOS/dev/branch_openmp/src/group_factory.cpp

    r1134 r1328  
    44{ 
    55   /// ////////////////////// Définitions ////////////////////// /// 
    6    StdString *CGroupFactory::CurrContext_ptr = new StdString; 
     6   StdString CGroupFactory::CurrContext(""); 
    77 
    88   void CGroupFactory::SetCurrentContextId(const StdString & context) 
    9    {   
    10       if(CGroupFactory::CurrContext_ptr == NULL ) CGroupFactory::CurrContext_ptr = new StdString;  
    11       CGroupFactory::CurrContext_ptr->assign(context); 
     9   {  
     10      CGroupFactory::CurrContext = context; 
    1211   } 
    1312 
    1413   StdString & CGroupFactory::GetCurrentContextId(void) 
    1514   {  
    16       return (*CGroupFactory::CurrContext_ptr); 
     15      return (CGroupFactory::CurrContext); 
    1716   } 
    1817 
  • XIOS/dev/branch_openmp/src/group_factory.hpp

    r1134 r1328  
    6969 
    7070         /// Propriétés statiques /// 
    71          static StdString *CurrContext_ptr; 
    72          #pragma omp threadprivate(CurrContext_ptr) 
     71         static StdString CurrContext; 
    7372 
    7473   }; // class CGroupFactory 
  • XIOS/dev/branch_openmp/src/group_factory_decl.cpp

    r1287 r1328  
    55{ 
    66# define  macro(U) \ 
    7   template void CGroupFactory::AddGroup<U>(boost::shared_ptr<U> pgroup,boost::shared_ptr<U> cgroup); \ 
    8   template void CGroupFactory::AddChild<U>(boost::shared_ptr<U> group, boost::shared_ptr<U::RelChild> child); \ 
    9   template boost::shared_ptr<U>  CGroupFactory::GetGroup<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    10   template boost::shared_ptr<U::RelChild> CGroupFactory::GetChild<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    11   template int CGroupFactory::GetGroupNum<U>(boost::shared_ptr<U> group); \ 
    12   template int CGroupFactory::GetGroupIdNum<U>(boost::shared_ptr<U> group); \ 
    13   template int CGroupFactory::GetChildNum<U>(boost::shared_ptr<U> group); \ 
     7  template void CGroupFactory::AddGroup<U>(shared_ptr<U> pgroup,shared_ptr<U> cgroup); \ 
     8  template void CGroupFactory::AddChild<U>(shared_ptr<U> group, shared_ptr<U::RelChild> child); \ 
     9  template shared_ptr<U>  CGroupFactory::GetGroup<U>(shared_ptr<U> group, const StdString & id); \ 
     10  template shared_ptr<U::RelChild> CGroupFactory::GetChild<U>(shared_ptr<U> group, const StdString & id); \ 
     11  template int CGroupFactory::GetGroupNum<U>(shared_ptr<U> group); \ 
     12  template int CGroupFactory::GetGroupIdNum<U>(shared_ptr<U> group); \ 
     13  template int CGroupFactory::GetChildNum<U>(shared_ptr<U> group); \ 
    1414  template int CGroupFactory::GetChildIdNum<U>(boost::shared_ptr<U> group); \ 
    15   template bool CGroupFactory::HasGroup<U>(boost::shared_ptr<U> group, const StdString & id); \ 
     15  template bool CGroupFactory::HasGroup<U>(shared_ptr<U> group, const StdString & id); \ 
    1616  template bool CGroupFactory::HasChild<U>(boost::shared_ptr<U> group, const StdString & id); \ 
    17   template boost::shared_ptr<U> CGroupFactory::CreateGroup<U>(boost::shared_ptr<U> group, const StdString & id ); \ 
    18   template boost::shared_ptr<U::RelChild>  CGroupFactory::CreateChild<U>(boost::shared_ptr<U> group, const StdString & id); 
     17  template shared_ptr<U> CGroupFactory::CreateGroup<U>(shared_ptr<U> group, const StdString & id ); \ 
     18  template shared_ptr<U::RelChild>  CGroupFactory::CreateChild<U>(shared_ptr<U> group, const StdString & id); 
    1919 
    2020  macro(CFieldGroup) 
  • XIOS/dev/branch_openmp/src/indent.hpp

    r1134 r1328  
    1010    public: 
    1111    static int defaultIncSize; 
    12     #pragma omp threadprivate(defaultIncSize) 
    13      
    1412    static int index ; 
    15     #pragma omp threadprivate(index) 
    16      
    1713    int incSize ; 
    1814    int offset ; 
  • XIOS/dev/branch_openmp/src/indent_xml.cpp

    r1134 r1328  
    1515   { 
    1616      static unsigned int LineNB = 1; 
    17       #pragma omp threadprivate(LineNB) 
    18        
    1917      if (CIndent::WithLine) out << LineNB++ << ". "; 
    2018      for(unsigned int i = 0; i < CIndent::Indent; out << CIndent::Increm , i++){} 
  • XIOS/dev/branch_openmp/src/indent_xml.hpp

    r1134 r1328  
    2222         /// Propriétés  statiques /// 
    2323         static unsigned int Indent; 
    24          #pragma omp threadprivate(Indent) 
    25  
    2624         static StdString    Increm; 
    27          #pragma omp threadprivate(Increm) 
    28  
    2925         static bool         WithLine; 
    30          #pragma omp threadprivate(WithLine) 
    3126 
    3227   }; // class CIndent 
  • XIOS/dev/branch_openmp/src/interface/c/icdata.cpp

    r1205 r1328  
    11/* ************************************************************************** * 
    2  *      Copyright © IPSL/LSCE, xios, Avril 2010 - Octobre 2011         * 
     2 *      Copyright IPSL/LSCE, xios, Avril 2010 - Octobre 2011         * 
    33 * ************************************************************************** */ 
    44 
     
    99#include <iostream> 
    1010 
    11  
     11#include "mpi_std.hpp" 
    1212#include "xios.hpp" 
    1313//#include "oasis_cinterface.hpp" 
     
    2323#include "context.hpp" 
    2424#include "context_client.hpp" 
    25 #include "mpi_std.hpp" 
     25 
    2626#include "timer.hpp" 
    27 #include "array_new.hpp" 
    28  
    2927 
    3028extern "C" 
    3129{ 
    32 // /////////////////////////////// Définitions ////////////////////////////// // 
    33  
    34    // ----------------------- Redéfinition de types ---------------------------- 
     30// /////////////////////////////// Dfinitions ////////////////////////////// // 
     31 
     32   // ----------------------- Redfinition de types ---------------------------- 
    3533 
    3634   typedef enum { NETCDF4 = 0 } XFileType; 
     
    3836   typedef xios::CContext* XContextPtr; 
    3937 
    40    // -------------------- Traitement des données ------------------------------ 
     38   // -------------------- Traitement des donnes ------------------------------ 
    4139 
    4240   // This function is not exported to the public Fortran interface, 
     
    6462      int initialized; 
    6563      MPI_Initialized(&initialized); 
    66  
    67       #ifdef _usingEP 
    68       if (initialized) local_comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_local_comm)); 
    69       else local_comm = MPI_COMM_NULL; 
    70       #else 
     64      #ifdef _usingMPI 
    7165      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm); 
    72       else local_comm = MPI_COMM_NULL; 
     66      else local_comm=MPI_COMM_NULL; 
     67      #elif _usingEP 
     68      ep_lib::fc_comm_map.clear(); 
     69      if (initialized) local_comm=ep_lib::EP_Comm_f2c(static_cast<int>(*f_local_comm)); 
     70      else local_comm=MPI_COMM_NULL; 
    7371      #endif 
    7472       
    75       
     73 
    7674 
    7775      CXios::initClientSide(str, local_comm, return_comm); 
    78  
    79       #ifdef _usingEP 
    80       *f_return_comm = ep_lib::EP_Comm_c2f(return_comm); 
    81       #else 
    82       *f_return_comm = MPI_Comm_c2f(return_comm); 
     76      #ifdef _usingMPI 
     77      *f_return_comm=MPI_Comm_c2f(return_comm); 
     78      #elif _usingEP 
     79      *f_return_comm=ep_lib::EP_Comm_c2f(return_comm); 
    8380      #endif 
    84  
    8581      CTimer::get("XIOS init").suspend(); 
    8682      CTimer::get("XIOS").suspend(); 
     
    9591     CTimer::get("XIOS").resume(); 
    9692     CTimer::get("XIOS init context").resume(); 
     93     #ifdef _usingMPI 
     94     comm=MPI_Comm_f2c(*f_comm); 
     95     #elif _usingEP 
    9796     comm = ep_lib::EP_Comm_f2c(static_cast< int >(*f_comm)); 
    98  
    99      CClient::registerContext(str,comm); 
    100            
     97     #endif 
     98     CClient::registerContext(str, comm); 
    10199     CTimer::get("XIOS init context").suspend(); 
    102100     CTimer::get("XIOS").suspend(); 
     
    382380 
    383381 
    384    // ---------------------- Ecriture des données ------------------------------ 
     382   // ---------------------- Ecriture des donnes ------------------------------ 
    385383 
    386384   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     
    448446      CContext* context = CContext::getCurrent(); 
    449447      if (!context->hasServer && !context->client->isAttachedModeEnabled()) 
    450       { 
    451         context->checkBuffersAndListen(); 
    452       }   
     448        context->checkBuffersAndListen(); 
    453449 
    454450      CArray<double, 3>data(data_k8, shape(data_Xsize, data_Ysize, data_Zsize), neverDeleteData); 
     
    717713    } 
    718714 
    719    // ---------------------- Lecture des données ------------------------------ 
     715   // ---------------------- Lecture des donnes ------------------------------ 
    720716 
    721717   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
  • XIOS/dev/branch_openmp/src/interface/c/oasis_cinterface.cpp

    r1134 r1328  
    11#include "oasis_cinterface.hpp" 
    22#include <string> 
    3 //#include "mpi_std.hpp" 
     3using namespace ep_lib; 
    44 
    55namespace xios 
     
    2626     
    2727    fxios_oasis_get_localcomm(&f_comm) ; 
    28     #ifdef _usingEP 
    2928    comm=EP_Comm_f2c(f_comm.mpi_fint) ; 
    30     #else 
    31     comm=MPI_Comm_f2c(f_comm) ; 
    32     #endif 
    3329  } 
    3430  
     
    3834     
    3935    fxios_oasis_get_intracomm(&f_comm,server_id.data(),server_id.size()) ; 
    40     #ifdef _usingEP 
    4136    comm_client_server=EP_Comm_f2c(f_comm.mpi_fint) ; 
    42     #else 
    43     comm_client_server=MPI_Comm_f2c(f_comm) ; 
    44     #endif 
    4537  } 
    4638  
     
    5042     
    5143    fxios_oasis_get_intercomm(&f_comm,server_id.data(),server_id.size()) ; 
    52     #ifdef _usingEP 
    5344    comm_client_server=EP_Comm_f2c(f_comm.mpi_fint) ; 
    54     #else 
    55     comm_client_server=MPI_Comm_f2c(f_comm) ; 
    56     #endif 
    5745  } 
    5846} 
  • XIOS/dev/branch_openmp/src/interface/c/oasis_cinterface.hpp

    r501 r1328  
    1010  void fxios_oasis_enddef(void) ; 
    1111  void fxios_oasis_finalize(void) ; 
    12   void fxios_oasis_get_localcomm(MPI_Fint* f_comm) ; 
    13   void fxios_oasis_get_intracomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
    14   void fxios_oasis_get_intercomm(MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
     12  void fxios_oasis_get_localcomm(ep_lib::MPI_Fint* f_comm) ; 
     13  void fxios_oasis_get_intracomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
     14  void fxios_oasis_get_intercomm(ep_lib::MPI_Fint* f_comm_client_server,const char* client_id,int str_len) ; 
    1515} 
    1616  
     
    2020  void oasis_enddef(void) ; 
    2121  void oasis_finalize(void) ; 
    22   void oasis_get_localcomm(MPI_Comm& comm) ; 
    23   void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) ; 
    24   void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) ; 
     22  void oasis_get_localcomm(ep_lib::MPI_Comm& comm) ; 
     23  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ; 
     24  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) ; 
    2525} 
    2626#endif 
  • XIOS/dev/branch_openmp/src/io/inetcdf4.cpp

    r1287 r1328  
    44 
    55#include <boost/algorithm/string.hpp> 
    6 // mpi_std.hpp 
    7 #ifdef _usingEP 
    8 #include "ep_declaration.hpp" 
    9 #endif 
    106 
    117namespace xios 
    128{ 
    13   CINetCDF4::CINetCDF4(const StdString& filename, const MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/, const StdString& timeCounterName /*= "time_counter"*/) 
     9  CINetCDF4::CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm /*= NULL*/, bool multifile /*= true*/, const StdString& timeCounterName /*= "time_counter"*/) 
    1410  { 
    1511    // Don't use parallel mode if there is only one process 
     
    1713    { 
    1814      int commSize = 0; 
    19       MPI_Comm_size(*comm, &commSize); 
     15      ep_lib::MPI_Comm_size(*comm, &commSize); 
    2016      if (commSize <= 1) 
    2117        comm = NULL; 
    2218    } 
    23  
    2419    mpi = comm && !multifile; 
    25     MPI_Info m_info = MPI_INFO_NULL.mpi_info; 
     20    ep_lib::MPI_Info info_null; 
    2621 
    2722    // The file format will be detected automatically by NetCDF, it is safe to always set NC_MPIIO 
    2823    // even if Parallel NetCDF ends up being used. 
    2924    if (mpi) 
    30       CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, m_info, this->ncidp); 
     25      //CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, *comm, info_null, this->ncidp); 
     26      CNetCdfInterface::openPar(filename, NC_NOWRITE | NC_MPIIO, static_cast<MPI_Comm>(comm->mpi_comm), info_null.mpi_info, this->ncidp); 
    3127    else 
    3228      CNetCdfInterface::open(filename, NC_NOWRITE, this->ncidp); 
  • XIOS/dev/branch_openmp/src/io/inetcdf4.hpp

    r1138 r1328  
    1414#endif  // UNLIMITED_DIM 
    1515 
    16  
    1716namespace xios 
    1817{ 
     
    2322    public: 
    2423      /// Constructors /// 
    25       CINetCDF4(const StdString& filename, const MPI_Comm* comm = NULL, bool multifile = true, 
     24      CINetCDF4(const StdString& filename, const ep_lib::MPI_Comm* comm = NULL, bool multifile = true, 
    2625                const StdString& timeCounterName = "time_counter"); 
    2726      CINetCDF4(const CINetCDF4& inetcdf4);       // Not implemented. 
  • XIOS/dev/branch_openmp/src/io/inetcdf4_decl.cpp

    r1138 r1328  
    11#include "inetcdf4_impl.hpp" 
    2 // mpi_std.hpp 
    32 
    43namespace xios 
  • XIOS/dev/branch_openmp/src/io/inetcdf4_impl.hpp

    r1138 r1328  
    44#include "inetcdf4.hpp" 
    55#include "netCdfInterface.hpp" 
    6 // mpi_std.hpp 
    76 
    87namespace xios 
  • XIOS/dev/branch_openmp/src/io/nc4_data_input.cpp

    r1176 r1328  
    88#include "scalar.hpp" 
    99 
    10 // mpi.hpp 
    11  
    1210namespace xios 
    1311{ 
    14   CNc4DataInput::CNc4DataInput(const StdString& filename, ::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, const StdString& timeCounterName /*= "time_counter"*/) 
     12  CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, const StdString& timeCounterName /*= "time_counter"*/) 
    1513    : SuperClass() 
    1614    , SuperClassWriter(filename, &comm_file, multifile, timeCounterName) 
     
    5553    CArray<double,1> fieldData(grid->getWrittenDataSize()); 
    5654    if (!field->default_value.isEmpty()) fieldData = field->default_value; 
    57     #ifdef _usingEP 
    58     SuperClass::type = ONE_FILE; 
    59     printf("SuperClass::type = %d\n", SuperClass::type); 
    60     #endif 
     55 
    6156    switch (SuperClass::type) 
    6257    { 
     
    326321      std::vector<StdSize> nBeginBndsLatLon(3), nSizeBndsLatLon(3); 
    327322      nBeginBndsLatLon[0] = 0; nSizeBndsLatLon[0] = domain->nj_glo.getValue(); 
    328       nBeginBndsLatLon[1] = 0; nSizeBndsLatLon[1] = domain->nj_glo.getValue(); 
     323      nBeginBndsLatLon[1] = 0; nSizeBndsLatLon[1] = domain->ni_glo.getValue(); 
    329324      nBeginBndsLatLon[2] = 0; nSizeBndsLatLon[2] = nbVertex; 
    330325 
  • XIOS/dev/branch_openmp/src/io/nc4_data_input.hpp

    r1138 r1328  
    33 
    44/// XIOS headers /// 
     5#include "mpi_std.hpp" 
    56#include "xios_spl.hpp" 
    67#include "data_input.hpp" 
    78#include "inetcdf4.hpp" 
    8 // mpi_std.hpp 
    99 
    1010namespace xios 
     
    2424 
    2525    /// Constructors /// 
    26     CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective = true, 
     26    CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true, 
    2727                  const StdString& timeCounterName = "time_counter"); 
    2828    CNc4DataInput(const CNc4DataInput& dataInput);       // Not implemented. 
     
    7171  private: 
    7272    /// Private attributes /// 
    73     MPI_Comm comm_file; 
     73    ep_lib::MPI_Comm comm_file; 
    7474    const StdString filename; 
    7575    bool isCollective; 
  • XIOS/dev/branch_openmp/src/io/nc4_data_output.cpp

    r1205 r1328  
    1313#include "timer.hpp" 
    1414#include "uuid.hpp" 
    15 // mpi.hpp 
    16  
    1715namespace xios 
    1816{ 
     
    3028      CNc4DataOutput::CNc4DataOutput 
    3129         (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, bool useCFConvention, 
    32           ::MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName) 
     30          ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective, const StdString& timeCounterName) 
    3331            : SuperClass() 
    3432            , SuperClassWriter(filename, exist, useClassicFormat, useCFConvention, &comm_file, multifile, timeCounterName) 
     
    465463      StdString domainName = domain->name; 
    466464      domain->assignMesh(domainName, domain->nvertex); 
    467       domain->mesh->createMeshEpsilon(static_cast< ::MPI_Comm >(server->intraComm.mpi_comm), domain->lonvalue_srv, domain->latvalue_srv, domain->bounds_lon_srv, domain->bounds_lat_srv); 
     465      domain->mesh->createMeshEpsilon(server->intraComm, domain->lonvalue_srv, domain->latvalue_srv, domain->bounds_lon_srv, domain->bounds_lat_srv); 
    468466 
    469467      StdString node_x = domainName + "_node_x"; 
  • XIOS/dev/branch_openmp/src/io/nc4_data_output.hpp

    r1138 r1328  
    44/// XIOS headers /// 
    55#include "xios_spl.hpp" 
     6#include "mpi_std.hpp" 
    67#include "onetcdf4.hpp" 
    78#include "data_output.hpp" 
    8 // mpi_std.hpp 
    99 
    1010namespace xios 
     
    2727            CNc4DataOutput 
    2828               (CFile* file, const StdString & filename, bool exist, bool useClassicFormat, 
    29                 bool useCFConvention, MPI_Comm comm_file, bool multifile,  
    30                 bool isCollective = true, const StdString& timeCounterName = "time_counter"); 
     29                bool useCFConvention, 
     30                ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective = true, 
     31                const StdString& timeCounterName = "time_counter"); 
    3132 
    3233            CNc4DataOutput(const CNc4DataOutput & dataoutput);       // Not implemented. 
     
    116117 
    117118            /// Propriétés privées /// 
    118             MPI_Comm comm_file; 
     119            ep_lib::MPI_Comm comm_file; 
    119120            const StdString filename; 
    120121            std::map<Time, StdSize> timeToRecordCache; 
  • XIOS/dev/branch_openmp/src/io/netCdfInterface.cpp

    r1153 r1328  
    1010#include "netCdfInterface.hpp" 
    1111#include "netCdfException.hpp" 
    12 // mpi_std.hpp 
    1312 
    1413namespace xios 
     
    5049int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    5150{ 
    52   int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId); 
     51  int status = xios::nc_create_par(fileName.c_str(), cMode, comm, MPI_INFO_NULL.mpi_info, &ncId); 
    5352  if (NC_NOERR != status) 
    5453  { 
     
    7574int CNetCdfInterface::open(const StdString& fileName, int oMode, int& ncId) 
    7675{ 
    77   int status = NC_NOERR; 
    78   #pragma omp critical (_netcdf) 
    79   status = nc_open(fileName.c_str(), oMode, &ncId); 
    80    
     76  int status = nc_open(fileName.c_str(), oMode, &ncId); 
    8177  if (NC_NOERR != status) 
    8278  { 
     
    106102int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    107103{ 
    108   int status; 
    109   #pragma omp critical (_netcdf) 
    110   status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId); // nc_open 
     104  //int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId); 
     105  int status = xios::nc_open_par(fileName.c_str(), oMode, comm, MPI_INFO_NULL.mpi_info, &ncId); 
    111106  if (NC_NOERR != status) 
    112107  { 
     
    131126int CNetCdfInterface::close(int ncId) 
    132127{ 
    133   int status = NC_NOERR; 
    134   #pragma omp critical (_netcdf) 
    135   //#pragma omp master 
    136   { 
    137   status = nc_close(ncId); 
     128  int status = nc_close(ncId); 
    138129  if (NC_NOERR != status) 
    139130  { 
     
    146137    throw CNetCdfException(e); 
    147138  } 
    148   } 
     139 
    149140  return status; 
    150141} 
     
    356347int CNetCdfInterface::inqDimLen(int ncid, int dimId, StdSize& dimLen) 
    357348{ 
    358   int status; 
    359   #pragma omp critical (_netcdf) 
    360   status = nc_inq_dimlen(ncid, dimId, &dimLen); 
     349  int status = nc_inq_dimlen(ncid, dimId, &dimLen); 
    361350  if (NC_NOERR != status) 
    362351  { 
  • XIOS/dev/branch_openmp/src/io/netCdfInterface.hpp

    r1134 r1328  
    1010#define __NETCDF_INTERFACE_HPP_ 
    1111 
     12#include "mpi_std.hpp" 
    1213#include "xios_spl.hpp" 
    1314 
     
    1617#endif 
    1718 
    18 #include "mpi_std.hpp" 
    1919#include "netcdf.hpp" 
    2020 
  • XIOS/dev/branch_openmp/src/io/netCdfInterface_decl.cpp

    r1138 r1328  
    99 
    1010#include "netCdfInterface_impl.hpp" 
    11 // mpi_std.hpp 
    1211 
    1312namespace xios 
  • XIOS/dev/branch_openmp/src/io/netCdfInterface_impl.hpp

    r1146 r1328  
    1313#include "netCdfInterface.hpp" 
    1414#include "netCdfException.hpp" 
    15 // mpi_std.hpp 
    1615 
    1716namespace xios 
     
    8685  int CNetCdfInterface::getVaraType(int ncid, int varId, const StdSize* start, const StdSize* count, T* data) 
    8786  { 
    88     int status; 
    89     #pragma omp critical (_netcdf) 
    90     status = ncGetVaraType(ncid, varId, start, count, data); 
     87    int status = ncGetVaraType(ncid, varId, start, count, data); 
    9188    if (NC_NOERR != status) 
    9289    { 
  • XIOS/dev/branch_openmp/src/io/netCdf_cf_constant.hpp

    r1138 r1328  
    44#include "inetcdf4.hpp" 
    55#include "netCdfInterface.hpp" 
    6  
    7 // mpi_std.hpp 
    86 
    97namespace xios 
  • XIOS/dev/branch_openmp/src/io/netcdf.hpp

    r1138 r1328  
    1818extern "C" 
    1919{ 
    20   #include <netcdf_par.h> 
     20include <netcdf_par.h> 
    2121} 
    2222#  endif 
  • XIOS/dev/branch_openmp/src/io/onetcdf4.cpp

    r1287 r1328  
    1212      /// ////////////////////// Définitions ////////////////////// /// 
    1313 
    14       CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention,  
    15                            const MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
     14      CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat, 
     15                                                        bool useCFConvention, 
     16                           const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
    1617        : path() 
    1718        , wmpi(false) 
     
    3132 
    3233      void CONetCDF4::initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention,  
    33                                  const MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
     34                                 const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName) 
    3435      { 
    3536         this->useClassicFormat = useClassicFormat; 
     
    4243         { 
    4344            int commSize = 0; 
    44             MPI_Comm_size(*comm, &commSize); 
     45            ep_lib::MPI_Comm_size(*comm, &commSize); 
    4546            if (commSize <= 1) 
    4647               comm = NULL; 
    4748         } 
    4849         wmpi = comm && !multifile; 
     50         ep_lib::MPI_Info info_null; 
    4951 
    5052         if (wmpi) 
     
    5658            CTimer::get("Files : create").resume(); 
    5759            if (wmpi) 
    58                CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL.mpi_info, this->ncidp); 
     60               CNetCdfInterface::createPar(filename, mode, static_cast<MPI_Comm>(comm->mpi_comm), info_null.mpi_info, this->ncidp); 
    5961            else 
    6062               CNetCdfInterface::create(filename, mode, this->ncidp); 
     
    6870            CTimer::get("Files : open").resume(); 
    6971            if (wmpi) 
    70                CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL.mpi_info, this->ncidp); 
     72               CNetCdfInterface::openPar(filename, mode, static_cast<MPI_Comm>(comm->mpi_comm), info_null.mpi_info, this->ncidp); 
    7173            else 
    7274               CNetCdfInterface::open(filename, mode, this->ncidp); 
     
    539541                                 const std::vector<StdSize>& scount, const int* data) 
    540542      { 
    541          CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data); 
    542       } 
    543  
     543          CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data); 
     544      } 
    544545      //--------------------------------------------------------------- 
    545546 
     
    549550                                 const std::vector<StdSize>& scount, const float* data) 
    550551      { 
    551          CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data); 
     552          CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data); 
    552553      } 
    553554 
  • XIOS/dev/branch_openmp/src/io/onetcdf4.hpp

    r1205 r1328  
    44/// XIOS headers /// 
    55#include "xios_spl.hpp" 
     6#include "mpi_std.hpp" 
    67#include "exception.hpp" 
    78#include "data_output.hpp" 
    89#include "array_new.hpp" 
    9 #include "mpi_std.hpp" 
    1010#include "netcdf.hpp" 
    1111 
     
    1313   #define UNLIMITED_DIM (size_t)(-1) 
    1414#endif  //UNLIMITED_DIM 
    15  
    16 // mpi_std.hpp 
    1715 
    1816namespace xios 
     
    3028            CONetCDF4(const StdString& filename, bool append, bool useClassicFormat = false, 
    3129                          bool useCFConvention = true, 
    32                       const MPI_Comm* comm = NULL, bool multifile = true, 
     30                      const ep_lib::MPI_Comm* comm = NULL, bool multifile = true, 
    3331                      const StdString& timeCounterName = "time_counter"); 
    3432 
     
    3937            /// Initialisation /// 
    4038            void initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
    41                             const MPI_Comm* comm, bool multifile, const StdString& timeCounterName); 
     39                            const ep_lib::MPI_Comm* comm, bool multifile, const StdString& timeCounterName); 
    4240            void close(void); 
    4341            void sync(void); 
  • XIOS/dev/branch_openmp/src/io/onetcdf4_decl.cpp

    r1138 r1328  
    11#include "onetcdf4_impl.hpp" 
    2 // mpi_std.hpp 
    32 
    43namespace xios 
  • XIOS/dev/branch_openmp/src/io/onetcdf4_impl.hpp

    r1205 r1328  
    55#include "netCdfInterface.hpp" 
    66#include "timer.hpp" 
    7 // mpi_std.hpp 
    87 
    98namespace xios 
  • XIOS/dev/branch_openmp/src/log.cpp

    r1164 r1328  
    11#include "log.hpp" 
    2 #include <string> 
    3 #include <iostream> 
    4 #include <string> 
    52 
    63namespace xios 
    74{ 
    8  
    9   std::filebuf* info_FB[16]; 
    10  
    11  
    125  CLog info("info") ; 
    136  CLog report("report") ; 
    147  CLog error("error", cerr.rdbuf()) ; 
    15  
    16    
    17   CLog& CLog::operator()(int l) 
    18     { 
    19       if (l<=level) 
    20       { 
    21         omp_set_lock( &mutex ); 
    22         //rdbuf(strBuf_);  
    23         rdbuf(strBuf_array[omp_get_thread_num()]);  
    24         *this<<"-> "<<name<<" : " ; 
    25         omp_unset_lock( &mutex ); 
    26       } 
    27       else rdbuf(NULL) ; 
    28       return *this; 
    29     } 
    30  
    31  
    32  
    33   int test_omp_rank; 
    34   #pragma omp threadprivate(test_omp_rank) 
    35  
    36    
    37  
    388} 
  • XIOS/dev/branch_openmp/src/log.hpp

    r1164 r1328  
    55#include <iostream> 
    66#include <string> 
    7 #include <stdio.h> 
    8 #include <omp.h> 
    97 
    108namespace xios 
     
    1614    public : 
    1715    CLog(const string& name_, std::streambuf* sBuff = cout.rdbuf()) 
    18       : ostream(cout.rdbuf()), level(0), name(name_), strBuf_(sBuff)  
     16      : ostream(sBuff), level(0), name(name_), strBuf_(sBuff) {} 
     17    CLog& operator()(int l) 
    1918    { 
    20       omp_init_lock( &mutex ); 
    21       for(int i=0; i<16; i++) 
    22         strBuf_array[i] = sBuff; 
     19      if (l<=level) 
     20      { 
     21        rdbuf(strBuf_); 
     22        *this<<"-> "<<name<<" : " ; 
     23      } 
     24      else rdbuf(NULL) ; 
     25      return *this; 
    2326    } 
    24  
    25     ~CLog() 
    26     { 
    27       omp_destroy_lock( &mutex ); 
    28     } 
    29  
    30  
    31     CLog& operator()(int l); 
    3227    void setLevel(int l) {level=l; } 
    33     int  getLevel() {return level ;} 
     28    int getLevel() {return level ;} 
    3429    bool isActive(void) { if (rdbuf()==NULL) return true ; else return false ;} 
    3530    bool isActive(int l) {if (l<=level) return true ; else return false ; } 
     
    5146     * \param [in] pointer to new streambuf 
    5247    */ 
    53     void changeStreamBuff(std::streambuf* sBuff)  
    54     {  
    55       strBuf_ = sBuff;  
    56       strBuf_array[omp_get_thread_num()] = sBuff; 
    57       rdbuf(sBuff); 
    58     } 
     48    void changeStreamBuff(std::streambuf* sBuff) { strBuf_ = sBuff; rdbuf(sBuff); } 
    5949 
    6050    int level ; 
    6151    string name ; 
    6252    std::streambuf* strBuf_; 
    63     std::streambuf* strBuf_array[16]; 
    64     omp_lock_t mutex; 
    6553  }; 
    6654 
     
    6856  extern CLog report; 
    6957  extern CLog error; 
    70  
    71  
    72   extern std::filebuf* info_FB[16]; 
    73  
    74  
    7558} 
    7659#endif 
  • XIOS/dev/branch_openmp/src/memtrack.cpp

    r1205 r1328  
    4444#include <sstream> 
    4545#include <string> 
     46 
    4647#include <execinfo.h> 
    4748 
     
    7677        private:    // static member variables 
    7778            static BlockHeader *ourFirstNode; 
    78             #pragma omp threadprivate(ourFirstNode) 
    7979     
    8080        private:    // member variables 
  • XIOS/dev/branch_openmp/src/mpi.hpp

    r1134 r1328  
    1010/* skip C++ Binding for OpenMPI */ 
    1111#define OMPI_SKIP_MPICXX 
    12  
    1312#ifdef _usingEP 
    1413  #include <omp.h> 
    1514  #include "../extern/src_ep_dev/ep_lib.hpp" 
    16   using namespace ep_lib; 
     15  #include "../extern/src_ep_dev/ep_declaration.hpp" 
     16  //using namespace ep_lib; 
    1717#elif _usingMPI 
    1818  #include <mpi.h> 
  • XIOS/dev/branch_openmp/src/mpi_std.hpp

    r1134 r1328  
    1111#define OMPI_SKIP_MPICXX 
    1212 
     13#include <mpi.h> 
    1314#include "../extern/src_ep_dev/ep_lib.hpp" 
    14 #include <mpi.h> 
    15  
    16  
     15#include "../extern/src_ep_dev/ep_declaration.hpp" 
    1716 
    1817#endif 
  • XIOS/dev/branch_openmp/src/node/axis.cpp

    r1205 r1328  
    4444   { /* Ne rien faire de plus */ } 
    4545 
    46    std::map<StdString, ETranformationType> *CAxis::transformationMapList_ptr = 0; //new std::map<StdString, ETranformationType>();   
    47    //bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_ptr); 
    48  
     46   //std::map<StdString, ETranformationType> CAxis::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     47   std::map<StdString, ETranformationType> *CAxis::transformationMapList_ptr = 0; 
     48   //bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_); 
     49    
    4950   bool CAxis::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
    5051   { 
     
    5556     m["extract_domain"] = TRANS_EXTRACT_DOMAIN_TO_AXIS; 
    5657   } 
    57  
    5858 
    5959   bool CAxis::initializeTransformationMap() 
     
    6666     (*CAxis::transformationMapList_ptr)["extract_domain"]   = TRANS_EXTRACT_DOMAIN_TO_AXIS; 
    6767   } 
    68  
    6968 
    7069   ///--------------------------------------------------------------- 
     
    500499        globalAxisZoom[nZoomCount] = globalZoomIndex; 
    501500        ++nZoomCount; 
    502       } 
     501      }  
    503502    } 
    504503 
     
    831830      CContextServer* server = CContext::getCurrent()->server; 
    832831      axis->numberWrittenIndexes_ = axis->indexesToWrite.size(); 
    833       ep_lib::MPI_Allreduce(&axis->numberWrittenIndexes_, &axis->totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    834       ep_lib::MPI_Scan(&axis->numberWrittenIndexes_, &axis->offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     832      MPI_Allreduce(&axis->numberWrittenIndexes_, &axis->totalNumberWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
     833      MPI_Scan(&axis->numberWrittenIndexes_, &axis->offsetWrittenIndexes_, 1, MPI_INT, MPI_SUM, server->intraComm); 
    835834      axis->offsetWrittenIndexes_ -= axis->numberWrittenIndexes_; 
    836835    } 
     
    978977        msg << ni << begin << end; 
    979978        msg << global_zoom_begin.getValue() << global_zoom_n.getValue(); 
    980         msg << isCompressible_; 
     979        msg << isCompressible_;         
    981980        msg << zoomIndex; 
    982981        if (zoomIndex) 
     
    11571156 
    11581157        nodeElementName = node.getElementName(); 
    1159  
     1158        //std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it; 
    11601159        if(transformationMapList_ptr == 0) initializeTransformationMap(); 
    1161         //transformationMapList_ptr = new std::map<StdString, ETranformationType>(); 
    1162  
    1163         std::map<StdString, ETranformationType>::const_iterator ite = (*CAxis::transformationMapList_ptr).end(), it; 
    1164         it = (*CAxis::transformationMapList_ptr).find(nodeElementName); 
     1160        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_ptr->end(), it; 
     1161        //it = transformationMapList_.find(nodeElementName); 
     1162        it = transformationMapList_ptr->find(nodeElementName); 
    11651163        if (ite != it) 
    11661164        { 
     
    11841182 
    11851183} // namespace xios 
    1186  
  • XIOS/dev/branch_openmp/src/node/axis.hpp

    r1205 r1328  
    172172       private: 
    173173         static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m); 
    174          //static bool initializeTransformationMap(std::map<StdString, ETranformationType>* m); 
    175174         static bool initializeTransformationMap(); 
    176  
    177175         //static std::map<StdString, ETranformationType> transformationMapList_; 
    178           
    179176         static std::map<StdString, ETranformationType> *transformationMapList_ptr; 
    180          #pragma omp threadprivate(transformationMapList_ptr) 
    181  
    182          //static bool dummyTransformationMapList_; 
    183          //#pragma omp threadprivate(dummyTransformationMapList_) 
     177         static bool dummyTransformationMapList_; 
    184178 
    185179         DECLARE_REF_FUNC(Axis,axis) 
     
    193187 
    194188#endif // __XIOS_CAxis__ 
    195  
  • XIOS/dev/branch_openmp/src/node/compute_connectivity_domain.hpp

    r1134 r1328  
    6060      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    63        
    6462  }; // class CComputeConnectivityDomain 
    6563 
  • XIOS/dev/branch_openmp/src/node/context.cpp

    r1287 r1328  
     1 
    12#include "context.hpp" 
    23#include "attribute_template.hpp" 
     
    1718#include "memtrack.hpp" 
    1819 
     20using namespace ep_lib; 
     21 
    1922 
    2023namespace xios { 
    2124 
    22   //shared_ptr<CContextGroup> CContext::root; 
    23   boost::shared_ptr<CContextGroup> * CContext::root_ptr = 0; 
    24  
    25    /// ////////////////////// Dfinitions ////////////////////// /// 
     25  shared_ptr<CContextGroup> CContext::root; 
     26 
     27   /// ////////////////////// Définitions ////////////////////// /// 
    2628 
    2729   CContext::CContext(void) 
     
    5759   CContextGroup* CContext::getRoot(void) 
    5860   { 
    59       //if (root.get()==NULL) root=shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 
    60       //return root.get(); 
    61  
    62       //static shared_ptr<CContextGroup> *root_ptr; 
    63       if(root_ptr == 0) //root_ptr = new shared_ptr<CContextGroup>; 
    64       // if (root_ptr->get()==NULL)  
    65       root_ptr = new boost::shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 
    66       return root_ptr->get(); 
     61      if (root.get()==NULL) root=shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 
     62      return root.get(); 
    6763   } 
    6864 
     
    186182      if (!this->hasChild()) 
    187183      { 
    188          //oss << "<!-- No definition -->" << std::endl; // fait planter l'incrmentation 
     184         //oss << "<!-- No definition -->" << std::endl; // fait planter l'incrémentation 
    189185      } 
    190186      else 
     
    248244   { 
    249245     hasClient=true; 
    250      client = new CContextClient(this, intraComm, interComm, cxtServer); 
    251  
    252      int tmp_rank; 
    253      MPI_Comm_rank(intraComm, &tmp_rank); 
    254      MPI_Barrier(intraComm); 
    255       
    256  
     246     client = new CContextClient(this,intraComm, interComm, cxtServer); 
    257247     registryIn=new CRegistry(intraComm); 
    258248     registryIn->setPath(getId()) ; 
     
    271261     else 
    272262     { 
    273        MPI_Comm_dup(intraComm, &intraCommServer); 
     263       ep_lib::MPI_Comm_dup(intraComm, &intraCommServer); 
    274264       comms.push_back(intraCommServer); 
    275        MPI_Comm_dup(interComm, &interCommServer); 
     265       ep_lib::MPI_Comm_dup(interComm, &interCommServer); 
    276266       comms.push_back(interCommServer); 
    277267     } 
     
    353343     else 
    354344     { 
    355        MPI_Comm_dup(intraComm, &intraCommClient); 
     345       ep_lib::MPI_Comm_dup(intraComm, &intraCommClient); 
    356346       comms.push_back(intraCommClient); 
    357        MPI_Comm_dup(interComm, &interCommClient); 
     347       ep_lib::MPI_Comm_dup(interComm, &interCommClient); 
    358348       comms.push_back(interCommClient); 
    359349     } 
     
    395385 
    396386        for (std::list<ep_lib::MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
    397           MPI_Comm_free(&(*it)); 
     387          ep_lib::MPI_Comm_free(&(*it)); 
    398388        comms.clear(); 
    399389      } 
     
    527517   } 
    528518 
    529    void CContext::checkPrefetchingOfEnabledReadModeFiles() 
     519   void CContext::doPostTimestepOperationsForEnabledReadModeFiles() 
    530520   { 
    531521     int size = enabledReadModeFiles.size(); 
    532522     for (int i = 0; i < size; ++i) 
    533523     { 
    534         enabledReadModeFiles[i]->prefetchEnabledReadModeFieldsIfNeeded(); 
     524        enabledReadModeFiles[i]->doPostTimestepOperationsForEnabledReadModeFields(); 
    535525     } 
    536526   } 
     
    563553  } 
    564554 
    565    void CContext::solveAllInheritance(bool apply) 
    566    { 
    567      // Rsolution des hritages descendants (cd des hritages de groupes) 
     555   void CContext::solveAllInheritance(bool apply) // default : apply = true 
     556   { 
     557     // Résolution des héritages descendants (càd des héritages de groupes) 
    568558     // pour chacun des contextes. 
    569559      solveDescInheritance(apply); 
    570560 
    571      // Rsolution des hritages par rfrence au niveau des fichiers. 
     561     // Résolution des héritages par référence au niveau des fichiers. 
    572562      const vector<CFile*> allFiles=CFile::getAll(); 
    573563      const vector<CGrid*> allGrids= CGrid::getAll(); 
     
    593583 
    594584      for (unsigned int i = 0; i < allFiles.size(); i++) 
    595          if (!allFiles[i]->enabled.isEmpty()) // Si l'attribut 'enabled' est dfini. 
     585         if (!allFiles[i]->enabled.isEmpty()) // Si l'attribut 'enabled' est défini. 
    596586         { 
    597             if (allFiles[i]->enabled.getValue()) // Si l'attribut 'enabled' est fix  vrai. 
     587            if (allFiles[i]->enabled.getValue()) // Si l'attribut 'enabled' est fixé à vrai. 
    598588            { 
    599589              if ((initDate + allFiles[i]->output_freq.getValue()) < (initDate + this->getCalendar()->getTimeStep())) 
     
    620610 
    621611      if (enabledFiles.size() == 0) 
    622          DEBUG(<<"Aucun fichier ne va tre sorti dans le contexte nomm \"" 
     612         DEBUG(<<"Aucun fichier ne va être sorti dans le contexte nommé \"" 
    623613               << getId() << "\" !"); 
    624614   } 
     
    836826   void CContext::postProcessing() 
    837827   { 
    838      int myRank; 
    839      MPI_Comm_rank(MPI_COMM_WORLD, &myRank); 
    840  
    841828     if (isPostProcessed) return; 
    842829 
     
    860847      prepareTimeseries(); 
    861848 
    862       //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers sortir. 
     849      //Initialisation du vecteur 'enabledFiles' contenant la liste des fichiers à sortir. 
    863850      this->findEnabledFiles(); 
    864851      this->findEnabledReadModeFiles(); 
     
    12181205   void CContext::updateCalendar(int step) 
    12191206   { 
    1220       #pragma omp critical (_output) 
    1221       {info(50) << "updateCalendar : before : " << calendar->getCurrentDate() << endl;} 
     1207      info(50) << "updateCalendar : before : " << calendar->getCurrentDate() << endl; 
    12221208      calendar->update(step); 
    1223       #pragma omp critical (_output) 
    1224       {info(50) << "updateCalendar : after : " << calendar->getCurrentDate() << endl;} 
     1209      info(50) << "updateCalendar : after : " << calendar->getCurrentDate() << endl; 
    12251210#ifdef XIOS_MEMTRACK_LIGHT 
    1226       #pragma omp critical (_output) 
    1227       {info(50) << " Current memory used by XIOS : "<<  MemTrack::getCurrentMemorySize()*1.0/(1024*1024)<<" Mbyte, at timestep "<<step<<" of context "<<this->getId()<<endl ;} 
     1211      info(50) << " Current memory used by XIOS : "<<  MemTrack::getCurrentMemorySize()*1.0/(1024*1024)<<" Mbyte, at timestep "<<step<<" of context "<<this->getId()<<endl ; 
    12281212#endif 
    12291213      if (hasClient) 
    12301214      { 
    1231         checkPrefetchingOfEnabledReadModeFiles(); 
     1215        doPostTimestepOperationsForEnabledReadModeFiles(); 
    12321216        garbageCollector.invalidate(calendar->getCurrentDate()); 
    12331217      } 
     
    12731257    CContext* context = CObjectFactory::CreateObject<CContext>(id).get(); 
    12741258    getRoot(); 
    1275     if (!hasctxt) CGroupFactory::AddChild(*root_ptr, context->getShared()); 
     1259    if (!hasctxt) CGroupFactory::AddChild(root, context->getShared()); 
    12761260 
    12771261#define DECLARE_NODE(Name_, name_) \ 
  • XIOS/dev/branch_openmp/src/node/context.hpp

    r1287 r1328  
    55#include "xios_spl.hpp" 
    66//#include "node_type.hpp" 
     7#include "mpi_std.hpp" 
    78#include "calendar_wrapper.hpp" 
    89 
     
    1314#include "garbage_collector.hpp" 
    1415#include "registry.hpp" 
    15 #include "mpi.hpp" 
    1616 
    1717 
     
    115115         void buildFilterGraphOfEnabledFields(); 
    116116         void startPrefetchingOfEnabledReadModeFiles(); 
    117          void checkPrefetchingOfEnabledReadModeFiles(); 
     117         void doPostTimestepOperationsForEnabledReadModeFiles(); 
    118118         void findFieldsWithReadAccess(void); 
    119119         void solveAllRefOfFieldsWithReadAccess(); 
     
    206206 
    207207         // Context root 
    208          //static shared_ptr<CContextGroup> root; 
    209  
    210          static boost::shared_ptr<CContextGroup> *root_ptr; 
    211          #pragma omp threadprivate(root_ptr) 
     208         static shared_ptr<CContextGroup> root; 
    212209 
    213210         // Determine context on client or not 
     
    222219         // Concrete contex client 
    223220         CContextClient* client; 
    224  
    225  
    226221         CRegistry* registryIn ;  //!< input registry which is read from file 
    227222         CRegistry* registryOut ; //!< output registry which will be wrote on file at the finalize 
    228           
    229223 
    230224      private: 
  • XIOS/dev/branch_openmp/src/node/domain.cpp

    r1138 r1328  
    2626namespace xios { 
    2727 
    28    /// ////////////////////// Dfinitions ////////////////////// /// 
     28   /// ////////////////////// Définitions ////////////////////// /// 
    2929 
    3030   CDomain::CDomain(void) 
     
    6666 
    6767   //std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     68   std::map<StdString, ETranformationType> *CDomain::transformationMapList_ptr = 0; 
    6869   //bool CDomain::_dummyTransformationMapList = CDomain::initializeTransformationMap(CDomain::transformationMapList_); 
    69  
    70    std::map<StdString, ETranformationType> *CDomain::transformationMapList_ptr = 0; 
    7170 
    7271   bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     
    8887     (*CDomain::transformationMapList_ptr)["expand_domain"] = TRANS_EXPAND_DOMAIN; 
    8988   } 
    90  
    9189 
    9290   const std::set<StdString> & CDomain::getRelFiles(void) const 
     
    445443      break; 
    446444     } 
     445     completeLonLatClient() ; 
    447446 
    448447   } 
     
    636635   { 
    637636          CContext* context = CContext::getCurrent(); 
    638           CContextClient* client = context->client; 
     637      CContextClient* client = context->client; 
    639638          lon_g.resize(ni_glo) ; 
    640639          lat_g.resize(nj_glo) ; 
     
    14951494 
    14961495      if (context->hasClient) 
    1497       { // Ct client uniquement 
     1496      { // CÃŽté client uniquement 
    14981497         this->checkMask(); 
    14991498         this->checkDomainData(); 
     
    15021501      } 
    15031502      else 
    1504       { // Ct serveur uniquement 
     1503      { // CÃŽté serveur uniquement 
    15051504      } 
    15061505 
     
    15351534 
    15361535      if (context->hasClient) 
    1537       { // Ct client uniquement 
     1536      { // CÃŽté client uniquement 
    15381537         this->checkMask(); 
    15391538         this->checkDomainData(); 
     
    15431542      } 
    15441543      else 
    1545       { // Ct serveur uniquement 
     1544      { // CÃŽté serveur uniquement 
    15461545      } 
    15471546 
     
    17261725                                                                                client->intraComm); 
    17271726    clientServerMap->computeServerIndexMapping(globalIndexDomain); 
    1728      
    17291727    const CClientServerMapping::GlobalIndexMap& globalIndexDomainOnServer = clientServerMap->getGlobalIndexOnServer(); 
    17301728 
     
    23652363        nodeElementName = node.getElementName(); 
    23662364        if(transformationMapList_ptr == 0) initializeTransformationMap(); 
    2367         std::map<StdString, ETranformationType>::const_iterator ite = (*transformationMapList_ptr).end(), it; 
    2368         it = (*transformationMapList_ptr).find(nodeElementName); 
     2365        //std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it; 
     2366        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_ptr->end(), it; 
     2367        //it = transformationMapList_.find(nodeElementName); 
     2368        it = transformationMapList_ptr->find(nodeElementName); 
    23692369        if (ite != it) 
    23702370        { 
  • XIOS/dev/branch_openmp/src/node/domain.hpp

    r1134 r1328  
    218218         static bool initializeTransformationMap(); 
    219219         //static std::map<StdString, ETranformationType> transformationMapList_; 
    220   
    221220         static std::map<StdString, ETranformationType> *transformationMapList_ptr; 
    222          #pragma omp threadprivate(transformationMapList_ptr) 
    223  
    224          //static bool _dummyTransformationMapList; 
    225          //#pragma omp threadprivate(_dummyTransformationMapList) 
     221         static bool _dummyTransformationMapList; 
    226222 
    227223         DECLARE_REF_FUNC(Domain,domain) 
  • XIOS/dev/branch_openmp/src/node/expand_domain.hpp

    r1134 r1328  
    6060      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    63        
    6462  }; // class CExpandDomain 
    6563 
  • XIOS/dev/branch_openmp/src/node/extract_axis_to_scalar.hpp

    r1134 r1328  
    6060      static CTransformation<CScalar>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CExtractAxisToScalar 
    6463 
  • XIOS/dev/branch_openmp/src/node/extract_domain_to_axis.hpp

    r1134 r1328  
    6060      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CExtractDomainToAxis 
    6463 
  • XIOS/dev/branch_openmp/src/node/field.cpp

    r1209 r1328  
    2424#include "spatial_transform_filter.hpp" 
    2525 
     26#include <stdio.h> 
     27 
    2628namespace xios{ 
    2729 
    2830   /// ////////////////////// Dfinitions ////////////////////// /// 
     31 
     32  CField* CField::my_getDirectFieldReference(void) const 
     33  {                                                                       
     34    // if (this->field_ref.isEmpty())                                      
     35    // ERROR("C" #type "* C" #type "::getDirect" #type "Reference(void)",  
     36    //       << "The " #name_ " with id = '" << getId() << "'"             
     37    //       << " has no " #name_ "_ref.");                                
     38                                                                        
     39    // if (!C##type::has(this->name_##_ref))                                 
     40    // ERROR("C" #type "* C" #type "::getDirect" #type "Reference(void)",  
     41    //       << this->name_##_ref                                          
     42    //       << " refers to an unknown " #name_ " id.");                   
     43                                                                        
     44    return CField::get(this->field_ref);                               
     45  } 
     46 
    2947 
    3048   CField::CField(void) 
     
    3856      , hasTimeInstant(false) 
    3957      , hasTimeCentered(false) 
     58      , wasDataRequestedFromServer(false) 
    4059      , wasDataAlreadyReceivedFromServer(false) 
    4160      , isEOF(false) 
     
    5271      , hasTimeInstant(false) 
    5372      , hasTimeCentered(false) 
     73      , wasDataRequestedFromServer(false) 
    5474      , wasDataAlreadyReceivedFromServer(false) 
    5575      , isEOF(false) 
     
    261281    lastDataRequestedFromServer = tsDataRequested; 
    262282 
    263     if (!isEOF) // No need to send the request if we already know we are at EOF 
     283    // No need to send the request if we are sure that we are already at EOF 
     284    if (!isEOF || context->getCalendar()->getCurrentDate() <= dateEOF) 
    264285    { 
    265286      CEventClient event(getType(), EVENT_ID_READ_DATA); 
     
    277298    else 
    278299      serverSourceFilter->signalEndOfStream(tsDataRequested); 
     300 
     301    wasDataRequestedFromServer = true; 
    279302 
    280303    return !isEOF; 
     
    293316    while (currentDate >= lastDataRequestedFromServer) 
    294317    { 
    295       #pragma omp critical (_output) 
    296       { 
    297         info(20) << "currentDate : " << currentDate << endl ; 
    298         info(20) << "lastDataRequestedFromServer : " << lastDataRequestedFromServer << endl ; 
    299         info(20) << "file->output_freq.getValue() : " << file->output_freq.getValue() << endl ; 
    300         info(20) << "lastDataRequestedFromServer + file->output_freq.getValue() : " << lastDataRequestedFromServer + file->output_freq << endl ; 
    301       } 
     318      info(20) << "currentDate : " << currentDate << endl ; 
     319      info(20) << "lastDataRequestedFromServer : " << lastDataRequestedFromServer << endl ; 
     320      info(20) << "file->output_freq.getValue() : " << file->output_freq.getValue() << endl ; 
     321      info(20) << "lastDataRequestedFromServer + file->output_freq.getValue() : " << lastDataRequestedFromServer + file->output_freq << endl ; 
     322 
    302323      dataRequested |= sendReadDataRequest(lastDataRequestedFromServer + file->output_freq); 
    303324    } 
     
    435456  { 
    436457    CContext* context = CContext::getCurrent(); 
    437     int record; 
    438458    std::map<int, CArray<double,1> > data; 
     459    const bool wasEOF = isEOF; 
    439460 
    440461    for (int i = 0; i < ranks.size(); i++) 
    441462    { 
    442463      int rank = ranks[i]; 
     464      int record; 
    443465      *buffers[i] >> record; 
    444466      isEOF = (record == int(-1)); 
     
    459481 
    460482    if (isEOF) 
     483    { 
     484      if (!wasEOF) 
     485        dateEOF = lastDataReceivedFromServer; 
     486 
    461487      serverSourceFilter->signalEndOfStream(lastDataReceivedFromServer); 
     488    } 
    462489    else 
    463490      serverSourceFilter->streamDataFromServer(lastDataReceivedFromServer, data); 
     491  } 
     492 
     493  void CField::checkForLateDataFromServer(void) 
     494  { 
     495    CContext* context = CContext::getCurrent(); 
     496    const CDate& currentDate = context->getCalendar()->getCurrentDate(); 
     497 
     498    // Check if data previously requested has been received as expected 
     499    if (wasDataRequestedFromServer && (!isEOF || currentDate <= dateEOF)) 
     500    { 
     501      CTimer timer("CField::checkForLateDataFromServer"); 
     502 
     503      bool isDataLate; 
     504      do 
     505      { 
     506        const CDate nextDataDue = wasDataAlreadyReceivedFromServer ? (lastDataReceivedFromServer + file->output_freq) : context->getCalendar()->getInitDate(); 
     507        isDataLate = nextDataDue < currentDate; 
     508 
     509        if (isDataLate) 
     510        { 
     511          timer.resume(); 
     512 
     513          context->checkBuffersAndListen(); 
     514 
     515          timer.suspend(); 
     516        } 
     517      } 
     518      while (isDataLate && timer.getCumulatedTime() < CXios::recvFieldTimeout); 
     519 
     520      if (isDataLate) 
     521        ERROR("void CField::checkForLateDataFromServer(void)", 
     522              << "Late data at timestep = " << currentDate); 
     523    } 
    464524  } 
    465525 
     
    694754     CContext* context = CContext::getCurrent(); 
    695755     solveOnlyReferenceEnabledField(doSending2Server); 
    696      int myRank; 
    697      MPI_Comm_rank(context->client->intraComm, &myRank); 
     756 
     757     //std::cout<<"Field "<<this->getId()<<" areAllReferenceSolved = "<<areAllReferenceSolved<<std::endl;  
    698758 
    699759     if (!areAllReferenceSolved) 
    700760     { 
    701761        areAllReferenceSolved = true; 
    702  
     762        //std::cout<<"Field "<<this->getId()<<" all reference solved"<<std::endl;  
    703763        if (context->hasClient) 
    704764        { 
     
    825885       // Check if the data is to be read from a file 
    826886       else if (file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read) 
    827          instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, 
    828                                                                                                      freq_offset.isEmpty() ? NoneDu : freq_offset, 
    829                                                                                                      true, 
     887       { 
     888         checkAttributes(); 
     889         instantDataFilter = serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, freq_offset, true, 
    830890                                                                                                     detectMissingValues, defaultValue)); 
     891       } 
    831892       else // The data might be passed from the model 
    832893       { 
     
    910971       { 
    911972         if (!serverSourceFilter) 
    912            serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, 
    913                                                                                    freq_offset.isEmpty() ? NoneDu : freq_offset, 
    914                                                                                    true, 
     973         { 
     974           checkAttributes(); 
     975           serverSourceFilter = boost::shared_ptr<CSourceFilter>(new CSourceFilter(gc, grid, freq_offset, true, 
    915976                                                                                   detectMissingValues, defaultValue)); 
     977         } 
    916978 
    917979         selfReferenceFilter = serverSourceFilter; 
     
    9581020               << "An operation must be defined for field \"" << getId() << "\"."); 
    9591021 
    960        if (freq_op.isEmpty()) 
    961          freq_op.setValue(TimeStep); 
    962        if (freq_offset.isEmpty()) 
    963          freq_offset.setValue(NoneDu); 
     1022       checkAttributes(); 
    9641023 
    9651024       const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    966         
    9671025       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    9681026                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 
     
    10001058               << "An operation must be defined for field \"" << getId() << "\"."); 
    10011059 
    1002        if (freq_op.isEmpty()) freq_op.setValue(TimeStep); 
    1003        if (freq_offset.isEmpty()) freq_offset.setValue(NoneDu); 
     1060       checkAttributes(); 
    10041061 
    10051062       const bool detectMissingValues = (!detect_missing_value.isEmpty() && !default_value.isEmpty() && detect_missing_value == true); 
    1006  
    10071063       boost::shared_ptr<CTemporalFilter> temporalFilter(new CTemporalFilter(gc, operation, 
    10081064                                                                             CContext::getCurrent()->getCalendar()->getInitDate(), 
     
    14501506 
    14511507   /*! 
     1508    * Check on freq_off and freq_op attributes. 
     1509    */ 
     1510   void CField::checkAttributes(void) 
     1511   { 
     1512     bool isFieldRead = file && !file->mode.isEmpty() && file->mode == CFile::mode_attr::read; 
     1513     if (isFieldRead && operation.getValue() != "instant") 
     1514       ERROR("void CField::checkAttributes(void)", 
     1515             << "Unsupported operation for field '" << getFieldOutputName() << "'." << std::endl 
     1516             << "Currently only \"instant\" is supported for fields read from file.") 
     1517 
     1518     if (freq_op.isEmpty()) 
     1519     { 
     1520       if (operation.getValue() == "instant") 
     1521         freq_op.setValue(file->output_freq.getValue()); 
     1522       else 
     1523         freq_op.setValue(TimeStep); 
     1524     } 
     1525     if (freq_offset.isEmpty()) 
     1526       freq_offset.setValue(isFieldRead ? NoneDu : (freq_op.getValue() - TimeStep)); 
     1527   } 
     1528 
     1529   /*! 
    14521530    * Returns string arithmetic expression associated to the field. 
    14531531    * \return if content is defined return content string, otherwise, if "expr" attribute is defined, return expr string. 
  • XIOS/dev/branch_openmp/src/node/field.hpp

    r1119 r1328  
    150150        static void recvReadDataReady(CEventServer& event); 
    151151        void recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers); 
     152        void checkForLateDataFromServer(void); 
    152153        void outputField(CArray<double,3>& fieldOut); 
    153154        void outputField(CArray<double,2>& fieldOut); 
     
    176177        void sendAddAllVariables(); 
    177178 
     179        /// Vérifications /// 
     180        void checkAttributes(void); 
    178181 
    179182        const std::vector<StdString>& getRefDomainAxisIds(); 
     
    181184        const string& getExpression(void); 
    182185        bool hasExpression(void) const; 
     186 
     187        CField* my_getDirectFieldReference(void) const; 
     188 
     189 
    183190 
    184191      public: 
     
    195202         bool isEOF; 
    196203         CDate lastlast_Write_srv, last_Write_srv, last_operation_srv; 
    197          CDate lastDataRequestedFromServer, lastDataReceivedFromServer; 
    198          bool wasDataAlreadyReceivedFromServer; 
     204         CDate lastDataRequestedFromServer, lastDataReceivedFromServer, dateEOF; 
     205         bool wasDataRequestedFromServer, wasDataAlreadyReceivedFromServer; 
    199206 
    200207         map<int,boost::shared_ptr<func::CFunctor> > foperation_srv; 
  • XIOS/dev/branch_openmp/src/node/file.cpp

    r1287 r1328  
    1818#include "timer.hpp" 
    1919 
     20 
    2021namespace xios { 
    2122 
     
    2425   CFile::CFile(void) 
    2526      : CObjectTemplate<CFile>(), CFileAttributes() 
    26       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL) 
     27      , vFieldGroup(), data_out(), enabledFields() 
    2728      , allDomainEmpty(false), isOpen(false) 
    2829   { 
     
    3334   CFile::CFile(const StdString & id) 
    3435      : CObjectTemplate<CFile>(id), CFileAttributes() 
    35       , vFieldGroup(), data_out(), enabledFields(), fileComm(MPI_COMM_NULL) 
     36      , vFieldGroup(), data_out(), enabledFields() 
    3637      , allDomainEmpty(false), isOpen(false) 
    3738    { 
     
    263264      // create sub communicator for file 
    264265      int color = allDomainEmpty ? 0 : 1; 
    265       MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
    266       if (allDomainEmpty) MPI_Comm_free(&fileComm); 
     266      ep_lib::MPI_Comm_split(server->intraComm, color, server->intraCommRank, &fileComm); 
     267      if (allDomainEmpty) ep_lib::MPI_Comm_free(&fileComm); 
    267268 
    268269      // if (time_counter.isEmpty()) time_counter.setValue(time_counter_attr::centered); 
     
    461462         { 
    462463            int commSize, commRank; 
    463             MPI_Comm_size(fileComm, &commSize); 
    464             MPI_Comm_rank(fileComm, &commRank); 
     464            ep_lib::MPI_Comm_size(fileComm, &commSize); 
     465            ep_lib::MPI_Comm_rank(fileComm, &commRank); 
    465466 
    466467            if (server->intraCommSize > 1) 
     
    482483         if (isOpen) data_out->closeFile(); 
    483484 
    484         data_out = boost::shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention, 
    485                                                               static_cast< ::MPI_Comm >(fileComm.mpi_comm), multifile, isCollective, time_counter_name)); 
     485        data_out = shared_ptr<CDataOutput>(new CNc4DataOutput(this, oss.str(), append, useClassicFormat, useCFConvention, 
     486                                                              fileComm, multifile, isCollective, time_counter_name)); 
    486487        isOpen = true; 
    487488 
     
    577578      { 
    578579        int commSize, commRank; 
    579         MPI_Comm_size(fileComm, &commSize); 
    580         MPI_Comm_rank(fileComm, &commRank); 
     580        ep_lib::MPI_Comm_size(fileComm, &commSize); 
     581        ep_lib::MPI_Comm_rank(fileComm, &commRank); 
    581582 
    582583        if (server->intraCommSize > 1) 
     
    596597      bool isCollective = par_access.isEmpty() || par_access == par_access_attr::collective; 
    597598 
    598       #ifdef _usingEP 
    599       //printf("multifile was %d\n", multifile); 
    600       multifile = true; 
    601599      if (isOpen) data_out->closeFile(); 
    602       if (time_counter_name.isEmpty()) data_in = boost::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), static_cast< ::MPI_Comm >(fileComm.mpi_comm), multifile, isCollective)); 
    603       else data_in = boost::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), static_cast< ::MPI_Comm >(fileComm.mpi_comm), multifile, isCollective, time_counter_name)); 
     600      if (time_counter_name.isEmpty()) data_in = shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), fileComm, multifile, isCollective)); 
     601      else data_in = shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), fileComm, multifile, isCollective, time_counter_name)); 
    604602      isOpen = true; 
    605       #else 
    606       if (isOpen) data_out->closeFile(); 
    607       if (time_counter_name.isEmpty()) data_in = boost::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), static_cast< ::MPI_Comm >(fileComm.mpi_comm), multifile, isCollective)); 
    608       else data_in = boost::shared_ptr<CDataInput>(new CNc4DataInput(oss.str(), static_cast< ::MPI_Comm >(fileComm.mpi_comm), multifile, isCollective, time_counter_name)); 
    609       isOpen = true; 
    610       #endif 
    611  
    612        
    613603    } 
    614604  } 
     
    625615          this->data_in->closeFile(); 
    626616       } 
    627       if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
     617//      if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
     618      //if (fileComm.mpi_comm != ::MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
    628619   } 
    629620   //---------------------------------------------------------------- 
     
    638629 
    639630     // It would probably be better to call initFile() somehow 
    640       
    641      MPI_Comm_dup(client->intraComm, &fileComm); 
     631     ep_lib::MPI_Comm_dup(client->intraComm, &fileComm); 
    642632     if (time_counter_name.isEmpty()) time_counter_name = "time_counter"; 
    643633 
    644      //#pragma omp critical (_readAttributesOfEnabledFieldsInReadMode_) 
    645      //{ 
    646      checkFile(); // calls nc_open 
     634     checkFile(); 
    647635 
    648636     for (int idx = 0; idx < enabledFields.size(); ++idx) 
     
    658646 
    659647        // Read necessary value from file 
    660         #pragma omp critical (_func) 
    661         { 
    662           //checkFile(); 
    663           this->data_in->readFieldAttributesValues(enabledFields[idx]); 
    664           //close(); 
    665         } 
    666          
     648        this->data_in->readFieldAttributesValues(enabledFields[idx]); 
     649 
    667650        // Fill attributes for base reference 
    668651        enabledFields[idx]->solveGridDomainAxisBaseRef(); 
     
    671654     // Now everything is ok, close it 
    672655     close(); 
    673      //} 
    674       
    675      //if (fileComm != MPI_COMM_NULL) MPI_Comm_free(&fileComm); 
    676       
    677656   } 
    678657 
     
    806785 
    807786   /*! 
    808      Prefetching the data for enabled fields read from file whose data is out-of-date. 
    809    */ 
    810    void CFile::prefetchEnabledReadModeFieldsIfNeeded(void) 
     787     Do all post timestep operations for enabled fields in read mode: 
     788      - Prefetch the data read from file when needed 
     789      - Check that the data excepted from server has been received 
     790   */ 
     791   void CFile::doPostTimestepOperationsForEnabledReadModeFields(void) 
    811792   { 
    812793     if (mode.isEmpty() || mode.getValue() != mode_attr::read) 
     
    815796     int size = this->enabledFields.size(); 
    816797     for (int i = 0; i < size; ++i) 
     798     { 
     799       this->enabledFields[i]->checkForLateDataFromServer(); 
    817800       this->enabledFields[i]->sendReadDataRequestIfNeeded(); 
     801     } 
    818802   } 
    819803 
     
    11211105       CField* field = this->enabledFields[i]; 
    11221106       this->sendAddField(field->getId()); 
     1107       field->checkAttributes(); 
    11231108       field->sendAllAttributesToServer(); 
    11241109       field->sendAddAllVariables(); 
  • XIOS/dev/branch_openmp/src/node/file.hpp

    r1134 r1328  
    44/// XIOS headers /// 
    55#include "xios_spl.hpp" 
     6#include "mpi_std.hpp" 
    67#include "field.hpp" 
    78#include "data_output.hpp" 
     
    1112#include "attribute_enum.hpp" 
    1213#include "attribute_enum_impl.hpp" 
    13 #include "mpi.hpp" 
    14 #ifdef _usingEP 
    15 #include "ep_declaration.hpp" 
    16 #endif 
    1714 
    1815namespace xios { 
     
    110107         void buildFilterGraphOfEnabledFields(CGarbageCollector& gc); 
    111108         void prefetchEnabledReadModeFields(); 
    112          void prefetchEnabledReadModeFieldsIfNeeded(); 
     109         void doPostTimestepOperationsForEnabledReadModeFields(); 
    113110 
    114111         // Add component into file 
  • XIOS/dev/branch_openmp/src/node/generate_rectilinear_domain.hpp

    r1134 r1328  
    6060      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CGenerateRectilinearDomain 
    6463 
  • XIOS/dev/branch_openmp/src/node/grid.cpp

    r1205 r1328  
    11141114          outLocalIndexToServer(idx) = itIndex->second; 
    11151115        } 
    1116  
     1116         
    11171117        const std::list<int>& ranks = client->getRanksServerLeader(); 
    11181118        for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     
    17501750        pDom->solveRefInheritance(apply); 
    17511751        pDom->solveInheritanceTransformation(); 
     1752        //cout<<"pDom check"<<endl; 
    17521753      } 
    17531754    } 
  • XIOS/dev/branch_openmp/src/node/interpolate_axis.hpp

    r1134 r1328  
    6262      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
    6363      static bool _dummyRegistered; 
    64       #pragma omp threadprivate(_dummyRegistered) 
    65        
    6664  }; // class CInterpolateAxis 
    6765 
  • XIOS/dev/branch_openmp/src/node/interpolate_domain.hpp

    r1134 r1328  
    6060      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CInterpolateDomain 
    6463 
  • XIOS/dev/branch_openmp/src/node/inverse_axis.hpp

    r1134 r1328  
    5959      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
    6060      static bool _dummyRegistered; 
    61       #pragma omp threadprivate(_dummyRegistered) 
    6261 
    6362  }; // class CInverseAxis 
  • XIOS/dev/branch_openmp/src/node/mesh.cpp

    r1134 r1328  
    66 
    77#include "mesh.hpp" 
     8using namespace ep_lib; 
    89 
    910namespace xios { 
     
    3132  } 
    3233 
    33   std::map <StdString, CMesh> CMesh::meshList = std::map <StdString, CMesh>(); 
    34   std::map <StdString, vector<int> > CMesh::domainList = std::map <StdString, vector<int> >(); 
     34  //std::map <StdString, CMesh> CMesh::meshList = std::map <StdString, CMesh>(); 
     35  //std::map <StdString, vector<int> > CMesh::domainList = std::map <StdString, vector<int> >(); 
    3536 
    3637  std::map <StdString, CMesh> *CMesh::meshList_ptr = 0; 
    3738  std::map <StdString, vector<int> > *CMesh::domainList_ptr = 0; 
    38  
    3939 
    4040///--------------------------------------------------------------- 
     
    4545 * \param [in] nvertex Number of verteces (1 for nodes, 2 for edges, 3 and up for faces). 
    4646 */ 
    47  
    48 /* bkp 
    49   CMesh* CMesh::getMesh (StdString meshName, int nvertex) 
    50   { 
    51     CMesh::domainList[meshName].push_back(nvertex); 
    52  
    53     if ( CMesh::meshList.begin() != CMesh::meshList.end() ) 
    54     { 
    55       for (std::map<StdString, CMesh>::iterator it=CMesh::meshList.begin(); it!=CMesh::meshList.end(); ++it) 
    56       { 
    57         if (it->first == meshName) 
    58           return &meshList[meshName]; 
    59         else 
    60         { 
    61           CMesh newMesh; 
    62           CMesh::meshList.insert( make_pair(meshName, newMesh) ); 
    63           return &meshList[meshName]; 
    64         } 
    65       } 
    66     } 
    67     else 
    68     { 
    69       CMesh newMesh; 
    70       CMesh::meshList.insert( make_pair(meshName, newMesh) ); 
    71       return &meshList[meshName]; 
    72     } 
    73   } 
    74 */ 
    75  
    7647  CMesh* CMesh::getMesh (StdString meshName, int nvertex) 
    7748  { 
     
    7950    if(CMesh::meshList_ptr == NULL)   CMesh::meshList_ptr   = new std::map <StdString, CMesh>(); 
    8051 
    81     (*CMesh::domainList_ptr)[meshName].push_back(nvertex); 
    82  
    83     if ( (*CMesh::meshList_ptr).begin() != (*CMesh::meshList_ptr).end() ) 
    84     { 
    85       for (std::map<StdString, CMesh>::iterator it=(*CMesh::meshList_ptr).begin(); it!=(*CMesh::meshList_ptr).end(); ++it) 
     52    //CMesh::domainList[meshName].push_back(nvertex); 
     53    CMesh::domainList_ptr->at(meshName).push_back(nvertex); 
     54 
     55    //if ( CMesh::meshList.begin() != CMesh::meshList.end() ) 
     56    if ( CMesh::meshList_ptr->begin() != CMesh::meshList_ptr->end() ) 
     57    { 
     58      //for (std::map<StdString, CMesh>::iterator it=CMesh::meshList.begin(); it!=CMesh::meshList.end(); ++it) 
     59      for (std::map<StdString, CMesh>::iterator it=CMesh::meshList_ptr->begin(); it!=CMesh::meshList_ptr->end(); ++it) 
    8660      { 
    8761        if (it->first == meshName) 
    88           return &((*CMesh::meshList_ptr)[meshName]); 
     62          //return &meshList[meshName]; 
     63          return &meshList_ptr->at(meshName); 
    8964        else 
    9065        { 
    9166          CMesh newMesh; 
    92           (*CMesh::meshList_ptr).insert( make_pair(meshName, newMesh) ); 
    93           return &((*CMesh::meshList_ptr)[meshName]); 
     67          //CMesh::meshList.insert( make_pair(meshName, newMesh) ); 
     68          CMesh::meshList_ptr->insert( make_pair(meshName, newMesh) ); 
     69          //return &meshList[meshName]; 
     70          return &meshList_ptr->at(meshName); 
    9471        } 
    9572      } 
     
    9875    { 
    9976      CMesh newMesh; 
    100       (*CMesh::meshList_ptr).insert( make_pair(meshName, newMesh) ); 
    101       return &((*CMesh::meshList_ptr)[meshName]); 
     77      //CMesh::meshList.insert( make_pair(meshName, newMesh) ); 
     78      CMesh::meshList_ptr->insert( make_pair(meshName, newMesh) ); 
     79      //return &meshList[meshName]; 
     80      return &meshList_ptr->at(meshName); 
    10281    } 
    10382  } 
     
    524503 * \param [in] bounds_lat Array of boundary latitudes. Its size depends on the element type. 
    525504 */ 
    526   void CMesh::createMeshEpsilon(const ep_lib::MPI_Comm& comm, 
     505  void CMesh::createMeshEpsilon(const MPI_Comm& comm, 
    527506                                const CArray<double, 1>& lonvalue, const CArray<double, 1>& latvalue, 
    528507                                const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat) 
     
    17241703   */ 
    17251704 
    1726   void CMesh::getGloNghbFacesNodeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx, 
     1705  void CMesh::getGloNghbFacesNodeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx, 
    17271706                               const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
    17281707                               CArray<int, 2>& nghbFaces) 
     
    18801859   */ 
    18811860 
    1882   void CMesh::getGloNghbFacesEdgeType(const ep_lib::MPI_Comm& comm, const CArray<int, 1>& face_idx, 
     1861  void CMesh::getGloNghbFacesEdgeType(const MPI_Comm& comm, const CArray<int, 1>& face_idx, 
    18831862                               const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
    18841863                               CArray<int, 2>& nghbFaces) 
     
    20612040   */ 
    20622041 
    2063   void CMesh::getGlobalNghbFaces(const int nghbType, const ep_lib::MPI_Comm& comm, 
     2042  void CMesh::getGlobalNghbFaces(const int nghbType, const MPI_Comm& comm, 
    20642043                                 const CArray<int, 1>& face_idx, 
    20652044                                 const CArray<double, 2>& bounds_lon, const CArray<double, 2>& bounds_lat, 
  • XIOS/dev/branch_openmp/src/node/mesh.hpp

    r1134 r1328  
    8080      int nbFaces_; 
    8181 
    82       static std::map <StdString, CMesh> meshList; 
    83       static std::map <StdString, vector<int> > domainList; 
    84  
     82      //static std::map <StdString, CMesh> meshList; 
    8583      static std::map <StdString, CMesh> *meshList_ptr; 
     84      //static std::map <StdString, vector<int> > domainList; 
    8685      static std::map <StdString, vector<int> > *domainList_ptr; 
    87       #pragma omp threadprivate(meshList_ptr, domainList_ptr) 
    88     
    8986      CClientClientDHTSizet* pNodeGlobalIndex;                    // pointer to a map <nodeHash, nodeIdxGlo> 
    9087      CClientClientDHTSizet* pEdgeGlobalIndex;                    // pointer to a map <edgeHash, edgeIdxGlo> 
  • XIOS/dev/branch_openmp/src/node/reduce_axis_to_scalar.hpp

    r1134 r1328  
    5959      static CTransformation<CScalar>* create(const StdString& id, xml::CXMLNode* node); 
    6060      static bool _dummyRegistered; 
    61       #pragma omp threadprivate(_dummyRegistered) 
    6261  }; // class CReduceAxisToScalar 
    6362 
  • XIOS/dev/branch_openmp/src/node/reduce_domain_to_axis.hpp

    r1134 r1328  
    6060      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CReduceDomainToAxis 
    6463 
  • XIOS/dev/branch_openmp/src/node/reduce_domain_to_scalar.hpp

    r1134 r1328  
    6060      static CTransformation<CScalar>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CReduceDomainToScalar 
    6463 
  • XIOS/dev/branch_openmp/src/node/scalar.cpp

    r1134 r1328  
    2828 
    2929   //std::map<StdString, ETranformationType> CScalar::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     30   std::map<StdString, ETranformationType> *CScalar::transformationMapList_ptr = 0; 
    3031   //bool CScalar::dummyTransformationMapList_ = CScalar::initializeTransformationMap(CScalar::transformationMapList_); 
    31  
    32    std::map<StdString, ETranformationType> *CScalar::transformationMapList_ptr = 0; 
    33     
    3432   bool CScalar::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
    3533   { 
     
    175173 
    176174        nodeElementName = node.getElementName(); 
     175        //std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_.end(), it; 
    177176        if(CScalar::transformationMapList_ptr == 0) initializeTransformationMap(); 
    178         std::map<StdString, ETranformationType>::const_iterator ite = (*CScalar::transformationMapList_ptr).end(), it; 
    179         it = (*CScalar::transformationMapList_ptr).find(nodeElementName); 
     177        std::map<StdString, ETranformationType>::const_iterator ite = transformationMapList_ptr->end(), it; 
     178        //it = transformationMapList_.find(nodeElementName); 
     179        it = transformationMapList_ptr->find(nodeElementName); 
    180180        if (ite != it) 
    181181        { 
  • XIOS/dev/branch_openmp/src/node/scalar.hpp

    r1134 r1328  
    8888           static bool initializeTransformationMap(std::map<StdString, ETranformationType>& m); 
    8989           static bool initializeTransformationMap(); 
    90             
    91            //static bool dummyTransformationMapList_; 
    92  
     90           //static std::map<StdString, ETranformationType> transformationMapList_; 
    9391           static std::map<StdString, ETranformationType> *transformationMapList_ptr; 
    94            #pragma omp threadprivate(transformationMapList_ptr) 
     92           static bool dummyTransformationMapList_; 
    9593 
    9694 
  • XIOS/dev/branch_openmp/src/node/transformation.hpp

    r1138 r1328  
    3535      typedef std::map<ETranformationType, CreateTransformationCallBack> CallBackMap; 
    3636      static CallBackMap* transformationCreationCallBacks_; 
    37       //#pragma omp threadprivate(transformationCreationCallBacks_) 
    3837 
    3938      static bool registerTransformation(ETranformationType transType, CreateTransformationCallBack createFn); 
     
    6665    if (0 == transformationCreationCallBacks_) 
    6766      transformationCreationCallBacks_ = new CallBackMap(); 
     67 
    6868    return (*transformationCreationCallBacks_).insert(make_pair(transType, createFn)).second; 
    6969  } 
  • XIOS/dev/branch_openmp/src/node/zoom_axis.hpp

    r1134 r1328  
    6060      static CTransformation<CAxis>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    6362  }; // class CZoomAxis 
    6463 
  • XIOS/dev/branch_openmp/src/node/zoom_domain.hpp

    r1134 r1328  
    6060      static CTransformation<CDomain>* create(const StdString& id, xml::CXMLNode* node); 
    6161      static bool _dummyRegistered; 
    62       #pragma omp threadprivate(_dummyRegistered) 
    63        
    6462  }; // class CZoomDomain 
    6563 
  • XIOS/dev/branch_openmp/src/object_factory.cpp

    r1134 r1328  
    55   /// ////////////////////// Définitions ////////////////////// /// 
    66 
    7    StdString *CObjectFactory::CurrContext_ptr = new StdString; 
     7   StdString CObjectFactory::CurrContext(""); 
    88 
    99   void CObjectFactory::SetCurrentContextId(const StdString & context) 
    10    { 
    11      if(CObjectFactory::CurrContext_ptr == NULL ) CObjectFactory::CurrContext_ptr = new StdString; 
    12      CObjectFactory::CurrContext_ptr->assign(context);  
    13    } 
     10   { CObjectFactory::CurrContext = context; } 
    1411 
    1512   StdString & CObjectFactory::GetCurrentContextId(void) 
    16    {  
    17      return (*CObjectFactory::CurrContext_ptr);  
    18    } 
     13   { return (CObjectFactory::CurrContext); } 
    1914 
    2015} // namespace xios 
  • XIOS/dev/branch_openmp/src/object_factory.hpp

    r1134 r1328  
    5959 
    6060         /// Propriétés statiques /// 
    61          static StdString *CurrContext_ptr; 
    62          #pragma omp threadprivate(CurrContext_ptr) 
     61         static StdString CurrContext; 
    6362 
    6463   }; // class CObjectFactory 
  • XIOS/dev/branch_openmp/src/object_factory_decl.cpp

    r1287 r1328  
    55{ 
    66#define macro(U) \ 
    7   template boost::shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& id);  \ 
    8   template boost::shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& context,const StdString& id); \ 
    9   template boost::shared_ptr<U> CObjectFactory::GetObject<U>(const U* const object); \ 
     7  template shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& id);  \ 
     8  template shared_ptr<U> CObjectFactory::GetObject<U>(const StdString& context,const StdString& id); \ 
     9  template shared_ptr<U> CObjectFactory::GetObject<U>(const U* const object); \ 
    1010  template int CObjectFactory::GetObjectNum<U>(void); \ 
    1111  template int CObjectFactory::GetObjectIdNum<U>(void); \ 
    12   template const std::vector<boost::shared_ptr<U> >& CObjectFactory::GetObjectVector<U>(const StdString& context ); \ 
     12  template const std::vector<shared_ptr<U> >& CObjectFactory::GetObjectVector<U>(const StdString& context ); \ 
    1313  template bool CObjectFactory::HasObject<U>(const StdString& id); \ 
    1414  template bool CObjectFactory::HasObject<U>(const StdString& context,const StdString& id); \ 
  • XIOS/dev/branch_openmp/src/object_factory_impl.hpp

    r1134 r1328  
    66namespace xios 
    77{ 
    8    /// ////////////////////// Définitions ////////////////////// /// 
     8   /// ////////////////////// Dfinitions ////////////////////// /// 
    99   template <typename U> 
    1010       int CObjectFactory::GetObjectNum(void) 
    1111   { 
    12       if (CurrContext_ptr->size() == 0) 
     12      if (CurrContext.size() == 0) 
    1313         ERROR("CObjectFactory::GetObjectNum(void)", 
    1414               << "please define current context id !"); 
    15  
    16       if(U::AllVectObj == NULL) return 0; 
    17        
    18        
    19       return (*U::AllVectObj)[*CObjectFactory::CurrContext_ptr].size(); 
     15      //return (U::AllVectObj[CObjectFactory::CurrContext].size()); 
     16      if(U::AllVectObj_ptr == NULL) return 0; 
     17      return (*U::AllVectObj_ptr)[CObjectFactory::CurrContext].size(); 
    2018   } 
    2119 
     
    2321      int CObjectFactory::GetObjectIdNum(void) 
    2422   { 
    25       if (CurrContext_ptr->size() == 0) 
     23      if (CurrContext.size() == 0) 
    2624         ERROR("CObjectFactory::GetObjectIdNum(void)", 
    2725               << "please define current context id !"); 
    28       if(U::AllMapObj  == NULL) return 0; 
    29  
    30        
    31  
    32       return (* U::AllMapObj) [*CObjectFactory::CurrContext_ptr].size(); 
     26      //return (U::AllMapObj[CObjectFactory::CurrContext].size()); 
     27      if(U::AllMapObj_ptr == NULL) return 0; 
     28      return (*U::AllMapObj_ptr)[CObjectFactory::CurrContext].size(); 
    3329   } 
    3430 
     
    3632      bool CObjectFactory::HasObject(const StdString & id) 
    3733   { 
    38       if (CurrContext_ptr->size() == 0) 
     34      if (CurrContext.size() == 0) 
    3935         ERROR("CObjectFactory::HasObject(const StdString & id)", 
    4036               << "[ id = " << id << " ] please define current context id !"); 
    41        
    42       if(U::AllMapObj  == NULL)  return false; 
     37      //return (U::AllMapObj[CObjectFactory::CurrContext].find(id) != 
     38      //        U::AllMapObj[CObjectFactory::CurrContext].end()); 
     39      if(U::AllMapObj_ptr  == NULL)  return false; 
     40      return ((*U::AllMapObj_ptr)[CObjectFactory::CurrContext].find(id) != 
     41              (*U::AllMapObj_ptr)[CObjectFactory::CurrContext].end()); 
    4342 
    44        
    45  
    46       return ((*U::AllMapObj)[*CObjectFactory::CurrContext_ptr].find(id) != 
    47               (*U::AllMapObj)[*CObjectFactory::CurrContext_ptr].end()); 
    4843   } 
    4944 
     
    5146      bool CObjectFactory::HasObject(const StdString & context, const StdString & id) 
    5247   { 
    53       if(U::AllMapObj  == NULL) return false; 
    5448 
    55       if (U::AllMapObj->find(context) == U::AllMapObj->end()) return false ; 
     49      // if (U::AllMapObj.find(context) == U::AllMapObj.end()) return false ; 
     50      // else return (U::AllMapObj[context].find(id) !=  U::AllMapObj[context].end()); 
     51      if(U::AllMapObj_ptr  == NULL) return false; 
    5652 
    57       else 
    58       { 
    59          return ((*U::AllMapObj)[context].find(id) !=  (*U::AllMapObj)[context].end()); 
    60       }  
    61           
     53      if (U::AllMapObj_ptr->find(context) == U::AllMapObj_ptr->end()) return false ; 
     54      else return ((*U::AllMapObj_ptr)[context].find(id) !=  (*U::AllMapObj_ptr)[context].end()); 
    6255   } 
    6356 
     
    6558      boost::shared_ptr<U> CObjectFactory::GetObject(const U * const object) 
    6659   { 
    67       if(U::AllVectObj == NULL) return (boost::shared_ptr<U>()); 
    68     
    69       if (CurrContext_ptr->size() == 0) 
     60      if(U::AllVectObj_ptr == NULL) return (boost::shared_ptr<U>()); 
     61      if (CurrContext.size() == 0) 
    7062         ERROR("CObjectFactory::GetObject(const U * const object)", 
    7163               << "please define current context id !"); 
    72       std::vector<boost::shared_ptr<U> > & vect = 
    73                      (*U::AllVectObj)[*CObjectFactory::CurrContext_ptr]; 
     64      //std::vector<boost::shared_ptr<U> > & vect = U::AllVectObj[CObjectFactory::CurrContext]; 
     65      std::vector<boost::shared_ptr<U> > & vect = (*U::AllVectObj_ptr)[CObjectFactory::CurrContext]; 
    7466 
    7567      typename std::vector<boost::shared_ptr<U> >::const_iterator 
     
    9284      boost::shared_ptr<U> CObjectFactory::GetObject(const StdString & id) 
    9385   { 
    94       if(U::AllMapObj  == NULL) return (boost::shared_ptr<U>()); 
    95  
    96       if (CurrContext_ptr->size() == 0) 
     86      if(U::AllMapObj_ptr  == NULL) return (boost::shared_ptr<U>()); 
     87      if (CurrContext.size() == 0) 
    9788         ERROR("CObjectFactory::GetObject(const StdString & id)", 
    9889               << "[ id = " << id << " ] please define current context id !"); 
     
    10192               << "[ id = " << id << ", U = " << U::GetName() << " ] " 
    10293               << "object was not found."); 
    103       return (*U::AllMapObj)[*CObjectFactory::CurrContext_ptr][id]; 
     94 
     95      //cout<<"CObjectFactory::GetObject(const StdString & id)[ id = " << id << ", U = " << U::GetName() << " ] "<<endl; 
     96      if(id == "src_domain_regular_read") 
     97      { 
     98         //cout<<"match"<<endl; 
     99      } 
     100 
     101      //return (U::AllMapObj[CObjectFactory::CurrContext][id]); 
     102      return (*U::AllMapObj_ptr)[CObjectFactory::CurrContext][id]; 
    104103   } 
    105104 
     
    107106      boost::shared_ptr<U> CObjectFactory::GetObject(const StdString & context, const StdString & id) 
    108107   { 
    109       if(U::AllMapObj  == NULL) return (boost::shared_ptr<U>()); 
     108      if(U::AllMapObj_ptr  == NULL) return (boost::shared_ptr<U>()); 
    110109 
    111110      if (!CObjectFactory::HasObject<U>(context,id)) 
     
    114113               << "object was not found."); 
    115114 
    116       return (*U::AllMapObj)[context][id]; 
     115      //cout<<"CObjectFactory::GetObject(const StdString & context, const StdString & id)[ id = " << id << ", U = " << U::GetName() << " ] "<<endl; 
     116      if(id == "src_domain_regular_read") 
     117      { 
     118         //cout<<"match"<<endl; 
     119         boost::shared_ptr<U> value; 
     120      } 
     121      //return (U::AllMapObj[context][id]); 
     122      return (*U::AllMapObj_ptr)[context][id]; 
    117123   } 
    118124 
     
    120126   boost::shared_ptr<U> CObjectFactory::CreateObject(const StdString& id) 
    121127   { 
    122       if(U::AllVectObj == NULL) U::AllVectObj = new xios_map<StdString, std::vector<boost::shared_ptr<U> > >; 
    123       if(U::AllMapObj  == NULL) U::AllMapObj  = new xios_map<StdString, xios_map<StdString, boost::shared_ptr<U> > >; 
     128      if(U::AllVectObj_ptr == NULL) U::AllVectObj_ptr = new xios_map<StdString, std::vector<boost::shared_ptr<U> > >; 
     129      if(U::AllMapObj_ptr  == NULL) U::AllMapObj_ptr  = new xios_map<StdString, xios_map<StdString, boost::shared_ptr<U> > >; 
    124130 
    125        
    126       if (CurrContext_ptr->empty()) 
     131      if (CurrContext.empty()) 
    127132         ERROR("CObjectFactory::CreateObject(const StdString& id)", 
    128133               << "[ id = " << id << " ] please define current context id !"); 
     
    136141         boost::shared_ptr<U> value(new U(id.empty() ? CObjectFactory::GenUId<U>() : id)); 
    137142 
    138          (* U::AllVectObj)[*CObjectFactory::CurrContext_ptr].insert((*U::AllVectObj)[*CObjectFactory::CurrContext_ptr].end(), value); 
    139          (* U::AllMapObj) [*CObjectFactory::CurrContext_ptr].insert(std::make_pair(value->getId(), value)); 
     143         //U::AllVectObj[CObjectFactory::CurrContext].insert(U::AllVectObj[CObjectFactory::CurrContext].end(), value); 
     144         //U::AllMapObj[CObjectFactory::CurrContext].insert(std::make_pair(value->getId(), value)); 
     145 
     146         (*U::AllVectObj_ptr)[CObjectFactory::CurrContext].insert((*U::AllVectObj_ptr)[CObjectFactory::CurrContext].end(), value); 
     147         (*U::AllMapObj_ptr) [CObjectFactory::CurrContext].insert(std::make_pair(value->getId(), value)); 
     148         //cout<<"CObjectFactory::CreateObject(const StdString& id) [ id = " << id << " ]" <<endl; 
    140149 
    141150         return value; 
     
    147156         CObjectFactory::GetObjectVector(const StdString & context) 
    148157   { 
    149       if(U::AllVectObj != NULL)  
    150        
    151       return (*U::AllVectObj)[context]; 
     158      //return (U::AllVectObj[context]); 
     159      return (*U::AllVectObj_ptr)[context]; 
    152160   } 
    153161 
     
    163171   { 
    164172      StdOStringStream oss; 
    165       if(U::GenId == NULL) U::GenId = new xios_map< StdString, long int >; 
    166       oss << GetUIdBase<U>() << (*U::GenId)[*CObjectFactory::CurrContext_ptr]++; 
     173      if(U::GenId_ptr == NULL) U::GenId_ptr = new xios_map< StdString, long int >; 
     174      oss << GetUIdBase<U>() << (*U::GenId_ptr)[CObjectFactory::CurrContext]++; 
    167175      return oss.str(); 
    168176   } 
  • XIOS/dev/branch_openmp/src/object_template.hpp

    r1287 r1328  
    7777         static T* get(const string& contextId, const string& id) ; 
    7878         T* get(void) ; 
    79          boost::shared_ptr<T> getShared(void) ; 
    80          static boost::shared_ptr<T> getShared(const T* ptr) ; 
     79         shared_ptr<T> getShared(void) ; 
     80         static shared_ptr<T> getShared(const T* ptr) ; 
    8181 
    8282         static T* create(const string& id=string("")) ; 
     
    100100 
    101101         /// Propriétés statiques /// 
    102          // bkp 
    103          // static xios_map<StdString, 
    104          //        xios_map<StdString, 
    105          //        boost::shared_ptr<DerivedType> > > AllMapObj; 
    106          // static xios_map<StdString, 
    107          //        std::vector<boost::shared_ptr<DerivedType> > > AllVectObj; 
     102         static xios_map<StdString, 
     103                xios_map<StdString, 
     104                boost::shared_ptr<DerivedType> > > *AllMapObj_ptr; 
     105         static xios_map<StdString, 
     106                std::vector<boost::shared_ptr<DerivedType> > > *AllVectObj_ptr; 
    108107 
    109          // static xios_map< StdString, long int > GenId ; 
    110  
    111  
    112          static xios_map<StdString, xios_map<StdString, boost::shared_ptr<DerivedType> > > *AllMapObj; 
    113          static xios_map<StdString, std::vector<boost::shared_ptr<DerivedType> > > *AllVectObj; 
    114          static xios_map< StdString, long int > *GenId; 
    115          #pragma omp threadprivate(AllMapObj, AllVectObj, GenId) 
     108         static xios_map< StdString, long int > *GenId_ptr ; 
    116109 
    117110   }; // class CObjectTemplate 
  • XIOS/dev/branch_openmp/src/object_template_impl.hpp

    r1287 r1328  
    2424      xios_map<StdString, 
    2525      xios_map<StdString, 
    26       boost::shared_ptr<T> > > *CObjectTemplate<T>::AllMapObj = 0; 
     26      //boost::shared_ptr<T> > > CObjectTemplate<T>::AllMapObj; 
     27      boost::shared_ptr<T> > > *CObjectTemplate<T>::AllMapObj_ptr = 0; 
    2728 
    2829   template <class T> 
    2930      xios_map<StdString, 
    30       std::vector<boost::shared_ptr<T> > > *CObjectTemplate<T>::AllVectObj = 0; 
    31  
    32    template <class T> 
    33       xios_map<StdString,long int> *CObjectTemplate<T>::GenId = 0; 
     31      //std::vector<boost::shared_ptr<T> > > CObjectTemplate<T>::AllVectObj; 
     32      std::vector<boost::shared_ptr<T> > > *CObjectTemplate<T>::AllVectObj_ptr = 0; 
     33 
     34   template <class T> 
     35      //xios_map<StdString,long int> CObjectTemplate<T>::GenId; 
     36      xios_map<StdString,long int> *CObjectTemplate<T>::GenId_ptr = 0; 
    3437 
    3538   template <class T> 
     
    6669         CObjectTemplate<T>::GetAllVectobject(const StdString & contextId) 
    6770   { 
    68       return (CObjectTemplate<T>::AllVectObj->at(contextId)); 
     71      //return (CObjectTemplate<T>::AllVectObj[contextId]); 
     72    return (CObjectTemplate<T>::AllVectObj_ptr->at(contextId)); 
    6973   } 
    7074 
     
    321325 
    322326   template <typename T> 
    323    boost::shared_ptr<T> CObjectTemplate<T>::getShared(const T* ptr) 
     327   shared_ptr<T> CObjectTemplate<T>::getShared(const T* ptr) 
    324328   { 
    325329     return CObjectFactory::GetObject<T>(ptr); 
     
    327331 
    328332   template <typename T> 
    329    boost::shared_ptr<T> CObjectTemplate<T>::getShared(void) 
     333   shared_ptr<T> CObjectTemplate<T>::getShared(void) 
    330334   { 
    331335     return CObjectFactory::GetObject<T>((T*)this); 
     
    335339   const vector<T*> CObjectTemplate<T>::getAll() 
    336340   { 
    337      const vector< boost::shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>(); 
     341     const vector< shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>(); 
    338342     vector<T*> vect; 
    339343 
    340      typename vector<boost::shared_ptr<T> >::const_iterator it; 
     344     typename vector<shared_ptr<T> >::const_iterator it; 
    341345     for(it=shared_vect.begin();it!=shared_vect.end();++it) vect.push_back(it->get()); 
    342346     return vect; 
     
    346350   const vector<T*> CObjectTemplate<T>::getAll(const string & id) 
    347351   {