mymalloc.h File Reference

#include <stddef.h>

Go to the source code of this file.

Data Structures
struct	mallinfo

Macros
#define	MSPACES   1
#define	ONLY_MSPACES   0 /* define to a value */
#define	NO_MALLINFO   0
#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	dlindependent_calloc   myindependent_calloc
#define	dlindependent_comalloc   myindependent_comalloc
#define	MALLINFO_FIELD_TYPE   size_t
#define	STRUCT_MALLINFO_DECLARED   1
#define	M_TRIM_THRESHOLD   (-1)
#define	M_GRANULARITY   (-2)
#define	M_MMAP_THRESHOLD   (-3)

Typedefs
typedef void *	mspace

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 ()
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 ()
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)
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)

Macro Definition Documentation

#define dlcalloc   mycalloc

Definition at line 47 of file mymalloc.h.

#define dlfree   myfree

Definition at line 48 of file mymalloc.h.

#define dlindependent_calloc   myindependent_calloc

Definition at line 60 of file mymalloc.h.

#define dlindependent_comalloc   myindependent_comalloc

Definition at line 61 of file mymalloc.h.

#define dlmallinfo   mymallinfo

Definition at line 54 of file mymalloc.h.

#define dlmalloc   mymalloc

Definition at line 49 of file mymalloc.h.

#define dlmalloc_footprint   mymalloc_footprint

Definition at line 59 of file mymalloc.h.

void dlmalloc_stats   mymalloc_stats

Definition at line 57 of file mymalloc.h.

#define dlmalloc_trim   mymalloc_trim

Definition at line 56 of file mymalloc.h.

#define dlmalloc_usable_size   mymalloc_usable_size

Definition at line 58 of file mymalloc.h.

#define dlmallopt   mymallopt

Definition at line 55 of file mymalloc.h.

#define dlmemalign   mymemalign

Definition at line 50 of file mymalloc.h.

#define dlpvalloc   mypvalloc

Definition at line 53 of file mymalloc.h.

#define dlrealloc   myrealloc

Definition at line 51 of file mymalloc.h.

#define dlvalloc   myvalloc

Definition at line 52 of file mymalloc.h.

#define M_GRANULARITY   (-2)

Definition at line 185 of file mymalloc.h.

#define M_MMAP_THRESHOLD   (-3)

Definition at line 186 of file mymalloc.h.

#define M_TRIM_THRESHOLD   (-1)

Definition at line 184 of file mymalloc.h.

#define MALLINFO_FIELD_TYPE   size_t

Definition at line 67 of file mymalloc.h.

#define MSPACES   1

Definition at line 28 of file mymalloc.h.

#define NO_MALLINFO   0

Definition at line 40 of file mymalloc.h.

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

Definition at line 37 of file mymalloc.h.

#define STRUCT_MALLINFO_DECLARED   1

Definition at line 70 of file mymalloc.h.

Typedef Documentation

typedef void* mspace

Definition at line 419 of file mymalloc.h.

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_comalloc	(	size_t	,
		size_t *	,
		void **
	)

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;
}

void dlmalloc_stats

(

)

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);
}

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;
}