140 lines
6.8 KiB
C++
140 lines
6.8 KiB
C++
|
|
# ifndef SR_MEM_CONTROL_H
|
|
# define SR_MEM_CONTROL_H
|
|
|
|
# include <stdlib.h>
|
|
|
|
/** \file sr_mem_control.h
|
|
* Functions and macros to control memory allocation.
|
|
* The idea of usage is similar to sr_trace.h: only inside
|
|
* files that testing memory allocation is required that the activation
|
|
* of macros should be defined. */
|
|
|
|
/*! This function saves in an internal buffer the given parameters
|
|
in order to keep track of allocated memory.
|
|
It may be used by replacing new/malloc calls to:
|
|
\code sr_mem_control_alloc("X",__FILE__,__LINE__,sizeof(X),new X) \endcode
|
|
Then sr_memory_report() can be called to see all allocated data that was not
|
|
freed. It is better to use this function with the macros SR_NEW and SR_MALLOC. */
|
|
void* sr_mem_control_alloc ( const char* type, char* file, int line, int size, void* addr );
|
|
|
|
/*! This function erases from the internal buffer the given address
|
|
of memory, that was previously registered with sr_mem_control_alloc().
|
|
It is to be used replacing delete/free calls in the following way:
|
|
\code sr_mem_control_free(__FILE__,__LINE__,X); delete X; \endcode
|
|
It is better to use this function with the macros SR_DEL, SR_DELA and SR_FREE. */
|
|
bool sr_mem_control_free ( char* file, int line, void* addr );
|
|
|
|
/*! This function performs a call to realloc(addr,size), and returns the new
|
|
pointer. But it also updates the pointers saved in the internal buffer in
|
|
order to keep track of allocated memory.
|
|
It may be used replacing realloc calls in the following way:
|
|
\code pt=sr_mem_control_realloc(__FILE__,__LINE__,newsize,pt) \endcode
|
|
It is better to use this function with the macro SR_REALLOC. */
|
|
void* sr_mem_control_realloc ( char* file, int line, int size, void* addr );
|
|
|
|
/*! This function gives a report about all allocated data that was not freed
|
|
using sr_out. But to make it work, the user needs to change all
|
|
new/malloc/delete/free calls by calls to the macros SR_NEW, SR_MALLOC,
|
|
SR_REALLOC, SR_DEL, SR_DELA, SR_FREE or functions
|
|
sr_mem_control_alloc/free/realloc. */
|
|
void sr_memory_report ();
|
|
|
|
/*! Returns the total of memory allocated. Only the memory allocated using
|
|
sr_mem_control_alloc/free/realloc, or the related macros are taken into account. */
|
|
unsigned sr_memory_allocated ();
|
|
|
|
class SrOutput;
|
|
|
|
/*! Changes the output used for the reports. */
|
|
void sr_memory_report_output ( SrOutput& o );
|
|
|
|
# ifdef SR_USE_MEM_CONTROL
|
|
# define SR_DEL(X) if (sr_mem_control_free(__FILE__,__LINE__,X)) delete X;
|
|
# define SR_DELA(X) if (sr_mem_control_free(__FILE__,__LINE__,X)) delete[] X;
|
|
# define SR_FREE(p) if (sr_mem_control_free(__FILE__,__LINE__,p)) free(p);
|
|
# define SR_NEW(X) ((X*)sr_mem_control_alloc(#X,__FILE__,__LINE__,sizeof(X),new X))
|
|
# define SR_NEW1(X,A) ((X*)sr_mem_control_alloc(#X,__FILE__,__LINE__,sizeof(X),new X(A)))
|
|
# define SR_NEW2(X,A,B) ((X*)sr_mem_control_alloc(#X,__FILE__,__LINE__,sizeof(X),new X(A,B)))
|
|
# define SR_NEWA(X,s) ((X*)sr_mem_control_alloc(#X,__FILE__,__LINE__,sizeof(X),new X[s]))
|
|
# define SR_MALLOC(s) sr_mem_control_alloc("malloc",__FILE__,__LINE__,s,malloc(s))
|
|
# define SR_REALLOC(p,s) sr_mem_control_realloc(__FILE__,__LINE__,s,p)
|
|
# else
|
|
# define SR_DEL(X) delete X
|
|
# define SR_DELA(X) delete[] X
|
|
# define SR_FREE(p) free(p)
|
|
# define SR_NEW(X) new X
|
|
# define SR_NEW1(X,A) new X(A)
|
|
# define SR_NEW2(X,A,B) new X(A,B)
|
|
# define SR_MALLOC(s) malloc(s)
|
|
# define SR_REALLOC(p,s) realloc(p,s)
|
|
# endif
|
|
|
|
/*! \def SR_DEL(X)
|
|
The user needs to use SR_DEL in place of delete, in order to be able to
|
|
use sr_memory_report() for obtaining a report of memory that was allocated
|
|
but not freed.
|
|
But to activate this define, the user must define SR_USE_MEM_CONTROL before
|
|
including the header sr_mem_control.h. Otherwise this define will just
|
|
directly call delete, with no overhead to the compiled code.
|
|
Use: SR_DEL(X); instead of delete X; */
|
|
|
|
/*! \def SR_DELA(X)
|
|
The user needs to use SR_DELA in place of delete[], in order to be able to
|
|
use sr_memory_report() for obtaining a report of memory that was allocated
|
|
but not freed.
|
|
But to activate this define, the user must define SR_USE_MEM_CONTROL before
|
|
including the header sr_mem_control.h. Otherwise this define will just
|
|
directly call delete[], with no overhead to the compiled code.
|
|
Use: SR_DELA(X); instead of delete[] X; */
|
|
|
|
/*! \def SR_FREE(p)
|
|
The user needs to use SR_FREE in place of free(), in order to be able to use
|
|
sr_memory report() for obtaining a report of memory that was allocated but
|
|
not freed.
|
|
But to activate this define, the user must define SR_USE_MEM_CONTROL before
|
|
including the header sr_mem_control.h. Otherwise this define will just directly
|
|
call free(), with no overhead to the compiled code.
|
|
Use: SR_FREE(p); instead of free(p); */
|
|
|
|
/*! \def SR_NEW(X)
|
|
The user needs to use SR_NEW in place of new, in order to be able to use
|
|
sr_memory report() for obtaining a report of memory that was allocated but
|
|
not freed.
|
|
But to activate this define, the user must define SR_USE_MEM_CONTROL before
|
|
including the header sr_mem_control.h. Otherwise this define will just
|
|
directly call new, with no overhead to the compiled code.
|
|
Use: pt=SR_NEW(X); instead of pt=new X; */
|
|
|
|
/*! \def SR_NEW1(X,A)
|
|
Equivalent to macro SR_NEW, but allows to set one initialisation parameter for
|
|
the constructor of class X.
|
|
Use: pt=SR_NEW(X,A); instead of pt=new X(A); */
|
|
|
|
/*! \def SR_NEW2(X,A,B)
|
|
Equivalent to macro SR_NEW, but allows to set two initialisation parameters for
|
|
the constructor of class X.
|
|
Use: pt=SR_NEW(X,A,B); instead of pt=new X(A,B); */
|
|
|
|
/*! \def SR_MALLOC(s)
|
|
The user needs to use SR_MALLOC in place of malloc(), in order to be able
|
|
to use sr_memory report() for obtaining a report of memory that was allocated
|
|
but not freed.
|
|
But to activate this define, the user must define SR_USE_MEM_CONTROL before
|
|
including the header sr_mem_control.h. Otherwise this define will just directly
|
|
call malloc(), with no overhead to the compiled code.
|
|
Use: pt=SR_MALLOC(s); instead of pt=malloc(s); */
|
|
|
|
/*! \def SR_REALLOC(p,s)
|
|
The user needs to use SR_REALLOC in place of realloc(), in order to be able to
|
|
use sr_memory report() for obtaining a report of memory that was allocated but
|
|
not freed.
|
|
But to activate this define, the user must define SR_USE_MEM_CONTROL before
|
|
including the header sr_mem_control.h. Otherwise this define will just directly
|
|
call realloc(), with no overhead to the compiled code.
|
|
Use: pt=SR_REALLOC(p,s); instead of pt=realloc(p,s); */
|
|
|
|
//============================= end of file ==========================
|
|
|
|
# endif // SR_MEM_CONTROL_H
|