Blender V5.3
BLI_memblock.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include <algorithm>
12#include <cstdlib>
13#include <cstring>
14
15#include "BLI_utildefines.hh"
16
17#include "BLI_memblock.hh" /* own include */
18
19#include "MEM_guardedalloc.h"
20
21#include "BLI_strict_flags.hh" /* IWYU pragma: keep. Keep last. */
22
23namespace blender {
24
25#define CHUNK_LIST_SIZE 16
26
47
49{
50 BLI_assert(elem_size < chunk_size);
51
52 BLI_memblock *mblk = MEM_new_zeroed<BLI_memblock>("BLI_memblock");
53 mblk->elem_size = int(elem_size);
54 mblk->elem_next = 0;
55 mblk->elem_last = -1;
56 mblk->chunk_size = int(chunk_size);
58 mblk->chunk_list = MEM_new_array_zeroed<void *>(size_t(mblk->chunk_len), "chunk list");
60 size_t(mblk->chunk_size), 32, "BLI_memblock chunk");
61 memset(mblk->chunk_list[0], 0x0, uint(mblk->chunk_size));
62 mblk->chunk_max_ofs = (mblk->chunk_size / mblk->elem_size) * mblk->elem_size;
63 mblk->elem_next_ofs = 0;
64 mblk->chunk_next = 0;
65 return mblk;
66}
67
69{
70 int elem_per_chunk = mblk->chunk_size / mblk->elem_size;
71
72 if (free_callback) {
73 for (int i = 0; i <= mblk->elem_last; i++) {
74 int chunk_idx = i / elem_per_chunk;
75 int elem_idx = i - elem_per_chunk * chunk_idx;
76 void *val = static_cast<char *>(mblk->chunk_list[chunk_idx]) + mblk->elem_size * elem_idx;
77 free_callback(val);
78 }
79 }
80
81 for (int i = 0; i < mblk->chunk_len; i++) {
82 MEM_SAFE_DELETE_VOID(mblk->chunk_list[i]);
83 }
84 MEM_SAFE_DELETE(mblk->chunk_list);
85 MEM_delete(mblk);
86}
87
89{
90 int elem_per_chunk = mblk->chunk_size / mblk->elem_size;
91 int last_used_chunk = mblk->elem_next / elem_per_chunk;
92
93 if (free_callback) {
94 for (int i = mblk->elem_last; i >= mblk->elem_next; i--) {
95 int chunk_idx = i / elem_per_chunk;
96 int elem_idx = i - elem_per_chunk * chunk_idx;
97 void *val = static_cast<char *>(mblk->chunk_list[chunk_idx]) + mblk->elem_size * elem_idx;
98 free_callback(val);
99 }
100 }
101
102 for (int i = last_used_chunk + 1; i < mblk->chunk_len; i++) {
103 MEM_SAFE_DELETE_VOID(mblk->chunk_list[i]);
104 }
105
106 if (last_used_chunk + 1 < mblk->chunk_len - CHUNK_LIST_SIZE) [[unlikely]] {
107 mblk->chunk_len -= CHUNK_LIST_SIZE;
108 mblk->chunk_list = static_cast<void **>(
109 MEM_realloc_zeroed(mblk->chunk_list, sizeof(void *) * uint(mblk->chunk_len)));
110 }
111
112 mblk->elem_last = mblk->elem_next - 1;
113 mblk->elem_next = 0;
114 mblk->elem_next_ofs = 0;
115 mblk->chunk_next = 0;
116}
117
119{
120 /* Bookkeeping. */
121 mblk->elem_last = std::max(mblk->elem_last, mblk->elem_next);
122 mblk->elem_next++;
123
124 void *ptr = static_cast<char *>(mblk->chunk_list[mblk->chunk_next]) + mblk->elem_next_ofs;
125
126 mblk->elem_next_ofs += mblk->elem_size;
127
128 if (mblk->elem_next_ofs == mblk->chunk_max_ofs) {
129 mblk->elem_next_ofs = 0;
130 mblk->chunk_next++;
131
132 if (mblk->chunk_next >= mblk->chunk_len) [[unlikely]] {
133 mblk->chunk_len += CHUNK_LIST_SIZE;
134 mblk->chunk_list = static_cast<void **>(
135 MEM_realloc_zeroed(mblk->chunk_list, sizeof(void *) * uint(mblk->chunk_len)));
136 }
137
138 if (mblk->chunk_list[mblk->chunk_next] == nullptr) [[unlikely]] {
140 uint(mblk->chunk_size), 32, "BLI_memblock chunk");
141 memset(mblk->chunk_list[mblk->chunk_next], 0x0, uint(mblk->chunk_size));
142 }
143 }
144 return ptr;
145}
146
148{
149 /* Small copy of the memblock used for better cache coherence. */
150 iter->chunk_list = mblk->chunk_list;
151 iter->end_index = mblk->elem_next;
152 iter->cur_index = 0;
153 iter->chunk_idx = 0;
154 iter->elem_ofs = 0;
155 iter->elem_size = mblk->elem_size;
156 iter->chunk_max_ofs = mblk->chunk_max_ofs;
157}
158
160{
161 if (iter->cur_index == iter->end_index) {
162 return nullptr;
163 }
164
165 iter->cur_index++;
166
167 void *ptr = static_cast<char *>(iter->chunk_list[iter->chunk_idx]) + iter->elem_ofs;
168
169 iter->elem_ofs += iter->elem_size;
170
171 if (iter->elem_ofs == iter->chunk_max_ofs) {
172 iter->elem_ofs = 0;
173 iter->chunk_idx++;
174 }
175 return ptr;
176}
177
178void *BLI_memblock_elem_get(BLI_memblock *mblk, int chunk, int elem)
179{
180 BLI_assert(chunk < mblk->chunk_len);
181 int elem_per_chunk = mblk->chunk_size / mblk->elem_size;
182 chunk += elem / elem_per_chunk;
183 elem = elem % elem_per_chunk;
184 return static_cast<char *>(mblk->chunk_list[chunk]) + mblk->elem_size * elem;
185}
186
187} // namespace blender
#define CHUNK_LIST_SIZE
Read Blender memory allocation and freeing.
#define MEM_realloc_zeroed(vmemh, len)
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned int uint
Definition BKE_text.h:55
void BLI_memblock_clear(BLI_memblock *mblk, MemblockValFreeFP free_callback) ATTR_NONNULL(1)
BLI_memblock * BLI_memblock_create_ex(uint elem_size, uint chunk_size) ATTR_WARN_UNUSED_RESULT
void * MEM_new_uninitialized_aligned(size_t len, size_t alignment, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(3)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BLI_memblock_destroy(BLI_memblock *mblk, MemblockValFreeFP free_callback) ATTR_NONNULL(1)
void BLI_memblock_iternew(BLI_memblock *mblk, BLI_memblock_iter *iter) ATTR_NONNULL()
void * BLI_memblock_iterstep(BLI_memblock_iter *iter) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void * BLI_memblock_alloc(BLI_memblock *mblk) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void * BLI_memblock_elem_get(BLI_memblock *mblk, int chunk, int elem) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void(*) MemblockValFreeFP(void *val)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1