source: XIOS/dev/branch_yushan/src/context_client.hpp @ 1073

#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"
#ifdef _usingEP
//#include "ep_declaration.hpp"
#endif


namespace xios
{
  class CContext;

  /*!
  \class CContextClient
  A context can be both on client and on server side. In order to differenciate the role of
  context on each side, e.x client sending events, server receiving and processing events, there is a need of
  concrete "context" classes for both sides.
  CContextClient processes and sends events from client to server where CContextServer receives these events
  and processes them.
  */
  class CContextClient
  {
    public:
      // Contructor
      CContextClient(CContext* parent, ep_lib::MPI_Comm intraComm, ep_lib::MPI_Comm interComm, CContext* parentServer = 0);

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

      // Functions relates to set/get buffers
      list<CBufferOut*> getBuffers(list<int>& serverlist, list<int>& sizeList);
      void newBuffer(int rank);
      bool checkBuffers(list<int>& ranks);
      bool checkBuffers(void);
      void releaseBuffers(void);

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

      bool isAttachedModeEnabled() const;

      // Close and finalize context client
      void closeContext(void);
      void finalize(void);

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

    public:
      CContext* context; //!< Context for client

      size_t timeLine; //!< Timeline of each event

      int clientRank; //!< Rank of current client

      int clientSize; //!< Size of client group

      int serverSize; //!< Size of server group

      ep_lib::MPI_Comm interComm; //!< Communicator of server group

      ep_lib::MPI_Comm intraComm; //!< Communicator of client group

      map<int,CClientBuffer*> buffers; //!< Buffers for connection to servers

    private:
      //! Mapping of server and buffer size for each connection to server
      std::map<int,StdSize> mapBufferSize_;
      //! Maximum number of events that can be buffered
      StdSize maxBufferedEvents;

      //! Context for server (Only used in attached mode)
      CContext* parentServer;

      //! List of server ranks for which the client is leader
      std::list<int> ranksServerLeader;

    public: // Some function should be removed in the future
      //    void registerEvent(CEventClient& event);
//    list<CBufferOut*> newEvent(CEventClient& event,list<int>& sizes);
//    bool locked;
//    set<int> connectedServer;

  };
}

#endif // __CONTEXT_CLIENT_HPP__