MemoryPool.h

Go to the documentation of this file.

// $Id: MemoryPool.h 4506 2020-05-26 07:55:57Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_MemoryPool
#define DABC_MemoryPool
 
#ifndef DABC_ModuleAsync
#include "dabc/ModuleAsync.h"
#endif
 
namespace dabc {
 
   class Mutex;
   class MemoryBlock;
   class MemoryPoolRef;
 
   class BufferContainer;
 
   class MemoryPool : public ModuleAsync {
      friend class Manager;
      friend class Buffer;
      friend class MemoryPoolRef;
      friend class BufferContainer;
 
      struct RequesterReq {
         BufferSize_t   size;
         bool           pending;   // if true, request is pending
         bool           disconn;   // if true, requester output is free and can be reused
 
         RequesterReq() : size(0), pending(false), disconn(false) {}
      };
 
      protected:
 
         MemoryBlock*              fMem;    
 
         unsigned                  fAlignment;      
 
         std::vector<RequesterReq> fReqests;        
 
         Queue<unsigned, true>    fPending;    
 
         bool                     fEvntFired;      
         bool                     fProcessingReq;  
 
         unsigned                 fChangeCounter;  
 
         bool                     fUseThread;      
 
         static unsigned          fDfltAlignment;   
         static unsigned          fDfltBufSize;     
 
         virtual bool Find(ConfigIO &cfg);
 
         bool TakeRawBuffer(unsigned& indx);
 
         void ReleaseRawBuffer(unsigned indx);
 
         Buffer _TakeBuffer(BufferSize_t size, bool except, bool reserve_memory = true);
 
         bool _Allocate(BufferSize_t bufsize = 0, unsigned number = 0) throw();
 
         bool _ProcessRequests();
 
         void ReplyReadyRequests();
 
         void IncreaseSegmRefs(MemSegment* segm, unsigned num);
 
         void DecreaseSegmRefs(MemSegment* segm, unsigned num);
 
         bool IsSingleSegmRefs(MemSegment* segm, unsigned num);
 
         virtual void OnThreadAssigned()
         {
            fUseThread = HasThread();
            dabc::ModuleAsync::OnThreadAssigned();
         }
 
         bool ProcessSend(unsigned port);
 
         virtual void ProcessEvent(const EventId&);
 
         virtual int ExecuteCommand(Command cmd);
 
         virtual void ProcessConnectionActivated(const std::string &name, bool on);
 
         virtual void ProcessConnectEvent(const std::string &name, bool on);
 
 
         bool RecheckRequests(bool from_recv = false);
 
      public:
 
         MemoryPool(const std::string &name, bool withmanager = false);
         virtual ~MemoryPool();
 
         virtual const char* ClassName() const { return "MemoryPool"; }
 
         inline Mutex* GetPoolMutex() const { return ObjectMutex(); }
 
         bool IsEmpty() const;
 
         bool SetAlignment(unsigned align);
 
         bool Allocate(BufferSize_t bufsize = 0, unsigned number = 0) throw();
 
         bool Assign(bool isowner, const std::vector<void*>& bufs, const std::vector<unsigned>& sizes) throw();
 
         bool _GetPoolInfo(std::vector<void*>& bufs, std::vector<unsigned>& sizes, unsigned* changecnt = 0);
 
         bool GetPoolInfo(std::vector<void*>& bufs, std::vector<unsigned>& sizes);
 
 
         bool Release() throw();
 
         unsigned GetAlignment() const;
 
         unsigned GetMaxNumSegments() const;
 
         unsigned GetNumBuffers() const;
 
         unsigned GetBufferSize(unsigned id) const;
 
         void* GetBufferLocation(unsigned id) const;
 
         double GetUsedRatio() const;
 
         unsigned GetMaxBufSize() const;
 
         unsigned GetMinBufSize() const;
 
 
         Buffer TakeBuffer(BufferSize_t size = 0) throw();
 
         bool CheckChangeCounter(unsigned &cnt);
 
         bool Reconstruct(Command cmd);
 
         // these are static methods to change default configuration for all newly created pools
 
         static unsigned GetDfltAlignment() { return fDfltAlignment; }
         static unsigned GetDfltBufSize() { return fDfltBufSize; }
 
         static void SetDfltAlignment(unsigned v) { fDfltAlignment = v; }
         static void SetDfltBufSize(unsigned v) { fDfltBufSize = v; }
   };
 
 
   class CmdCreateMemoryPool : public Command {
 
      DABC_COMMAND(CmdCreateMemoryPool, "CreateMemoryPool")
 
      CmdCreateMemoryPool(const std::string &poolname) : Command(CmdName())
      {
         SetStr(xmlPoolName, poolname);
      }
 
      void SetMem(unsigned buffersize, unsigned numbuffers, unsigned align = 0)
      {
         if (buffersize*numbuffers != 0) {
            SetUInt(xmlNumBuffers, numbuffers);
            SetUInt(xmlBufferSize, buffersize);
         }
 
         if (align) SetUInt(xmlAlignment, align);
      }
   };
 
   // ________________________________________________________________________________
 
   class MemoryPoolRef : public ModuleAsyncRef {
 
      DABC_REFERENCE(MemoryPoolRef, ModuleAsyncRef, MemoryPool)
 
      
      double GetUsedRatio() const
      {
         return GetObject() ? GetObject()->GetUsedRatio() : 0.;
      }
 
      unsigned GetMaxBufSize() const
      {
         return GetObject() ? GetObject()->GetMaxBufSize() : 0;
      }
 
      unsigned GetMinBufSize() const
      {
         return GetObject() ? GetObject()->GetMinBufSize() : 0;
      }
 
      Buffer TakeBuffer(BufferSize_t size = 0)
      {
         return GetObject() ? GetObject()->TakeBuffer(size) : Buffer();
      }
 
      Reference CreateNewRequester();
   };
 
}
 
#endif