debugDrawerSharedMemoryManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2011 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include "vlutil/vlShmPool.h"
#include "vlutil/vlMutex.h"
#include "vlutil/vlScopedLock.h"
#include "vlutil/vlString.h"

#include "simTerrainDrawer/simTerrainDrawerDefines.h"
#include "simTerrainDrawer/debugDrawerNameManager.h"
#include "simTerrainDrawer/debugDrawerGeometryMemory.h"
#include "simTerrainDrawer/debugDrawerSphereMemory.h"
#include "simTerrainDrawer/debugDrawerLineMemory.h"
#include "simTerrainDrawer/debugDrawerTriangleMemory.h"
#include "simTerrainDrawer/debugDrawerTextMemory.h"
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_array.hpp>
#include <boost/noncopyable.hpp>

class DtDebugDrawerNameManager;
struct DtDebugMemoryBlockHeader;


class DT_DLL_simTerrainDrawer DtDebugDrawerSharedMemoryManager
{
   public:
      class LocalSharedMemoryPoolManager;

      typedef DtDebugDrawerNameManager::MemoryType MemoryType;
      typedef DtDebugMemoryBlockHeader DtMemoryHeader;

      class DT_DLL_simTerrainDrawer ReadLock : boost::noncopyable
      {
      public:
         explicit ReadLock(DtDebugDrawerSharedMemoryManager& manager);

         ~ReadLock();

      protected:
         DtDebugDrawerSharedMemoryManager& myManager;
      };

      class DT_DLL_simTerrainDrawer ScopedFrame : boost::noncopyable
      {
      public:
         explicit ScopedFrame(DtDebugDrawerSharedMemoryManager& manager, bool erase = true);

         ~ScopedFrame();

         void reset(DtDebugDrawerSharedMemoryManager& mgr, bool erase = true);
         void reset();

         bool isSet() const;

         void setOutput(bool flag);

      protected:
         DtDebugDrawerSharedMemoryManager* myManager;
         bool myOutputFlag;
      };

      friend class ScopedLock;
      friend class ScopedFrame;

      struct DT_DLL_simTerrainDrawer Header
      {
         Header();
      };

      static const unsigned long KB = static_cast<unsigned long>(1) << 10;
      static const unsigned long MB = static_cast<unsigned long>(1) << 20;
      static const unsigned long GB = static_cast<unsigned long>(1) << 30;

      DtDebugDrawerSharedMemoryManager(unsigned long memorySize=30*MB);

      virtual ~DtDebugDrawerSharedMemoryManager();

      virtual bool init(MemoryType memoryType, bool clearMemory=false);

      virtual bool init(
         std::string tag,
         bool clearMemory=false,
         MemoryType memoryType=DtDebugDrawerNameManager::DtDebugDrawerSharedMemoryVRFType);

      Header header() const;
      void setHeader(const Header&);

      long getName() const;

      bool enabled() const;
      void setEnabled(bool val);

      virtual bool push(DtDebugDrawerGeometryMemory* shape);


      virtual unsigned long frameCount() const;

      virtual unsigned long numEntries() const;

      virtual unsigned long currentSize() const;

      virtual const char* getNext(const char* previousPtr, DtDebugDrawerGeometryMemory** shape);

      virtual std::vector<DtDebugDrawerNameManager::Slot> getMemoryBlockNames();

      virtual bool pointToMemoryBlock(long name);

   protected:
      void readLock() const;
      void readUnlock() const;

      void startNewFrame(bool erase = true);
      void advanceFrameCount(bool outputErrors = true);

      unsigned long myRequestedMaxSize;

      unsigned long myCurrentSize;

      char* myCurrentMemPtr;

      char* myMemoryPtr;

      DtMemoryHeader* myHeader;

      LocalSharedMemoryPoolManager* myManager;
      DtSharedMemoryPoolClient* myClient;
      
      DtDebugDrawerNameManager* myNameManager;

      bool myIsReader;

      long myMemoryName;

      MemoryType myMemoryType;

      boost::scoped_array<char> myBuffer;
      size_t myBufferSize;
};

class DT_DLL_simTerrainDrawer DtMultiBufferDebugDrawer
{
public:
   static const unsigned long KB = DtDebugDrawerSharedMemoryManager::KB;
   static const unsigned long MB = DtDebugDrawerSharedMemoryManager::MB;
   static const unsigned long GB = DtDebugDrawerSharedMemoryManager::GB;

   typedef boost::shared_ptr<DtDebugDrawerSharedMemoryManager> BufferPtr;
   typedef std::vector<BufferPtr> BufferVector;

   class DT_DLL_simTerrainDrawer ScopedFrame : boost::noncopyable
   {
   public:
      ScopedFrame(DtMultiBufferDebugDrawer& drawer, bool erase=true);
      ~ScopedFrame();

      bool push(DtDebugDrawerGeometryMemory* shape);

   protected:
      DtMultiBufferDebugDrawer& myDrawer;
      DtScopedLock myFrameLock;
      bool myEraseFlag;
      unsigned long myNumDrawn;
      unsigned long myNumOverflows;
      BufferVector::iterator myCurrentBuffer;
      DtDebugDrawerSharedMemoryManager::ScopedFrame mySubFrame;
   };

   friend class ScopedFrame;

   static DtMultiBufferDebugDrawer* Make(
      std::string tag,
      unsigned long bufferSize = 5*MB,
      unsigned long maxSize = 50*MB,
      double factor = 1.0);

   explicit DtMultiBufferDebugDrawer(
      std::string tag,
      DtDebugDrawerNameManager::MemoryType type
         = DtDebugDrawerNameManager::DtDebugDrawerSharedMemoryVRFType,
      unsigned long bufferSize = 5*MB,
      unsigned long maxSize = 50*MB,
      double factor = 1.0);

   DtDebugDrawerSharedMemoryManager::Header header() const;
   void setHeader(const DtDebugDrawerSharedMemoryManager::Header&);

   bool enabled() const;
   void setEnabled(bool);

protected:
   BufferVector::iterator lastBuffer();

   mutable DtMutex myFrameMutex;
   std::string myTag;
   DtDebugDrawerSharedMemoryManager::Header myHeader;
   unsigned long myBufferSize;
   BufferVector myBuffers;
   DtDebugDrawerNameManager::MemoryType myType;
   double myFactor;
   bool myEnabledFlag;
};