1 #define JEMALLOC_BASE_C_
2 #include "jemalloc/internal/jemalloc_internal.h"
3
4 /******************************************************************************/
5 /* Data. */
6
7 static malloc_mutex_t base_mtx;
8
9 /*
10 * Current pages that are being used for internal memory allocations. These
11 * pages are carved up in cacheline-size quanta, so that there is no chance of
12 * false cache line sharing.
13 */
14 static void *base_pages;
15 static void *base_next_addr;
16 static void *base_past_addr; /* Addr immediately past base_pages. */
17 static extent_node_t *base_nodes;
18
19 /******************************************************************************/
20 /* Function prototypes for non-inline static functions. */
21
22 static bool base_pages_alloc(size_t minsize);
23
24 /******************************************************************************/
25
26 static bool
base_pages_alloc(size_t minsize)27 base_pages_alloc(size_t minsize)
28 {
29 size_t csize;
30 bool zero;
31
32 assert(minsize != 0);
33 csize = CHUNK_CEILING(minsize);
34 zero = false;
35 base_pages = chunk_alloc(csize, chunksize, true, &zero,
36 chunk_dss_prec_get());
37 if (base_pages == NULL)
38 return (true);
39 base_next_addr = base_pages;
40 base_past_addr = (void *)((uintptr_t)base_pages + csize);
41
42 return (false);
43 }
44
45 void *
base_alloc(size_t size)46 base_alloc(size_t size)
47 {
48 void *ret;
49 size_t csize;
50
51 /* Round size up to nearest multiple of the cacheline size. */
52 csize = CACHELINE_CEILING(size);
53
54 malloc_mutex_lock(&base_mtx);
55 /* Make sure there's enough space for the allocation. */
56 if ((uintptr_t)base_next_addr + csize > (uintptr_t)base_past_addr) {
57 if (base_pages_alloc(csize)) {
58 malloc_mutex_unlock(&base_mtx);
59 return (NULL);
60 }
61 }
62 /* Allocate. */
63 ret = base_next_addr;
64 base_next_addr = (void *)((uintptr_t)base_next_addr + csize);
65 malloc_mutex_unlock(&base_mtx);
66 VALGRIND_MAKE_MEM_UNDEFINED(ret, csize);
67
68 return (ret);
69 }
70
71 void *
base_calloc(size_t number,size_t size)72 base_calloc(size_t number, size_t size)
73 {
74 void *ret = base_alloc(number * size);
75
76 if (ret != NULL)
77 memset(ret, 0, number * size);
78
79 return (ret);
80 }
81
82 extent_node_t *
base_node_alloc(void)83 base_node_alloc(void)
84 {
85 extent_node_t *ret;
86
87 malloc_mutex_lock(&base_mtx);
88 if (base_nodes != NULL) {
89 ret = base_nodes;
90 base_nodes = *(extent_node_t **)ret;
91 malloc_mutex_unlock(&base_mtx);
92 VALGRIND_MAKE_MEM_UNDEFINED(ret, sizeof(extent_node_t));
93 } else {
94 malloc_mutex_unlock(&base_mtx);
95 ret = (extent_node_t *)base_alloc(sizeof(extent_node_t));
96 }
97
98 return (ret);
99 }
100
101 void
base_node_dealloc(extent_node_t * node)102 base_node_dealloc(extent_node_t *node)
103 {
104
105 VALGRIND_MAKE_MEM_UNDEFINED(node, sizeof(extent_node_t));
106 malloc_mutex_lock(&base_mtx);
107 *(extent_node_t **)node = base_nodes;
108 base_nodes = node;
109 malloc_mutex_unlock(&base_mtx);
110 }
111
112 bool
base_boot(void)113 base_boot(void)
114 {
115
116 base_nodes = NULL;
117 if (malloc_mutex_init(&base_mtx))
118 return (true);
119
120 return (false);
121 }
122
123 void
base_prefork(void)124 base_prefork(void)
125 {
126
127 malloc_mutex_prefork(&base_mtx);
128 }
129
130 void
base_postfork_parent(void)131 base_postfork_parent(void)
132 {
133
134 malloc_mutex_postfork_parent(&base_mtx);
135 }
136
137 void
base_postfork_child(void)138 base_postfork_child(void)
139 {
140
141 malloc_mutex_postfork_child(&base_mtx);
142 }
143