#include <sys/types.h>
#include <iostream>
#include "tls.hh"
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/param.h>

Data Structures
struct	mallinfo

struct	malloc_chunk

struct	malloc_tree_chunk

struct	malloc_segment

struct	malloc_state

struct	malloc_params

Macros
#define	MSPACES 1

#define	DLMALLOC_VERSION 20804

#define	SPIN_LOCKS_AVAILABLE 0

#define	MAX_SIZE_T (~(size_t)0)

#define	ONLY_MSPACES 0 /* define to a value */

#define	MALLOC_ALIGNMENT ((size_t)8U)

#define	FOOTERS 0

#define	ABORT abort()

#define	ABORT_ON_ASSERT_FAILURE 1

#define	PROCEED_ON_ERROR 0

#define	USE_LOCKS 0

#define	USE_SPIN_LOCKS 0

#define	INSECURE 0

#define	HAVE_MMAP 1

#define	MMAP_CLEARS 1

#define	HAVE_MREMAP 0

#define	MALLOC_FAILURE_ACTION errno = ENOMEM;

#define	HAVE_MORECORE 1

#define	MORECORE_DEFAULT sbrk

#define	MORECORE_CONTIGUOUS 1

#define	DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */

#define	DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)

#define	DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)

#define	MAX_RELEASE_CHECK_RATE 4095

#define	USE_BUILTIN_FFS 0

#define	USE_DEV_RANDOM 0

#define	NO_MALLINFO 0

#define	MALLINFO_FIELD_TYPE size_t

#define	NO_SEGMENT_TRAVERSAL 0

#define	M_TRIM_THRESHOLD (-1)

#define	M_GRANULARITY (-2)

#define	M_MMAP_THRESHOLD (-3)

#define	STRUCT_MALLINFO_DECLARED 1

#define	NOINLINE

#define	FORCEINLINE

#define	dlcalloc mycalloc

#define	dlfree myfree

#define	dlmalloc mymalloc

#define	dlmemalign mymemalign

#define	dlrealloc myrealloc

#define	dlvalloc myvalloc

#define	dlpvalloc mypvalloc

#define	dlmallinfo mymallinfo

#define	dlmallopt mymallopt

#define	dlmalloc_trim mymalloc_trim

#define	dlmalloc_stats mymalloc_stats

#define	dlmalloc_usable_size mymalloc_usable_size

#define	dlmalloc_footprint mymalloc_footprint

#define	dlmalloc_max_footprint mymalloc_max_footprint

#define	dlindependent_calloc myindependent_calloc

#define	dlindependent_comalloc myindependent_comalloc

#define	assert(x)

#define	DEBUG 0

#define	malloc_getpagesize ((size_t)4096U)

#define	SIZE_T_SIZE (sizeof(size_t))

#define	SIZE_T_BITSIZE (sizeof(size_t) << 3)

#define	SIZE_T_ZERO ((size_t)0)

#define	SIZE_T_ONE ((size_t)1)

#define	SIZE_T_TWO ((size_t)2)

#define	SIZE_T_FOUR ((size_t)4)

#define	TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1)

#define	FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2)

#define	SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

#define	HALF_MAX_SIZE_T (MAX_SIZE_T / 2U)

#define	CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)

#define	is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)

#define	align_offset(A)

#define	MFAIL ((void*)(MAX_SIZE_T))

#define	CMFAIL ((char)(MFAIL)) / defined for convenience */

#define	MUNMAP_DEFAULT(a, s) munmap((a), (s))

#define	MMAP_PROT (PROT_READ\|PROT_WRITE)

#define	MMAP_FLAGS (MAP_PRIVATE)

#define	MMAP_DEFAULT(s)

#define	DIRECT_MMAP_DEFAULT(s) MMAP_DEFAULT(s)

#define	CALL_MORECORE(S) MORECORE_DEFAULT(S)

#define	USE_MMAP_BIT (SIZE_T_ONE)

#define	CALL_MMAP(s) MMAP_DEFAULT(s)

#define	CALL_MUNMAP(a, s) MUNMAP_DEFAULT((a), (s))

#define	CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s)

#define	CALL_MREMAP(addr, osz, nsz, mv) MFAIL

#define	USE_NONCONTIGUOUS_BIT (4U)

#define	EXTERN_BIT (8U)

#define	USE_LOCK_BIT (0U)

#define	INITIAL_LOCK(l)

#define	ACQUIRE_MALLOC_GLOBAL_LOCK()

#define	RELEASE_MALLOC_GLOBAL_LOCK()

#define	MCHUNK_SIZE (sizeof(mchunk))

#define	CHUNK_OVERHEAD (SIZE_T_SIZE)

#define	MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)

#define	MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES)

#define	MIN_CHUNK_SIZE ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

#define	chunk2mem(p) ((void)((char)(p) + TWO_SIZE_T_SIZES))

#define	mem2chunk(mem) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES))

#define	align_as_chunk(A) (mchunkptr)((A) + align_offset(chunk2mem(A)))

#define	MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2)

#define	MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

#define	pad_request(req) (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

#define	request2size(req) (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req))

#define	PINUSE_BIT (SIZE_T_ONE)

#define	CINUSE_BIT (SIZE_T_TWO)

#define	FLAG4_BIT (SIZE_T_FOUR)

#define	INUSE_BITS (PINUSE_BIT\|CINUSE_BIT)

#define	FLAG_BITS (PINUSE_BIT\|CINUSE_BIT\|FLAG4_BIT)

#define	FENCEPOST_HEAD (INUSE_BITS\|SIZE_T_SIZE)

#define	cinuse(p) ((p)->head & CINUSE_BIT)

#define	pinuse(p) ((p)->head & PINUSE_BIT)

#define	is_inuse(p) (((p)->head & INUSE_BITS) != PINUSE_BIT)

#define	is_mmapped(p) (((p)->head & INUSE_BITS) == 0)

#define	chunksize(p) ((p)->head & ~(FLAG_BITS))

#define	clear_pinuse(p) ((p)->head &= ~PINUSE_BIT)

#define	chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))

#define	chunk_minus_offset(p, s) ((mchunkptr)(((char*)(p)) - (s)))

#define	next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS)))

#define	prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) ))

#define	next_pinuse(p) ((next_chunk(p)->head) & PINUSE_BIT)

#define	get_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot)

#define	set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s))

#define	set_size_and_pinuse_of_free_chunk(p, s) ((p)->head = (s\|PINUSE_BIT), set_foot(p, s))

#define	set_free_with_pinuse(p, s, n) (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s))

#define	overhead_for(p) (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)

#define	calloc_must_clear(p) (!is_mmapped(p))

#define	leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])

#define	is_mmapped_segment(S) ((S)->sflags & USE_MMAP_BIT)

#define	is_extern_segment(S) ((S)->sflags & EXTERN_BIT)

#define	NSMALLBINS (32U)

#define	NTREEBINS (32U)

#define	SMALLBIN_SHIFT (3U)

#define	SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT)

#define	TREEBIN_SHIFT (8U)

#define	MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT)

#define	MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE)

#define	MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

#define	ensure_initialization() (void)(mparams.magic != 0 \|\| init_mparams())

#define	gm (&_gm_)

#define	is_global(M) ((M) == &_gm_)

#define	is_initialized(M) ((M)->top != 0)

#define	use_lock(M) ((M)->mflags & USE_LOCK_BIT)

#define	enable_lock(M) ((M)->mflags \|= USE_LOCK_BIT)

#define	disable_lock(M) ((M)->mflags &= ~USE_LOCK_BIT)

#define	use_mmap(M) ((M)->mflags & USE_MMAP_BIT)

#define	enable_mmap(M) ((M)->mflags \|= USE_MMAP_BIT)

#define	disable_mmap(M) ((M)->mflags &= ~USE_MMAP_BIT)

#define	use_noncontiguous(M) ((M)->mflags & USE_NONCONTIGUOUS_BIT)

#define	disable_contiguous(M) ((M)->mflags \|= USE_NONCONTIGUOUS_BIT)

#define	set_lock(M, L)

#define	page_align(S) (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE))

#define	granularity_align(S)

#define	mmap_align(S) page_align(S)

#define	SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT)

#define	is_page_aligned(S) (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)

#define	is_granularity_aligned(S) (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)

#define	segment_holds(S, A) ((char)(A) >= S->base && (char)(A) < S->base + S->size)

#define	should_trim(M, s) ((s) > (M)->trim_check)

#define	TOP_FOOT_SIZE (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)

#define	PREACTION(M) (0)

#define	POSTACTION(M)

#define	CORRUPTION_ERROR_ACTION(m) ABORT

#define	USAGE_ERROR_ACTION(m, p) ABORT

#define	check_free_chunk(M, P)

#define	check_inuse_chunk(M, P)

#define	check_malloced_chunk(M, P, N)

#define	check_mmapped_chunk(M, P)

#define	check_malloc_state(M)

#define	check_top_chunk(M, P)

#define	is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS)

#define	small_index(s) ((s) >> SMALLBIN_SHIFT)

#define	small_index2size(i) ((i) << SMALLBIN_SHIFT)

#define	MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE))

#define	smallbin_at(M, i) ((sbinptr)((char*)&((M)->smallbins[(i)<<1])))

#define	treebin_at(M, i) (&((M)->treebins[i]))

#define	compute_tree_index(S, I)

#define	bit_for_tree_index(i) (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2)

#define	leftshift_for_tree_index(i)

#define	minsize_for_tree_index(i)

#define	idx2bit(i) ((binmap_t)(1) << (i))

#define	mark_smallmap(M, i) ((M)->smallmap \|= idx2bit(i))

#define	clear_smallmap(M, i) ((M)->smallmap &= ~idx2bit(i))

#define	smallmap_is_marked(M, i) ((M)->smallmap & idx2bit(i))

#define	mark_treemap(M, i) ((M)->treemap \|= idx2bit(i))

#define	clear_treemap(M, i) ((M)->treemap &= ~idx2bit(i))

#define	treemap_is_marked(M, i) ((M)->treemap & idx2bit(i))

#define	least_bit(x) ((x) & -(x))

#define	left_bits(x) ((x<<1) \| -(x<<1))

#define	same_or_left_bits(x) ((x) \| -(x))

#define	compute_bit2idx(X, I)

#define	ok_address(M, a) ((char*)(a) >= (M)->least_addr)

#define	ok_next(p, n) ((char)(p) < (char)(n))

#define	ok_inuse(p) is_inuse(p)

#define	ok_pinuse(p) pinuse(p)

#define	ok_magic(M) (1)

#define	RTCHECK(e) (e)

#define	mark_inuse_foot(M, p, s)

#define	set_inuse(M, p, s)

#define	set_inuse_and_pinuse(M, p, s)

#define	set_size_and_pinuse_of_inuse_chunk(M, p, s) ((p)->head = (s\|PINUSE_BIT\|CINUSE_BIT))

#define	insert_small_chunk(M, P, S)

#define	unlink_small_chunk(M, P, S)

#define	unlink_first_small_chunk(M, B, P, I)

#define	replace_dv(M, P, S)

#define	insert_large_chunk(M, X, S)

#define	unlink_large_chunk(M, X)

#define	insert_chunk(M, P, S)

#define	unlink_chunk(M, P, S)

#define	internal_malloc(m, b) (m == gm)? dlmalloc(b) : mspace_malloc(m, b)

#define	internal_free(m, mem) if (m == gm) dlfree(mem); else mspace_free(m,mem);

#define	fm gm

Typedefs
typedef void *	mspace

typedef struct malloc_chunk	mchunk

typedef struct malloc_chunk *	mchunkptr

typedef struct malloc_chunk *	sbinptr

typedef unsigned int	bindex_t

typedef unsigned int	binmap_t

typedef unsigned int	flag_t

typedef struct malloc_tree_chunk	tchunk

typedef struct malloc_tree_chunk *	tchunkptr

typedef struct malloc_tree_chunk *	tbinptr

typedef struct malloc_segment	msegment

typedef struct malloc_segment *	msegmentptr

typedef struct malloc_state *	mstate

Functions
void *	dlmalloc (size_t)

void	dlfree (void *)

void *	dlcalloc (size_t, size_t)

void *	dlrealloc (void *, size_t)

void *	dlmemalign (size_t, size_t)

void *	dlvalloc (size_t)

int	dlmallopt (int, int)

size_t	dlmalloc_footprint (void)

size_t	dlmalloc_max_footprint (void)

struct mallinfo	dlmallinfo (void)

void **	dlindependent_calloc (size_t, size_t, void **)

void **	dlindependent_comalloc (size_t, size_t , void *)

void *	dlpvalloc (size_t)

int	dlmalloc_trim (size_t)

void	dlmalloc_stats (void)

size_t	dlmalloc_usable_size (void *)

mspace	create_mspace (size_t capacity, int locked)

size_t	destroy_mspace (mspace msp)

mspace	create_mspace_with_base (void *base, size_t capacity, int locked)

int	mspace_track_large_chunks (mspace msp, int enable)

void *	mspace_malloc (mspace msp, size_t bytes)

void	mspace_free (mspace msp, void *mem)

void *	mspace_realloc (mspace msp, void *mem, size_t newsize)

void *	mspace_calloc (mspace msp, size_t n_elements, size_t elem_size)

void *	mspace_memalign (mspace msp, size_t alignment, size_t bytes)

void **	mspace_independent_calloc (mspace msp, size_t n_elements, size_t elem_size, void *chunks[])

void **	mspace_independent_comalloc (mspace msp, size_t n_elements, size_t sizes[], void *chunks[])

size_t	mspace_footprint (mspace msp)

size_t	mspace_max_footprint (mspace msp)

struct mallinfo	mspace_mallinfo (mspace msp)

size_t	mspace_usable_size (void *mem)

void	mspace_malloc_stats (mspace msp)

int	mspace_trim (mspace msp, size_t pad)

int	mspace_mallopt (int, int)

void **	dlindependent_calloc (size_t n_elements, size_t elem_size, void *chunks[])

void **	dlindependent_comalloc (size_t n_elements, size_t sizes[], void *chunks[])

Macro Definition Documentation

#define ABORT abort()

Definition at line 566 of file mymalloc.cc.

#define ABORT_ON_ASSERT_FAILURE 1

Definition at line 569 of file mymalloc.cc.

#define ACQUIRE_MALLOC_GLOBAL_LOCK ( )

Definition at line 1915 of file mymalloc.cc.

#define align_as_chunk ( A ) (mchunkptr)((A) + align_offset(chunk2mem(A)))

Definition at line 2094 of file mymalloc.cc.

#define align_offset ( A )

Value:

((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\

((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))

CHUNK_ALIGN_MASK

#define CHUNK_ALIGN_MASK

Definition: mymalloc.cc:1456

MALLOC_ALIGNMENT

#define MALLOC_ALIGNMENT

Definition: mymalloc.cc:560

Definition at line 1462 of file mymalloc.cc.

#define assert ( x )

Definition at line 1309 of file mymalloc.cc.

Referenced by G4VoxelLimits::AddLimit(), addThread(), CLHEP::sp::abstract_ctrl_block::class_invariant(), G4VUserDetectorConstruction::CloneF(), G4VUserDetectorConstruction::CloneSD(), Run::ComputeStatistics(), G4WorkerRunManager::ConstructScoringWorlds(), G4VisManager::CurrentTrajDrawModel(), G4MagneticFieldModel::DescribeYourselfTo(), CLHEP::sp::abstract_ctrl_block::destroy(), G4VisManager::DispatchToModel(), dlmalloc(), G4TrajectoryDrawByOriginVolume::Draw(), G4TrajectoryDrawByAttribute::Draw(), CLibSymbolInfo::DumpSymbols(), ElectronRunAction::EndOfRunAction(), G4TrajectoryOriginVolumeFilter::Evaluate(), tbbTask::execute(), FinishDetection(), finishtracer(), G4AtomicShells::GetBindingEnergy(), G4VTrajectoryModel::GetContext(), G4AttFilterUtils::GetNewFilter(), G4AtomicShells::GetNumberOfElectrons(), G4AtomicShells::GetNumberOfShells(), G4SandiaTable::GetSandiaCofForMaterial(), G4SandiaTable::GetSandiaCofForMaterialPAI(), G4SandiaTable::GetSandiaCofPerAtom(), G4SandiaTable::GetSandiaMatTable(), G4SandiaTable::GetSandiaMatTablePAI(), G4AtomicShells::GetTotalBindingEnergy(), G4SandiaTable::GetZtoA(), insertAddress(), mspace_malloc(), CLHEP::shared_ptr< T >::operator*(), CLHEP::shared_ptr< T >::operator->(), CLHEP::RandGeneral::put(), ElectronRun::RecordEvent(), G4VisListManager< T >::Register(), G4ITModelHandler::RegisterModel(), CLHEP::shared_ptr< T >::reset(), G4VoxelSafety::SafetyForVoxelHeader(), G4ITModelManager::SetModel(), G4ITModelHandler::SetModel(), G4VisCommandListManagerList< Manager >::SetNewValue(), G4VisCommandModelCreate< Factory >::SetNewValue(), G4VisCommandListManagerSelect< Manager >::SetNewValue(), G4VisCommandManagerMode< Manager >::SetNewValue(), CLHEP::NonRandomEngine::setRandomSequence(), SingleSteps(), StartDetection(), startThreadTracers(), traceloop(), waitForAllTracers(), and XML_GetParsingStatus().

#define bit_for_tree_index ( i ) (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2)

Definition at line 2757 of file mymalloc.cc.

#define CALL_DIRECT_MMAP ( s ) DIRECT_MMAP_DEFAULT(s)

Definition at line 1583 of file mymalloc.cc.

#define CALL_MMAP ( s ) MMAP_DEFAULT(s)

Definition at line 1573 of file mymalloc.cc.

Referenced by create_mspace().

#define CALL_MORECORE ( S ) MORECORE_DEFAULT(S)

Define CALL_MORECORE

Definition at line 1558 of file mymalloc.cc.

#define CALL_MREMAP	(	addr,
		osz,
		nsz,
		mv
	)	MFAIL

Define CALL_MREMAP

Definition at line 1606 of file mymalloc.cc.

#define CALL_MUNMAP	(	a,
		s
	)	MUNMAP_DEFAULT((a), (s))

Definition at line 1578 of file mymalloc.cc.

Referenced by destroy_mspace(), dlfree(), and mspace_free().

#define calloc_must_clear ( p ) (!is_mmapped(p))

Definition at line 2167 of file mymalloc.cc.

Referenced by dlcalloc(), and mspace_calloc().

#define check_free_chunk	(	M,
		P
	)

Definition at line 2651 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define check_inuse_chunk	(	M,
		P
	)

Definition at line 2652 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define check_malloc_state ( M )

Definition at line 2655 of file mymalloc.cc.

#define check_malloced_chunk	(	M,
		P,
		N
	)

Definition at line 2653 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define check_mmapped_chunk	(	M,
		P
	)

Definition at line 2654 of file mymalloc.cc.

#define check_top_chunk	(	M,
		P
	)

Definition at line 2656 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define chunk2mem ( p ) ((void*)((char*)(p) + TWO_SIZE_T_SIZES))

Definition at line 2091 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)

Definition at line 1456 of file mymalloc.cc.

#define chunk_minus_offset	(	p,
		s
	)	((mchunkptr)(((char*)(p)) - (s)))

Definition at line 2140 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define CHUNK_OVERHEAD (SIZE_T_SIZE)

Definition at line 2078 of file mymalloc.cc.

#define chunk_plus_offset	(	p,
		s
	)	((mchunkptr)(((char*)(p)) + (s)))

Definition at line 2139 of file mymalloc.cc.

Referenced by dlfree(), dlmalloc(), mspace_free(), and mspace_malloc().

#define chunksize ( p ) ((p)->head & ~(FLAG_BITS))

Definition at line 2134 of file mymalloc.cc.

Referenced by dlfree(), dlmalloc(), dlmalloc_usable_size(), mspace_free(), mspace_malloc(), and mspace_usable_size().

#define cinuse ( p ) ((p)->head & CINUSE_BIT)

Definition at line 2129 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define CINUSE_BIT (SIZE_T_TWO)

Definition at line 2120 of file mymalloc.cc.

#define clear_pinuse ( p ) ((p)->head &= ~PINUSE_BIT)

Definition at line 2136 of file mymalloc.cc.

#define clear_smallmap	(	M,
		i
	)	((M)->smallmap &= ~idx2bit(i))

Definition at line 2778 of file mymalloc.cc.

#define clear_treemap	(	M,
		i
	)	((M)->treemap &= ~idx2bit(i))

Definition at line 2782 of file mymalloc.cc.

#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */

Definition at line 1477 of file mymalloc.cc.

Referenced by create_mspace().

#define compute_bit2idx	(	X,
		I
	)

Value:

{\
  unsigned int Y = X - 1;\
  unsigned int K = Y >> (16-4) & 16;\
  unsigned int N = K;        Y >>= K;\
  N += K = Y >> (8-3) &  8;  Y >>= K;\
  N += K = Y >> (4-2) &  4;  Y >>= K;\
  N += K = Y >> (2-1) &  2;  Y >>= K;\
  N += K = Y >> (1-0) &  1;  Y >>= K;\
  I = (bindex_t)(N + Y);\
}

Definition at line 2824 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define compute_tree_index	(	S,
		I
	)

Value:

{\
  size_t X = S >> TREEBIN_SHIFT;\
  if (X == 0)\
    I = 0;\
  else if (X > 0xFFFF)\
    I = NTREEBINS-1;\
  else {\
    unsigned int Y = (unsigned int)X;\
    unsigned int N = ((Y - 0x100) >> 16) & 8;\
    unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;\
    N += K;\
    N += K = (((Y <<= K) - 0x4000) >> 16) & 2;\
    K = 14 - N + ((Y <<= K) >> 15);\
    I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));\
  }\
}

Definition at line 2737 of file mymalloc.cc.

#define CORRUPTION_ERROR_ACTION ( m ) ABORT

Definition at line 2638 of file mymalloc.cc.

#define DEBUG 0

Definition at line 1311 of file mymalloc.cc.

Referenced by G4GMocrenIO::retrieveData2(), G4GMocrenIO::retrieveData3(), G4GMocrenIO::retrieveData4(), G4GMocrenIO::storeData2(), G4GMocrenIO::storeData3(), and G4GMocrenIO::storeData4().

#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */

Definition at line 620 of file mymalloc.cc.

#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)

Definition at line 634 of file mymalloc.cc.

#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)

Definition at line 627 of file mymalloc.cc.

#define DIRECT_MMAP_DEFAULT ( s ) MMAP_DEFAULT(s)

Definition at line 1503 of file mymalloc.cc.

#define disable_contiguous ( M ) ((M)->mflags |= USE_NONCONTIGUOUS_BIT)

Definition at line 2519 of file mymalloc.cc.

#define disable_lock ( M ) ((M)->mflags &= ~USE_LOCK_BIT)

Definition at line 2512 of file mymalloc.cc.

#define disable_mmap ( M ) ((M)->mflags &= ~USE_MMAP_BIT)

Definition at line 2516 of file mymalloc.cc.

Referenced by mspace_track_large_chunks().

#define dlcalloc mycalloc

Definition at line 760 of file mymalloc.cc.

#define dlfree myfree

Definition at line 761 of file mymalloc.cc.

Referenced by dlrealloc().

#define dlindependent_calloc myindependent_calloc

Definition at line 774 of file mymalloc.cc.

#define dlindependent_comalloc myindependent_comalloc

Definition at line 775 of file mymalloc.cc.

#define dlmallinfo mymallinfo

Definition at line 767 of file mymalloc.cc.

#define dlmalloc mymalloc

Definition at line 762 of file mymalloc.cc.

Referenced by dlcalloc(), and dlrealloc().

#define dlmalloc_footprint mymalloc_footprint

Definition at line 772 of file mymalloc.cc.

#define dlmalloc_max_footprint mymalloc_max_footprint

Definition at line 773 of file mymalloc.cc.

#define dlmalloc_stats mymalloc_stats

Definition at line 770 of file mymalloc.cc.

#define dlmalloc_trim mymalloc_trim

Definition at line 769 of file mymalloc.cc.

#define dlmalloc_usable_size mymalloc_usable_size

Definition at line 771 of file mymalloc.cc.

#define DLMALLOC_VERSION 20804

Definition at line 488 of file mymalloc.cc.

#define dlmallopt mymallopt

Definition at line 768 of file mymalloc.cc.

#define dlmemalign mymemalign

Definition at line 763 of file mymalloc.cc.

Referenced by dlpvalloc(), and dlvalloc().

#define dlpvalloc mypvalloc

Definition at line 766 of file mymalloc.cc.

#define dlrealloc myrealloc

Definition at line 764 of file mymalloc.cc.

#define dlvalloc myvalloc

Definition at line 765 of file mymalloc.cc.

#define enable_lock ( M ) ((M)->mflags |= USE_LOCK_BIT)

Definition at line 2511 of file mymalloc.cc.

#define enable_mmap ( M ) ((M)->mflags |= USE_MMAP_BIT)

Definition at line 2515 of file mymalloc.cc.

Referenced by mspace_track_large_chunks().

#define ensure_initialization ( ) (void)(mparams.magic != 0 || init_mparams())

Definition at line 2493 of file mymalloc.cc.

Referenced by create_mspace(), create_mspace_with_base(), dlmalloc(), dlmalloc_trim(), dlpvalloc(), and dlvalloc().

#define EXTERN_BIT (8U)

Definition at line 1613 of file mymalloc.cc.

Referenced by create_mspace_with_base(), and destroy_mspace().

#define FENCEPOST_HEAD (INUSE_BITS|SIZE_T_SIZE)

Definition at line 2126 of file mymalloc.cc.

#define FLAG4_BIT (SIZE_T_FOUR)

Definition at line 2121 of file mymalloc.cc.

#define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|FLAG4_BIT)

Definition at line 2123 of file mymalloc.cc.

#define fm gm

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4hPairProductionModel::ComputeDMicroscopicCrossSection(), G4MuPairProductionModel::ComputeDMicroscopicCrossSection(), dlfree(), G4VEnergyLossProcess::GetDEDXDispersion(), G4ExcitedXiConstructor::GetMass(), G4ePolarizedBremsstrahlung::InitialiseEnergyLossProcess(), G4hPairProduction::InitialiseEnergyLossProcess(), G4hBremsstrahlung::InitialiseEnergyLossProcess(), G4MuPairProduction::InitialiseEnergyLossProcess(), G4eBremsstrahlung::InitialiseEnergyLossProcess(), G4MuBremsstrahlung::InitialiseEnergyLossProcess(), mspace_free(), G4WentzelOKandVIxSection::SampleSingleScattering(), and G4WentzelVIRelXSection::SampleSingleScattering().

#define FOOTERS 0

Definition at line 563 of file mymalloc.cc.

#define FORCEINLINE

Definition at line 752 of file mymalloc.cc.

#define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2)

Definition at line 1451 of file mymalloc.cc.

#define get_foot	(	p,
		s
	)	(((mchunkptr)((char*)(p) + (s)))->prev_foot)

Definition at line 2150 of file mymalloc.cc.

#define gm (&_gm_)

Definition at line 2499 of file mymalloc.cc.

Referenced by diqdss(), diqdzz(), diqssd(), diqsv(), diqvs(), diqzzd(), dlindependent_calloc(), dlindependent_comalloc(), dlmallinfo(), dlmalloc(), dlmalloc_footprint(), dlmalloc_max_footprint(), dlmalloc_stats(), dlmalloc_trim(), dlmemalign(), dlrealloc(), flksaa(), and xptfl1().

#define granularity_align ( S )

Value:

(((S) + (mparams.granularity - SIZE_T_ONE))\

& ~(mparams.granularity - SIZE_T_ONE))

SIZE_T_ONE

#define SIZE_T_ONE

Definition: mymalloc.cc:1447

malloc_params::granularity

size_t granularity

Definition: mymalloc.cc:2484

Definition at line 2531 of file mymalloc.cc.

Referenced by create_mspace().

#define HALF_MAX_SIZE_T (MAX_SIZE_T / 2U)

Definition at line 1453 of file mymalloc.cc.

#define HAVE_MMAP 1

Definition at line 588 of file mymalloc.cc.

Referenced by create_mspace().

#define HAVE_MORECORE 1

Definition at line 607 of file mymalloc.cc.

Referenced by create_mspace().

#define HAVE_MREMAP 0

Definition at line 597 of file mymalloc.cc.

#define idx2bit ( i ) ((binmap_t)(1) << (i))

Definition at line 2774 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define INITIAL_LOCK ( l )

Definition at line 1904 of file mymalloc.cc.

#define INSECURE 0

Definition at line 585 of file mymalloc.cc.

#define insert_chunk	(	M,
		P,
		S
	)

Value:

if (is_small(S)) insert_small_chunk(M, P, S)\

else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); }

malloc_tree_chunk

Definition: mymalloc.cc:2263

tchunkptr

struct malloc_tree_chunk * tchunkptr

Definition: mymalloc.cc:2276

insert_small_chunk

#define insert_small_chunk(M, P, S)

Definition: mymalloc.cc:3415

is_small

#define is_small(s)

Definition: mymalloc.cc:2682

insert_large_chunk

#define insert_large_chunk(M, X, S)

Definition: mymalloc.cc:3488

Definition at line 3629 of file mymalloc.cc.

#define insert_large_chunk	(	M,
		X,
		S
	)

Definition at line 3488 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define insert_small_chunk	(	M,
		P,
		S
	)

Value:

{\
  bindex_t I  = small_index(S);\
  mchunkptr B = smallbin_at(M, I);\
  mchunkptr F = B;\
  assert(S >= MIN_CHUNK_SIZE);\
  if (!smallmap_is_marked(M, I))\
    mark_smallmap(M, I);\
  else if (RTCHECK(ok_address(M, B->fd)))\
    F = B->fd;\
  else {\
    CORRUPTION_ERROR_ACTION(M);\
  }\
  B->fd = P;\
  F->bk = P;\
  P->fd = F;\
  P->bk = B;\
}

Definition at line 3415 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define internal_free	(	m,
		mem
	)	if (m == gm) dlfree(mem); else mspace_free(m,mem);

Definition at line 3647 of file mymalloc.cc.

#define internal_malloc	(	m,
		b
	)	(m == gm)? dlmalloc(b) : mspace_malloc(m, b)

Definition at line 3645 of file mymalloc.cc.

Referenced by mspace_calloc().

#define INUSE_BITS (PINUSE_BIT|CINUSE_BIT)

Definition at line 2122 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define is_aligned ( A ) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)

Definition at line 1459 of file mymalloc.cc.

#define is_extern_segment ( S ) ((S)->sflags & EXTERN_BIT)

Definition at line 2347 of file mymalloc.cc.

#define is_global ( M ) ((M) == &_gm_)

Definition at line 2500 of file mymalloc.cc.

#define is_granularity_aligned ( S ) (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)

Definition at line 2548 of file mymalloc.cc.

#define is_initialized ( M ) ((M)->top != 0)

Definition at line 2504 of file mymalloc.cc.

#define is_inuse ( p ) (((p)->head & INUSE_BITS) != PINUSE_BIT)

Definition at line 2131 of file mymalloc.cc.

Referenced by dlmalloc_usable_size(), and mspace_usable_size().

#define is_mmapped ( p ) (((p)->head & INUSE_BITS) == 0)

Definition at line 2132 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define is_mmapped_segment ( S ) ((S)->sflags & USE_MMAP_BIT)

Definition at line 2346 of file mymalloc.cc.

#define is_page_aligned ( S ) (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)

Definition at line 2546 of file mymalloc.cc.

#define is_small ( s ) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS)

Definition at line 2682 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define least_bit ( x ) ((x) & -(x))

Definition at line 2786 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define left_bits ( x ) ((x<<1) | -(x<<1))

Definition at line 2789 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define leftmost_child ( t ) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])

Definition at line 2280 of file mymalloc.cc.

#define leftshift_for_tree_index ( i )

Value:

((i == NTREEBINS-1)? 0 : \

((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2)))

SIZE_T_ONE

#define SIZE_T_ONE

Definition: mymalloc.cc:1447

TREEBIN_SHIFT

#define TREEBIN_SHIFT

Definition: mymalloc.cc:2441

NTREEBINS

#define NTREEBINS

Definition: mymalloc.cc:2438

SIZE_T_BITSIZE

#define SIZE_T_BITSIZE

Definition: mymalloc.cc:1442

Definition at line 2761 of file mymalloc.cc.

#define M_GRANULARITY (-2)

Definition at line 670 of file mymalloc.cc.

#define M_MMAP_THRESHOLD (-3)

Definition at line 671 of file mymalloc.cc.

#define M_TRIM_THRESHOLD (-1)

Definition at line 669 of file mymalloc.cc.

#define MALLINFO_FIELD_TYPE size_t

Definition at line 656 of file mymalloc.cc.

#define MALLOC_ALIGNMENT ((size_t)8U)

Definition at line 560 of file mymalloc.cc.

#define MALLOC_FAILURE_ACTION errno = ENOMEM;

Definition at line 601 of file mymalloc.cc.

#define malloc_getpagesize ((size_t)4096U)

Definition at line 1425 of file mymalloc.cc.

#define mark_inuse_foot	(	M,
		p,
		s
	)

Definition at line 2906 of file mymalloc.cc.

#define mark_smallmap	(	M,
		i
	)	((M)->smallmap \|= idx2bit(i))

Definition at line 2777 of file mymalloc.cc.

#define mark_treemap	(	M,
		i
	)	((M)->treemap \|= idx2bit(i))

Definition at line 2781 of file mymalloc.cc.

#define MAX_RELEASE_CHECK_RATE 4095

Definition at line 641 of file mymalloc.cc.

#define MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2)

Definition at line 2097 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define MAX_SIZE_T (~(size_t)0)

Definition at line 545 of file mymalloc.cc.

Referenced by dlcalloc(), dlmalloc(), mspace_calloc(), and mspace_malloc().

#define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

Definition at line 2444 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE)

Definition at line 2443 of file mymalloc.cc.

#define MCHUNK_SIZE (sizeof(mchunk))

Definition at line 2073 of file mymalloc.cc.

#define mem2chunk ( mem ) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES))

Definition at line 2092 of file mymalloc.cc.

Referenced by dlcalloc(), dlfree(), dlmalloc_usable_size(), dlrealloc(), mspace_calloc(), mspace_free(), mspace_realloc(), and mspace_usable_size().

#define MFAIL ((void*)(MAX_SIZE_T))

Definition at line 1476 of file mymalloc.cc.

#define MIN_CHUNK_SIZE ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

Definition at line 2087 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT)

Definition at line 2442 of file mymalloc.cc.

#define MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

Definition at line 2098 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE))

Definition at line 2685 of file mymalloc.cc.

#define minsize_for_tree_index ( i )

Value:

((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \

(((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1)))

SIZE_T_ONE

#define SIZE_T_ONE

Definition: mymalloc.cc:1447

TREEBIN_SHIFT

#define TREEBIN_SHIFT

Definition: mymalloc.cc:2441

Definition at line 2766 of file mymalloc.cc.

#define mmap_align ( S ) page_align(S)

Definition at line 2540 of file mymalloc.cc.

#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)

Definition at line 2082 of file mymalloc.cc.

#define MMAP_CLEARS 1

Definition at line 591 of file mymalloc.cc.

#define MMAP_DEFAULT ( s )

Value:

((dev_zero_fd < 0) ? \
           (dev_zero_fd = open("/dev/zero", O_RDWR), \
            mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \
            mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0))

Definition at line 1497 of file mymalloc.cc.

#define MMAP_FLAGS (MAP_PRIVATE)

Definition at line 1495 of file mymalloc.cc.

#define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES)

Definition at line 2084 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define MMAP_PROT (PROT_READ|PROT_WRITE)

Definition at line 1483 of file mymalloc.cc.

#define MORECORE_CONTIGUOUS 1

Definition at line 615 of file mymalloc.cc.

#define MORECORE_DEFAULT sbrk

Definition at line 613 of file mymalloc.cc.

#define MSPACES 1

Definition at line 485 of file mymalloc.cc.

Referenced by create_mspace().

#define MUNMAP_DEFAULT	(	a,
		s
	)	munmap((a), (s))

Definition at line 1482 of file mymalloc.cc.

#define next_chunk ( p ) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS)))

Definition at line 2143 of file mymalloc.cc.

#define next_pinuse ( p ) ((next_chunk(p)->head) & PINUSE_BIT)

Definition at line 2147 of file mymalloc.cc.

#define NO_MALLINFO 0

Definition at line 653 of file mymalloc.cc.

#define NO_SEGMENT_TRAVERSAL 0

Definition at line 659 of file mymalloc.cc.

#define NOINLINE

Definition at line 741 of file mymalloc.cc.

#define NSMALLBINS (32U)

Definition at line 2437 of file mymalloc.cc.

#define NTREEBINS (32U)

Definition at line 2438 of file mymalloc.cc.

#define ok_address	(	M,
		a
	)	((char*)(a) >= (M)->least_addr)

Definition at line 2868 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define ok_inuse ( p ) is_inuse(p)

Definition at line 2872 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define ok_magic ( M ) (1)

Definition at line 2887 of file mymalloc.cc.

Referenced by destroy_mspace(), dlfree(), dlrealloc(), mspace_calloc(), mspace_footprint(), mspace_free(), mspace_independent_calloc(), mspace_independent_comalloc(), mspace_mallinfo(), mspace_malloc(), mspace_malloc_stats(), mspace_max_footprint(), mspace_memalign(), mspace_realloc(), and mspace_trim().

#define ok_next	(	p,
		n
	)	((char)(p) < (char)(n))

Definition at line 2870 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define ok_pinuse ( p ) pinuse(p)

Definition at line 2874 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define ONLY_MSPACES 0 /* define to a value */

Definition at line 548 of file mymalloc.cc.

Referenced by create_mspace().

#define overhead_for ( p ) (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)

Definition at line 2162 of file mymalloc.cc.

Referenced by dlmalloc_usable_size(), and mspace_usable_size().

#define pad_request ( req ) (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

Definition at line 2101 of file mymalloc.cc.

Referenced by create_mspace(), create_mspace_with_base(), dlmalloc(), and mspace_malloc().

#define page_align ( S ) (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE))

Definition at line 2527 of file mymalloc.cc.

#define pinuse ( p ) ((p)->head & PINUSE_BIT)

Definition at line 2130 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define PINUSE_BIT (SIZE_T_ONE)

Definition at line 2119 of file mymalloc.cc.

Referenced by dlfree(), dlmalloc(), mspace_free(), and mspace_malloc().

#define POSTACTION ( M )

Definition at line 2611 of file mymalloc.cc.

Referenced by dlfree(), dlmalloc(), dlmalloc_trim(), mspace_free(), mspace_malloc(), mspace_track_large_chunks(), and mspace_trim().

#define PREACTION ( M ) (0)

Definition at line 2607 of file mymalloc.cc.

Referenced by dlfree(), dlmalloc(), dlmalloc_trim(), mspace_free(), mspace_malloc(), mspace_track_large_chunks(), and mspace_trim().

#define prev_chunk ( p ) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) ))

Definition at line 2144 of file mymalloc.cc.

#define PROCEED_ON_ERROR 0

Definition at line 572 of file mymalloc.cc.

#define RELEASE_MALLOC_GLOBAL_LOCK ( )

Definition at line 1916 of file mymalloc.cc.

#define replace_dv	(	M,
		P,
		S
	)

Value:

{\
  size_t DVS = M->dvsize;\
  if (DVS != 0) {\
    mchunkptr DV = M->dv;\
    assert(is_small(DVS));\
    insert_small_chunk(M, DV, DVS);\
  }\
  M->dvsize = S;\
  M->dv = P;\
}

Definition at line 3474 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define request2size ( req ) (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req))

Definition at line 2105 of file mymalloc.cc.

#define RTCHECK ( e ) (e)

Definition at line 2896 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define same_or_left_bits ( x ) ((x) | -(x))

Definition at line 2792 of file mymalloc.cc.

#define segment_holds	(	S,
		A
	)	((char)(A) >= S->base && (char)(A) < S->base + S->size)

Definition at line 2552 of file mymalloc.cc.

#define set_foot	(	p,
		s
	)	(((mchunkptr)((char*)(p) + (s)))->prev_foot = (s))

Definition at line 2151 of file mymalloc.cc.

#define set_free_with_pinuse	(	p,
		s,
		n
	)	(clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s))

Definition at line 2158 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define set_inuse	(	M,
		p,
		s
	)

Value:

((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\

((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)

CINUSE_BIT

#define CINUSE_BIT

Definition: mymalloc.cc:2120

s

const XML_Char * s

Definition: include/expat.h:262

PINUSE_BIT

#define PINUSE_BIT

Definition: mymalloc.cc:2119

p

const char * p

Definition: xmltok.h:285

malloc_chunk

Definition: mymalloc.cc:2057

Definition at line 2911 of file mymalloc.cc.

#define set_inuse_and_pinuse	(	M,
		p,
		s
	)

Value:

((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\

((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)

CINUSE_BIT

#define CINUSE_BIT

Definition: mymalloc.cc:2120

mchunkptr

struct malloc_chunk * mchunkptr

Definition: mymalloc.cc:2065

s

const XML_Char * s

Definition: include/expat.h:262

PINUSE_BIT

#define PINUSE_BIT

Definition: mymalloc.cc:2119

p

const char * p

Definition: xmltok.h:285

Definition at line 2916 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define set_lock	(	M,
		L
	)

Value:

((M)->mflags = (L)?\
  ((M)->mflags | USE_LOCK_BIT) :\
  ((M)->mflags & ~USE_LOCK_BIT))

Definition at line 2521 of file mymalloc.cc.

Referenced by create_mspace(), and create_mspace_with_base().

#define set_size_and_pinuse_of_free_chunk	(	p,
		s
	)	((p)->head = (s\|PINUSE_BIT), set_foot(p, s))

Definition at line 2154 of file mymalloc.cc.

Referenced by dlfree(), dlmalloc(), mspace_free(), and mspace_malloc().

#define set_size_and_pinuse_of_inuse_chunk	(	M,
		p,
		s
	)	((p)->head = (s\|PINUSE_BIT\|CINUSE_BIT))

Definition at line 2921 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define should_trim	(	M,
		s
	)	((s) > (M)->trim_check)

Definition at line 2578 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

Definition at line 1452 of file mymalloc.cc.

#define SIZE_T_BITSIZE (sizeof(size_t) << 3)

Definition at line 1442 of file mymalloc.cc.

#define SIZE_T_FOUR ((size_t)4)

Definition at line 1449 of file mymalloc.cc.

#define SIZE_T_ONE ((size_t)1)

Definition at line 1447 of file mymalloc.cc.

Referenced by dlpvalloc().

#define SIZE_T_SIZE (sizeof(size_t))

Definition at line 1441 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define SIZE_T_TWO ((size_t)2)

Definition at line 1448 of file mymalloc.cc.

#define SIZE_T_ZERO ((size_t)0)

Definition at line 1446 of file mymalloc.cc.

#define small_index ( s ) ((s) >> SMALLBIN_SHIFT)

Definition at line 2683 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define small_index2size ( i ) ((i) << SMALLBIN_SHIFT)

Definition at line 2684 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define smallbin_at	(	M,
		i
	)	((sbinptr)((char*)&((M)->smallbins[(i)<<1])))

Definition at line 2688 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define SMALLBIN_SHIFT (3U)

Definition at line 2439 of file mymalloc.cc.

#define SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT)

Definition at line 2440 of file mymalloc.cc.

#define smallmap_is_marked	(	M,
		i
	)	((M)->smallmap & idx2bit(i))

Definition at line 2779 of file mymalloc.cc.

#define SPIN_LOCKS_AVAILABLE 0

Definition at line 541 of file mymalloc.cc.

#define STRUCT_MALLINFO_DECLARED 1

Definition at line 706 of file mymalloc.cc.

#define SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT)

Definition at line 2544 of file mymalloc.cc.

#define TOP_FOOT_SIZE (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)

Definition at line 2588 of file mymalloc.cc.

Referenced by create_mspace(), and create_mspace_with_base().

#define treebin_at	(	M,
		i
	)	(&((M)->treebins[i]))

Definition at line 2689 of file mymalloc.cc.

#define TREEBIN_SHIFT (8U)

Definition at line 2441 of file mymalloc.cc.

#define treemap_is_marked	(	M,
		i
	)	((M)->treemap & idx2bit(i))

Definition at line 2783 of file mymalloc.cc.

#define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1)

Definition at line 1450 of file mymalloc.cc.

#define unlink_chunk	(	M,
		P,
		S
	)

Value:

if (is_small(S)) unlink_small_chunk(M, P, S)\

else { tchunkptr TP = (tchunkptr)(P); unlink_large_chunk(M, TP); }

malloc_tree_chunk

Definition: mymalloc.cc:2263

tchunkptr

struct malloc_tree_chunk * tchunkptr

Definition: mymalloc.cc:2276

is_small

#define is_small(s)

Definition: mymalloc.cc:2682

unlink_large_chunk

#define unlink_large_chunk(M, X)

Definition: mymalloc.cc:3556

unlink_small_chunk

#define unlink_small_chunk(M, P, S)

Definition: mymalloc.cc:3434

Definition at line 3633 of file mymalloc.cc.

Referenced by dlfree(), and mspace_free().

#define unlink_first_small_chunk	(	M,
		B,
		P,
		I
	)

Value:

{\
  mchunkptr F = P->fd;\
  assert(P != B);\
  assert(P != F);\
  assert(chunksize(P) == small_index2size(I));\
  if (B == F)\
    clear_smallmap(M, I);\
  else if (RTCHECK(ok_address(M, F))) {\
    B->fd = F;\
    F->bk = B;\
  }\
  else {\
    CORRUPTION_ERROR_ACTION(M);\
  }\
}

Definition at line 3454 of file mymalloc.cc.

Referenced by dlmalloc(), and mspace_malloc().

#define unlink_large_chunk	(	M,
		X
	)

Definition at line 3556 of file mymalloc.cc.

#define unlink_small_chunk	(	M,
		P,
		S
	)

Value:

{\
  mchunkptr F = P->fd;\
  mchunkptr B = P->bk;\
  bindex_t I = small_index(S);\
  assert(P != B);\
  assert(P != F);\
  assert(chunksize(P) == small_index2size(I));\
  if (F == B)\
    clear_smallmap(M, I);\
  else if (RTCHECK((F == smallbin_at(M,I) || ok_address(M, F)) &&\
                   (B == smallbin_at(M,I) || ok_address(M, B)))) {\
    F->bk = B;\
    B->fd = F;\
  }\
  else {\
    CORRUPTION_ERROR_ACTION(M);\
  }\
}

Definition at line 3434 of file mymalloc.cc.

#define USAGE_ERROR_ACTION	(	m,
		p
	)	ABORT

Definition at line 2642 of file mymalloc.cc.

Referenced by destroy_mspace(), dlfree(), dlrealloc(), mspace_calloc(), mspace_footprint(), mspace_free(), mspace_independent_calloc(), mspace_independent_comalloc(), mspace_mallinfo(), mspace_malloc(), mspace_malloc_stats(), mspace_max_footprint(), mspace_memalign(), mspace_realloc(), and mspace_trim().

#define USE_BUILTIN_FFS 0

Definition at line 647 of file mymalloc.cc.

#define USE_DEV_RANDOM 0

Definition at line 650 of file mymalloc.cc.

#define use_lock ( M ) ((M)->mflags & USE_LOCK_BIT)

Definition at line 2510 of file mymalloc.cc.

#define USE_LOCK_BIT (0U)

Definition at line 1903 of file mymalloc.cc.

#define USE_LOCKS 0

Definition at line 575 of file mymalloc.cc.

Referenced by create_mspace().

#define use_mmap ( M ) ((M)->mflags & USE_MMAP_BIT)

Definition at line 2514 of file mymalloc.cc.

Referenced by mspace_track_large_chunks().

#define USE_MMAP_BIT (SIZE_T_ONE)

Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP

Definition at line 1568 of file mymalloc.cc.

Referenced by create_mspace(), and destroy_mspace().

#define use_noncontiguous ( M ) ((M)->mflags & USE_NONCONTIGUOUS_BIT)

Definition at line 2518 of file mymalloc.cc.

#define USE_NONCONTIGUOUS_BIT (4U)

Definition at line 1610 of file mymalloc.cc.

#define USE_SPIN_LOCKS 0

Definition at line 581 of file mymalloc.cc.

Typedef Documentation

typedef unsigned int bindex_t

Definition at line 2067 of file mymalloc.cc.

typedef unsigned int binmap_t

Definition at line 2068 of file mymalloc.cc.

typedef unsigned int flag_t

Definition at line 2069 of file mymalloc.cc.

typedef struct malloc_chunk mchunk

Definition at line 2064 of file mymalloc.cc.

typedef struct malloc_chunk* mchunkptr

Definition at line 2065 of file mymalloc.cc.

typedef struct malloc_segment msegment

Definition at line 2349 of file mymalloc.cc.

typedef struct malloc_segment* msegmentptr

Definition at line 2350 of file mymalloc.cc.

typedef void* mspace

Definition at line 1123 of file mymalloc.cc.

typedef struct malloc_state* mstate

Definition at line 2470 of file mymalloc.cc.

typedef struct malloc_chunk* sbinptr

Definition at line 2066 of file mymalloc.cc.

typedef struct malloc_tree_chunk* tbinptr

Definition at line 2277 of file mymalloc.cc.

typedef struct malloc_tree_chunk tchunk

Definition at line 2275 of file mymalloc.cc.

typedef struct malloc_tree_chunk* tchunkptr

Definition at line 2276 of file mymalloc.cc.

Function Documentation

mspace create_mspace	(	size_t	capacity,
		int	locked
	)

Definition at line 4974 of file mymalloc.cc.

References CALL_MMAP, CMFAIL, ensure_initialization, malloc_params::granularity, granularity_align, HAVE_MMAP, HAVE_MORECORE, python.hepunit::m, MSPACES, ONLY_MSPACES, pad_request, malloc_params::page_size, malloc_state::seg, set_lock, malloc_segment::sflags, TOP_FOOT_SIZE, USE_LOCKS, and USE_MMAP_BIT.

Referenced by calloc(), malloc(), realloc(), and valloc().

                                                   {
 
   //Added by xindong
   std::cout << "HAVE_MORECORE: " << HAVE_MORECORE << ", "
             << "MSPACES: " << MSPACES  << ", "
             << "ONLY_MSPACES: " << ONLY_MSPACES << ", "
             << "HAVE_MMAP: " << HAVE_MMAP << ", "
             << " USE_LOCKS: " << USE_LOCKS << std::endl;  
 
   mstate m = 0;
   size_t msize;
   ensure_initialization();
   msize = pad_request(sizeof(struct malloc_state));
   //Commented out by xindong
   if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
     std::cout << "handle capacity paramenter: " << capacity << ", "
               << (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)
               << std::endl;
     size_t rs = ((capacity == 0)? mparams.granularity :
                  (capacity + TOP_FOOT_SIZE + msize));
     size_t tsize = granularity_align(rs);
     char* tbase = (char*)(CALL_MMAP(tsize));
     if (tbase != CMFAIL) {
       m = init_user_mstate(tbase, tsize);
       m->seg.sflags = USE_MMAP_BIT;
       set_lock(m, locked);
     }
   }
   return (mspace)m;
 }

mspace create_mspace_with_base	(	void *	base,
		size_t	capacity,
		int	locked
	)

Definition at line 5005 of file mymalloc.cc.

References ensure_initialization, EXTERN_BIT, python.hepunit::m, pad_request, malloc_params::page_size, malloc_state::seg, set_lock, malloc_segment::sflags, and TOP_FOOT_SIZE.

                                                                         {
   mstate m = 0;
   size_t msize;
   ensure_initialization();
   msize = pad_request(sizeof(struct malloc_state));
   if (capacity > msize + TOP_FOOT_SIZE &&
       capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
     m = init_user_mstate((char*)base, capacity);
     m->seg.sflags = EXTERN_BIT;
     set_lock(m, locked);
   }
   return (mspace)m;
 }

size_t destroy_mspace ( mspace msp )

Definition at line 5034 of file mymalloc.cc.

References malloc_segment::base, CALL_MUNMAP, EXTERN_BIT, python.hepunit::ms, malloc_segment::next, ok_magic, malloc_state::seg, malloc_segment::sflags, malloc_segment::size, USAGE_ERROR_ACTION, and USE_MMAP_BIT.

                                   {
   size_t freed = 0;
   mstate ms = (mstate)msp;
   if (ok_magic(ms)) {
     msegmentptr sp = &ms->seg;
     while (sp != 0) {
       char* base = sp->base;
       size_t size = sp->size;
       flag_t flag = sp->sflags;
       sp = sp->next;
       if ((flag & USE_MMAP_BIT) && !(flag & EXTERN_BIT) &&
           CALL_MUNMAP(base, size) == 0)
         freed += size;
     }
   }
   else {
     USAGE_ERROR_ACTION(ms,ms);
   }
   return freed;
 }

void* dlcalloc	(	size_t	n_elements,
		size_t	elem_size
	)

Definition at line 4837 of file mymalloc.cc.

References calloc_must_clear, dlmalloc, MAX_SIZE_T, and mem2chunk.

                                                     {
   void* mem;
   size_t req = 0;
   if (n_elements != 0) {
     req = n_elements * elem_size;
     if (((n_elements | elem_size) & ~(size_t)0xffff) &&
         (req / n_elements != elem_size))
       req = MAX_SIZE_T; /* force downstream failure on overflow */
   }
   mem = dlmalloc(req);
   if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
     memset(mem, 0, req);
   return mem;
 }

void dlfree ( void * mem )

Definition at line 4728 of file mymalloc.cc.

References CALL_MUNMAP, check_free_chunk, check_inuse_chunk, chunk_minus_offset, chunk_plus_offset, chunksize, cinuse, malloc_state::dv, malloc_state::dvsize, fm, malloc_state::footprint, malloc_chunk::head, insert_large_chunk, insert_small_chunk, INUSE_BITS, is_mmapped, is_small, mem2chunk, MMAP_FOOT_PAD, ok_address, ok_inuse, ok_magic, ok_next, ok_pinuse, pinuse, PINUSE_BIT, POSTACTION, PREACTION, malloc_chunk::prev_foot, malloc_state::release_checks, RTCHECK, set_free_with_pinuse, set_size_and_pinuse_of_free_chunk, should_trim, malloc_state::top, malloc_state::topsize, unlink_chunk, and USAGE_ERROR_ACTION.

                        {
   /*
      Consolidate freed chunks with preceeding or succeeding bordering
      free chunks, if they exist, and then place in a bin.  Intermixed
      with special cases for top, dv, mmapped chunks, and usage errors.
   */
 
   if (mem != 0) {
     mchunkptr p  = mem2chunk(mem);
 #if FOOTERS
     mstate fm = get_mstate_for(p);
     if (!ok_magic(fm)) {
       USAGE_ERROR_ACTION(fm, p);
       return;
     }
 #else /* FOOTERS */
 #define fm gm
 #endif /* FOOTERS */
     if (!PREACTION(fm)) {
       check_inuse_chunk(fm, p);
       if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) {
         size_t psize = chunksize(p);
         mchunkptr next = chunk_plus_offset(p, psize);
         if (!pinuse(p)) {
           size_t prevsize = p->prev_foot;
           if (is_mmapped(p)) {
             psize += prevsize + MMAP_FOOT_PAD;
             if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
               fm->footprint -= psize;
             goto postaction;
           }
           else {
             mchunkptr prev = chunk_minus_offset(p, prevsize);
             psize += prevsize;
             p = prev;
             if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
               if (p != fm->dv) {
                 unlink_chunk(fm, p, prevsize);
               }
               else if ((next->head & INUSE_BITS) == INUSE_BITS) {
                 fm->dvsize = psize;
                 set_free_with_pinuse(p, psize, next);
                 goto postaction;
               }
             }
             else
               goto erroraction;
           }
         }
 
         if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
           if (!cinuse(next)) {  /* consolidate forward */
             if (next == fm->top) {
               size_t tsize = fm->topsize += psize;
               fm->top = p;
               p->head = tsize | PINUSE_BIT;
               if (p == fm->dv) {
                 fm->dv = 0;
                 fm->dvsize = 0;
               }
               if (should_trim(fm, tsize))
                 sys_trim(fm, 0);
               goto postaction;
             }
             else if (next == fm->dv) {
               size_t dsize = fm->dvsize += psize;
               fm->dv = p;
               set_size_and_pinuse_of_free_chunk(p, dsize);
               goto postaction;
             }
             else {
               size_t nsize = chunksize(next);
               psize += nsize;
               unlink_chunk(fm, next, nsize);
               set_size_and_pinuse_of_free_chunk(p, psize);
               if (p == fm->dv) {
                 fm->dvsize = psize;
                 goto postaction;
               }
             }
           }
           else
             set_free_with_pinuse(p, psize, next);
 
           if (is_small(psize)) {
             insert_small_chunk(fm, p, psize);
             check_free_chunk(fm, p);
           }
           else {
             tchunkptr tp = (tchunkptr)p;
             insert_large_chunk(fm, tp, psize);
             check_free_chunk(fm, p);
             if (--fm->release_checks == 0)
               release_unused_segments(fm);
           }
           goto postaction;
         }
       }
     erroraction:
       USAGE_ERROR_ACTION(fm, p);
     postaction:
       POSTACTION(fm);
     }
   }
 #if !FOOTERS
 #undef fm
 #endif /* FOOTERS */
 }

void** dlindependent_calloc	(	size_t	,
		size_t	,
		void **
	)

void** dlindependent_calloc	(	size_t	n_elements,
		size_t	elem_size,
		void *	chunks[]
	)

Definition at line 4879 of file mymalloc.cc.

References gm.

                                                  {
   size_t sz = elem_size; /* serves as 1-element array */
   return ialloc(gm, n_elements, &sz, 3, chunks);
 }

void** dlindependent_comalloc	(	size_t	,
		size_t *	,
		void **
	)

void** dlindependent_comalloc	(	size_t	n_elements,
		size_t	sizes[],
		void *	chunks[]
	)

Definition at line 4885 of file mymalloc.cc.

References gm.

                                                    {
   return ialloc(gm, n_elements, sizes, 0, chunks);
 }

struct mallinfo dlmallinfo ( void )

Definition at line 4923 of file mymalloc.cc.

References gm.

                                  {
   return internal_mallinfo(gm);
 }

void* dlmalloc ( size_t bytes )

Definition at line 4592 of file mymalloc.cc.

References assert, test::b, check_malloced_chunk, check_top_chunk, chunk2mem, chunk_plus_offset, chunksize, compute_bit2idx, ensure_initialization, malloc_chunk::fd, gm, malloc_chunk::head, idx2bit, least_bit, left_bits, MAX_REQUEST, MAX_SIZE_T, MAX_SMALL_REQUEST, MIN_CHUNK_SIZE, MIN_REQUEST, pad_request, PINUSE_BIT, POSTACTION, PREACTION, replace_dv, set_inuse_and_pinuse, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, SIZE_T_SIZE, small_index, small_index2size, smallbin_at, and unlink_first_small_chunk.

                              {
   /*
      Basic algorithm:
      If a small request (< 256 bytes minus per-chunk overhead):
        1. If one exists, use a remainderless chunk in associated smallbin.
           (Remainderless means that there are too few excess bytes to
           represent as a chunk.)
        2. If it is big enough, use the dv chunk, which is normally the
           chunk adjacent to the one used for the most recent small request.
        3. If one exists, split the smallest available chunk in a bin,
           saving remainder in dv.
        4. If it is big enough, use the top chunk.
        5. If available, get memory from system and use it
      Otherwise, for a large request:
        1. Find the smallest available binned chunk that fits, and use it
           if it is better fitting than dv chunk, splitting if necessary.
        2. If better fitting than any binned chunk, use the dv chunk.
        3. If it is big enough, use the top chunk.
        4. If request size >= mmap threshold, try to directly mmap this chunk.
        5. If available, get memory from system and use it
 
      The ugly goto's here ensure that postaction occurs along all paths.
   */
 
 #if USE_LOCKS
   ensure_initialization(); /* initialize in sys_alloc if not using locks */
 #endif
 
   if (!PREACTION(gm)) {
     void* mem;
     size_t nb;
     if (bytes <= MAX_SMALL_REQUEST) {
       bindex_t idx;
       binmap_t smallbits;
       nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
       idx = small_index(nb);
       smallbits = gm->smallmap >> idx;
 
       if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
         mchunkptr b, p;
         idx += ~smallbits & 1;       /* Uses next bin if idx empty */
         b = smallbin_at(gm, idx);
         p = b->fd;
         assert(chunksize(p) == small_index2size(idx));
         unlink_first_small_chunk(gm, b, p, idx);
         set_inuse_and_pinuse(gm, p, small_index2size(idx));
         mem = chunk2mem(p);
         check_malloced_chunk(gm, mem, nb);
         goto postaction;
       }
 
       else if (nb > gm->dvsize) {
         if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
           mchunkptr b, p, r;
           size_t rsize;
           bindex_t i;
           binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
           binmap_t leastbit = least_bit(leftbits);
           compute_bit2idx(leastbit, i);
           b = smallbin_at(gm, i);
           p = b->fd;
           assert(chunksize(p) == small_index2size(i));
           unlink_first_small_chunk(gm, b, p, i);
           rsize = small_index2size(i) - nb;
           /* Fit here cannot be remainderless if 4byte sizes */
           if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
             set_inuse_and_pinuse(gm, p, small_index2size(i));
           else {
             set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
             r = chunk_plus_offset(p, nb);
             set_size_and_pinuse_of_free_chunk(r, rsize);
             replace_dv(gm, r, rsize);
           }
           mem = chunk2mem(p);
           check_malloced_chunk(gm, mem, nb);
           goto postaction;
         }
 
         else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) {
           check_malloced_chunk(gm, mem, nb);
           goto postaction;
         }
       }
     }
     else if (bytes >= MAX_REQUEST)
       nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
     else {
       nb = pad_request(bytes);
       if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
         check_malloced_chunk(gm, mem, nb);
         goto postaction;
       }
     }
 
     if (nb <= gm->dvsize) {
       size_t rsize = gm->dvsize - nb;
       mchunkptr p = gm->dv;
       if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
         mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
         gm->dvsize = rsize;
         set_size_and_pinuse_of_free_chunk(r, rsize);
         set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
       }
       else { /* exhaust dv */
         size_t dvs = gm->dvsize;
         gm->dvsize = 0;
         gm->dv = 0;
         set_inuse_and_pinuse(gm, p, dvs);
       }
       mem = chunk2mem(p);
       check_malloced_chunk(gm, mem, nb);
       goto postaction;
     }
 
     else if (nb < gm->topsize) { /* Split top */
       size_t rsize = gm->topsize -= nb;
       mchunkptr p = gm->top;
       mchunkptr r = gm->top = chunk_plus_offset(p, nb);
       r->head = rsize | PINUSE_BIT;
       set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
       mem = chunk2mem(p);
       check_top_chunk(gm, gm->top);
       check_malloced_chunk(gm, mem, nb);
       goto postaction;
     }
 
     mem = sys_alloc(gm, nb);
 
   postaction:
     POSTACTION(gm);
     return mem;
   }
 
   return 0;
 }

size_t dlmalloc_footprint ( void )

Definition at line 4914 of file mymalloc.cc.

References gm.

                                 {
   return gm->footprint;
 }

size_t dlmalloc_max_footprint ( void )

Definition at line 4918 of file mymalloc.cc.

References gm.

                                     {
   return gm->max_footprint;
 }

void dlmalloc_stats ( void )

Definition at line 4928 of file mymalloc.cc.

References gm.

                       {
   internal_malloc_stats(gm);
 }

int dlmalloc_trim ( size_t pad )

Definition at line 4904 of file mymalloc.cc.

References ensure_initialization, gm, POSTACTION, and PREACTION.

                               {
   int result = 0;
   ensure_initialization();
   if (!PREACTION(gm)) {
     result = sys_trim(gm, pad);
     POSTACTION(gm);
   }
   return result;
 }

size_t dlmalloc_usable_size ( void * mem )

Definition at line 4938 of file mymalloc.cc.

References chunksize, is_inuse, mem2chunk, and overhead_for.

                                        {
   if (mem != 0) {
     mchunkptr p = mem2chunk(mem);
     if (is_inuse(p))
       return chunksize(p) - overhead_for(p);
   }
   return 0;
 }

int dlmallopt	(	int	param_number,
		int	value
	)

Definition at line 4932 of file mymalloc.cc.

                                            {
   return change_mparam(param_number, value);
 }

void* dlmemalign	(	size_t	alignment,
		size_t	bytes
	)

Definition at line 4875 of file mymalloc.cc.

References gm.

                                                  {
   return internal_memalign(gm, alignment, bytes);
 }

void* dlpvalloc ( size_t bytes )

Definition at line 4897 of file mymalloc.cc.

References dlmemalign, ensure_initialization, malloc_params::page_size, and SIZE_T_ONE.

                               {
   size_t pagesz;
   ensure_initialization();
   pagesz = mparams.page_size;
   return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
 }

void* dlrealloc	(	void *	oldmem,
		size_t	bytes
	)

Definition at line 4852 of file mymalloc.cc.

References dlfree, dlmalloc, gm, mem2chunk, ok_magic, and USAGE_ERROR_ACTION.

                                             {
   if (oldmem == 0)
     return dlmalloc(bytes);
 #ifdef REALLOC_ZERO_BYTES_FREES
   if (bytes == 0) {
     dlfree(oldmem);
     return 0;
   }
 #endif /* REALLOC_ZERO_BYTES_FREES */
   else {
 #if ! FOOTERS
     mstate m = gm;
 #else /* FOOTERS */
     mstate m = get_mstate_for(mem2chunk(oldmem));
     if (!ok_magic(m)) {
       USAGE_ERROR_ACTION(m, oldmem);
       return 0;
     }
 #endif /* FOOTERS */
     return internal_realloc(m, oldmem, bytes);
   }
 }

void* dlvalloc ( size_t bytes )

Definition at line 4890 of file mymalloc.cc.

References dlmemalign, ensure_initialization, and malloc_params::page_size.

                              {
   size_t pagesz;
   ensure_initialization();
   pagesz = mparams.page_size;
   return dlmemalign(pagesz, bytes);
 }

void* mspace_calloc	(	mspace	msp,
		size_t	n_elements,
		size_t	elem_size
	)

Definition at line 5276 of file mymalloc.cc.

References calloc_must_clear, internal_malloc, MAX_SIZE_T, mem2chunk, python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

Referenced by calloc().

                                                                      {
   void* mem;
   size_t req = 0;
   mstate ms = (mstate)msp;
   if (!ok_magic(ms)) {
     USAGE_ERROR_ACTION(ms,ms);
     return 0;
   }
   if (n_elements != 0) {
     req = n_elements * elem_size;
     if (((n_elements | elem_size) & ~(size_t)0xffff) &&
         (req / n_elements != elem_size))
       req = MAX_SIZE_T; /* force downstream failure on overflow */
   }
   mem = internal_malloc(ms, req);
   if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
     memset(mem, 0, req);
   return mem;
 }

size_t mspace_footprint ( mspace msp )

Definition at line 5375 of file mymalloc.cc.

References malloc_state::footprint, python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                     {
   size_t result = 0;
   mstate ms = (mstate)msp;
   if (ok_magic(ms)) {
     result = ms->footprint;
   }
   else {
     USAGE_ERROR_ACTION(ms,ms);
   }
   return result;
 }

void mspace_free	(	mspace	msp,
		void *	mem
	)

Definition at line 5175 of file mymalloc.cc.

References CALL_MUNMAP, check_free_chunk, check_inuse_chunk, chunk_minus_offset, chunk_plus_offset, chunksize, cinuse, malloc_state::dv, malloc_state::dvsize, fm, malloc_state::footprint, malloc_chunk::head, insert_large_chunk, insert_small_chunk, INUSE_BITS, is_mmapped, is_small, mem2chunk, MMAP_FOOT_PAD, ok_address, ok_inuse, ok_magic, ok_next, ok_pinuse, pinuse, PINUSE_BIT, POSTACTION, PREACTION, malloc_chunk::prev_foot, malloc_state::release_checks, RTCHECK, set_free_with_pinuse, set_size_and_pinuse_of_free_chunk, should_trim, malloc_state::top, malloc_state::topsize, unlink_chunk, and USAGE_ERROR_ACTION.

Referenced by cfree(), free(), and mspace_realloc().

                                         {
   if (mem != 0) {
     mchunkptr p  = mem2chunk(mem);
 #if FOOTERS
     mstate fm = get_mstate_for(p);
     msp = msp; /* placate people compiling -Wunused */
 #else /* FOOTERS */
     mstate fm = (mstate)msp;
 #endif /* FOOTERS */
     if (!ok_magic(fm)) {
       USAGE_ERROR_ACTION(fm, p);
       return;
     }
     if (!PREACTION(fm)) {
       check_inuse_chunk(fm, p);
       if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) {
         size_t psize = chunksize(p);
         mchunkptr next = chunk_plus_offset(p, psize);
         if (!pinuse(p)) {
           size_t prevsize = p->prev_foot;
           if (is_mmapped(p)) {
             psize += prevsize + MMAP_FOOT_PAD;
             if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
               fm->footprint -= psize;
             goto postaction;
           }
           else {
             mchunkptr prev = chunk_minus_offset(p, prevsize);
             psize += prevsize;
             p = prev;
             if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
               if (p != fm->dv) {
                 unlink_chunk(fm, p, prevsize);
               }
               else if ((next->head & INUSE_BITS) == INUSE_BITS) {
                 fm->dvsize = psize;
                 set_free_with_pinuse(p, psize, next);
                 goto postaction;
               }
             }
             else
               goto erroraction;
           }
         }
 
         if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
           if (!cinuse(next)) {  /* consolidate forward */
             if (next == fm->top) {
               size_t tsize = fm->topsize += psize;
               fm->top = p;
               p->head = tsize | PINUSE_BIT;
               if (p == fm->dv) {
                 fm->dv = 0;
                 fm->dvsize = 0;
               }
               if (should_trim(fm, tsize))
                 sys_trim(fm, 0);
               goto postaction;
             }
             else if (next == fm->dv) {
               size_t dsize = fm->dvsize += psize;
               fm->dv = p;
               set_size_and_pinuse_of_free_chunk(p, dsize);
               goto postaction;
             }
             else {
               size_t nsize = chunksize(next);
               psize += nsize;
               unlink_chunk(fm, next, nsize);
               set_size_and_pinuse_of_free_chunk(p, psize);
               if (p == fm->dv) {
                 fm->dvsize = psize;
                 goto postaction;
               }
             }
           }
           else
             set_free_with_pinuse(p, psize, next);
 
           if (is_small(psize)) {
             insert_small_chunk(fm, p, psize);
             check_free_chunk(fm, p);
           }
           else {
             tchunkptr tp = (tchunkptr)p;
             insert_large_chunk(fm, tp, psize);
             check_free_chunk(fm, p);
             if (--fm->release_checks == 0)
               release_unused_segments(fm);
           }
           goto postaction;
         }
       }
     erroraction:
       USAGE_ERROR_ACTION(fm, p);
     postaction:
       POSTACTION(fm);
     }
   }
 }

void** mspace_independent_calloc	(	mspace	msp,
		size_t	n_elements,
		size_t	elem_size,
		void *	chunks[]
	)

Definition at line 5329 of file mymalloc.cc.

References python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                                                    {
   size_t sz = elem_size; /* serves as 1-element array */
   mstate ms = (mstate)msp;
   if (!ok_magic(ms)) {
     USAGE_ERROR_ACTION(ms,ms);
     return 0;
   }
   return ialloc(ms, n_elements, &sz, 3, chunks);
 }

void** mspace_independent_comalloc	(	mspace	msp,
		size_t	n_elements,
		size_t	sizes[],
		void *	chunks[]
	)

Definition at line 5340 of file mymalloc.cc.

References python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                                                    {
   mstate ms = (mstate)msp;
   if (!ok_magic(ms)) {
     USAGE_ERROR_ACTION(ms,ms);
     return 0;
   }
   return ialloc(ms, n_elements, sizes, 0, chunks);
 }

struct mallinfo mspace_mallinfo ( mspace msp )

Definition at line 5402 of file mymalloc.cc.

References python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                             {
   mstate ms = (mstate)msp;
   if (!ok_magic(ms)) {
     USAGE_ERROR_ACTION(ms,ms);
   }
   return internal_mallinfo(ms);
 }

void* mspace_malloc	(	mspace	msp,
		size_t	bytes
	)

Definition at line 5061 of file mymalloc.cc.

References assert, test::b, check_malloced_chunk, check_top_chunk, chunk2mem, chunk_plus_offset, chunksize, compute_bit2idx, malloc_state::dv, malloc_state::dvsize, malloc_chunk::fd, malloc_chunk::head, idx2bit, least_bit, left_bits, MAX_REQUEST, MAX_SIZE_T, MAX_SMALL_REQUEST, MIN_CHUNK_SIZE, MIN_REQUEST, python.hepunit::ms, ok_magic, pad_request, PINUSE_BIT, POSTACTION, PREACTION, replace_dv, set_inuse_and_pinuse, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, SIZE_T_SIZE, small_index, small_index2size, smallbin_at, malloc_state::smallmap, malloc_state::top, malloc_state::topsize, malloc_state::treemap, unlink_first_small_chunk, and USAGE_ERROR_ACTION.

Referenced by malloc(), mspace_realloc(), and valloc().

                                               {
   mstate ms = (mstate)msp;
   if (!ok_magic(ms)) {
     USAGE_ERROR_ACTION(ms,ms);
     return 0;
   }
   if (!PREACTION(ms)) {
     void* mem;
     size_t nb;
     if (bytes <= MAX_SMALL_REQUEST) {
       bindex_t idx;
       binmap_t smallbits;
       nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
       idx = small_index(nb);
       smallbits = ms->smallmap >> idx;
 
       if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
         mchunkptr b, p;
         idx += ~smallbits & 1;       /* Uses next bin if idx empty */
         b = smallbin_at(ms, idx);
         p = b->fd;
         assert(chunksize(p) == small_index2size(idx));
         unlink_first_small_chunk(ms, b, p, idx);
         set_inuse_and_pinuse(ms, p, small_index2size(idx));
         mem = chunk2mem(p);
         check_malloced_chunk(ms, mem, nb);
         goto postaction;
       }
 
       else if (nb > ms->dvsize) {
         if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
           mchunkptr b, p, r;
           size_t rsize;
           bindex_t i;
           binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
           binmap_t leastbit = least_bit(leftbits);
           compute_bit2idx(leastbit, i);
           b = smallbin_at(ms, i);
           p = b->fd;
           assert(chunksize(p) == small_index2size(i));
           unlink_first_small_chunk(ms, b, p, i);
           rsize = small_index2size(i) - nb;
           /* Fit here cannot be remainderless if 4byte sizes */
           if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
             set_inuse_and_pinuse(ms, p, small_index2size(i));
           else {
             set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
             r = chunk_plus_offset(p, nb);
             set_size_and_pinuse_of_free_chunk(r, rsize);
             replace_dv(ms, r, rsize);
           }
           mem = chunk2mem(p);
           check_malloced_chunk(ms, mem, nb);
           goto postaction;
         }
 
         else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) {
           check_malloced_chunk(ms, mem, nb);
           goto postaction;
         }
       }
     }
     else if (bytes >= MAX_REQUEST)
       nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
     else {
       nb = pad_request(bytes);
       if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) {
         check_malloced_chunk(ms, mem, nb);
         goto postaction;
       }
     }
 
     if (nb <= ms->dvsize) {
       size_t rsize = ms->dvsize - nb;
       mchunkptr p = ms->dv;
       if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
         mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
         ms->dvsize = rsize;
         set_size_and_pinuse_of_free_chunk(r, rsize);
         set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
       }
       else { /* exhaust dv */
         size_t dvs = ms->dvsize;
         ms->dvsize = 0;
         ms->dv = 0;
         set_inuse_and_pinuse(ms, p, dvs);
       }
       mem = chunk2mem(p);
       check_malloced_chunk(ms, mem, nb);
       goto postaction;
     }
 
     else if (nb < ms->topsize) { /* Split top */
       size_t rsize = ms->topsize -= nb;
       mchunkptr p = ms->top;
       mchunkptr r = ms->top = chunk_plus_offset(p, nb);
       r->head = rsize | PINUSE_BIT;
       set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
       mem = chunk2mem(p);
       check_top_chunk(ms, ms->top);
       check_malloced_chunk(ms, mem, nb);
       goto postaction;
     }
 
     mem = sys_alloc(ms, nb);
 
   postaction:
     POSTACTION(ms);
     return mem;
   }
 
   return 0;
 }

void mspace_malloc_stats ( mspace msp )

Definition at line 5365 of file mymalloc.cc.

References python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                      {
   mstate ms = (mstate)msp;
   if (ok_magic(ms)) {
     internal_malloc_stats(ms);
   }
   else {
     USAGE_ERROR_ACTION(ms,ms);
   }
 }

int mspace_mallopt	(	int	param_number,
		int	value
	)

Definition at line 5420 of file mymalloc.cc.

                                                 {
   return change_mparam(param_number, value);
 }

size_t mspace_max_footprint ( mspace msp )

Definition at line 5388 of file mymalloc.cc.

References malloc_state::max_footprint, python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                         {
   size_t result = 0;
   mstate ms = (mstate)msp;
   if (ok_magic(ms)) {
     result = ms->max_footprint;
   }
   else {
     USAGE_ERROR_ACTION(ms,ms);
   }
   return result;
 }

void* mspace_memalign	(	mspace	msp,
		size_t	alignment,
		size_t	bytes
	)

Definition at line 5320 of file mymalloc.cc.

References python.hepunit::ms, ok_magic, and USAGE_ERROR_ACTION.

                                                                   {
   mstate ms = (mstate)msp;
   if (!ok_magic(ms)) {
     USAGE_ERROR_ACTION(ms,ms);
     return 0;
   }
   return internal_memalign(ms, alignment, bytes);
 }

void* mspace_realloc	(	mspace	msp,
		void *	mem,
		size_t	newsize
	)

Definition at line 5296 of file mymalloc.cc.

References mem2chunk, python.hepunit::ms, mspace_free(), mspace_malloc(), ok_magic, and USAGE_ERROR_ACTION.

Referenced by realloc().

                                                              {
   if (oldmem == 0)
     return mspace_malloc(msp, bytes);
 #ifdef REALLOC_ZERO_BYTES_FREES
   if (bytes == 0) {
     mspace_free(msp, oldmem);
     return 0;
   }
 #endif /* REALLOC_ZERO_BYTES_FREES */
   else {
 #if FOOTERS
     mchunkptr p  = mem2chunk(oldmem);
     mstate ms = get_mstate_for(p);
 #else /* FOOTERS */
     mstate ms = (mstate)msp;
 #endif /* FOOTERS */
     if (!ok_magic(ms)) {
       USAGE_ERROR_ACTION(ms,ms);
       return 0;
     }
     return internal_realloc(ms, oldmem, bytes);
   }
 }

int mspace_track_large_chunks	(	mspace	msp,
		int	enable
	)

Definition at line 5019 of file mymalloc.cc.

References disable_mmap, enable_mmap, python.hepunit::ms, POSTACTION, PREACTION, and use_mmap.

                                                       {
   int ret = 0;
   mstate ms = (mstate)msp;
   if (!PREACTION(ms)) {
     if (!use_mmap(ms))
       ret = 1;
     if (!enable)
       enable_mmap(ms);
     else
       disable_mmap(ms);
     POSTACTION(ms);
   }
   return ret;
 }

int mspace_trim	(	mspace	msp,
		size_t	pad
	)

Definition at line 5350 of file mymalloc.cc.

References python.hepunit::ms, ok_magic, POSTACTION, PREACTION, and USAGE_ERROR_ACTION.

                                         {
   int result = 0;
   mstate ms = (mstate)msp;
   if (ok_magic(ms)) {
     if (!PREACTION(ms)) {
       result = sys_trim(ms, pad);
       POSTACTION(ms);
     }
   }
   else {
     USAGE_ERROR_ACTION(ms,ms);
   }
   return result;
 }

size_t mspace_usable_size ( void * mem )

Definition at line 5411 of file mymalloc.cc.

References chunksize, is_inuse, mem2chunk, and overhead_for.

                                      {
   if (mem != 0) {
     mchunkptr p = mem2chunk(mem);
     if (is_inuse(p))
       return chunksize(p) - overhead_for(p);
   }
   return 0;
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation