pegasus/src/Pegasus/suballoc/Attic/suballoc.h - diff

Return to suballoc.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / suballoc / Attic

Diff for /pegasus/src/Pegasus/suballoc/Attic/suballoc.h between version 1.4 and 1.25

version 1.4, 2002/05/06 16:18:22

version 1.25, 2002/05/14 18:15:23

Line 18

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

//============================================================================

// Author: Mike Day (mdday@us.ibm.com)

Line 30

#define PEGASUS_SUBALLOC_INCLUDE 1

#include <Pegasus/Common/Config.h>

#include <Pegasus/suballoc/Linkage.h>

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

#include <windows.h>

#include <process.h>

#include <stdio.h>

#include <malloc.h>

#include <stdlib.h>

#elif defined (PEGASUS_PLATFORM_LINUX_IX86_GNU)

#include <pthread.h>

#include <semaphore.h>

Line 45

Line 49

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>

typedef pthread_mutex_t PEGASUS_MUTEX_T;

#elif defined (PEGASUS_PLATFORM_HPUX_PARISC_ACC)

#include <sched.h>

Line 71

Line 74

#include <pthread.h>

#include <unistd.h>

typedef Uint32 PEGASUS_MUTEX_T;

#elif defined (PEGASUS_PLATFORM_LINUX_IA64_GNU)

#include <sched.h>

#include <semaphore.h>

Line 91

Line 92

#include <malloc.h>

#include <errno.h>

#include <signal.h>

#include <new.h>

namespace

{

static const int GUARD_SIZE = 0x10;

static const int MAX_PATH_LEN = 0xff;

static const int MAX_LINE_LEN = 0x14;

static const int MAX_CLASS_LEN = 0x40;

static const int PRE_ALLOCATE = 0x00;

static const int STEP_ALLOCATE = 0x01;

static const int AVAILABLE = 0x00;

static const int NORMAL = 0x00;

static const int ARRAY = 0x01;

static const unsigned int IS_HEAD_NODE = 0x00000001;

static const unsigned int AVAIL = 0x00000002;

static const unsigned int ARRAY_NODE = 0x00000004;

static const unsigned int CHECK_FAILED = 0x00000008;

static const unsigned int ALREADY_DELETED = 0x00000010;

static const unsigned int OVERWRITE = 0x00000020;

static const unsigned int CHECK_LEAK = 0x00000040;

static const unsigned int HUGE_NODE = 0x00000080;

}

PEGASUS_NAMESPACE_BEGIN

struct SUBALLOC_HANDLE;

#if defined(PEGASUS_DEBUG_MEMORY)

PEGASUS_SUBALLOC_LINKAGE void * pegasus_alloc(size_t,

void *,

int type,

const Sint8 *classname,

Sint8 *file,

Uint32 line );

PEGASUS_SUBALLOC_LINKAGE void pegasus_free(void *dead,

void *,

int type,

Sint8 *classname,

Sint8 *file,

Uint32 line);

#else

PEGASUS_SUBALLOC_LINKAGE void * pegasus_alloc(size_t);

PEGASUS_SUBALLOC_LINKAGE void pegasus_free(void *);

#endif

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

#define ENOTSOCK WSAENOTSOCK

Line 147

Line 194

#endif

// to reduce the number of wasted bytes:

// reduce GUARD_SIZE

// eliminate guard checking from SUBALLOC_NODEs

class PEGASUS_SUBALLOC_LINKAGE peg_suballocator

class peg_suballoc;

{

public:

#if defined(PEGASUS_DEBUG_MEMORY)

#define PEGASUS_NEW(a, h) new((pegasus_alloc(sizeof(a), ((void *)h), NORMAL, (#a), __FILE__, __LINE__)))

#define PEGASUS_ARRAY_NEW(a, i, h) new(pegasus_alloc(sizeof(a) * (i), ((void *)(h)), ARRAY, (#a), __FILE__, __LINE__)) (a)

#define PEGASUS_DELETE(a) pegasus_free((a), NULL, NORMAL, (#a), __FILE__, __LINE__)

#define PEGASUS_ARRAY_DELETE(a) pegasus_free(a, NULL, ARRAY, (#a), __FILE__, __LINE__)

#define PEGASUS_CHECK_FOR_LEAKS(h) peg_suballocator::get_instance()->_UnfreedNodes((h))

#define PEGASUS_START_LEAK_CHECK() peg_suballocator::get_instance()->set_leak_mode(true)

#define PEGASUS_STOP_LEAK_CHECK() peg_suballocator::get_instance()->set_leak_mode(false)

#else

#define PEGASUS_NEW(a, h) new

#define PEGASUS_ARRAY_NEW(a, i, h) new a[(i)]

#define PEGASUS_DELETE(a) delete((a))

#define PEGASUS_ARRAY_DELETE(a) delete [] ((a))

#define PEGASUS_CHECK_FOR_LEAKS(h)

#define PEGASUS_START_LEAK_CHECK()

#define PEGASUS_STOP_LEAK_CHECK()

#endif

class PEGASUS_SUBALLOC_LINKAGE peg_suballocator

{

private:

peg_suballocator(const peg_suballocator &);

peg_suballocator & operator = (const peg_suballocator &);

Boolean _debug;

typedef struct _subAllocTemplate {

struct _subAllocNode *next;

struct _subAllocNode *prev;

Boolean isHead;

Boolean avail;

Uint32 allocSize;

Uint8 guardPre[GUARD_SIZE];

} SUB_TEMPLATE;

typedef struct _subAllocNode {

struct _subAllocNode *next;

struct _subAllocNode *prev;

Boolean isHead;

Uint32 flags;

Boolean avail;

Uint32 allocSize;

Uint8 guardPre[GUARD_SIZE];

Uint32 nodeSize;

void *allocPtr;

void *concurrencyHandle;

Uint8 guardPost[GUARD_SIZE];

#if defined(PEGASUS_DEBUG_MEMORY)

Sint8 file[MAX_PATH_LEN + 1];

Sint8 line[MAX_LINE_LEN + 1];

void *concurrencyHandle;

Sint8 classname[MAX_CLASS_LEN + 1];

Sint8 d_file[MAX_PATH_LEN + 1];

Sint8 d_line[MAX_LINE_LEN + 1];

Sint8 d_classname[MAX_CLASS_LEN + 1];

Uint8 guardPre[GUARD_SIZE];

#endif

} SUBALLOC_NODE;

SUBALLOC_NODE *nodeListHeads[3][16];

PEGASUS_MUTEX_T globalSemHandle;

Line 194

Line 256

Uint32 totalAllocs;

Uint32 totalMemoryInUse;

static const Uint32 preAlloc[][16];

static const Uint32 preAlloc[3][16];

static const Uint32 step[][16];

static const Uint32 step[3][16];

Sint32 initialized;

Sint32 init_count;

PEGASUS_MUTEX_T init_mutex;

Boolean debug_mode;

Boolean abort_on_error;

Boolean check_for_leaks;

public:

int CREATE_MUTEX(PEGASUS_MUTEX_T *mut);

static int CREATE_MUTEX(PEGASUS_MUTEX_T *mut);

void WAIT_MUTEX(PEGASUS_MUTEX_T *mut, Uint32 msec, int *result);

static void WAIT_MUTEX(PEGASUS_MUTEX_T *mut, Uint32 msec, int *result);

void WAIT_MUTEX(PEGASUS_MUTEX_T *mut);

static void WAIT_MUTEX(PEGASUS_MUTEX_T *mut);

void RELEASE_MUTEX(PEGASUS_MUTEX_T *mut);

static void RELEASE_MUTEX(PEGASUS_MUTEX_T *mut);

void CLOSE_MUTEX(PEGASUS_MUTEX_T *mut);

static void CLOSE_MUTEX(PEGASUS_MUTEX_T *mut);

private:

Boolean IS_HEAD(SUBALLOC_NODE *x);

static Boolean IS_ARRAY(SUBALLOC_NODE *x);

void INSERT(SUBALLOC_NODE *new_node, SUBALLOC_NODE *after);

static Boolean IS_HEAD(SUBALLOC_NODE *x);

void INSERT_AFTER(SUBALLOC_NODE *new_node, SUBALLOC_NODE *after);

static void INSERT(SUBALLOC_NODE *new_node, SUBALLOC_NODE *after);

void INSERT_BEFORE(SUBALLOC_NODE *new_node, SUBALLOC_NODE *before);

static void INSERT_AFTER(SUBALLOC_NODE *new_node, SUBALLOC_NODE *after);

void _DELETE(SUBALLOC_NODE *x);

static void INSERT_BEFORE(SUBALLOC_NODE *new_node, SUBALLOC_NODE *before);

Boolean IS_LAST(SUBALLOC_NODE *head, SUBALLOC_NODE *node);

static void _DELETE(SUBALLOC_NODE *x);

Boolean IS_FIRST(SUBALLOC_NODE *head, SUBALLOC_NODE *node);

static Boolean IS_LAST(SUBALLOC_NODE *head, SUBALLOC_NODE *node);

Boolean IS_ONLY(SUBALLOC_NODE *head, SUBALLOC_NODE *node);

static Boolean IS_FIRST(SUBALLOC_NODE *head, SUBALLOC_NODE *node);

inline Boolean IS_EMPTY(SUBALLOC_NODE *h) ;

static Boolean IS_ONLY(SUBALLOC_NODE *head, SUBALLOC_NODE *node);

static Boolean IS_EMPTY(SUBALLOC_NODE *h) ;

Boolean _Allocate(Sint32, Sint32, Sint32);

void _DeAllocate(Sint32 vector, Sint32 index);

Line 224

Line 290

SUBALLOC_NODE *GetHugeNode(Sint32 size);

void PutNode(Sint32 vector, Sint32 index, SUBALLOC_NODE *node);

void PutHugeNode(SUBALLOC_NODE *node);

#if defined(PEGASUS_DEBUG_MEMORY)

static const Sint8 dumpFileName[];

Sint8 global_log_filename[MAX_PATH_LEN + 1];

FILE *dumpFile ;

static const Uint8 guard[];

static const Uint8 alloc_pattern;

static const Uint8 delete_pattern;

static Boolean _CheckGuard(SUBALLOC_NODE *);

static Uint32 _CheckNode(void *m);

SUBALLOC_NODE *_CheckNode(void *m, int type, Sint8 *file, Uint32 line);

public:

static Uint32 CheckMemory(void *);

#endif

public:

peg_suballocator(void);

peg_suballocator(Sint8 *log_filename);

peg_suballocator(Boolean mode );

virtual ~peg_suballocator(void);

inline Boolean PEGASUS_DEBUG_ALLOC(void) { return _debug; }

typedef class _suballocHandle

typedef class PEGASUS_SUBALLOC_LINKAGE _suballocHandle

{

public:

Sint8 logpath[MAX_PATH_LEN + 1];

_suballocHandle(Sint8 *log_path = 0)

Sint8 classname[MAX_CLASS_LEN + 1];

_suballocHandle(const Sint8 *log_path = 0)

{

if(log_path)

snprintf(logpath, MAX_PATH_LEN, "%s", log_path);

Line 258

Line 329

}SUBALLOC_HANDLE;

Boolean InitializeSubAllocator(Sint8 *f = NULL);

Boolean InitializeSubAllocator(void);

SUBALLOC_HANDLE *InitializeProcessHeap(Sint8 *f = NULL);

static SUBALLOC_HANDLE *InitializeProcessHeap(Sint8 *f = NULL);

void *vs_malloc(size_t size, void *handle, Sint8 *f = 0, Sint32 l = 0);

#if defined(PEGASUS_DEBUG_MEMORY)

void *vs_calloc(size_t num, size_t size, void *handle, Sint8 *f = 0, Sint32 l = 0);

void *vs_malloc(size_t size, void *handle, int type = NORMAL, const Sint8 *classname = 0, const Sint8 *f = 0, Uint32 l = 0);

void *vs_realloc(void *pblock, size_t newsize, void *handle, Sint8 *f = 0, Sint32 l = 0);

void *vs_calloc(size_t num, size_t size, void *handle, int type = NORMAL, Sint8 *f = 0, Uint32 l = 0);

Sint8 * vs_strdup(const Sint8 *string, void *handle, Sint8 *f = 0, Sint32 l = 0);

void *vs_realloc(void *pblock, size_t newsize, void *handle, int type = NORMAL, Sint8 *f = 0, Uint32 l = 0);

void vs_free(void *m);

Sint8 * vs_strdup(const Sint8 *string, void *handle, int type = NORMAL, Sint8 *f = 0, Uint32 l = 0);

void vs_free(void *m, void *handle, int type, Sint8 *classname, Sint8 *f, Uint32 l);

Boolean _UnfreedNodes(void *handle);

Boolean get_mode(void) { return debug_mode; }

void set_leak_mode(Boolean mode) { check_for_leaks = mode; }

#else

void *vs_malloc(size_t size);

void *vs_calloc(size_t num, size_t size);

void *vs_realloc(void *pblock, size_t newsize);

Sint8 *vs_strdup(const Sint8 *str);

void vs_free(void *m);

Boolean get_mode(void) { return false; }

void set_leak_mode(Boolean mode) { }

#endif

void DeInitSubAllocator(void *handle);

static void _CheckNode(void *m);

static peg_suballocator *get_instance(void);

SUBALLOC_HANDLE & get_handle(void) { return internal_handle; }

private:

_suballocHandle internal_handle;

};

static peg_suballocator *_suballoc_instance;

};

inline Boolean peg_suballocator::IS_ARRAY(SUBALLOC_NODE *x)

{

return (x->flags & ARRAY_NODE) ? true : false ;

}

inline Boolean peg_suballocator::IS_HEAD(SUBALLOC_NODE *x) { return x->isHead; }

inline Boolean peg_suballocator::IS_HEAD(SUBALLOC_NODE *x)

{

return (x->flags & IS_HEAD_NODE) ? true : false ;

}

inline Boolean peg_suballocator::IS_EMPTY(SUBALLOC_NODE *h)

{

Line 606

Line 698

#endif /* SUBALLOC_INCLUDE */

// how to debug a specific object:

// add an operator new to the object such that

// void * operator new(size_t size, peg_suballocator::_sub_handle = 0);

// void operator delete(void *dead, size_t size);

// have operator delete check for unfreed nodes by calling sub->unfreed_nodes

Legend:

Removed from v.1.4
changed lines
	Added in v.1.25

No CVS admin address has been configured