MemoryDebug.h

/* 
A* -------------------------------------------------------------------
B* This file contains source code for the PyMOL computer program
C* copyright 1998-2000 by Warren Lyford Delano of DeLano Scientific. 
D* -------------------------------------------------------------------
E* It is unlawful to modify or remove this copyright notice.
F* -------------------------------------------------------------------
G* Please see the accompanying LICENSE file for further information. 
H* -------------------------------------------------------------------
I* Additional authors of this source file include:
-* 
-* 
-*
Z* -------------------------------------------------------------------
*/
#ifndef _H_MemoryDebug
#define _H_MemoryDebug

#include "os_std.h"
#include "PyMOLGlobals.h"

#ifdef OV_JENARIX


/* NEW Jenarix-based MemoryDebug wrapper */

#include "ov_port.h"

#define mmalloc(size) OV_HEAP_MALLOC_RAW_VOID(size)
#define mcalloc(num,size) OV_HEAP_CALLOC_RAW_VOID((num)*(ov_size)(size))
#define mrealloc(ptr,size) OV_HEAP_REALLOC_RAW_VOID(ptr,size)
#define mfree(ptr) OV_HEAP_FREE_RAW(ptr)

#define ReallocForSure(ptr,type,size) OV_HEAP_REALLOC_RAW_RECOPY(ptr,type,size,size)
#define ReallocForSureSafe(ptr,type,size,old_size) OV_HEAP_REALLOC_RAW_RECOPY(ptr,type,size,old_size)

#define MemoryDebugDump() ov_heap_dump(0)
#define MemoryDebugUsage() ov_heap_usage()

#define VLAlloc(type,init_size) OV_HEAP_VLA_MALLOC_RAW(type, init_size)

#ifndef OV_HEAP_TRACKER
#define VLAMalloc(init_size, unit_size, grow_factor, auto_zero) \
    ov_heap_VlaAllocRaw(unit_size, init_size, auto_zero)
#define VLACheck(vla,type,idx) \
   (vla=(type*)(((((ov_size)idx)>=((Ov_HeapVLA*)(vla))[-1].size) ? \
    ov_heap_VlaAddIndexRaw(vla,((ov_size)idx)) : (vla))))
#else
#define VLAMalloc(init_size, unit_size, grow_factor, auto_zero) \
    ov_heap_VlaAllocRaw(unit_size, init_size, auto_zero, OV__FILE__, OV__LINE__)
#define VLACheck(vla,type,idx) \
   (vla=(type*)(((((ov_size)idx)>=((Ov_HeapVLA*)(vla))[-1].size) ? \
    ov_heap_VlaAddIndexRaw(vla,((ov_size)idx), OV__FILE__, OV__LINE__) : (vla))))
#endif

#define VLACalloc(type,init_size) OV_HEAP_VLA_CALLOC_RAW(type, init_size)
#define VLAFreeP(ptr) {if(ptr) {OV_HEAP_VLA_FREE_RAW(ptr);ptr=NULL;}}
#define VLAFree(ptr) OV_HEAP_VLA_FREE_RAW(ptr)
#define VLASize(ptr,type,size) {ptr=(type*)OV_HEAP_VLA_SET_SIZE_RAW(ptr,size);}
#define VLASetSize(ptr,size) OV_HEAP_VLA_SET_SIZE_RAW(ptr,size)
#define VLAGetSize(ptr) OV_HEAP_VLA_GET_SIZE_RAW(ptr)
#define VLASizeForSure(ptr,type,size) {ptr=(type*)OV_HEAP_VLA_SET_SIZE_RAW_RECOPY(ptr,size);}
#define VLASetSizeForSure(ptr,size) OV_HEAP_VLA_SET_SIZE_RAW_RECOPY(ptr,size);
#define VLACopy(ptr,type) (type*)OV_HEAP_VLA_CLONE_RAW(ptr)
#define VLANewCopy(ptr) OV_HEAP_VLA_CLONE_RAW(ptr)

#define Alloc(type,size) ((type*)mmalloc(sizeof(type)*(size)))
#define Calloc(type,size) ((type*)mcalloc(sizeof(type),size))
#define Realloc(ptr,type,size) ((type*)mrealloc(ptr,sizeof(type)*(size))

#define FreeP(ptr) {if(ptr) {mfree(ptr);ptr=NULL;}}

OV_INLINE_STATIC void MemoryZero(char *p, char *q)
{
  if(q > p)
    ov_os_memset(p, 0, q - p);
}

#else


/* OLD proven MemoryDebug implementation */


/* This file can be included by C and C++ programs for
   debugging of malloc, realloc, free in C and in addition,
   of new and delete in C++ 

  it also includes a two functions for variable length arrays

  In order to use the debugging system, you must do the following...

  * use mmalloc for malloc
  * use mcalloc for calloc
  * use mrealloc for mrealloc
  * use mfree for free

*/


/* ==================== Master Switch ============================= 
 * Define _MemoryDebug_ON to enable the debugging system...*/


/* WARNING!!! MemoryDebug is not thread safe...it must be disabled
   for stable multi-threaded operation within the PyMOL core */

#define _MemoryDebug_OFF


/* ================================================================ 
 * Don't touch below unless you know what you are doing */

void UtilMemCpy(void *dst, void *src, unsigned int *size);

typedef struct VLARec {
  ov_size size, unit_size;
  float grow_factor;
  int auto_zero;
} VLARec;


/* NOTE: in VLACheck, rec is a zero based array index, not a record count */
#define VLACheck(ptr,type,rec) (ptr=(type*)(((((ov_size)rec)>=((VLARec*)(ptr))[-1].size) ? VLAExpand(ptr,((ov_size)rec)) : (ptr))))

#define VLAlloc(type,init_size) (type*)VLAMalloc(init_size,sizeof(type),5,0)
#define VLACalloc(type,init_size) (type*)VLAMalloc(init_size,sizeof(type),5,1)
#define VLAFreeP(ptr) {if(ptr) {VLAFree(ptr);ptr=NULL;}}
#define VLASize(ptr,type,size) {ptr=(type*)VLASetSize(ptr,size);}
#define VLASizeForSure(ptr,type,size) {ptr=(type*)VLASetSizeForSure(ptr,size);}
#define VLACopy(ptr,type) (type*)VLANewCopy(ptr);
#define VLAInsert(ptr,type,index,count) {ptr=(type*)VLAInsertRaw(ptr,index,count);}
#define VLADelete(ptr,type,index,count) {ptr=(type*)VLADeleteRaw(ptr,index,count);}

#define Alloc(type,size) (type*)mmalloc(sizeof(type)*(size))
#define Calloc(type,size) (type*)mcalloc(sizeof(type),size)
#define Realloc(ptr,type,size) (type*)mrealloc(ptr,sizeof(type)*(size))

#define FreeP(ptr) {if(ptr) {mfree(ptr);ptr=NULL;}}

void *VLAExpand(void *ptr, ov_size rec);        /* NOTE: rec is index (total-1) */
void *MemoryReallocForSure(void *ptr, unsigned int newSize);
void *MemoryReallocForSureSafe(void *ptr, unsigned int newSize, unsigned int oldSize);

void *VLADeleteRaw(void *ptr, int index, unsigned int count);
void *VLAInsertRaw(void *ptr, int index, unsigned int count);

#ifndef _MemoryDebug_ON
void *VLAMalloc(ov_size init_size, ov_size unit_size, unsigned int grow_factor, int auto_zero); /*growfactor 1-10 */

#else
#define VLAMalloc(a,b,c,d) _VLAMalloc(__FILE__,__LINE__,a,b,c,d)

void *_VLAMalloc(const char *file, int line, ov_size init_size, ov_size unit_size, unsigned int grow_factor, int auto_zero);    /*growfactor 1-10 */
#endif

void VLAFree(void *ptr);
void *VLASetSize(void *ptr, unsigned int newSize);
void *VLASetSizeForSure(void *ptr, unsigned int newSize);

unsigned int VLAGetSize(void *ptr);
void *VLANewCopy(void *ptr);
void MemoryZero(char *p, char *q);

#ifndef _MemoryDebug_ON


/* _MemoryDebug_ON not defined */

#define mcalloc calloc
#define mmalloc malloc
#define mrealloc realloc
#define mfree free
#define ReallocForSure(ptr,type,size) (type*)MemoryReallocForSure(ptr,sizeof(type)*(size))
#define ReallocForSureSafe(ptr,type,size,old_size) (type*)MemoryReallocForSure(ptr,sizeof(type)*(size),sizeof(type)*(old_size))

#define MemoryDebugDump()

#ifdef __cplusplus
#define mnew new
#endif

#define MD_FILE_LINE_Call
#define MD_FILE_LINE_Decl
#define MD_FILE_LINE_Nest
#define MD_FILE_LINE_PTR_Call

#else


/* _MemoryDebug_ON is defined */

#ifdef __cplusplus
extern "C" {
#endif

#define _MDPointer 1

#define MD_FILE_LINE_Call ,__FILE__,__LINE__
#define MD_FILE_LINE_Decl ,const char *file,int line
#define MD_FILE_LINE_Nest ,file,line
#define MD_FILE_LINE_PTR_Call ,__FILE__,__LINE__,_MDPointer

#define mmalloc(x) MemoryDebugMalloc(x,__FILE__,__LINE__,_MDPointer)
#define mcalloc(x,y) MemoryDebugCalloc(x,y,__FILE__,__LINE__,_MDPointer)
#define mrealloc(x,y) MemoryDebugRealloc(x,y,__FILE__,__LINE__,_MDPointer)
#define mfree(x) MemoryDebugFree(x,__FILE__,__LINE__,_MDPointer)

#define ReallocForSure(ptr,type,size) (type*)MemoryDebugReallocForSure(ptr,sizeof(type)*(size),__FILE__,__LINE__,_MDPointer)
#define ReallocForSureSafe(ptr,type,size,old_size) (type*)MemoryDebugReallocForSureSafe(ptr,sizeof(type)*(size),\
                    sizeof(type)*(old_size),__FILE__,__LINE__,_MDPointer)

  void *MemoryDebugMalloc(size_t size, const char *file, int line, int type);
  void *MemoryDebugCalloc(size_t nmemb, size_t size, const char *file, int line,
                          int type);
  void *MemoryDebugRealloc(void *ptr, size_t size, const char *file, int line, int type);
  void *MemoryDebugReallocForSure(void *ptr, size_t size, const char *file,
                                  int line, int type);
  void *MemoryDebugReallocForSureSafe(void *ptr, size_t size, size_t old_size,
                                      const char *file, int line, int type);

  void MemoryDebugFree(void *ptr, const char *file, int line, int type);
  void MemoryDebugQuietFree(void *ptr, int type);

  void MemoryDebugDump(void);
  int MemoryDebugUsage(void);

#ifdef __cplusplus
} void *operator   new(size_t size, const char *file, int line);

#define mnew new(__FILE__,__LINE__)

#endif

#endif
#endif

#endif