memory.hpp

Go to the documentation of this file.

#ifndef PARGEMSLR_MEMORY_H
#define PARGEMSLR_MEMORY_H
 
#include <vector>
#include <unordered_map>
 
namespace pargemslr
{
   
   enum MemoryLocationEnum
   {
      kMemoryHost,
      kMemoryDevice,
      kMemoryUnified,
      kMemoryPinned
   };
   
   void* PargemslrMalloc( size_t length, int location);
   void* PargemslrCalloc( size_t length, int location);
   
   void* PargemslrRealloc( void* ptr, size_t current_length, size_t new_length, int location);
 
   void PargemslrMemcpy( void* ptr_to, const void* ptr_from, size_t length, int loc_to, int loc_from);
 
   void PargemslrFree( void* ptr, int location); 
 
#ifdef PARGEMSLR_DEBUG_MEMORY
 
   typedef struct MemoryDebuggerStruct
   {
      std::vector<char>                                                 _actions;
      
      std::vector<size_t>                                               _lengths;
      
      std::vector<void*>                                                _addresses;
      
      std::vector<std::string>                                          _filenames;
      
      std::vector<std::string>                                          _functions;
      
      std::vector<int>                                                  _line;
      
      static std::unordered_map< void*, MemoryDebuggerStruct>           _memory_tracker;
      
      static void InsertMemoryAction( char action, size_t length, const void *address, const char *filename, const char *function, const int line);
      
      static void CheckMemoryLocation( const void *ptr, int location, const char *filename, const char *function, const int line);
      
   }memory_debugger;
   
#endif
   
}
 
#ifdef PARGEMSLR_DEBUG_MEMORY
 
#define PARGEMSLR_MALLOC_VOID(ptr, length, location) {\
   (ptr) = pargemslr::PargemslrMalloc( (size_t)(length), location);\
   pargemslr::MemoryDebuggerStruct::InsertMemoryAction('m', (size_t)(length), (const void*)ptr, __FILE__, __func__, __LINE__);\
}
 
#define PARGEMSLR_MALLOC(ptr, length, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrMalloc( (size_t)(length)*sizeof(__VA_ARGS__), location);\
   pargemslr::MemoryDebuggerStruct::InsertMemoryAction('m', (size_t)(length)*sizeof(__VA_ARGS__), (const void*)ptr, __FILE__, __func__, __LINE__);\
}
 
#define PARGEMSLR_CALLOC_VOID(ptr, length, location) {\
   (ptr) = pargemslr::PargemslrCalloc( (size_t)(length), location);\
   pargemslr::MemoryDebuggerStruct::InsertMemoryAction('c', (size_t)(length), (const void*)ptr, __FILE__, __func__, __LINE__);\
}
 
#define PARGEMSLR_CALLOC(ptr, length, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrCalloc( (size_t)length*sizeof(__VA_ARGS__), location);\
   pargemslr::MemoryDebuggerStruct::InsertMemoryAction('c', (size_t)(length)*sizeof(__VA_ARGS__), (const void*)ptr, __FILE__, __func__, __LINE__);\
}
 
#define PARGEMSLR_REALLOC_VOID(ptr, current_length, new_length, location) {\
   (ptr) = pargemslr::PargemslrRealloc( (void*)(ptr), (size_t)(current_length), (size_t)(new_length), location);\
   pargemslr::MemoryDebuggerStruct::InsertMemoryAction('r', (size_t)(new_length), (const void*)ptr, __FILE__, __func__, __LINE__);\
}
 
#define PARGEMSLR_REALLOC(ptr, current_length, new_length, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrRealloc( (void*)(ptr), (size_t)(current_length)*sizeof(__VA_ARGS__), (size_t)(new_length)*sizeof(__VA_ARGS__), location);\
   pargemslr::MemoryDebuggerStruct::InsertMemoryAction('r', (size_t)(new_length)*sizeof(__VA_ARGS__), (const void*)ptr, __FILE__, __func__, __LINE__);\
}
 
#define PARGEMSLR_MEMCPY(ptr_to, ptr_from, length, loc_to, loc_from, ...) {\
   pargemslr::MemoryDebuggerStruct::CheckMemoryLocation( (const void*)(ptr_to), loc_to, __FILE__, __func__, __LINE__);\
   pargemslr::MemoryDebuggerStruct::CheckMemoryLocation( (const void*)(ptr_from), loc_from, __FILE__, __func__, __LINE__);\
   pargemslr::PargemslrMemcpy( (void*)(ptr_to), (void*)(ptr_from), (size_t)(length)*sizeof(__VA_ARGS__), loc_to, loc_from);\
}
 
#define PARGEMSLR_FREE( ptr, location) {\
   pargemslr::MemoryDebuggerStruct::CheckMemoryLocation( (const void*)ptr, location, __FILE__, __func__, __LINE__);\
   pargemslr::PargemslrFree( (void*)(ptr), location);\
   (ptr) = NULL;\
}
 
#else
 
#define PARGEMSLR_MALLOC_VOID(ptr, length, location) {\
   (ptr) = pargemslr::PargemslrMalloc( (size_t)(length), location);\
}
 
#define PARGEMSLR_MALLOC(ptr, length, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrMalloc( (size_t)(length)*sizeof(__VA_ARGS__), location);\
}
 
#define PARGEMSLR_CALLOC_VOID(ptr, length, location) {\
   (ptr) = pargemslr::PargemslrCalloc( (size_t)(length), location);\
}
 
#define PARGEMSLR_CALLOC(ptr, length, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrCalloc( (size_t)(length)*sizeof(__VA_ARGS__), location);\
}
 
#define PARGEMSLR_REALLOC_VOID(ptr, current_length, new_length, location) {\
   (ptr) = (void*) pargemslr::PargemslrRealloc( (void*)(ptr), (size_t)(current_length), (size_t)(new_length), location);\
}
 
#define PARGEMSLR_REALLOC(ptr, current_length, new_length, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrRealloc( (void*)(ptr), (size_t)(current_length)*sizeof(__VA_ARGS__), (size_t)(new_length)*sizeof(__VA_ARGS__), location);\
}
 
#define PARGEMSLR_MEMCPY(ptr_to, ptr_from, length, loc_to, loc_from, ...) {\
   pargemslr::PargemslrMemcpy( (void*)(ptr_to), (void*)(ptr_from), (size_t)(length)*sizeof(__VA_ARGS__), loc_to, loc_from);\
}
 
#define PARGEMSLR_FREE( ptr, location) {\
   pargemslr::PargemslrFree( (void*)(ptr), location);\
   (ptr) = NULL;\
}
 
#endif
 
#define PARGEMSLR_PLACEMENT_NEW(ptr, location, ...) {\
   (ptr) = (__VA_ARGS__*) pargemslr::PargemslrMalloc( (size_t)sizeof(__VA_ARGS__), location);\
   (ptr) = new (ptr) __VA_ARGS__();\
}
 
#endif