MeVis/Foundation/Sources/MLMemoryManager/Include/mlMemoryManager.h

Go to the documentation of this file.

// **InsertLicense** code
//-----------------------------------------------------------------------------
// The memory manager.
//
// \file    mlMemoryManager.h
// \author  Marcus Barann
// \date    03/2008
//
//-----------------------------------------------------------------------------

#ifndef MLMEMORYMANAGER_H_INCLUDED
#define MLMEMORYMANAGER_H_INCLUDED

#include <iosfwd>
#include <string>

#include "../mlMemoryManagerDllExport.h"
#include "mlDeleteMemoryBlockCallback.h"
#include "mlMemoryBlockHandle.h"

// Included for convenience, i.e. a user needs only to
// include this header file.
#include "mlWeakMemoryBlockHandle.h"



#define ML_BYTE_TO_KB(x) ((x) >> 10)

#define ML_BYTE_TO_MB(x) ((x) >> 20)

#define ML_BYTE_TO_GB(x) ((x) >> 30)

#define ML_KB_TO_BYTE(x) ((x) << 10)

#define ML_MB_TO_BYTE(x) ((x) << 20)

#define ML_GB_TO_BYTE(x) ((x) << 30)
 // End of group Macros

MLMEMORYMANAGER_EXPORT std::string mlByteToHumanReadable(size_t byte);


#ifndef DOXYGEN_SHOULD_SKIP_THIS

class MLMemoryManagerPrivate;

#endif // DOXYGEN_SHOULD_SKIP_THIS

namespace boost
{
  class mutex;
}


enum MLMemoryManagerErrorHandlingType
{
  NotifyUser,

  Abort
};


typedef void (*MLMemoryManagerErrorHandler)(const std::string& message, const char* file, int line,
                                            MLMemoryManagerErrorHandlingType errorHandling);


class MLMEMORYMANAGER_EXPORT MLMemoryManager
{
public:
  static void initialize();

  static void deinitialize();

  static MLMemoryManager* singleton();

  ~MLMemoryManager();








  MLMemoryBlockHandle allocate(unsigned int id, size_t size);

  MLMemoryBlockHandle addAllocatedMemory(unsigned int                id,
                                         void*                       data,
                                         size_t                      size,
                                         MLDeleteMemoryBlockCallback deleteMemoryBlockCallback,
                                         void*                       deleteMemoryBlockCallbackUserData);

  void deleteMemoryBlockData(void* data);

  void setCacheAndLockedMemorySizeLimit(const size_t cacheSizeLimit);

  size_t clearCachedMemory(size_t numBytes);

  void clearCache();

  void clearCacheToLimit();

  size_t cacheAndLockedMemorySizeLimit() const;

  size_t cacheSize() const;

  size_t lockedMemorySize() const;

  size_t cacheAndLockedMemorySize() const;

  void printCache(std::ostream& out) const;

  void setStatisticsEnabled(bool enabled);

  void printStatistics(std::ostream& out);
 // End of group ThreadSafe

  unsigned int registerLibrary(const std::string& libraryName);

  void setErrorHandlingCallback(MLMemoryManagerErrorHandler errorHandler);



  boost::mutex& getCacheAccessMutex();

  void replaceDeletionCallback(const MLMemoryBlockHandle& handle,
                               MLDeleteMemoryBlockCallback  newCallback, void*  newUserData,
                               MLDeleteMemoryBlockCallback* oldCallback = NULL, void** oldUserData = NULL) const;

  void replaceDeletionCallback(const MLWeakMemoryBlockHandle& handle,
                               MLDeleteMemoryBlockCallback  newCallback, void*  newUserData,
                               MLDeleteMemoryBlockCallback* oldCallback = NULL, void** oldUserData = NULL) const;

  void clearMemoryBlockHandles(MLMemoryBlockHandle** handles, size_t handleCount);

  void clearMemoryBlockHandles(MLWeakMemoryBlockHandle** handles, size_t handleCount);


private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  MLMemoryManager(size_t cacheSizeLimit);
  MLMemoryManager(const MLMemoryManager&);
  MLMemoryManager& operator=(const MLMemoryManager&);


private:
  MLMemoryManagerPrivate* _private;

  friend class MLMemoryBlock;
  friend class MLMemoryBlockHandle;
  friend class MLWeakMemoryBlockHandle;
#endif
};

#endif // MLMEMORYMANAGER_H_INCLUDED