1
#if USE_TCACHE
2
/* We want 64 entries.  This is an arbitrary limit, which tunables can reduce.  */
3
# define TCACHE_MAX_BINS    64
4
# define MAX_TCACHE_SIZE  tidx2usize (TCACHE_MAX_BINS-1)
5

6
/* Only used to pre-fill the tunables.  */
7
# define tidx2usize(idx)  (((size_t) idx) * MALLOC_ALIGNMENT + MINSIZE - SIZE_SZ)
8

9
/* When "x" is from chunksize().  */
10
# define csize2tidx(x) (((x) - MINSIZE + MALLOC_ALIGNMENT - 1) / MALLOC_ALIGNMENT)
11
/* When "x" is a user-provided size.  */
12
# define usize2tidx(x) csize2tidx (request2size (x))
13

14
/* With rounding and alignment, the bins are...
15
   idx 0   bytes 0..24 (64-bit) or 0..12 (32-bit)
16
   idx 1   bytes 25..40 or 13..20
17
   idx 2   bytes 41..56 or 21..28
18
   etc.  */
19

20
/* This is another arbitrary limit, which tunables can change.  Each
21
   tcache bin will hold at most this number of chunks.  */
22
# define TCACHE_FILL_COUNT 7
23
#endif

1
struct malloc_par
2
{
3
  /* Tunable parameters */
4
  unsigned long trim_threshold;
5
  INTERNAL_SIZE_T top_pad;
6
  INTERNAL_SIZE_T mmap_threshold;
7
  INTERNAL_SIZE_T arena_test;
8
  INTERNAL_SIZE_T arena_max;
9

10
  /* Memory map support */
11
  int n_mmaps;
12
  int n_mmaps_max;
13
  int max_n_mmaps;
14
  /* the mmap_threshold is dynamic, until the user sets
15
     it manually, at which point we need to disable any
16
     dynamic behavior. */
17
  int no_dyn_threshold;
18

19
  /* Statistics */
20
  INTERNAL_SIZE_T mmapped_mem;
21
  INTERNAL_SIZE_T max_mmapped_mem;
22

23
  /* First address handed out by MORECORE/sbrk.  */
24
  char *sbrk_base;
25

26
//下面是tcache相关的内容
27
---------------------------------------------------------------------
28

29

30
#if USE_TCACHE
31
  /* Maximum number of buckets to use.  */
32
  size_t tcache_bins;
33
  size_t tcache_max_bytes;
34
  /* Maximum number of chunks in each bucket.  */
35
  size_t tcache_count;
36
  /* Maximum number of chunks to remove from the unsorted list, which
37
     aren't used to prefill the cache.  */
38
  size_t tcache_unsorted_limit;
39
#endif
40
};

1
static struct malloc_par mp_ =
2
{
3
  .top_pad = DEFAULT_TOP_PAD,
4
  .n_mmaps_max = DEFAULT_MMAP_MAX,
5
  .mmap_threshold = DEFAULT_MMAP_THRESHOLD,
6
  .trim_threshold = DEFAULT_TRIM_THRESHOLD,
7
#define NARENAS_FROM_NCORES(n) ((n) * (sizeof (long) == 4 ? 2 : 8))
8
  .arena_test = NARENAS_FROM_NCORES (1)
9
#if USE_TCACHE
10
  ,
11
  .tcache_count = TCACHE_FILL_COUNT,
12
  .tcache_bins = TCACHE_MAX_BINS,
13
  .tcache_max_bytes = tidx2usize (TCACHE_MAX_BINS-1),
14
  .tcache_unsorted_limit = 0 /* No limit.  */
15
#endif

1
#if USE_TCACHE
2

3
/* We overlay this structure on the user-data portion of a chunk when
4
   the chunk is stored in the per-thread cache.  */
5
typedef struct tcache_entry
6
{
7
  struct tcache_entry *next;
8
} tcache_entry;

1
typedef struct tcache_perthread_struct
2
{
3
  char counts[TCACHE_MAX_BINS];
4
  tcache_entry *entries[TCACHE_MAX_BINS];
5
} tcache_perthread_struct;

1
#define MAX_TCACHE_COUNT 127  /* Maximum value of counts[] entries.  */
2

3
static __thread bool tcache_shutting_down = false;
4
static __thread tcache_perthread_struct *tcache = NULL;

1
/* Caller must ensure that we know tc_idx is valid and there's room
2
   for more chunks.  */
3
tatic __always_inline void
4
tcache_put (mchunkptr chunk, size_t tc_idx)
5
{
6
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
7
  assert (tc_idx < TCACHE_MAX_BINS);
8
  e->next = tcache->entries[tc_idx];   //这里采用的是头插法
9
  tcache->entries[tc_idx] = e;
10
  ++(tcache->counts[tc_idx]);
11
}

1
static __always_inline void *
2
tcache_get (size_t tc_idx)
3
{
4
  tcache_entry *e = tcache->entries[tc_idx];
5
  assert (tc_idx < TCACHE_MAX_BINS);
6
  assert (tcache->entries[tc_idx] > 0);
7
  tcache->entries[tc_idx] = e->next;
8
  --(tcache->counts[tc_idx]);
9
  return (void *) e;
10
}

1
#if USE_TCACHE
2

3
/* We overlay this structure on the user-data portion of a chunk when
4
   the chunk is stored in the per-thread cache.  */
5
typedef struct tcache_entry
6
{
7
  struct tcache_entry *next;
8
  /* This field exists to detect double frees.  */
9
  struct tcache_perthread_struct *key;
10
} tcache_entry;

1
typedef struct tcache_perthread_struct
2
{
3
  uint16_t counts[TCACHE_MAX_BINS];
4
  tcache_entry *entries[TCACHE_MAX_BINS];
5
} tcache_perthread_struct;

1
#define PROTECT_PTR(pos, ptr) \
2
  ((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))

1
static __always_inline void
2
tcache_put (mchunkptr chunk, size_t tc_idx)
3
{
4
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
5

6
  /* Mark this chunk as "in the tcache" so the test in _int_free will
7
     detect a double free.  */
8
  e->key = tcache;
9

10
  e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
11
  tcache->entries[tc_idx] = e;
12
  ++(tcache->counts[tc_idx]);
13
}
14
/* Caller must ensure that we know tc_idx is valid and there's
15
   available chunks to remove.  */

1
#define REVEAL_PTR(ptr)  PROTECT_PTR (&ptr, ptr)

1
static __always_inline void *
2
tcache_get (size_t tc_idx)
3
{
4
  tcache_entry *e = tcache->entries[tc_idx];
5
  if (__glibc_unlikely (!aligned_OK (e)))
6
    malloc_printerr ("malloc(): unaligned tcache chunk detected");
7
  tcache->entries[tc_idx] = REVEAL_PTR (e->next);
8
  --(tcache->counts[tc_idx]);
9
  e->key = NULL;
10
  return (void *) e;
11
}

1
static void
2
_int_free (mstate av, mchunkptr p, int have_lock)
3
{
4
  INTERNAL_SIZE_T size;        /* its size */
5
  mfastbinptr *fb;             /* associated fastbin */
6
  mchunkptr nextchunk;         /* next contiguous chunk */
7
  INTERNAL_SIZE_T nextsize;    /* its size */
8
  int nextinuse;               /* true if nextchunk is used */
9
  INTERNAL_SIZE_T prevsize;    /* size of previous contiguous chunk */
10
  mchunkptr bck;               /* misc temp for linking */
11
  mchunkptr fwd;               /* misc temp for linking */
12

13
  size = chunksize (p);
14

15
  /* Little security check which won't hurt performance: the
16
     allocator never wrapps around at the end of the address space.
17
     Therefore we can exclude some size values which might appear
18
     here by accident or by "design" from some intruder.  */
19
  if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
20
      || __builtin_expect (misaligned_chunk (p), 0))
21
    malloc_printerr ("free(): invalid pointer");
22
  /* We know that each chunk is at least MINSIZE bytes in size or a
23
     multiple of MALLOC_ALIGNMENT.  */
24
  if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
25
    malloc_printerr ("free(): invalid size");
26

27
  check_inuse_chunk(av, p);
28

29
#if USE_TCACHE
30
  {
31
    size_t tc_idx = csize2tidx (size);
32
    if (tcache != NULL && tc_idx < mp_.tcache_bins)
33
      {
34
  /* Check to see if it's already in the tcache.  */
35
  tcache_entry *e = (tcache_entry *) chunk2mem (p);
36

37
  /* This test succeeds on double free.  However, we don't 100%
38
     trust it (it also matches random payload data at a 1 in
39
     2^<size_t> chance), so verify it's not an unlikely
40
     coincidence before aborting.  */
41
  if (__glibc_unlikely (e->key == tcache))
42
    {
43
      tcache_entry *tmp;
44
      size_t cnt = 0;
45
      LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
46
      for (tmp = tcache->entries[tc_idx];
47
     tmp;
48
     tmp = REVEAL_PTR (tmp->next), ++cnt)
49
        {
50
    if (cnt >= mp_.tcache_count)
51
      malloc_printerr ("free(): too many chunks detected in tcache");
52
    if (__glibc_unlikely (!aligned_OK (tmp)))
53
      malloc_printerr ("free(): unaligned chunk detected in tcache 2");
54
    if (tmp == e)
55
      malloc_printerr ("free(): double free detected in tcache 2");
56
    /* If we get here, it was a coincidence.  We've wasted a
57
       few cycles, but don't abort.  */
58
        }
59
    }
60

61
  if (tcache->counts[tc_idx] < mp_.tcache_count)
62
    {
63
      tcache_put (p, tc_idx);
64
      return;
65
    }
66
      }
67
  }
68
#endif

1
static __always_inline void
2
tcache_put (mchunkptr chunk, size_t tc_idx)
3
{
4
  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
5

6
  /* Mark this chunk as "in the tcache" so the test in _int_free will
7
     detect a double free.  */
8
  e->key = tcache_key;
9

10
  e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
11
  tcache->entries[tc_idx] = e;
12
  ++(tcache->counts[tc_idx]);
13
}

1
static void
2
tcache_key_initialize (void)
3
{
4
  if (__getrandom (&tcache_key, sizeof(tcache_key), GRND_NONBLOCK)
5
      != sizeof (tcache_key))
6
    {
7
      tcache_key = random_bits ();
8
#if __WORDSIZE == 64
9
      tcache_key = (tcache_key << 32) | random_bits ();
10
#endif
11
    }
12
}

1
static void
2
_int_free (mstate av, mchunkptr p, int have_lock)
3
{
4
  INTERNAL_SIZE_T size;        /* its size */
5
  mfastbinptr *fb;             /* associated fastbin */
6
  mchunkptr nextchunk;         /* next contiguous chunk */
7
  INTERNAL_SIZE_T nextsize;    /* its size */
8
  int nextinuse;               /* true if nextchunk is used */
9
  INTERNAL_SIZE_T prevsize;    /* size of previous contiguous chunk */
10
  mchunkptr bck;               /* misc temp for linking */
11
  mchunkptr fwd;               /* misc temp for linking */
12

13
  size = chunksize (p);
14

15
  /* Little security check which won't hurt performance: the
16
     allocator never wrapps around at the end of the address space.
17
     Therefore we can exclude some size values which might appear
18
     here by accident or by "design" from some intruder.  */
19
  if (__builtin_expect ((uintptr_t) p > (uintptr_t) -size, 0)
20
      || __builtin_expect (misaligned_chunk (p), 0))
21
    malloc_printerr ("free(): invalid pointer");
22
  /* We know that each chunk is at least MINSIZE bytes in size or a
23
     multiple of MALLOC_ALIGNMENT.  */
24
  if (__glibc_unlikely (size < MINSIZE || !aligned_OK (size)))
25
    malloc_printerr ("free(): invalid size");
26

27
  check_inuse_chunk(av, p);
28

29
#if USE_TCACHE
30
  {
31
    size_t tc_idx = csize2tidx (size);
32
    if (tcache != NULL && tc_idx < mp_.tcache_bins)
33
      {
34
  /* Check to see if it's already in the tcache.  */
35
  tcache_entry *e = (tcache_entry *) chunk2mem (p);
36

37
  /* This test succeeds on double free.  However, we don't 100%
38
     trust it (it also matches random payload data at a 1 in
39
     2^<size_t> chance), so verify it's not an unlikely
40
     coincidence before aborting.  */
41
  if (__glibc_unlikely (e->key == tcache_key))
42
    {
43
      tcache_entry *tmp;
44
      size_t cnt = 0;
45
      LIBC_PROBE (memory_tcache_double_free, 2, e, tc_idx);
46
      for (tmp = tcache->entries[tc_idx];
47
     tmp;
48
     tmp = REVEAL_PTR (tmp->next), ++cnt)
49
        {
50
    if (cnt >= mp_.tcache_count)
51
      malloc_printerr ("free(): too many chunks detected in tcache");
52
    if (__glibc_unlikely (!aligned_OK (tmp)))
53
      malloc_printerr ("free(): unaligned chunk detected in tcache 2");
54
    if (tmp == e)
55
      malloc_printerr ("free(): double free detected in tcache 2");
56
    /* If we get here, it was a coincidence.  We've wasted a
57
       few cycles, but don't abort.  */
58
        }
59
    }
60

61
  if (tcache->counts[tc_idx] < mp_.tcache_count)
62
    {
63
      tcache_put (p, tc_idx);
64
      return;
65
    }
66
      }
67
  }
68
#endif