context_client.hpp

Aller à la documentation de ce fichier.

#ifndef __CONTEXT_CLIENT_HPP__
#define __CONTEXT_CLIENT_HPP__

#include "xios_spl.hpp"
#include "buffer_out.hpp"
#include "buffer_in.hpp"
#include "buffer_client.hpp"
#include "event_client.hpp"
#include "event_server.hpp"
#include "mpi.hpp"
#include "registry.hpp"

namespace xios
{
  class CContext;

  class CContextClient
  {
    public:
      // Contructor
      CContextClient(CContext* parent, MPI_Comm intraComm, MPI_Comm interComm, CContext* parentServer = 0);

      // Send event to server
      void sendEvent(CEventClient& event);
      bool sendTemporarilyBufferedEvent();
      void waitEvent(list<int>& ranks);

      // Functions to set/get buffers
      bool getBuffers(const list<int>& serverList, const list<int>& sizeList, list<CBufferOut*>& retBuffers, bool nonBlocking = false);
      void newBuffer(int rank);
      bool checkBuffers(list<int>& ranks);
      bool checkBuffers(void);
      void releaseBuffers(void);
      bool havePendingRequests(void);

      bool isServerLeader(void) const;
      bool isServerNotLeader(void) const;
      const std::list<int>& getRanksServerLeader(void) const;
      const std::list<int>& getRanksServerNotLeader(void) const;

      bool isAttachedModeEnabled() const;
      bool hasTemporarilyBufferedEvent() const { return !tmpBufferedEvent.isEmpty(); };

      static void computeLeader(int clientRank, int clientSize, int serverSize,
                                std::list<int>& rankRecvLeader,
                                std::list<int>& rankRecvNotLeader);

      // Close and finalize context client
//      void closeContext(void);  Never been implemented.
      void finalize(void);

      void setBufferSize(const std::map<int,StdSize>& mapSize, const std::map<int,StdSize>& maxEventSize);

    public:
      CContext* context; 

      size_t timeLine; 

      int clientRank; 

      int clientSize; 

      int serverSize; 

      MPI_Comm interComm; 

      MPI_Comm intraComm; 

      map<int,CClientBuffer*> buffers; 

    private:
      std::map<int,StdSize> mapBufferSize_;
      std::map<int,StdSize> maxEventSizes;
      StdSize maxBufferedEvents;

      struct {
        std::list<int> ranks, sizes;
        std::list<CBufferOut*> buffers;

        bool isEmpty() const { return ranks.empty(); };
        void clear() {
          ranks.clear();
          sizes.clear();

          for (std::list<CBufferOut*>::iterator it = buffers.begin(); it != buffers.end(); it++)
            delete *it;

          buffers.clear();
        };
      } tmpBufferedEvent; 

      CContext* parentServer;

      std::list<int> ranksServerLeader;

      std::list<int> ranksServerNotLeader;

  };
}

#endif // __CONTEXT_CLIENT_HPP__