mlMemoryManager.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2008, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_MEMORY_MANAGER_H
#define ML_MEMORY_MANAGER_H
 
#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 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();
 
  /*
   * Returns \c true if registration was successful.
   * Returns \c false if memoryBlock is empty or registration fails, as deletion is already
   * ongoing.
   */
  template <typename T>
  static bool registerDeletionCallbackUnsafe(const T &handle, MLDeleteMemoryBlockCallback callback,
                                             void *userData);
 
  enum class Ownership{UserDataOwnershipStaysWithCaller,
                                     UserDataOwnershipGoesToMemoryBlock};
 
  template <typename T>
  static Ownership deregisterDeletionCallbackUnsafe(const T &handle,
                                                    MLDeleteMemoryBlockCallback callback,
                                                    const void *userData);
 

  template <typename T>
  void replaceDeletionCallback(const T &handle,
                                              MLDeleteMemoryBlockCallback newCallback,
                                              void *newUserData,
                                              MLDeleteMemoryBlockCallback *oldCallback = nullptr,
                                              void **oldUserData = nullptr) 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
};
 
extern template bool MLMEMORYMANAGER_EXPORT MLMemoryManager::registerDeletionCallbackUnsafe<MLWeakMemoryBlockHandle>(
    const MLWeakMemoryBlockHandle &handle, MLDeleteMemoryBlockCallback callback, void *userData);
 
extern template bool MLMEMORYMANAGER_EXPORT MLMemoryManager::registerDeletionCallbackUnsafe<MLMemoryBlockHandle>(
    const MLMemoryBlockHandle &handle, MLDeleteMemoryBlockCallback callback, void *userData);
 
extern template MLMemoryManager::Ownership MLMEMORYMANAGER_EXPORT
MLMemoryManager::deregisterDeletionCallbackUnsafe<MLWeakMemoryBlockHandle>(
    const MLWeakMemoryBlockHandle &handle, MLDeleteMemoryBlockCallback callback,
    const void *userData);
 
extern template MLMemoryManager::Ownership MLMEMORYMANAGER_EXPORT
MLMemoryManager::deregisterDeletionCallbackUnsafe<MLMemoryBlockHandle>(
    const MLMemoryBlockHandle &handle, MLDeleteMemoryBlockCallback callback, const void *userData);
 
 
extern template void MLMEMORYMANAGER_EXPORT MLMemoryManager::replaceDeletionCallback<MLWeakMemoryBlockHandle>(
    const MLWeakMemoryBlockHandle &handle, MLDeleteMemoryBlockCallback newCallback,
    void *newUserData, MLDeleteMemoryBlockCallback *oldCallback, void **oldUserData) const;
 
extern template void MLMEMORYMANAGER_EXPORT MLMemoryManager::replaceDeletionCallback<MLMemoryBlockHandle>(
    const MLMemoryBlockHandle &handle, MLDeleteMemoryBlockCallback newCallback, void *newUserData,
    MLDeleteMemoryBlockCallback *oldCallback, void **oldUserData) const;
 
 
#endif // MLMEMORYMANAGER_H_INCLUDED