]>
Commit | Line | Data |
---|---|---|
4934f93d | 1 | #define JEMALLOC_BASE_C_ |
2 | #include "jemalloc/internal/jemalloc_internal.h" | |
3 | ||
4 | /******************************************************************************/ | |
5 | /* Data. */ | |
6 | ||
7 | 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 | |
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, true, &zero); | |
36 | if (base_pages == NULL) | |
37 | return (true); | |
38 | base_next_addr = base_pages; | |
39 | base_past_addr = (void *)((uintptr_t)base_pages + csize); | |
40 | ||
41 | return (false); | |
42 | } | |
43 | ||
44 | void * | |
45 | base_alloc(size_t size) | |
46 | { | |
47 | void *ret; | |
48 | size_t csize; | |
49 | ||
50 | /* Round size up to nearest multiple of the cacheline size. */ | |
51 | csize = CACHELINE_CEILING(size); | |
52 | ||
53 | malloc_mutex_lock(&base_mtx); | |
54 | /* Make sure there's enough space for the allocation. */ | |
55 | if ((uintptr_t)base_next_addr + csize > (uintptr_t)base_past_addr) { | |
56 | if (base_pages_alloc(csize)) { | |
57 | malloc_mutex_unlock(&base_mtx); | |
58 | return (NULL); | |
59 | } | |
60 | } | |
61 | /* Allocate. */ | |
62 | ret = base_next_addr; | |
63 | base_next_addr = (void *)((uintptr_t)base_next_addr + csize); | |
64 | malloc_mutex_unlock(&base_mtx); | |
65 | ||
66 | return (ret); | |
67 | } | |
68 | ||
69 | extent_node_t * | |
70 | base_node_alloc(void) | |
71 | { | |
72 | extent_node_t *ret; | |
73 | ||
74 | malloc_mutex_lock(&base_mtx); | |
75 | if (base_nodes != NULL) { | |
76 | ret = base_nodes; | |
77 | base_nodes = *(extent_node_t **)ret; | |
78 | malloc_mutex_unlock(&base_mtx); | |
79 | } else { | |
80 | malloc_mutex_unlock(&base_mtx); | |
81 | ret = (extent_node_t *)base_alloc(sizeof(extent_node_t)); | |
82 | } | |
83 | ||
84 | return (ret); | |
85 | } | |
86 | ||
87 | void | |
88 | base_node_dealloc(extent_node_t *node) | |
89 | { | |
90 | ||
91 | malloc_mutex_lock(&base_mtx); | |
92 | *(extent_node_t **)node = base_nodes; | |
93 | base_nodes = node; | |
94 | malloc_mutex_unlock(&base_mtx); | |
95 | } | |
96 | ||
97 | bool | |
98 | base_boot(void) | |
99 | { | |
100 | ||
101 | base_nodes = NULL; | |
102 | if (malloc_mutex_init(&base_mtx)) | |
103 | return (true); | |
104 | ||
105 | return (false); | |
106 | } |