Changeset 178

Timestamp:

04/18/11 14:56:41 (14 years ago)

Author:

hozdoba

Message:

 

Location:

XMLIO_V2/dev/dev_rv

Files:

• Makefile.wk (modified) (1 diff)
• src/xmlio/buffer_list.cpp (modified) (1 diff)
• src/xmlio/buffer_pair.cpp (modified) (1 diff)
• src/xmlio/buffer_pair.hpp (modified) (2 diffs)
• src/xmlio/linear_buffer.cpp (modified) (1 diff)
• src/xmlio/manager/xios_manager.cpp (modified) (8 diffs)
• src/xmlio/manager/xios_manager.hpp (modified) (1 diff)

XMLIO_V2/dev/dev_rv/Makefile.wk

@@ -15 +15 @@
 VTK       = no
 GUI       = no
-NPROC     = 11
+NPROC     = 12
 CSUITE    = gnu
 PFORME    = fedora-wk

XMLIO_V2/dev/dev_rv/src/xmlio/buffer_list.cpp

@@ -54 +54 @@
 
       StdSize CBufferList::getNumberOfBuffers(void) const
-      { return (this->nbbuffer) ; }
+      { 
+         return (this->nbbuffer) ;
+      }
 
       ///--------------------------------------------------------------

XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.cpp

@@ -6 +6 @@
    {
       /// ////////////////////// Définitions ////////////////////// ///
+      CBufferPair::CBufferPair(MPIComm com_client_server)
+         : com_client_server(com_client_server) 
+         , first(BUFFER_CLIENT_SIZE), second(BUFFER_CLIENT_SIZE)
+         , first_request(-1), second_request(-1)
+         , currentBuffer(0)
+      { /* Ne rien faire de plus */ }
 
+      CBufferPair::~CBufferPair(void)
+      { /* Ne rien faire de plus */ }
+
+      ///--------------------------------------------------------------
+
+      bool CBufferPair::mustBeSent(void)
+      {
+         if (((currentBuffer == 0) && (first.getUsedSize() != 0) &&
+              ((second_request == -1) || CMPIManager::Test (second_request))) ||
+             ((currentBuffer == 1) && (second.getUsedSize() != 0) &&
+              ((first_request == -1) || CMPIManager::Test (first_request))))
+            return (true);
+         return (false);
+      }
+      
+      //---------------------------------------------------------------
+      
+      void CBufferPair::wait(void)
+      {
+         if (this->currentBuffer == 0)
+              CMPIManager::Wait(this->second_request);
+         else CMPIManager::Wait(this->first_request);
+      }
+      
+      //---------------------------------------------------------------
+      
+      void CBufferPair::sendCurrentBuffer(void)
+      {
+         if (this->currentBuffer == 0)
+         {
+            CMPIManager::SendLinearBuffer
+               (this->com_client_server, 0, this->first, this->first_request);
+            this->currentBuffer = 1;
+            this->second.clear();
+         }
+         else
+         {
+            CMPIManager::SendLinearBuffer
+               (this->com_client_server, 0, this->second, this->second_request);
+            this->currentBuffer = 0;
+            this->first.clear();
+         }
+      }
+      
+      //---------------------------------------------------------------
+      
+      CLinearBuffer & CBufferPair::getCurrentBuffer(void)
+      {
+         if (currentBuffer == 0) return (this->first);
+         return (this->second);
+      }
+      
+      ///--------------------------------------------------------------
 
    } // namespace tree

XMLIO_V2/dev/dev_rv/src/xmlio/buffer_pair.hpp

@@ -15 +15 @@
       /// ////////////////////// Déclarations ////////////////////// ///
       class CBufferPair
-         : public std::pair<CLinearBuffer, CLinearBuffer>   // << pas une liste
       {
 
             /// Définition de type ///
-            typedef std::pair<CLinearBuffer, CLinearBuffer> SuperClass;
             typedef CLinearBuffer BufferType;
 
@@ -29 +27 @@
             CBufferPair(const CBufferPair * const buffer_pair); // Not implemented yet.
 
+            template <typename A1, typename A2, typename A3, typename A4>
+               void prepareRequest(const long int & managerId,
+                                   const long int & methodId,
+                                   A1 * arg1 = CLinearBuffer::NULL_ARG,
+                                   A2 * arg2 = CLinearBuffer::NULL_ARG,
+                                   A3 * arg3 = CLinearBuffer::NULL_ARG,
+                                   A4 * arg4 = CLinearBuffer::NULL_ARG);
+                                  
             /// Destructeur ///
             virtual ~CBufferPair(void);
+            
+         protected :
+            
+            /// Test ///
+            bool mustBeSent(void);
+            
+            /// Traitements divers ///
+            void wait(void);
+            void sendCurrentBuffer(void);
+            
+            /// Accesseur ///    
+            CLinearBuffer & getCurrentBuffer(void);
 
          private :
 
             MPIComm com_client_server;
+            CLinearBuffer first, second;
+            MPIRequest first_request, second_request;
+            int currentBuffer;
 
       }; // class CBufferPair
+      
+      ///--------------------------------------------------------------
+      
+      template <typename A1, typename A2, typename A3, typename A4>
+         void CBufferPair::prepareRequest(const long int & managerId,
+                                          const long int & methodId,
+                                          A1 * arg1, A2 * arg2, A3 * arg3, A4 * arg4)
+      {
+         if (this->mustBeSent()) this->sendCurrentBuffer();       
+           
+         CLinearBuffer & cbuffer = this->getCurrentBuffer();
+         StdSize usize = cbuffer.getUnusedSize();         
+         StdSize rsize = cbuffer.getRequestedSize(arg1, arg2, arg3, arg4) ;
+         StdSize msize = cbuffer.getSize();
+         
+         long int nbargs = 0;
+         
+         if (arg1 != CLinearBuffer::NULL_ARG) nbargs++;
+         if (arg2 != CLinearBuffer::NULL_ARG) nbargs++;
+         if (arg3 != CLinearBuffer::NULL_ARG) nbargs++;
+         if (arg4 != CLinearBuffer::NULL_ARG) nbargs++;
+         
+         if (rsize > msize)
+            ERROR("CBufferPair::sendRequest(...)", << "Le tampon client est trop petit !");
+                  
+         if (rsize <= usize)
+         {
+            cbuffer.appendRequestInfos(managerId, methodId, nbargs);        
+         }
+         else
+         {
+            this->wait();
+            this->prepareRequest(managerId, methodId, arg1, arg2, arg3, arg4);
+         }
+      }
+      
+      ///--------------------------------------------------------------
+      
+      
    } // namespace comm
 } // namespace xmlioserver

XMLIO_V2/dev/dev_rv/src/xmlio/linear_buffer.cpp

@@ -44 +44 @@
       return (SuperClass::get##Type(this->bdata[position])); \
    }
-
 
       CLinearBufferGetter(char     , Char)

XMLIO_V2/dev/dev_rv/src/xmlio/manager/xios_manager.cpp

@@ -44 +44 @@
          (StdString clientName, comm::MPIComm comm_client_server, comm::MPIComm comm_server)
       {
-            
+
       }
       
       //--------------------------------------------------------------
-
-      void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server)
+      
+      void CXIOSManager::ShowInformation_CS(comm::MPIComm comm_client_server)
       {
          using namespace comm;
          typedef std::pair<StdString, XIOSClient> StdPairStrClient;
-
          if (CMPIManager::IsMaster(comm_client_server))
          {
@@ -89 +88 @@
 
          comm::CMPIManager::Barrier();
+         
+      }
+      
+      //--------------------------------------------------------------
+      
+      void CXIOSManager::RunClientServer(comm::MPIComm comm_client_server)
+      {
+         using namespace comm;
+         typedef std::pair<StdString, XIOSClient> StdPairStrClient;
+         
+         CXIOSManager::ShowInformation_CS(comm_client_server);
+         
+         xios_map<StdString, XIOSClient>::iterator
+               iit  = CXIOSManager::Clients.begin(),
+               eend = CXIOSManager::Clients.end();
+         
          StdSize start = 0, end   = 0;
          
-         xios_map<StdString, XIOSClient>::iterator
-            iit  = CXIOSManager::Clients.begin(),
-            eend = CXIOSManager::Clients.end();
-         
-         bool isClient = true, isIncl = false;
+         bool isClient = true, isIncl = false, isIncl_ = false;
          MPIComm comm_client = 0, comm_client_grp = 0; comm_client_server = 0;
 
@@ -130 +141 @@
                if (currentRank == start)
                {
-                  isClient = false;
+                  isClient = false; isIncl_  = true;
                   CXIOSManager::Comm_Client_Server = comm_;
                }               
                if (clieindex.size() == nbClient)
                {
-                  MPIComm comm___  =  CMPIManager::CreateComm
+                  MPIComm comm___ = CMPIManager::CreateComm
                   (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), clieindex));
-                  if (isIncl)
-                  {
-                     comm_client = comm___;
-                  }
+                  if (isIncl) comm_client = comm___;
                   clieindex.clear();
                   isIncl = false;
@@ -147 +155 @@
                start = start + nbClientPServer + 1;
             }
-            CXIOSManager::Comm_Server =  CMPIManager::CreateComm
+            MPIComm comm____ = CMPIManager::CreateComm
                (CMPIManager::CreateSubGroup(CMPIManager::GetGroupWorld(), servindex));
-            
-         }
-         
-         if (isClient)
+            if (isIncl_) CXIOSManager::Comm_Server = comm____;               
+            servindex.clear();
+            isIncl_ = false;            
+         }
+         
+         if (isClient && (CXIOSManager::Clients.find(CXIOSManager::ClientName) !=
+                          CXIOSManager::Clients.end()))
          {
             CXIOSManager::Clients[CXIOSManager::ClientName].entry
                (comm_client, comm_client_grp, comm_client_server);
          }
-         else
+         else if(CXIOSManager::Clients.find(CXIOSManager::ClientName) !=
+                 CXIOSManager::Clients.end())
          {
             CXIOSManager::RunServer(CXIOSManager::ClientName, 
@@ -164 +176 @@
          }
       }
-
+      
+      //---------------------------------------------------------------
+      
       void CXIOSManager::RunClient(comm::MPIComm comm_client)
       {
@@ -225 +239 @@
          }
       }
+      
+      //---------------------------------------------------------------
 
       StdSize CXIOSManager::GetNbLocClient(const StdString & clientName)
@@ -239 +255 @@
          }
       }
+
+      //---------------------------------------------------------------
 
       StdSize CXIOSManager::GetNbServer(void)
@@ -270 +288 @@
       }
 
+      //---------------------------------------------------------------
+
       StdSize CXIOSManager::GetNbLocServer(const StdString & clientName)
       {

XMLIO_V2/dev/dev_rv/src/xmlio/manager/xios_manager.hpp

@@ -55 +55 @@
 
       private :
+      
+         /// Information ///
+         static void ShowInformation_CS(comm::MPIComm comm_client_server);
 
          /// variables privées ///