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 true, if registration was successful
   * returns false, if memoryBlock is empty or registration fails, because 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