mirror of https://gitee.com/bigwinds/arangodb
171 lines
5.6 KiB
C
171 lines
5.6 KiB
C
/*
|
|
$Id: malloc-private.h,v 1.4 2006/03/31 12:56:52 wg Exp $
|
|
Private header file for ptmalloc3, created by Wolfram Gloger
|
|
and released to the public domain, as explained at
|
|
http://creativecommons.org/licenses/publicdomain.
|
|
*/
|
|
|
|
/* The following file is replicated from malloc.c */
|
|
|
|
#ifndef MALLOC_PRIVATE_H
|
|
#define MALLOC_PRIVATE_H
|
|
|
|
#ifndef MALLOC_ALIGNMENT
|
|
# define MALLOC_ALIGNMENT ((size_t)8U)
|
|
#endif
|
|
#ifndef USE_LOCKS
|
|
# define USE_LOCKS 0
|
|
#endif
|
|
|
|
/* The bit mask value corresponding to MALLOC_ALIGNMENT */
|
|
#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)
|
|
|
|
/* the number of bytes to offset an address to align it */
|
|
#define align_offset(A)\
|
|
((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\
|
|
((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))
|
|
|
|
#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
|
|
#define MAP_ANONYMOUS MAP_ANON
|
|
#endif /* MAP_ANON */
|
|
#ifdef MAP_ANONYMOUS
|
|
#define MMAP_FLAGS (MAP_PRIVATE|MAP_ANONYMOUS)
|
|
#define CALL_MMAP(s) mmap(0, (s), PROT_READ|PROT_WRITE, MMAP_FLAGS, -1, 0)
|
|
#else /* MAP_ANONYMOUS */
|
|
/*
|
|
Nearly all versions of mmap support MAP_ANONYMOUS, so the following
|
|
is unlikely to be needed, but is supplied just in case.
|
|
*/
|
|
#include <fcntl.h> /* for O_RDWR */
|
|
#define MMAP_FLAGS (MAP_PRIVATE)
|
|
static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
|
|
#define CALL_MMAP(s) ((dev_zero_fd < 0) ? \
|
|
(dev_zero_fd = open("/dev/zero", O_RDWR), \
|
|
mmap(0, (s), PROT_READ|PROT_WRITE, MMAP_FLAGS, dev_zero_fd, 0)) : \
|
|
mmap(0, (s), PROT_READ|PROT_WRITE, MMAP_FLAGS, dev_zero_fd, 0))
|
|
#endif /* MAP_ANONYMOUS */
|
|
#define CALL_MUNMAP(a, s) munmap((a), (s))
|
|
|
|
struct malloc_chunk {
|
|
size_t prev_foot; /* Size of previous chunk (if free). */
|
|
size_t head; /* Size and inuse bits. */
|
|
struct malloc_chunk* fd; /* double links -- used only if free. */
|
|
struct malloc_chunk* bk;
|
|
};
|
|
|
|
typedef struct malloc_chunk mchunk;
|
|
typedef struct malloc_chunk* mchunkptr;
|
|
|
|
typedef unsigned int binmap_t;
|
|
typedef unsigned int flag_t;
|
|
|
|
struct malloc_tree_chunk;
|
|
typedef struct malloc_tree_chunk* tbinptr;
|
|
|
|
struct malloc_segment {
|
|
char* base; /* base address */
|
|
size_t size; /* allocated size */
|
|
struct malloc_segment* next; /* ptr to next segment */
|
|
flag_t sflags; /* mmap and extern flag */
|
|
};
|
|
|
|
typedef struct malloc_segment msegment;
|
|
|
|
#define NSMALLBINS (32U)
|
|
#define NTREEBINS (32U)
|
|
|
|
struct malloc_state {
|
|
binmap_t smallmap;
|
|
binmap_t treemap;
|
|
size_t dvsize;
|
|
size_t topsize;
|
|
char* least_addr;
|
|
mchunkptr dv;
|
|
mchunkptr top;
|
|
size_t trim_check;
|
|
size_t release_checks;
|
|
size_t magic;
|
|
mchunkptr smallbins[(NSMALLBINS+1)*2];
|
|
tbinptr treebins[NTREEBINS];
|
|
size_t footprint;
|
|
size_t max_footprint;
|
|
flag_t mflags;
|
|
#if USE_LOCKS
|
|
MLOCK_T mutex;
|
|
#endif /* USE_LOCKS */
|
|
msegment seg;
|
|
void* extp;
|
|
size_t exts;
|
|
};
|
|
|
|
/*
|
|
TOP_FOOT_SIZE is padding at the end of a segment, including space
|
|
that may be needed to place segment records and fenceposts when new
|
|
noncontiguous segments are added.
|
|
*/
|
|
#define TOP_FOOT_SIZE\
|
|
(align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)
|
|
|
|
/* ------------------- Chunks sizes and alignments ----------------------- */
|
|
|
|
#define MCHUNK_SIZE (sizeof(mchunk))
|
|
|
|
#define CHUNK_OVERHEAD (SIZE_T_SIZE)
|
|
|
|
/* MMapped chunks need a second word of overhead ... */
|
|
#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)
|
|
/* ... and additional padding for fake next-chunk at foot */
|
|
#define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES)
|
|
|
|
/* The smallest size we can malloc is an aligned minimal chunk */
|
|
#define MIN_CHUNK_SIZE\
|
|
((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)
|
|
|
|
/* conversion from malloc headers to user pointers, and back */
|
|
#define chunk2mem(p) ((void*)((char*)(p) + TWO_SIZE_T_SIZES))
|
|
#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES))
|
|
/* chunk associated with aligned address A */
|
|
#define align_as_chunk(A) (mchunkptr)((A) + align_offset(chunk2mem(A)))
|
|
|
|
/* pad request bytes into a usable size */
|
|
#define pad_request(req) \
|
|
(((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)
|
|
|
|
/* The byte and bit size of a size_t */
|
|
#define SIZE_T_SIZE (sizeof(size_t))
|
|
#define SIZE_T_BITSIZE (sizeof(size_t) << 3)
|
|
|
|
/* Some constants coerced to size_t */
|
|
/* Annoying but necessary to avoid errors on some platforms */
|
|
#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 IS_MMAPPED_BIT (SIZE_T_ONE)
|
|
#define PINUSE_BIT (SIZE_T_ONE)
|
|
#define CINUSE_BIT (SIZE_T_TWO)
|
|
#define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|SIZE_T_FOUR)
|
|
|
|
/* head field is or'ed with NON_MAIN_ARENA if the chunk was obtained
|
|
from a non-main arena. This is only set immediately before handing
|
|
the chunk to the user, if necessary. */
|
|
#define NON_MAIN_ARENA (SIZE_T_FOUR)
|
|
|
|
#define cinuse(p) ((p)->head & CINUSE_BIT)
|
|
#define pinuse(p) ((p)->head & PINUSE_BIT)
|
|
#define chunksize(p) ((p)->head & ~(FLAG_BITS))
|
|
|
|
#define is_mmapped(p)\
|
|
(!((p)->head & PINUSE_BIT) && ((p)->prev_foot & IS_MMAPPED_BIT))
|
|
|
|
/* Get the internal overhead associated with chunk p */
|
|
#define overhead_for(p)\
|
|
(is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)
|
|
|
|
#endif /* MALLOC_PRIVATE_H */
|