Buffer.h

#ifndef DDMD_BUFFER_H
#define DDMD_BUFFER_H

/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/param/ParamComposite.h>  // base class
#include <util/misc/Setable.h>          // member
#include <util/global.h>

namespace DdMd
{

   using namespace Util;

   template <int N> class Group;

   class Buffer: public ParamComposite 
   {

   public:

      enum BlockDataType {NONE, ATOM, GHOST, UPDATE, FORCE, 
                          GROUP2, GROUP3, GROUP4, SPECIAL};

      Buffer();

      virtual ~Buffer();

      void readParameters(std::istream& in);

      virtual void loadParameters(Serializable::IArchive &ar);

      virtual void save(Serializable::OArchive &ar);
  
      void allocate(int atomCapacity, int ghostCapacity);

      
      void clearSendBuffer();

      void beginSendBlock(int sendType);

      template <typename T>
      void pack(const T& data);

      void incrementSendSize();

      void endSendBlock(bool isComplete = true);

      
      bool beginRecvBlock();

      template <typename T>
      void unpack(T& data);

      void decrementRecvSize();

      void endRecvBlock();

      #ifdef UTIL_MPI


      void sendRecv(MPI::Intracomm& comm, int source, int dest);

      void send(MPI::Intracomm& comm, int dest);

      void recv(MPI::Intracomm& comm, int source);

      void bcast(MPI::Intracomm& comm, int source);

      #endif

    
      #ifdef UTIL_MPI
      virtual void computeStatistics(MPI::Intracomm& comm);
      #else
      virtual void computeStatistics();
      #endif

      void outputStatistics(std::ostream& out);

      void clearStatistics();
      

      
      int sendSize() const;

      int recvSize() const;

      bool isAllocated() const;

      bool isInitialized() const;

      int atomCapacity() const;

      int ghostCapacity() const;

      template <int N>
      int groupCapacity() const;


   private:

      char* sendBufferBegin_;

      char* recvBufferBegin_;

      char* sendBufferEnd_;

      char* recvBufferEnd_;

      char* sendBlockBegin_;

      char* recvBlockBegin_;

      char* recvBlockEnd_;

      char* sendPtr_;

      char* recvPtr_;

      int bufferCapacity_;

      int dataCapacity_;

      int sendSize_;

      int recvSize_;

      int sendType_;

      int recvType_;

      int atomCapacity_;

      int ghostCapacity_;

      int maxSendLocal_;

      Setable<int> maxSend_;

      bool isInitialized_;

      /*
      * Allocate send and recv buffers, using preset capacities.
      */
      void allocate();

   };

   /*
   * Pack an object of type T into send buffer.
   */
   template <typename T>
   inline void Buffer::pack(const T& data)
   {
      if (sendPtr_ + sizeof(data) > sendBufferEnd_) {
         UTIL_THROW("Attempted write past end of send buffer");
      }
      T* ptr = (T *)sendPtr_;
      *ptr = data;
      ++ptr;
      sendPtr_ = (char *)ptr;
   }

   /*
   * Unpack an object of type T from recvBuffer.
   */
   template <typename T>
   inline void Buffer::unpack(T& data)
   {
      if (recvPtr_ + sizeof(data) > recvBufferEnd_) {
         UTIL_THROW("Attempted read past end of recv buffer");
      }
      T* ptr = (T *)recvPtr_;
      data = *ptr;
      ++ptr;
      recvPtr_ = (char *)ptr;
   }

   /*
   * Maximum number of Group<N> objects that can fit buffer.
   */
   template <int N>
   int Buffer::groupCapacity() const
   {
      if (dataCapacity_ <= 0) {
         UTIL_THROW("Buffer not allocated");
      }
      return (dataCapacity_/Group<N>::packedSize()); 
   }

   /*
   * Increment sendSize counter after packing an item.
   */
   inline void Buffer::incrementSendSize()
   { ++sendSize_; }

   /*
   * Decrement sendSize counter after receiving an item.
   */
   inline void Buffer::decrementRecvSize()
   { --recvSize_; }

}
#endif