Changeset 178


Ignore:
Timestamp:
04/18/11 14:56:41 (10 years ago)
Author:
hozdoba
Message:
 
Location:
XMLIO_V2/dev/dev_rv
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/dev_rv/Makefile.wk

    r177 r178  
    1515VTK       = no 
    1616GUI       = no 
    17 NPROC     = 11 
     17NPROC     = 12 
    1818CSUITE    = gnu 
    1919PFORME    = fedora-wk 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_list.cpp

    r152 r178  
    5454 
    5555      StdSize CBufferList::getNumberOfBuffers(void) const 
    56       { return (this->nbbuffer) ; } 
     56      {  
     57         return (this->nbbuffer) ; 
     58      } 
    5759 
    5860      ///-------------------------------------------------------------- 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.cpp

    r152 r178  
    66   { 
    77      /// ////////////////////// Définitions ////////////////////// /// 
     8      CBufferPair::CBufferPair(MPIComm com_client_server) 
     9         : com_client_server(com_client_server)  
     10         , first(BUFFER_CLIENT_SIZE), second(BUFFER_CLIENT_SIZE) 
     11         , first_request(-1), second_request(-1) 
     12         , currentBuffer(0) 
     13      { /* Ne rien faire de plus */ } 
    814 
     15      CBufferPair::~CBufferPair(void) 
     16      { /* Ne rien faire de plus */ } 
     17 
     18      ///-------------------------------------------------------------- 
     19 
     20      bool CBufferPair::mustBeSent(void) 
     21      { 
     22         if (((currentBuffer == 0) && (first.getUsedSize() != 0) && 
     23              ((second_request == -1) || CMPIManager::Test (second_request))) || 
     24             ((currentBuffer == 1) && (second.getUsedSize() != 0) && 
     25              ((first_request == -1) || CMPIManager::Test (first_request)))) 
     26            return (true); 
     27         return (false); 
     28      } 
     29       
     30      //--------------------------------------------------------------- 
     31       
     32      void CBufferPair::wait(void) 
     33      { 
     34         if (this->currentBuffer == 0) 
     35              CMPIManager::Wait(this->second_request); 
     36         else CMPIManager::Wait(this->first_request); 
     37      } 
     38       
     39      //--------------------------------------------------------------- 
     40       
     41      void CBufferPair::sendCurrentBuffer(void) 
     42      { 
     43         if (this->currentBuffer == 0) 
     44         { 
     45            CMPIManager::SendLinearBuffer 
     46               (this->com_client_server, 0, this->first, this->first_request); 
     47            this->currentBuffer = 1; 
     48            this->second.clear(); 
     49         } 
     50         else 
     51         { 
     52            CMPIManager::SendLinearBuffer 
     53               (this->com_client_server, 0, this->second, this->second_request); 
     54            this->currentBuffer = 0; 
     55            this->first.clear(); 
     56         } 
     57      } 
     58       
     59      //--------------------------------------------------------------- 
     60       
     61      CLinearBuffer & CBufferPair::getCurrentBuffer(void) 
     62      { 
     63         if (currentBuffer == 0) return (this->first); 
     64         return (this->second); 
     65      } 
     66       
     67      ///-------------------------------------------------------------- 
    968 
    1069   } // namespace tree 
  • XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.hpp

    r157 r178  
    1515      /// ////////////////////// Déclarations ////////////////////// /// 
    1616      class CBufferPair 
    17          : public std::pair<CLinearBuffer, CLinearBuffer>   // << pas une liste 
    1817      { 
    1918 
    2019            /// Définition de type /// 
    21             typedef std::pair<CLinearBuffer, CLinearBuffer> SuperClass; 
    2220            typedef CLinearBuffer BufferType; 
    2321 
     
    2927            CBufferPair(const CBufferPair * const buffer_pair); // Not implemented yet. 
    3028 
     29            template <typename A1, typename A2, typename A3, typename A4> 
     30               void prepareRequest(const long int & managerId, 
     31                                   const long int & methodId, 
     32                                   A1 * arg1 = CLinearBuffer::NULL_ARG, 
     33                                   A2 * arg2 = CLinearBuffer::NULL_ARG, 
     34                                   A3 * arg3 = CLinearBuffer::NULL_ARG, 
     35                                   A4 * arg4 = CLinearBuffer::NULL_ARG); 
     36                                   
    3137            /// Destructeur /// 
    3238            virtual ~CBufferPair(void); 
     39             
     40         protected : 
     41             
     42            /// Test /// 
     43            bool mustBeSent(void); 
     44             
     45            /// Traitements divers /// 
     46            void wait(void); 
     47            void sendCurrentBuffer(void); 
     48             
     49            /// Accesseur ///     
     50            CLinearBuffer & getCurrentBuffer(void); 
    3351 
    3452         private : 
    3553 
    3654            MPIComm com_client_server; 
     55            CLinearBuffer first, second; 
     56            MPIRequest first_request, second_request; 
     57            int currentBuffer; 
    3758 
    3859      }; // class CBufferPair 
     60       
     61      ///-------------------------------------------------------------- 
     62       
     63      template <typename A1, typename A2, typename A3, typename A4> 
     64         void CBufferPair::prepareRequest(const long int & managerId, 
     65                                          const long int & methodId, 
     66                                          A1 * arg1, A2 * arg2, A3 * arg3, A4 * arg4) 
     67      { 
     68         if (this->mustBeSent()) this->sendCurrentBuffer();        
     69            
     70         CLinearBuffer & cbuffer = this->getCurrentBuffer(); 
     71         StdSize usize = cbuffer.getUnusedSize();          
     72         StdSize rsize = cbuffer.getRequestedSize(arg1, arg2, arg3, arg4) ; 
     73         StdSize msize = cbuffer.getSize(); 
     74          
     75         long int nbargs = 0; 
     76          
     77         if (arg1 != CLinearBuffer::NULL_ARG) nbargs++; 
     78         if (arg2 != CLinearBuffer::NULL_ARG) nbargs++; 
     79         if (arg3 != CLinearBuffer::NULL_ARG) nbargs++; 
     80         if (arg4 != CLinearBuffer::NULL_ARG) nbargs++; 
     81          
     82         if (rsize > msize) 
     83            ERROR("CBufferPair::sendRequest(...)", << "Le tampon client est trop petit !"); 
     84                   
     85         if (rsize <= usize) 
     86         { 
     87            cbuffer.appendRequestInfos(managerId, methodId, nbargs);         
     88         } 
     89         else 
     90         { 
     91            this->wait(); 
     92            this->prepareRequest(managerId, methodId, arg1, arg2, arg3, arg4); 
     93         } 
     94      } 
     95       
     96      ///-------------------------------------------------------------- 
     97       
     98       
    3999   } // namespace comm 
    40100} // namespace xmlioserver 
  • XMLIO_V2/dev/dev_rv/src/xmlio/linear_buffer.cpp

    r152 r178  
    4444      return (SuperClass::get##Type(this->bdata[position])); \ 
    4545   } 
    46  
    4746 
    4847      CLinearBufferGetter(char     , Char) 
  • XMLIO_V2/dev/dev_rv/src/xmlio/manager/xios_manager.cpp

    r177 r178  
    4444         (StdString clientName, comm::MPIComm comm_client_server, comm::MPIComm comm_server) 
    4545      { 
    46              
     46 
    4747      } 
    4848       
    4949      //-------------------------------------------------------------- 
    50  
    51       void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server) 
     50       
     51      void CXIOSManager::ShowInformation_CS(comm::MPIComm comm_client_server) 
    5252      { 
    5353         using namespace comm; 
    5454         typedef std::pair<StdString, XIOSClient> StdPairStrClient; 
    55  
    5655         if (CMPIManager::IsMaster(comm_client_server)) 
    5756         { 
     
    8988 
    9089         comm::CMPIManager::Barrier(); 
     90          
     91      } 
     92       
     93      //-------------------------------------------------------------- 
     94       
     95      void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server) 
     96      { 
     97         using namespace comm; 
     98         typedef std::pair<StdString, XIOSClient> StdPairStrClient; 
     99          
     100         CXIOSManager::ShowInformation_CS(comm_client_server); 
     101          
     102         xios_map<StdString, XIOSClient>::iterator 
     103               iit  = CXIOSManager::Clients.begin(), 
     104               eend = CXIOSManager::Clients.end(); 
     105          
    91106         StdSize start = 0, end   = 0; 
    92107          
    93          xios_map<StdString, XIOSClient>::iterator 
    94             iit  = CXIOSManager::Clients.begin(), 
    95             eend = CXIOSManager::Clients.end(); 
    96           
    97          bool isClient = true, isIncl = false; 
     108         bool isClient = true, isIncl = false, isIncl_ = false; 
    98109         MPIComm comm_client = 0, comm_client_grp = 0; comm_client_server = 0; 
    99110 
     
    130141               if (currentRank == start) 
    131142               { 
    132                   isClient = false; 
     143                  isClient = false; isIncl_  = true; 
    133144                  CXIOSManager::Comm_Client_Server = comm_; 
    134145               }                
    135146               if (clieindex.size() == nbClient) 
    136147               { 
    137                   MPIComm comm___  = CMPIManager::CreateComm 
     148                  MPIComm comm___ = CMPIManager::CreateComm 
    138149                  (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), clieindex)); 
    139                   if (isIncl) 
    140                   { 
    141                      comm_client = comm___; 
    142                   } 
     150                  if (isIncl) comm_client = comm___; 
    143151                  clieindex.clear(); 
    144152                  isIncl = false; 
     
    147155               start = start + nbClientPServer + 1; 
    148156            } 
    149             CXIOSManager::Comm_Server = CMPIManager::CreateComm 
     157            MPIComm comm____ = CMPIManager::CreateComm 
    150158               (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), servindex)); 
    151              
    152          } 
    153           
    154          if (isClient) 
     159            if (isIncl_) CXIOSManager::Comm_Server = comm____;                
     160            servindex.clear(); 
     161            isIncl_ = false;             
     162         } 
     163          
     164         if (isClient && (CXIOSManager::Clients.find(CXIOSManager::ClientName) != 
     165                          CXIOSManager::Clients.end())) 
    155166         { 
    156167            CXIOSManager::Clients[CXIOSManager::ClientName].entry 
    157168               (comm_client, comm_client_grp, comm_client_server); 
    158169         } 
    159          else 
     170         else if(CXIOSManager::Clients.find(CXIOSManager::ClientName) != 
     171                 CXIOSManager::Clients.end()) 
    160172         { 
    161173            CXIOSManager::RunServer(CXIOSManager::ClientName,  
     
    164176         } 
    165177      } 
    166  
     178       
     179      //--------------------------------------------------------------- 
     180       
    167181      void CXIOSManager::RunClient(comm::MPIComm comm_client) 
    168182      { 
     
    225239         } 
    226240      } 
     241       
     242      //--------------------------------------------------------------- 
    227243 
    228244      StdSize CXIOSManager::GetNbLocClient(const StdString & clientName) 
     
    239255         } 
    240256      } 
     257 
     258      //--------------------------------------------------------------- 
    241259 
    242260      StdSize CXIOSManager::GetNbServer(void) 
     
    270288      } 
    271289 
     290      //--------------------------------------------------------------- 
     291 
    272292      StdSize CXIOSManager::GetNbLocServer(const StdString & clientName) 
    273293      { 
  • XMLIO_V2/dev/dev_rv/src/xmlio/manager/xios_manager.hpp

    r177 r178  
    5555 
    5656      private : 
     57       
     58         /// Information /// 
     59         static void ShowInformation_CS(comm::MPIComm comm_client_server); 
    5760 
    5861         /// variables privées /// 
Note: See TracChangeset for help on using the changeset viewer.