memory.h File Reference

#include <mrpt/utils/core_defs.h>
#include <cstring>

Include dependency graph for memory.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
	mrpt
	This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
	mrpt::system
	This namespace provides a OS-independent interface to many useful functions: filenames manipulation, time and date, string parsing, file I/O, threading, memory allocation, etc.
	mrpt::system::os
	This namespace provides a OS-independent interface to low-level functions.

Macros
#define	mrpt_alloca(nBytes)   ::malloc( nBytes )
	In platforms and compilers with support to "alloca", allocate a memory block on the stack; if alloca is not supported, it is emulated as a normal "malloc" - NOTICE: Since in some platforms alloca will be emulated with malloc, alloca_free MUST BE ALWAYS CALLED to avoid memory leaks. More...
#define	mrpt_alloca_free(mem_block)   free(mem_block)
	This method must be called to "free" each memory block allocated with "system::alloca": If the block was really allocated in the stack, no operation is actually performed, otherwise it will be freed from the heap. More...
#define	MRPT_MAKE_ALIGNED_OPERATOR_NEW

Functions
unsigned long BASE_IMPEXP	mrpt::system::getMemoryUsage ()
	Returns the memory occupied by this process, in bytes. More...
void BASE_IMPEXP *	mrpt::system::os::aligned_malloc (size_t bytes, size_t alignment)
	Returns an aligned memory block. More...
void *	mrpt::system::os::aligned_calloc (size_t bytes, size_t alignment)
	Identical to aligned_malloc, but it zeroes the reserved memory block. More...
void BASE_IMPEXP *	mrpt::system::os::aligned_realloc (void *old_ptr, size_t bytes, size_t alignment)
	Frees a memory block reserved by aligned_malloc. More...
void BASE_IMPEXP	mrpt::system::os::aligned_free (void *p)
	Frees a memory block reserved by aligned_malloc. More...
template<typename _Tp >
_Tp *	mrpt::system::os::align_ptr (_Tp *ptr, int n=(int) sizeof(_Tp))
	Returns a pointer a bit forward in memory so it's aligned for the given boundary size. More...
template<int bytes>
bool	mrpt::system::is_aligned (const void *ptr)
template<>
bool	mrpt::system::is_aligned< 8 > (const void *ptr)
template<>
bool	mrpt::system::is_aligned< 16 > (const void *ptr)

Macro Definition Documentation

MRPT_MAKE_ALIGNED_OPERATOR_NEW

#define MRPT_MAKE_ALIGNED_OPERATOR_NEW

Value:

void *operator new(size_t size)  { return mrpt::system::os::aligned_malloc(size,16); } \
                void *operator new[](size_t size){ return mrpt::system::os::aligned_malloc(size,16); } \
                void operator delete(void * ptr) MRPT_NO_THROWS { mrpt::system::os::aligned_free(ptr); } \
                void operator delete[](void * ptr) MRPT_NO_THROWS { mrpt::system::os::aligned_free(ptr); } \
                /* in-place new and delete. since (at least afaik) there is no actual   */ \
                /* memory allocated we can safely let the default implementation handle */ \
                /* this particular case. */ \
                static void *operator new(size_t size, void *ptr) { return ::operator new(size,ptr); } \
                void operator delete(void * memory, void *ptr) MRPT_NO_THROWS { return ::operator delete(memory,ptr); } \
                /* nothrow-new (returns zero instead of std::bad_alloc) */ \
                void* operator new(size_t size, const std::nothrow_t&) MRPT_NO_THROWS { try { return mrpt::system::os::aligned_malloc(size,16); } catch (...) { return 0; } } \
                void operator delete(void *ptr, const std::nothrow_t&) MRPT_NO_THROWS { mrpt::system::os::aligned_free(ptr); }

Definition at line 112 of file memory.h.