Changeset 987


Ignore:
Timestamp:
11/10/16 13:29:57 (7 years ago)
Author:
mhnguyen
Message:

First working version.
There are more things to do with it

Location:
XIOS/dev/dev_olga
Files:
2 added
16 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/dev_olga/inputs/iodef.xml

    r983 r987  
    66 
    77 
    8    <field_definition level="1" enabled=".FALSE."> 
     8   <field_definition level="1" enabled=".TRUE."> 
    99     <field id="field_A"  operation="average" freq_op="3600s" grid_ref="grid_A"/> 
    1010     <field id="field_A_zoom"  operation="average" freq_op="3600s" field_ref="field_A" grid_ref="grid_A_zoom"/> 
    … …  
    1212 
    1313 
    14    <file_definition type="multiple_file" par_access="collective" output_freq="6h" output_level="10" enabled=".TRUE."> 
     14   <file_definition type="one_file" par_access="collective" output_freq="1h" output_level="10" enabled=".TRUE."> 
    1515     <file id="output" name="output"> 
    1616        <field field_ref="field_A" name="field_A" /> 

  • XIOS/dev/dev_olga/src/group_template_impl.hpp

    r595 r987  
    373373   void CGroupTemplate<U, V, W>::sendCreateChild(const string& id) 
    374374   { 
    375     CContext* context=CContext::getCurrent() ; 
    376      
    377     if (! context->hasServer ) 
     375    CContext* context=CContext::getCurrent() ;   
     376 
     377    if (context->hasClient) 
     378    // if (!context->hasServer ) 
    378379    { 
    379        CContextClient* client=context->client ; 
     380      // Use correct context client to send message 
     381       CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer : context->client; 
    380382 
    381383       CEventClient event(this->getType(),EVENT_ID_CREATE_CHILD) ;    
    382        if (client->isServerLeader()) 
     384       if (contextClientTmp->isServerLeader()) 
    383385       { 
    384386         CMessage msg ; 
    385387         msg<<this->getId() ; 
    386388         msg<<id ; 
    387          const std::list<int>& ranks = client->getRanksServerLeader(); 
     389         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    388390         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    389391           event.push(*itRank,1,msg) ; 
    390          client->sendEvent(event) ; 
     392         contextClientTmp->sendEvent(event) ; 
    391393       } 
    392        else client->sendEvent(event) ; 
     394       else contextClientTmp->sendEvent(event) ; 
    393395    } 
     396 
     397    // if (! context->hasServer ) 
     398    // { 
     399    //    CContextClient* client=context->client ; 
     400 
     401    //    CEventClient event(this->getType(),EVENT_ID_CREATE_CHILD) ;    
     402    //    if (client->isServerLeader()) 
     403    //    { 
     404    //      CMessage msg ; 
     405    //      msg<<this->getId() ; 
     406    //      msg<<id ; 
     407    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     408    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     409    //        event.push(*itRank,1,msg) ; 
     410    //      client->sendEvent(event) ; 
     411    //    } 
     412    //    else client->sendEvent(event) ; 
     413    // } 
    394414       
    395415   } 
    … …  
    399419   { 
    400420    CContext* context=CContext::getCurrent() ; 
    401     if (! context->hasServer ) 
     421 
     422        // if (! context->hasServer ) 
     423    if (context->hasClient) 
    402424    { 
    403        CContextClient* client=context->client ; 
     425        // Use correct context client to send message 
     426       CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer : context->client; 
    404427 
    405428       CEventClient event(this->getType(),EVENT_ID_CREATE_CHILD_GROUP) ;    
    406        if (client->isServerLeader()) 
     429       if (contextClientTmp->isServerLeader()) 
    407430       { 
    408431         CMessage msg ; 
    409432         msg<<this->getId() ; 
    410433         msg<<id ; 
    411          const std::list<int>& ranks = client->getRanksServerLeader(); 
     434         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    412435         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    413436           event.push(*itRank,1,msg) ; 
    414          client->sendEvent(event) ; 
     437         contextClientTmp->sendEvent(event) ; 
    415438       } 
    416        else client->sendEvent(event) ; 
     439       else contextClientTmp->sendEvent(event) ; 
    417440    } 
     441 
     442    // if (! context->hasServer ) 
     443    // { 
     444    //    CContextClient* client=context->client ; 
     445 
     446    //    CEventClient event(this->getType(),EVENT_ID_CREATE_CHILD_GROUP) ;    
     447    //    if (client->isServerLeader()) 
     448    //    { 
     449    //      CMessage msg ; 
     450    //      msg<<this->getId() ; 
     451    //      msg<<id ; 
     452    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     453    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     454    //        event.push(*itRank,1,msg) ; 
     455    //      client->sendEvent(event) ; 
     456    //    } 
     457    //    else client->sendEvent(event) ; 
     458    // } 
    418459       
    419460   } 

  • XIOS/dev/dev_olga/src/node/axis.cpp

    r970 r987  
    845845  } 
    846846 
     847  // void CAxis::sendServerAttribut(const std::vector<int>& globalDim, int orderPositionInGrid, 
     848  //                                CServerDistributionDescription::ServerDistributionType distType) 
     849  // { 
     850  //   CContext* context = CContext::getCurrent(); 
     851  //   CContextClient* client = context->client; 
     852  //   int nbServer = client->serverSize; 
     853 
     854  //   CServerDistributionDescription serverDescription(globalDim, nbServer); 
     855  //   serverDescription.computeServerDistribution(); 
     856 
     857  //   std::vector<std::vector<int> > serverIndexBegin = serverDescription.getServerIndexBegin(); 
     858  //   std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes(); 
     859 
     860  //   CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT); 
     861  //   if (client->isServerLeader()) 
     862  //   { 
     863  //     std::list<CMessage> msgs; 
     864 
     865  //     const std::list<int>& ranks = client->getRanksServerLeader(); 
     866  //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     867  //     { 
     868  //       // Use const int to ensure CMessage holds a copy of the value instead of just a reference 
     869  //       const int begin = serverIndexBegin[*itRank][orderPositionInGrid]; 
     870  //       const int ni    = serverDimensionSizes[*itRank][orderPositionInGrid]; 
     871  //       const int end   = begin + ni - 1; 
     872 
     873  //       msgs.push_back(CMessage()); 
     874  //       CMessage& msg = msgs.back(); 
     875  //       msg << this->getId(); 
     876  //       msg << ni << begin << end; 
     877  //       msg << global_zoom_begin.getValue() << global_zoom_n.getValue(); 
     878  //       msg << isCompressible_; 
     879 
     880  //       event.push(*itRank,1,msg); 
     881  //     } 
     882  //     client->sendEvent(event); 
     883  //   } 
     884  //   else client->sendEvent(event); 
     885  // } 
     886 
    847887  void CAxis::sendServerAttribut(const std::vector<int>& globalDim, int orderPositionInGrid, 
    848888                                 CServerDistributionDescription::ServerDistributionType distType) 
    849889  { 
    850890    CContext* context = CContext::getCurrent(); 
    851     CContextClient* client = context->client; 
    852     int nbServer = client->serverSize; 
     891 
     892    CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer  
     893                                                                        : context->client; 
     894 
     895     
     896    int nbServer = contextClientTmp->serverSize; 
    853897 
    854898    CServerDistributionDescription serverDescription(globalDim, nbServer); 
    … …  
    858902    std::vector<std::vector<int> > serverDimensionSizes = serverDescription.getServerDimensionSizes(); 
    859903 
     904    globalDimGrid.resize(globalDim.size()); 
     905    for (int idx = 0; idx < globalDim.size(); ++idx) globalDimGrid(idx) = globalDim[idx]; 
     906 
    860907    CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT); 
    861     if (client->isServerLeader()) 
     908    if (contextClientTmp->isServerLeader()) 
    862909    { 
    863910      std::list<CMessage> msgs; 
    864911 
    865       const std::list<int>& ranks = client->getRanksServerLeader(); 
     912      const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    866913      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    867914      { 
    … …  
    877924        msg << global_zoom_begin.getValue() << global_zoom_n.getValue(); 
    878925        msg << isCompressible_; 
     926        msg << orderPositionInGrid; 
     927        msg << globalDimGrid; 
    879928 
    880929        event.push(*itRank,1,msg); 
    881930      } 
    882       client->sendEvent(event); 
    883     } 
    884     else client->sendEvent(event); 
     931      contextClientTmp->sendEvent(event); 
     932    } 
     933    else contextClientTmp->sendEvent(event); 
    885934  } 
    886935 
    … …  
    891940    *buffer >> axisId; 
    892941    get(axisId)->recvServerAttribut(*buffer); 
     942 
     943    CContext* context = CContext::getCurrent(); 
     944    if (context->hasClient && context->hasServer) 
     945    { 
     946      std::vector<int> globalDim(get(axisId)->globalDimGrid.numElements()); 
     947      for (int idx = 0; idx < globalDim.size(); ++idx) globalDim[idx] = get(axisId)->globalDimGrid(idx); 
     948      get(axisId)->sendServerAttribut(globalDim, get(axisId)->orderPosInGrid,  
     949                                      CServerDistributionDescription::BAND_DISTRIBUTION); 
     950    } 
    893951  } 
    894952 
    … …  
    900958    buffer >> global_zoom_begin_tmp >> global_zoom_n_tmp; 
    901959    buffer >> isCompressible_; 
     960    buffer >> orderPosInGrid; 
     961    buffer >> globalDimGrid; 
     962 
    902963    global_zoom_begin = global_zoom_begin_tmp; 
    903964    global_zoom_n  = global_zoom_n_tmp; 

  • XIOS/dev/dev_olga/src/node/axis.hpp

    r927 r987  
    3838      , public CAxisAttributes 
    3939   { 
     40               /// typedef /// 
     41         typedef CObjectTemplate<CAxis>   SuperClass; 
     42         typedef CAxisAttributes SuperClassAttribute; 
     43          
     44      public : 
    4045         enum EEventId 
    4146         { 
    … …  
    4651         } ; 
    4752 
    48          /// typedef /// 
    49          typedef CObjectTemplate<CAxis>   SuperClass; 
    50          typedef CAxisAttributes SuperClassAttribute; 
     53 
    5154 
    5255      public : 
    … …  
    124127        CArray<double,2> bound_srv; 
    125128        bool hasValue; 
     129        CArray<int,1> globalDimGrid; 
     130        int orderPosInGrid; 
    126131 
    127132      private: 

  • XIOS/dev/dev_olga/src/node/context.cpp

    r983 r987  
    521521     } 
    522522 
     523    // We have a xml tree on the server side and now, it should be also processed 
     524   // if (hasClient && !hasServer) sendPostProcessing(); 
     525 
    523526//     // Now tell server that it can process all messages from client 
    524527// //    if (hasClient && !hasServer) this->sendCloseDefinition(); 
    525528     if (hasClient) this->sendCloseDefinition(); 
    526  
    527     // We have a xml tree on the server side and now, it should be also processed 
    528 //    if (hasClient && !hasServer) sendPostProcessing(); 
    529529 
    530530    // There are some processings that should be done after all of above. For example: check mask or index 
    … …  
    536536      this->solveAllRefOfEnabledFields(true); 
    537537    } 
     538 
     539 
    538540 
    539541//    // Now tell server that it can process all messages from client 
    … …  
    763765   void CContext::sendCloseDefinition(void) 
    764766   { 
     767     // Use correct context client to send message 
     768     CContextClient* contextClientTmp = (0 != clientPrimServer) ? clientPrimServer : client; 
    765769     CEventClient event(getType(),EVENT_ID_CLOSE_DEFINITION); 
    766      if (!hasServer) 
    767      { 
    768        if (client->isServerLeader()) 
    769        { 
    770          CMessage msg; 
    771          msg<<this->getIdServer(); 
    772          const std::list<int>& ranks = client->getRanksServerLeader(); 
    773          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    774            event.push(*itRank,1,msg); 
    775          client->sendEvent(event); 
    776        } 
    777        else client->sendEvent(event); 
    778      } 
    779      else 
    780      { 
    781        if (clientPrimServer->isServerLeader()) 
    782        { 
    783          CMessage msg; 
    784          msg<<this->getIdServer(); 
    785          const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
    786          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    787            event.push(*itRank,1,msg); 
    788          clientPrimServer->sendEvent(event); 
    789        } 
    790        else clientPrimServer->sendEvent(event); 
    791  
    792      } 
     770 
     771     if (contextClientTmp->isServerLeader()) 
     772     { 
     773       CMessage msg; 
     774       msg<<this->getIdServer(); 
     775       const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
     776       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     777         event.push(*itRank,1,msg); 
     778       contextClientTmp->sendEvent(event); 
     779     } 
     780     else contextClientTmp->sendEvent(event); 
     781 
     782     // if (!hasServer) 
     783     // { 
     784     //   if (client->isServerLeader()) 
     785     //   { 
     786     //     CMessage msg; 
     787     //     msg<<this->getIdServer(); 
     788     //     const std::list<int>& ranks = client->getRanksServerLeader(); 
     789     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     790     //       event.push(*itRank,1,msg); 
     791     //     client->sendEvent(event); 
     792     //   } 
     793     //   else client->sendEvent(event); 
     794     // } 
     795     // else 
     796     // { 
     797     //   if (clientPrimServer->isServerLeader()) 
     798     //   { 
     799     //     CMessage msg; 
     800     //     msg<<this->getIdServer(); 
     801     //     const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
     802     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     803     //       event.push(*itRank,1,msg); 
     804     //     clientPrimServer->sendEvent(event); 
     805     //   } 
     806     //   else clientPrimServer->sendEvent(event); 
     807 
     808     // } 
    793809   } 
    794810 
    … …  
    796812   void CContext::recvCloseDefinition(CEventServer& event) 
    797813   { 
    798  
    799814      CBufferIn* buffer=event.subEvents.begin()->buffer; 
    800815      string id; 
    801816      *buffer>>id; 
    802817      get(id)->closeDefinition(); 
     818      if (get(id)->hasClient && get(id)->hasServer) 
     819      {         
     820        get(id)->sendCloseDefinition(); 
     821      } 
    803822   } 
    804823 
    … …  
    806825   void CContext::sendUpdateCalendar(int step) 
    807826   { 
     827     // Use correct context client to send message 
     828     CContextClient* contextClientTmp = (0 != clientPrimServer) ? clientPrimServer : client; 
    808829     CEventClient event(getType(),EVENT_ID_UPDATE_CALENDAR); 
    809      if (!hasServer) 
    810      { 
    811        if (client->isServerLeader()) 
     830 
     831       if (contextClientTmp->isServerLeader()) 
    812832       { 
    813833         CMessage msg; 
    814834         msg<<this->getIdServer()<<step; 
    815          const std::list<int>& ranks = client->getRanksServerLeader(); 
     835         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    816836         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    817837           event.push(*itRank,1,msg); 
    818          client->sendEvent(event); 
     838         contextClientTmp->sendEvent(event); 
    819839       } 
    820        else client->sendEvent(event); 
    821      } 
    822      else 
    823      { 
    824        if (clientPrimServer->isServerLeader()) 
    825        { 
    826          CMessage msg; 
    827          msg<<this->getIdServer()<<step; 
    828          const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
    829          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    830            event.push(*itRank,1,msg); 
    831          clientPrimServer->sendEvent(event); 
    832        } 
    833        else clientPrimServer->sendEvent(event); 
    834      } 
     840       else contextClientTmp->sendEvent(event); 
     841 
     842     // if (!hasServer) 
     843     // { 
     844     //   if (client->isServerLeader()) 
     845     //   { 
     846     //     CMessage msg; 
     847     //     msg<<this->getIdServer()<<step; 
     848     //     const std::list<int>& ranks = client->getRanksServerLeader(); 
     849     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     850     //       event.push(*itRank,1,msg); 
     851     //     client->sendEvent(event); 
     852     //   } 
     853     //   else client->sendEvent(event); 
     854     // } 
     855     // else 
     856     // { 
     857     //   if (clientPrimServer->isServerLeader()) 
     858     //   { 
     859     //     CMessage msg; 
     860     //     msg<<this->getIdServer()<<step; 
     861     //     const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
     862     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     863     //       event.push(*itRank,1,msg); 
     864     //     clientPrimServer->sendEvent(event); 
     865     //   } 
     866     //   else clientPrimServer->sendEvent(event); 
     867     // } 
    835868   } 
    836869 
    … …  
    850883      buffer>>step; 
    851884      updateCalendar(step); 
     885      if (hasClient && hasServer) 
     886      {         
     887        sendUpdateCalendar(step); 
     888      } 
    852889   } 
    853890 
    … …  
    855892   void CContext::sendCreateFileHeader(void) 
    856893   { 
     894     // Use correct context client to send message 
     895     CContextClient* contextClientTmp = (0 != clientPrimServer) ? clientPrimServer : client; 
    857896     CEventClient event(getType(),EVENT_ID_CREATE_FILE_HEADER); 
    858897 
    859      if (!hasServer) 
    860      { 
    861        if (client->isServerLeader()) 
    862        { 
    863          CMessage msg; 
    864          msg<<this->getIdServer(); 
    865          const std::list<int>& ranks = client->getRanksServerLeader(); 
    866          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    867            event.push(*itRank,1,msg) ; 
    868          client->sendEvent(event); 
    869        } 
    870        else client->sendEvent(event); 
    871      } 
    872      else 
    873      { 
    874        if (clientPrimServer->isServerLeader()) 
    875        { 
    876          CMessage msg; 
    877          msg<<this->getIdServer(); 
    878          const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
    879          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    880            event.push(*itRank,1,msg) ; 
    881          clientPrimServer->sendEvent(event); 
    882        } 
    883        else clientPrimServer->sendEvent(event); 
    884      } 
     898     if (contextClientTmp->isServerLeader()) 
     899     { 
     900       CMessage msg; 
     901       msg<<this->getIdServer(); 
     902       const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
     903       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     904         event.push(*itRank,1,msg) ; 
     905       contextClientTmp->sendEvent(event); 
     906     } 
     907     else contextClientTmp->sendEvent(event); 
     908 
     909     // if (!hasServer) 
     910     // { 
     911     //   if (client->isServerLeader()) 
     912     //   { 
     913     //     CMessage msg; 
     914     //     msg<<this->getIdServer(); 
     915     //     const std::list<int>& ranks = client->getRanksServerLeader(); 
     916     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     917     //       event.push(*itRank,1,msg) ; 
     918     //     client->sendEvent(event); 
     919     //   } 
     920     //   else client->sendEvent(event); 
     921     // } 
     922     // else 
     923     // { 
     924     //   if (clientPrimServer->isServerLeader()) 
     925     //   { 
     926     //     CMessage msg; 
     927     //     msg<<this->getIdServer(); 
     928     //     const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
     929     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     930     //       event.push(*itRank,1,msg) ; 
     931     //     clientPrimServer->sendEvent(event); 
     932     //   } 
     933     //   else clientPrimServer->sendEvent(event); 
     934     // } 
    885935   } 
    886936 
    … …  
    897947   void CContext::recvCreateFileHeader(CBufferIn& buffer) 
    898948   { 
    899       createFileHeader(); 
     949     // The creation of header file should be delegated to server2, for now 
     950      if (hasClient && hasServer) 
     951      {         
     952        sendCreateFileHeader(); 
     953      } 
     954       
     955      if (!hasClient && hasServer)  
     956        createFileHeader(); 
    900957   } 
    901958 
    … …  
    903960   void CContext::sendPostProcessing() 
    904961   { 
    905      if (hasClient) 
    906      { 
    907        if (!hasServer) 
    908        { 
    909          CEventClient event(getType(),EVENT_ID_POST_PROCESS); 
    910          if (client->isServerLeader()) 
    911          { 
    912            CMessage msg; 
    913            msg<<this->getIdServer(); 
    914            const std::list<int>& ranks = client->getRanksServerLeader(); 
    915            for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    916              event.push(*itRank,1,msg); 
    917            client->sendEvent(event); 
    918          } 
    919          else client->sendEvent(event); 
    920        } 
    921        else 
    922        { 
    923          CEventClient event(getType(),EVENT_ID_POST_PROCESS); 
    924          if (clientPrimServer->isServerLeader()) 
    925          { 
    926            CMessage msg; 
    927            msg<<this->getIdServer(); 
    928            const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
    929            for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    930              event.push(*itRank,1,msg); 
    931            clientPrimServer->sendEvent(event); 
    932          } 
    933          else clientPrimServer->sendEvent(event); 
    934        } 
    935      } 
     962      // Use correct context client to send message 
     963     CContextClient* contextClientTmp = (0 != clientPrimServer) ? clientPrimServer : client; 
     964     CEventClient event(getType(),EVENT_ID_POST_PROCESS); 
     965 
     966     if (contextClientTmp->isServerLeader()) 
     967     { 
     968       CMessage msg; 
     969       msg<<this->getIdServer(); 
     970       const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
     971       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     972         event.push(*itRank,1,msg); 
     973       contextClientTmp->sendEvent(event); 
     974     } 
     975     else contextClientTmp->sendEvent(event); 
     976 
     977     // if (hasClient) 
     978     // { 
     979     //   if (!hasServer) 
     980     //   { 
     981     //     CEventClient event(getType(),EVENT_ID_POST_PROCESS); 
     982     //     if (client->isServerLeader()) 
     983     //     { 
     984     //       CMessage msg; 
     985     //       msg<<this->getIdServer(); 
     986     //       const std::list<int>& ranks = client->getRanksServerLeader(); 
     987     //       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     988     //         event.push(*itRank,1,msg); 
     989     //       client->sendEvent(event); 
     990     //     } 
     991     //     else client->sendEvent(event); 
     992     //   } 
     993     //   else 
     994     //   { 
     995     //     CEventClient event(getType(),EVENT_ID_POST_PROCESS); 
     996     //     if (clientPrimServer->isServerLeader()) 
     997     //     { 
     998     //       CMessage msg; 
     999     //       msg<<this->getIdServer(); 
     1000     //       const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
     1001     //       for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1002     //         event.push(*itRank,1,msg); 
     1003     //       clientPrimServer->sendEvent(event); 
     1004     //     } 
     1005     //     else clientPrimServer->sendEvent(event); 
     1006     //   } 
     1007     // } 
    9361008   } 
    9371009 
    … …  
    13881460 
    13891461  void CContext::sendRegistry(void) 
    1390   { 
     1462  {     
    13911463    registryOut->hierarchicalGatherRegistry() ; 
    13921464 
     1465          // Use correct context client to send message 
     1466     CContextClient* contextClientTmp = (0 != clientPrimServer) ? clientPrimServer : client; 
    13931467    CEventClient event(CContext::GetType(), CContext::EVENT_ID_SEND_REGISTRY); 
    1394     if (!hasServer) 
    1395     { 
    1396       if (client->isServerLeader()) 
     1468          if (contextClientTmp->isServerLeader()) 
    13971469      { 
    13981470         CMessage msg ; 
    13991471         msg<<this->getIdServer(); 
    1400          if (client->clientRank==0) msg<<*registryOut ; 
     1472         if (contextClientTmp->clientRank==0) msg<<*registryOut ; 
    14011473         const std::list<int>& ranks = client->getRanksServerLeader(); 
    14021474         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    14031475           event.push(*itRank,1,msg); 
    1404          client->sendEvent(event); 
     1476         contextClientTmp->sendEvent(event); 
    14051477       } 
    1406        else client->sendEvent(event); 
    1407     } 
    1408     else 
    1409     { 
    1410       if (clientPrimServer->isServerLeader()) 
    1411       { 
    1412          CMessage msg ; 
    1413          msg<<this->getIdServer(); 
    1414          if (clientPrimServer->clientRank==0) msg<<*registryOut ; 
    1415          const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
    1416          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1417            event.push(*itRank,1,msg); 
    1418          clientPrimServer->sendEvent(event); 
    1419        } 
    1420        else clientPrimServer->sendEvent(event); 
    1421  
    1422     } 
     1478       else contextClientTmp->sendEvent(event); 
     1479 
     1480    // if (!hasServer) 
     1481    // { 
     1482    //   if (client->isServerLeader()) 
     1483    //   { 
     1484    //      CMessage msg ; 
     1485    //      msg<<this->getIdServer(); 
     1486    //      if (client->clientRank==0) msg<<*registryOut ; 
     1487    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1488    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1489    //        event.push(*itRank,1,msg); 
     1490    //      client->sendEvent(event); 
     1491    //    } 
     1492    //    else client->sendEvent(event); 
     1493    // } 
     1494    // else 
     1495    // { 
     1496    //   if (clientPrimServer->isServerLeader()) 
     1497    //   { 
     1498    //      CMessage msg ; 
     1499    //      msg<<this->getIdServer(); 
     1500    //      if (clientPrimServer->clientRank==0) msg<<*registryOut ; 
     1501    //      const std::list<int>& ranks = clientPrimServer->getRanksServerLeader(); 
     1502    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1503    //        event.push(*itRank,1,msg); 
     1504    //      clientPrimServer->sendEvent(event); 
     1505    //    } 
     1506    //    else clientPrimServer->sendEvent(event); 
     1507    // } 
    14231508  } 
    14241509 

  • XIOS/dev/dev_olga/src/node/domain.cpp

    r975 r987  
    13951395  { 
    13961396    CContext* context = CContext::getCurrent(); 
    1397     CContextClient* client = context->client; 
    1398     int nbServer = client->serverSize; 
     1397     // Use correct context client to send message 
     1398     CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer  
     1399                                                                         : context->client; 
     1400 
     1401    // CContextClient* client = context->client; 
     1402    int nbServer = contextClientTmp->serverSize; 
    13991403 
    14001404    CServerDistributionDescription serverDescription(nGlobDomain_, nbServer); 
    … …  
    14061410 
    14071411    CEventClient event(getType(),EVENT_ID_SERVER_ATTRIBUT); 
    1408     if (client->isServerLeader()) 
     1412    if (contextClientTmp->isServerLeader()) 
    14091413    { 
    14101414      std::list<CMessage> msgs; 
    14111415 
    1412       const std::list<int>& ranks = client->getRanksServerLeader(); 
     1416      const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    14131417      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    14141418      { 
    … …  
    14301434        event.push(*itRank,1,msg); 
    14311435      } 
    1432       client->sendEvent(event); 
    1433     } 
    1434     else client->sendEvent(event); 
     1436      contextClientTmp->sendEvent(event); 
     1437    } 
     1438    else contextClientTmp->sendEvent(event); 
    14351439  } 
    14361440 
    … …  
    18521856    *buffer>>domainId ; 
    18531857    get(domainId)->recvServerAttribut(*buffer) ; 
     1858     
     1859    CContext* context = CContext::getCurrent(); 
     1860    if (context->hasClient && context->hasServer) 
     1861    { 
     1862      get(domainId)->sendServerAttribut(); 
     1863    } 
     1864 
    18541865  } 
    18551866 

  • XIOS/dev/dev_olga/src/node/domain.hpp

    r953 r987  
    4242      , public CDomainAttributes 
    4343   { 
    44  
     44               /// typedef /// 
     45         typedef CObjectTemplate<CDomain>   SuperClass; 
     46         typedef CDomainAttributes SuperClassAttribute; 
     47          
     48      public : 
    4549         enum EEventId 
    4650         { 
    … …  
    4852         } ; 
    4953 
    50          /// typedef /// 
    51          typedef CObjectTemplate<CDomain>   SuperClass; 
    52          typedef CDomainAttributes SuperClassAttribute; 
     54 
    5355 
    5456      public: 

  • XIOS/dev/dev_olga/src/node/field.cpp

    r983 r987  
    12511251   void CField::sendAddVariable(const string& id) 
    12521252   { 
    1253     CContext* context = CContext::getCurrent(); 
    1254  
    1255     if (!context->hasServer) 
    1256     { 
    1257        CContextClient* client = context->client; 
    1258  
    1259        CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE); 
    1260        if (client->isServerLeader()) 
    1261        { 
    1262          CMessage msg; 
    1263          msg << this->getId(); 
    1264          msg << id; 
    1265          const std::list<int>& ranks = client->getRanksServerLeader(); 
    1266          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1267            event.push(*itRank,1,msg); 
    1268          client->sendEvent(event); 
    1269        } 
    1270        else client->sendEvent(event); 
    1271     } 
     1253      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE); 
     1254    // CContext* context = CContext::getCurrent(); 
     1255 
     1256    // if (!context->hasServer) 
     1257    // { 
     1258    //    CContextClient* client = context->client; 
     1259 
     1260    //    CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE); 
     1261    //    if (client->isServerLeader()) 
     1262    //    { 
     1263    //      CMessage msg; 
     1264    //      msg << this->getId(); 
     1265    //      msg << id; 
     1266    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1267    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1268    //        event.push(*itRank,1,msg); 
     1269    //      client->sendEvent(event); 
     1270    //    } 
     1271    //    else client->sendEvent(event); 
     1272    // } 
    12721273   } 
    12731274 
    12741275   void CField::sendAddVariableGroup(const string& id) 
    12751276   { 
    1276     CContext* context = CContext::getCurrent(); 
    1277     if (!context->hasServer) 
    1278     { 
    1279        CContextClient* client = context->client; 
    1280  
    1281        CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP); 
    1282        if (client->isServerLeader()) 
    1283        { 
    1284          CMessage msg; 
    1285          msg << this->getId(); 
    1286          msg << id; 
    1287          const std::list<int>& ranks = client->getRanksServerLeader(); 
    1288          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1289            event.push(*itRank,1,msg); 
    1290          client->sendEvent(event); 
    1291        } 
    1292        else client->sendEvent(event); 
    1293     } 
     1277      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP); 
     1278    // CContext* context = CContext::getCurrent(); 
     1279    // if (!context->hasServer) 
     1280    // { 
     1281    //    CContextClient* client = context->client; 
     1282 
     1283    //    CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP); 
     1284    //    if (client->isServerLeader()) 
     1285    //    { 
     1286    //      CMessage msg; 
     1287    //      msg << this->getId(); 
     1288    //      msg << id; 
     1289    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1290    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1291    //        event.push(*itRank,1,msg); 
     1292    //      client->sendEvent(event); 
     1293    //    } 
     1294    //    else client->sendEvent(event); 
     1295    // } 
    12941296   } 
    12951297 

  • XIOS/dev/dev_olga/src/node/file.cpp

    r957 r987  
    826826   void CFile::sendAddField(const string& id) 
    827827   { 
    828     CContext* context = CContext::getCurrent(); 
    829  
    830     if (! context->hasServer ) 
    831     { 
    832        CContextClient* client = context->client; 
    833  
    834        CEventClient event(this->getType(),EVENT_ID_ADD_FIELD); 
    835        if (client->isServerLeader()) 
    836        { 
    837          CMessage msg; 
    838          msg << this->getId(); 
    839          msg << id; 
    840          const std::list<int>& ranks = client->getRanksServerLeader(); 
    841          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    842            event.push(*itRank,1,msg); 
    843          client->sendEvent(event); 
    844        } 
    845        else client->sendEvent(event); 
    846     } 
     828      sendAddItem(id, EVENT_ID_ADD_FIELD); 
     829    // CContext* context = CContext::getCurrent(); 
     830 
     831    // if (! context->hasServer ) 
     832    // { 
     833    //    CContextClient* client = context->client; 
     834 
     835    //    CEventClient event(this->getType(),EVENT_ID_ADD_FIELD); 
     836    //    if (client->isServerLeader()) 
     837    //    { 
     838    //      CMessage msg; 
     839    //      msg << this->getId(); 
     840    //      msg << id; 
     841    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     842    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     843    //        event.push(*itRank,1,msg); 
     844    //      client->sendEvent(event); 
     845    //    } 
     846    //    else client->sendEvent(event); 
     847    // } 
    847848 
    848849   } 
    … …  
    854855   void CFile::sendAddFieldGroup(const string& id) 
    855856   { 
    856     CContext* context = CContext::getCurrent(); 
    857     if (! context->hasServer ) 
    858     { 
    859        CContextClient* client = context->client; 
    860  
    861        CEventClient event(this->getType(),EVENT_ID_ADD_FIELD_GROUP); 
    862        if (client->isServerLeader()) 
    863        { 
    864          CMessage msg; 
    865          msg << this->getId(); 
    866          msg << id; 
    867          const std::list<int>& ranks = client->getRanksServerLeader(); 
    868          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    869            event.push(*itRank,1,msg); 
    870          client->sendEvent(event); 
    871        } 
    872        else client->sendEvent(event); 
    873     } 
     857      sendAddItem(id, (int)EVENT_ID_ADD_FIELD_GROUP); 
     858    // CContext* context = CContext::getCurrent(); 
     859    // if (! context->hasServer ) 
     860    // { 
     861    //    CContextClient* client = context->client; 
     862 
     863    //    CEventClient event(this->getType(),EVENT_ID_ADD_FIELD_GROUP); 
     864    //    if (client->isServerLeader()) 
     865    //    { 
     866    //      CMessage msg; 
     867    //      msg << this->getId(); 
     868    //      msg << id; 
     869    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     870    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     871    //        event.push(*itRank,1,msg); 
     872    //      client->sendEvent(event); 
     873    //    } 
     874    //    else client->sendEvent(event); 
     875    // } 
    874876 
    875877   } 
    … …  
    950952   void CFile::sendAddVariable(const string& id) 
    951953   { 
    952     CContext* context = CContext::getCurrent(); 
    953  
    954     if (! context->hasServer ) 
    955     { 
    956        CContextClient* client = context->client; 
    957  
    958        CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE); 
    959        if (client->isServerLeader()) 
    960        { 
    961          CMessage msg; 
    962          msg << this->getId(); 
    963          msg << id; 
    964          const std::list<int>& ranks = client->getRanksServerLeader(); 
    965          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    966            event.push(*itRank,1,msg); 
    967          client->sendEvent(event); 
    968        } 
    969        else client->sendEvent(event); 
    970     } 
     954      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE); 
     955    // CContext* context = CContext::getCurrent(); 
     956 
     957    // if (! context->hasServer ) 
     958    // { 
     959    //    CContextClient* client = context->client; 
     960 
     961    //    CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE); 
     962    //    if (client->isServerLeader()) 
     963    //    { 
     964    //      CMessage msg; 
     965    //      msg << this->getId(); 
     966    //      msg << id; 
     967    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     968    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     969    //        event.push(*itRank,1,msg); 
     970    //      client->sendEvent(event); 
     971    //    } 
     972    //    else client->sendEvent(event); 
     973    // } 
    971974 
    972975   } 
    … …  
    978981   void CFile::sendAddVariableGroup(const string& id) 
    979982   { 
    980     CContext* context = CContext::getCurrent(); 
    981     if (! context->hasServer ) 
    982     { 
    983        CContextClient* client = context->client; 
    984  
    985        CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP); 
    986        if (client->isServerLeader()) 
    987        { 
    988          CMessage msg; 
    989          msg << this->getId(); 
    990          msg << id; 
    991          const std::list<int>& ranks = client->getRanksServerLeader(); 
    992          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    993            event.push(*itRank,1,msg); 
    994          client->sendEvent(event); 
    995        } 
    996        else client->sendEvent(event); 
    997     } 
     983      sendAddItem(id, (int)EVENT_ID_ADD_VARIABLE_GROUP); 
     984    // CContext* context = CContext::getCurrent(); 
     985    // if (! context->hasServer ) 
     986    // { 
     987    //    CContextClient* client = context->client; 
     988 
     989    //    CEventClient event(this->getType(),EVENT_ID_ADD_VARIABLE_GROUP); 
     990    //    if (client->isServerLeader()) 
     991    //    { 
     992    //      CMessage msg; 
     993    //      msg << this->getId(); 
     994    //      msg << id; 
     995    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     996    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     997    //        event.push(*itRank,1,msg); 
     998    //      client->sendEvent(event); 
     999    //    } 
     1000    //    else client->sendEvent(event); 
     1001    // } 
    9981002 
    9991003   } 

  • XIOS/dev/dev_olga/src/node/grid.cpp

    r983 r987  
    15141514   void CGrid::sendAddDomain(const string& id) 
    15151515   { 
    1516     CContext* context=CContext::getCurrent(); 
    1517  
    1518     if (! context->hasServer ) 
    1519     { 
    1520        CContextClient* client=context->client; 
    1521  
    1522        CEventClient event(this->getType(),EVENT_ID_ADD_DOMAIN); 
    1523        if (client->isServerLeader()) 
    1524        { 
    1525          CMessage msg; 
    1526          msg<<this->getId(); 
    1527          msg<<id; 
    1528          const std::list<int>& ranks = client->getRanksServerLeader(); 
    1529          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1530            event.push(*itRank,1,msg); 
    1531          client->sendEvent(event); 
    1532        } 
    1533        else client->sendEvent(event); 
    1534     } 
     1516      sendAddItem(id, (int)EVENT_ID_ADD_DOMAIN); 
     1517    // CContext* context=CContext::getCurrent(); 
     1518 
     1519    // if (! context->hasServer ) 
     1520    // { 
     1521    //    CContextClient* client=context->client; 
     1522 
     1523    //    CEventClient event(this->getType(),EVENT_ID_ADD_DOMAIN); 
     1524    //    if (client->isServerLeader()) 
     1525    //    { 
     1526    //      CMessage msg; 
     1527    //      msg<<this->getId(); 
     1528    //      msg<<id; 
     1529    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1530    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1531    //        event.push(*itRank,1,msg); 
     1532    //      client->sendEvent(event); 
     1533    //    } 
     1534    //    else client->sendEvent(event); 
     1535    // } 
    15351536   } 
    15361537 
    … …  
    15411542   void CGrid::sendAddAxis(const string& id) 
    15421543   { 
    1543     CContext* context=CContext::getCurrent(); 
    1544  
    1545     if (! context->hasServer ) 
    1546     { 
    1547        CContextClient* client=context->client; 
    1548  
    1549        CEventClient event(this->getType(),EVENT_ID_ADD_AXIS); 
    1550        if (client->isServerLeader()) 
    1551        { 
    1552          CMessage msg; 
    1553          msg<<this->getId(); 
    1554          msg<<id; 
    1555          const std::list<int>& ranks = client->getRanksServerLeader(); 
    1556          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1557            event.push(*itRank,1,msg); 
    1558          client->sendEvent(event); 
    1559        } 
    1560        else client->sendEvent(event); 
    1561     } 
     1544      sendAddItem(id, (int)EVENT_ID_ADD_AXIS); 
     1545    // CContext* context=CContext::getCurrent(); 
     1546 
     1547    // if (! context->hasServer ) 
     1548    // { 
     1549    //    CContextClient* client=context->client; 
     1550 
     1551    //    CEventClient event(this->getType(),EVENT_ID_ADD_AXIS); 
     1552    //    if (client->isServerLeader()) 
     1553    //    { 
     1554    //      CMessage msg; 
     1555    //      msg<<this->getId(); 
     1556    //      msg<<id; 
     1557    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1558    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1559    //        event.push(*itRank,1,msg); 
     1560    //      client->sendEvent(event); 
     1561    //    } 
     1562    //    else client->sendEvent(event); 
     1563    // } 
    15621564   } 
    15631565 
    … …  
    15681570   void CGrid::sendAddScalar(const string& id) 
    15691571   { 
    1570     CContext* context=CContext::getCurrent(); 
    1571  
    1572     if (! context->hasServer ) 
    1573     { 
    1574        CContextClient* client=context->client; 
    1575  
    1576        CEventClient event(this->getType(),EVENT_ID_ADD_SCALAR); 
    1577        if (client->isServerLeader()) 
    1578        { 
    1579          CMessage msg; 
    1580          msg<<this->getId(); 
    1581          msg<<id; 
    1582          const std::list<int>& ranks = client->getRanksServerLeader(); 
    1583          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    1584            event.push(*itRank,1,msg); 
    1585          client->sendEvent(event); 
    1586        } 
    1587        else client->sendEvent(event); 
    1588     } 
     1572      sendAddItem(id, (int)EVENT_ID_ADD_SCALAR); 
     1573    // CContext* context=CContext::getCurrent(); 
     1574 
     1575    // if (! context->hasServer ) 
     1576    // { 
     1577    //    CContextClient* client=context->client; 
     1578 
     1579    //    CEventClient event(this->getType(),EVENT_ID_ADD_SCALAR); 
     1580    //    if (client->isServerLeader()) 
     1581    //    { 
     1582    //      CMessage msg; 
     1583    //      msg<<this->getId(); 
     1584    //      msg<<id; 
     1585    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     1586    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     1587    //        event.push(*itRank,1,msg); 
     1588    //      client->sendEvent(event); 
     1589    //    } 
     1590    //    else client->sendEvent(event); 
     1591    // } 
    15891592   } 
    15901593 

  • XIOS/dev/dev_olga/src/node/variable.cpp

    r773 r987  
    8282   { 
    8383     CContext* context=CContext::getCurrent() ; 
    84      if (!context->hasServer) 
     84 
     85     if (context->hasClient) 
    8586     { 
    86        CContextClient* client=context->client ; 
     87           // Use correct context client to send message 
     88       CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer  
     89                                                                           : context->client; 
    8790 
    8891       CEventClient event(this->getType(),EVENT_ID_VARIABLE_VALUE) ; 
    89        if (client->isServerLeader()) 
     92       if (contextClientTmp->isServerLeader()) 
    9093       { 
    9194         CMessage msg ; 
    9295         msg<<this->getId() ; 
    9396         msg<<content ; 
    94          const std::list<int>& ranks = client->getRanksServerLeader(); 
     97         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    9598         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    9699           event.push(*itRank,1,msg); 
    97          client->sendEvent(event) ; 
     100         contextClientTmp->sendEvent(event) ; 
    98101       } 
    99        else client->sendEvent(event) ; 
     102       else contextClientTmp->sendEvent(event) ; 
    100103    } 
     104 
     105 
     106    //  if (!context->hasServer) 
     107    //  { 
     108    //    CContextClient* client=context->client ; 
     109 
     110    //    CEventClient event(this->getType(),EVENT_ID_VARIABLE_VALUE) ; 
     111    //    if (client->isServerLeader()) 
     112    //    { 
     113    //      CMessage msg ; 
     114    //      msg<<this->getId() ; 
     115    //      msg<<content ; 
     116    //      const std::list<int>& ranks = client->getRanksServerLeader(); 
     117    //      for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     118    //        event.push(*itRank,1,msg); 
     119    //      client->sendEvent(event) ; 
     120    //    } 
     121    //    else client->sendEvent(event) ; 
     122    // } 
    101123   } 
    102124 

  • XIOS/dev/dev_olga/src/node/variable.hpp

    r773 r987  
    3131         , public CVariableAttributes 
    3232      { 
     33                     /// typedef /// 
     34            typedef CObjectTemplate<CVariable>   SuperClass; 
     35            typedef CVariableAttributes SuperClassAttribute; 
     36             
     37         public : 
    3338            enum EEventId 
    3439            { 
    3540             EVENT_ID_VARIABLE_VALUE 
    3641            }; 
    37  
    38             /// typedef /// 
    39             typedef CObjectTemplate<CVariable>   SuperClass; 
    40             typedef CVariableAttributes SuperClassAttribute; 
    4142 
    4243            friend class CVariableGroup; 

  • XIOS/dev/dev_olga/src/object_template.hpp

    r731 r987  
    5858         void sendAttributToServer(CAttribute& attr) ; 
    5959         void sendAllAttributesToServer(); 
     60         void sendAddItem(const string& id, int itemType); 
    6061         static void recvAttributFromClient(CEventServer& event) ; 
    6162         static bool dispatchEvent(CEventServer& event) ; 

  • XIOS/dev/dev_olga/src/object_template_impl.hpp

    r769 r987  
    164164   std::map<int, size_t> CObjectTemplate<T>::getMinimumBufferSizeForAttributes() 
    165165   { 
    166      CContextClient* client = CContext::getCurrent()->client; 
     166     // CContextClient* client = CContext::getCurrent()->client; 
     167     CContext* context = CContext::getCurrent(); 
     168 
     169          // Use correct context client to send message 
     170     CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer : context->client; 
     171 
    167172     std::map<int, size_t> minimumSizes; 
    168173 
    169      if (client->isServerLeader()) 
     174     if (contextClientTmp->isServerLeader()) 
    170175     { 
    171176       size_t minimumSize = 0; 
    … …  
    187192         minimumSize += CEventClient::headerSize + getIdServer().size() + sizeof(size_t); 
    188193 
    189          const std::list<int>& ranks = client->getRanksServerLeader(); 
     194         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    190195         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    191196           minimumSizes.insert(std::make_pair(*itRank, minimumSize)); 
    192197       } 
    193198     } 
     199 
     200     // if (client->isServerLeader()) 
     201     // { 
     202     //   size_t minimumSize = 0; 
     203     //   CAttributeMap& attrMap = *this; 
     204     //   CAttributeMap::const_iterator it = attrMap.begin(), itE = attrMap.end(); 
     205     //   for (; it != itE; ++it) 
     206     //   { 
     207     //     if (!it->second->isEmpty()) 
     208     //     { 
     209     //       size_t size = it->second->getName().size() + sizeof(size_t) + it->second->size(); 
     210     //       if (size > minimumSize) 
     211     //         minimumSize = size; 
     212     //     } 
     213     //   } 
     214 
     215     //   if (minimumSize) 
     216     //   { 
     217     //     // Account for extra header info 
     218     //     minimumSize += CEventClient::headerSize + getIdServer().size() + sizeof(size_t); 
     219 
     220     //     const std::list<int>& ranks = client->getRanksServerLeader(); 
     221     //     for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     222     //       minimumSizes.insert(std::make_pair(*itRank, minimumSize)); 
     223     //   } 
     224     // } 
    194225 
    195226     return minimumSizes; 
    … …  
    220251    CContext* context=CContext::getCurrent(); 
    221252 
    222     if (!context->hasServer) 
     253     // Use correct context client to send message 
     254     CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer : context->client; 
     255 
     256    // if (!context->hasServer) 
     257    if (context->hasClient) 
    223258    { 
    224        CContextClient* client=context->client; 
     259       // CContextClient* contextClientTmp=context->contextClientTmp; 
    225260 
    226261       CEventClient event(getType(),EVENT_ID_SEND_ATTRIBUTE); 
    227        if (client->isServerLeader()) 
     262       if (contextClientTmp->isServerLeader()) 
    228263       { 
    229264         CMessage msg; 
    … …  
    232267         msg << attr.getName(); 
    233268         msg << attr; 
    234          const std::list<int>& ranks = client->getRanksServerLeader(); 
     269         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
    235270         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
    236271           event.push(*itRank,1,msg); 
    237          client->sendEvent(event); 
     272         contextClientTmp->sendEvent(event); 
    238273       } 
    239        else client->sendEvent(event); 
     274       else contextClientTmp->sendEvent(event); 
    240275    } 
    241276 
     277//     // if (!context->hasServer) 
     278//     if (context->hasClient) 
     279//     { 
     280//        CContextClient* client=context->client; 
     281 
     282//        CEventClient event(getType(),EVENT_ID_SEND_ATTRIBUTE); 
     283//        if (client->isServerLeader()) 
     284//        { 
     285//          CMessage msg; 
     286// //       msg << this->getId(); 
     287//          msg << this->getIdServer(); 
     288//          msg << attr.getName(); 
     289//          msg << attr; 
     290//          const std::list<int>& ranks = client->getRanksServerLeader(); 
     291//          for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     292//            event.push(*itRank,1,msg); 
     293//          client->sendEvent(event); 
     294//        } 
     295//        else client->sendEvent(event); 
     296//     } 
     297 
     298  } 
     299 
     300  /*! 
     301    This generic funtion only provides instance for sending, for receving, each  
     302    child class must define itself. 
     303    \param [in] id Id of added item 
     304    \param [in] itemType type of added item 
     305  */ 
     306  template<class T> 
     307  void CObjectTemplate<T>::sendAddItem(const StdString& id, int itemType) 
     308  { 
     309    CContext* context = CContext::getCurrent(); 
     310    typedef typename T::EEventId ItemType; 
     311    if (context->hasClient) 
     312    { 
     313       // Use correct context client to send message 
     314       CContextClient* contextClientTmp = (0 != context->clientPrimServer) ? context->clientPrimServer : context->client; 
     315       CEventClient event(this->getType(),ItemType(itemType)); 
     316       if (contextClientTmp->isServerLeader()) 
     317       { 
     318         CMessage msg; 
     319         msg << this->getId(); 
     320         msg << id; 
     321         const std::list<int>& ranks = contextClientTmp->getRanksServerLeader(); 
     322         for (std::list<int>::const_iterator itRank = ranks.begin(), itRankEnd = ranks.end(); itRank != itRankEnd; ++itRank) 
     323           event.push(*itRank,1,msg); 
     324         contextClientTmp->sendEvent(event); 
     325       } 
     326       else contextClientTmp->sendEvent(event); 
     327    } 
    242328  } 
    243329 

  • XIOS/dev/dev_olga/src/server.hpp

    r983 r987  
    1414      public: 
    1515        static void initialize(void); 
     16        static void initialize(const StdString& serverId); 
    1617        static void finalize(void); 
    1718        static void eventLoop(void); 

  • XIOS/dev/dev_olga/src/test/test_client.f90

    r983 r987  
    128128 
    129129  PRINT*,"field field_A is active ? ",xios_field_is_active("field_A") 
    130   DO ts=1,24*10 
     130  DO ts=1,24 
    131131    CALL xios_update_calendar(ts) 
    132132    CALL xios_send_field("field_A",field_A) 
Note: See TracChangeset for help on using the changeset viewer.