mirror of
git://git.psyced.org/git/psyclpc
synced 2024-08-15 03:20:16 +00:00
228 lines
5.4 KiB
C
228 lines
5.4 KiB
C
|
/*---------------------------------------------------------------------------
|
||
|
* Wrapper for the system's malloc() routines
|
||
|
*
|
||
|
*---------------------------------------------------------------------------
|
||
|
*/
|
||
|
|
||
|
#include "driver.h"
|
||
|
|
||
|
#include <stdlib.h>
|
||
|
|
||
|
#include "sysmalloc.h"
|
||
|
|
||
|
#include "mstrings.h"
|
||
|
#include "stdstrings.h"
|
||
|
#include "svalue.h"
|
||
|
|
||
|
#include "../mudlib/sys/debug_info.h"
|
||
|
|
||
|
/* Defines required by the xalloc.c wrapper */
|
||
|
#define MEM_ALIGN (MALLOC_ALIGN)
|
||
|
/* #undef REPLACE_MALLOC */
|
||
|
#define NO_MEM_BLOCK_SIZE
|
||
|
#define MEM_THREADSAFE
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
|
||
|
static char * heap_start = NULL;
|
||
|
static char * heap_end = NULL;
|
||
|
/* The start and end of the heap, as we know it.
|
||
|
*/
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static inline POINTER
|
||
|
mem_alloc (size_t size)
|
||
|
|
||
|
/* Allocate a memory block for <size> bytes at the source <file>:<line>.
|
||
|
* Result is the pointer the memory block, or NULL when out of memory.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
POINTER rc;
|
||
|
|
||
|
rc = malloc(size);
|
||
|
|
||
|
if (heap_start == NULL || (char *)rc < heap_start)
|
||
|
heap_start = rc;
|
||
|
if (heap_end == NULL || (char *)rc + size > heap_end)
|
||
|
heap_end = rc + size;
|
||
|
|
||
|
assert_stack_gap();
|
||
|
|
||
|
return rc;
|
||
|
} /* mem_alloc() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static INLINE void
|
||
|
mem_free (POINTER ptr)
|
||
|
|
||
|
/* Return the memoryblock <ptr> to the allocator.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
free(ptr);
|
||
|
} /* mem_free() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static POINTER
|
||
|
mem_realloc (POINTER p, size_t size)
|
||
|
|
||
|
/* Reallocate block <p> to the new size of <size> and return the pointer.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
return realloc(p, size);
|
||
|
} /* mem_realloc() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static INLINE void
|
||
|
mem_mark_permanent (POINTER p UNUSED)
|
||
|
|
||
|
/* Mark the allocated block at <p> as permanent, ie. it won't be subject
|
||
|
* to the GC.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
# ifdef __MWERKS__
|
||
|
# pragma unused(p)
|
||
|
# endif
|
||
|
/* Nothing */
|
||
|
} /* mem_mark_permanent() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static INLINE void
|
||
|
mem_mark_collectable (POINTER p UNUSED)
|
||
|
|
||
|
/* Mark the allocated block at <p> as non-permant, ie. it is subject
|
||
|
* to the GC.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
# ifdef __MWERKS__
|
||
|
# pragma unused(p)
|
||
|
# endif
|
||
|
/* Nothing */
|
||
|
} /* mem_mark_collectable() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static INLINE size_t
|
||
|
mem_block_size (POINTER p UNUSED)
|
||
|
|
||
|
/* Return the size of block <p> (sans internal overhead) in bytes.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
# ifdef __MWERKS__
|
||
|
# pragma unused(p)
|
||
|
# endif
|
||
|
return 0;
|
||
|
} /* mem_block_size() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static INLINE size_t
|
||
|
mem_overhead (void)
|
||
|
|
||
|
/* Return the size of each block's overhead in bytes.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
return EXTERN_MALLOC_OVERHEAD;
|
||
|
} /* mem_overhead() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
static INLINE void *
|
||
|
mem_increment_size (void *vp, size_t size)
|
||
|
|
||
|
/* Try to extent the allocation block for <vp> to hold <size> more bytes.
|
||
|
* If this is not possible, return NULL, otherwise return a pointer
|
||
|
* to the start of the block extension.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
return NULL;
|
||
|
} /* mem_increment_size() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
void
|
||
|
mem_dump_data (strbuf_t *sbuf)
|
||
|
|
||
|
/* For the status commands and functions: add the smalloc statistic
|
||
|
* to the buffer <sbuf>.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
strbuf_add(sbuf, "Using system standard malloc.\n");
|
||
|
} /* mem_dump_data() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
void
|
||
|
mem_dinfo_data (svalue_t *svp, int value)
|
||
|
|
||
|
/* Fill in the data for debug_info(DINFO_DATA, DID_MEMORY) into the
|
||
|
* svalue-block svp.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
if (value == -1)
|
||
|
put_ref_string(svp+DID_MEM_NAME, STR_SYSTEM_MALLOC);
|
||
|
else if (value == DID_MEM_NAME)
|
||
|
put_ref_string(svp, STR_SYSTEM_MALLOC);
|
||
|
} /* mem_dinfo_data() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
void
|
||
|
mem_dump_extdata (strbuf_t *sbuf)
|
||
|
|
||
|
/* For the status commands and functions: add the extended smalloc statistic
|
||
|
* to the buffer <sbuf>.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
strbuf_add(sbuf, "No detailed blocks statistics available.\n");
|
||
|
} /* mem_dump_extdata() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
Bool
|
||
|
mem_dump_memory (int fd)
|
||
|
|
||
|
/* Print the location, size, and (if available) the TRACE information
|
||
|
* of all memory blocks to file <fd>, and return TRUE.
|
||
|
* If the allocator doesn't support this operation, print nothing
|
||
|
* and return FALSE.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
return MY_FALSE;
|
||
|
} /* mem_dump_memory() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
void
|
||
|
mem_consolidate (Bool force UNUSED)
|
||
|
|
||
|
/* Consolidate the free small blocks, merging them into larger free blocks
|
||
|
* where possible, and rebuild the free lists.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
# ifdef __MWERKS__
|
||
|
# pragma unused(force)
|
||
|
# endif
|
||
|
/* Nothing */
|
||
|
} /* mem_consolidate() */
|
||
|
|
||
|
/*-------------------------------------------------------------------------*/
|
||
|
#ifdef MALLOC_EXT_STATISTICS
|
||
|
void
|
||
|
mem_update_stats (void)
|
||
|
|
||
|
/* Update whatever extended statistics the allocator has. Called every
|
||
|
* backend cycle or so to allow for the calculation of averages over time.
|
||
|
*/
|
||
|
|
||
|
{
|
||
|
/* Nothing */
|
||
|
} /* mem_update_stats() */
|
||
|
#endif /* MALLOC_EXT_STATISTICS */
|
||
|
|
||
|
/***************************************************************************/
|