Blender  V3.3
BLI_memarena.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved. */
3 
16 #include <stdlib.h>
17 #include <string.h>
18 
19 #include "MEM_guardedalloc.h"
20 
21 #include "BLI_asan.h"
22 #include "BLI_memarena.h"
23 #include "BLI_strict_flags.h"
24 #include "BLI_utildefines.h"
25 
26 #ifdef WITH_MEM_VALGRIND
27 # include "valgrind/memcheck.h"
28 #else
29 # define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) UNUSED_VARS(pool, rzB, is_zeroed)
30 # define VALGRIND_DESTROY_MEMPOOL(pool) UNUSED_VARS(pool)
31 # define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) UNUSED_VARS(pool, addr, size)
32 # define VALGRIND_MOVE_MEMPOOL(pool_a, pool_b) UNUSED_VARS(pool_a, pool_b)
33 #endif
34 
35 struct MemBuf {
36  struct MemBuf *next;
37  uchar data[0];
38 };
39 
40 struct MemArena {
41  unsigned char *curbuf;
42  const char *name;
43  struct MemBuf *bufs;
44 
45  size_t bufsize, cursize;
46  size_t align;
47 
48  bool use_calloc;
49 };
50 
51 static void memarena_buf_free_all(struct MemBuf *mb)
52 {
53  while (mb != NULL) {
54  struct MemBuf *mb_next = mb->next;
55 
56  /* Unpoison memory because MEM_freeN might overwrite it. */
58 
59  MEM_freeN(mb);
60  mb = mb_next;
61  }
62 }
63 
64 MemArena *BLI_memarena_new(const size_t bufsize, const char *name)
65 {
66  MemArena *ma = MEM_callocN(sizeof(*ma), "memarena");
67  ma->bufsize = bufsize;
68  ma->align = 8;
69  ma->name = name;
70 
71  VALGRIND_CREATE_MEMPOOL(ma, 0, false);
72 
73  return ma;
74 }
75 
77 {
78  ma->use_calloc = 1;
79 }
80 
82 {
83  ma->use_calloc = 0;
84 }
85 
86 void BLI_memarena_use_align(struct MemArena *ma, const size_t align)
87 {
88  /* Align must be a power of two. */
89  BLI_assert((align & (align - 1)) == 0);
90 
91  ma->align = align;
92 }
93 
95 {
97 
99 
100  MEM_freeN(ma);
101 }
102 
104 #define PADUP(num, amt) (((num) + ((amt)-1)) & ~((amt)-1))
105 
108 {
109  unsigned char *tmp;
110 
111  tmp = (unsigned char *)PADUP((intptr_t)ma->curbuf, (int)ma->align);
112  ma->cursize -= (size_t)(tmp - ma->curbuf);
113  ma->curbuf = tmp;
114 }
115 
116 void *BLI_memarena_alloc(MemArena *ma, size_t size)
117 {
118  void *ptr;
119 
120  /* Ensure proper alignment by rounding size up to multiple of 8. */
121  size = PADUP(size, ma->align);
122 
123  if (UNLIKELY(size > ma->cursize)) {
124  if (size > ma->bufsize - (ma->align - 1)) {
125  ma->cursize = PADUP(size + 1, ma->align);
126  }
127  else {
128  ma->cursize = ma->bufsize;
129  }
130 
131  struct MemBuf *mb = (ma->use_calloc ? MEM_callocN : MEM_mallocN)(sizeof(*mb) + ma->cursize,
132  ma->name);
133  ma->curbuf = mb->data;
134  mb->next = ma->bufs;
135  ma->bufs = mb;
136 
137  BLI_asan_poison(ma->curbuf, ma->cursize);
138 
140  }
141 
142  ptr = ma->curbuf;
143  ma->curbuf += size;
144  ma->cursize -= size;
145 
147 
149 
150  return ptr;
151 }
152 
154 {
155  void *ptr;
156 
157  /* No need to use this function call if we're calloc'ing by default. */
158  BLI_assert(ma->use_calloc == false);
159 
160  ptr = BLI_memarena_alloc(ma, size);
161  memset(ptr, 0, size);
162 
163  return ptr;
164 }
165 
166 void BLI_memarena_merge(MemArena *ma_dst, MemArena *ma_src)
167 {
168  /* Memory arenas must be compatible. */
169  BLI_assert(ma_dst != ma_src);
170  BLI_assert(ma_dst->align == ma_src->align);
171  BLI_assert(ma_dst->use_calloc == ma_src->use_calloc);
172  BLI_assert(ma_dst->bufsize == ma_src->bufsize);
173 
174  if (ma_src->bufs == NULL) {
175  return;
176  }
177 
178  if (UNLIKELY(ma_dst->bufs == NULL)) {
179  BLI_assert(ma_dst->curbuf == NULL);
180  ma_dst->bufs = ma_src->bufs;
181  ma_dst->curbuf = ma_src->curbuf;
182  ma_dst->cursize = ma_src->cursize;
183  }
184  else {
185  /* Keep the 'ma_dst->curbuf' for simplicity.
186  * Insert buffers after the first. */
187  if (ma_dst->bufs->next != NULL) {
188  /* Loop over `ma_src` instead of `ma_dst` since it's likely the destination is larger
189  * when used for accumulating from multiple sources. */
190  struct MemBuf *mb_src = ma_src->bufs;
191  mb_src = ma_src->bufs;
192  while (mb_src && mb_src->next) {
193  mb_src = mb_src->next;
194  }
195  mb_src->next = ma_dst->bufs->next;
196  }
197  ma_dst->bufs->next = ma_src->bufs;
198  }
199 
200  ma_src->bufs = NULL;
201  ma_src->curbuf = NULL;
202  ma_src->cursize = 0;
203 
204  VALGRIND_MOVE_MEMPOOL(ma_src, ma_dst);
205  VALGRIND_CREATE_MEMPOOL(ma_src, 0, false);
206 }
207 
209 {
210  if (ma->bufs) {
211  unsigned char *curbuf_prev;
212  size_t curbuf_used;
213 
214  if (ma->bufs->next) {
216  ma->bufs->next = NULL;
217  }
218 
219  curbuf_prev = ma->curbuf;
220  ma->curbuf = ma->bufs->data;
222 
223  /* restore to original size */
224  curbuf_used = (size_t)(curbuf_prev - ma->curbuf);
225  ma->cursize += curbuf_used;
226 
227  if (ma->use_calloc) {
228  memset(ma->curbuf, 0, curbuf_used);
229  }
230  BLI_asan_poison(ma->curbuf, ma->cursize);
231  }
232 
234  VALGRIND_CREATE_MEMPOOL(ma, 0, false);
235 }
#define BLI_asan_unpoison(addr, size)
Definition: BLI_asan.h:28
#define BLI_asan_poison(addr, size)
Definition: BLI_asan.h:23
#define BLI_assert(a)
Definition: BLI_assert.h:46
static void memarena_curbuf_align(MemArena *ma)
Definition: BLI_memarena.c:107
void * BLI_memarena_calloc(MemArena *ma, size_t size)
Definition: BLI_memarena.c:153
#define PADUP(num, amt)
Definition: BLI_memarena.c:104
void BLI_memarena_use_calloc(MemArena *ma)
Definition: BLI_memarena.c:76
#define VALGRIND_MEMPOOL_ALLOC(pool, addr, size)
Definition: BLI_memarena.c:31
MemArena * BLI_memarena_new(const size_t bufsize, const char *name)
Definition: BLI_memarena.c:64
void BLI_memarena_merge(MemArena *ma_dst, MemArena *ma_src)
Definition: BLI_memarena.c:166
void * BLI_memarena_alloc(MemArena *ma, size_t size)
Definition: BLI_memarena.c:116
#define VALGRIND_MOVE_MEMPOOL(pool_a, pool_b)
Definition: BLI_memarena.c:32
#define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed)
Definition: BLI_memarena.c:29
void BLI_memarena_use_malloc(MemArena *ma)
Definition: BLI_memarena.c:81
static void memarena_buf_free_all(struct MemBuf *mb)
Definition: BLI_memarena.c:51
#define VALGRIND_DESTROY_MEMPOOL(pool)
Definition: BLI_memarena.c:30
void BLI_memarena_free(MemArena *ma)
Definition: BLI_memarena.c:94
void BLI_memarena_use_align(struct MemArena *ma, const size_t align)
Definition: BLI_memarena.c:86
void BLI_memarena_clear(MemArena *ma)
Definition: BLI_memarena.c:208
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
unsigned char uchar
Definition: BLI_sys_types.h:70
unsigned int uint
Definition: BLI_sys_types.h:67
#define UNLIKELY(x)
Read Guarded memory(de)allocation.
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
size_t(* MEM_allocN_len)(const void *vmemh)
Definition: mallocn.c:26
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
_W64 int intptr_t
Definition: stdint.h:118
unsigned char * curbuf
Definition: BLI_memarena.c:41
struct MemBuf * bufs
Definition: BLI_memarena.c:43
const char * name
Definition: BLI_memarena.c:42
size_t align
Definition: BLI_memarena.c:46
bool use_calloc
Definition: BLI_memarena.c:48
size_t cursize
Definition: BLI_memarena.c:45
size_t bufsize
Definition: BLI_memarena.c:45
uchar data[0]
Definition: BLI_memarena.c:37
struct MemBuf * next
Definition: BLI_memarena.c:36
PointerRNA * ptr
Definition: wm_files.c:3480