127#define USE_FASTPATH_CHUNKS_FIRST
137#ifdef USE_FASTPATH_CHUNKS_FIRST
138# define USE_FASTPATH_CHUNKS_LAST
147#define USE_ALIGN_CHUNKS_TEST
153#define USE_HASH_TABLE_ACCUMULATE
155#ifdef USE_HASH_TABLE_ACCUMULATE
164# define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_DEFAULT 3
165# define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_32BITS 4
166# define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_16BITS 5
175# define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_8BITS 6
181# define BCHUNK_HASH_LEN 16
187#define USE_HASH_TABLE_KEY_CACHE
188#ifdef USE_HASH_TABLE_KEY_CACHE
189# define HASH_TABLE_KEY_UNSET ((hash_key) - 1)
190# define HASH_TABLE_KEY_FALLBACK ((hash_key) - 2)
201#define USE_HASH_TABLE_DEDUPLICATE
206#define BCHUNK_HASH_TABLE_MUL 3
219#define USE_MERGE_CHUNKS
221#ifdef USE_MERGE_CHUNKS
223# define BCHUNK_SIZE_MIN_DIV 8
232# define BCHUNK_SIZE_MAX_MUL 2
293#ifdef USE_HASH_TABLE_ACCUMULATE
357#ifdef USE_HASH_TABLE_KEY_CACHE
397#ifdef USE_HASH_TABLE_KEY_CACHE
406 memcpy(data_copy,
data, data_len);
407 return bchunk_new(bs_mem, data_copy, data_len);
413 if (chunk->
users == 1) {
414 MEM_delete(chunk->
data);
423 const uchar *data_base,
424 const size_t data_base_len,
429 return (memcmp(&data_base[offset], chunk->
data, chunk->
data_len) == 0);
433 const uchar *data_base,
434 const size_t data_base_len,
437 if (offset +
size_t(chunk->
data_len) <= data_base_len) {
456 chunk_list->
users = 0;
463 if (chunk_list->
users == 1) {
464 for (
BChunkRef *cref = chunk_list->
chunk_refs.first(), *cref_next; cref; cref = cref_next) {
465 cref_next = cref->next;
473 chunk_list->
users -= 1;
477#ifdef USE_VALIDATE_LIST_SIZE
479# define ASSERT_CHUNKLIST_SIZE(chunk_list, n) BLI_assert(bchunk_list_size(chunk_list) == n)
482#ifndef ASSERT_CHUNKLIST_SIZE
483# define ASSERT_CHUNKLIST_SIZE(chunk_list, n) (EXPR_NOP(chunk_list), EXPR_NOP(n))
486#ifdef USE_VALIDATE_LIST_DATA_PARTIAL
487static size_t bchunk_list_data_check(
const BChunkList *chunk_list,
const uchar *
data)
490 for (BChunkRef &cref : chunk_list->chunk_refs) {
491 if (memcmp(&
data[offset], cref.link->data, cref.link->data_len) != 0) {
494 offset += cref.link->data_len;
498# define ASSERT_CHUNKLIST_DATA(chunk_list, data) \
499 BLI_assert(bchunk_list_data_check(chunk_list, data))
501# define ASSERT_CHUNKLIST_DATA(chunk_list, data) (EXPR_NOP(chunk_list), EXPR_NOP(data))
504#ifdef USE_MERGE_CHUNKS
510 if (cref && cref->
prev) {
518 if (data_merge_len <= info->chunk_byte_size_max) {
528 memcpy(data_merge, chunk_prev->
data, chunk_prev->
data_len);
547 const size_t data_prev_len =
split;
548 const size_t data_curr_len = data_merge_len -
split;
552 if (data_prev_len <= chunk_prev->data_len) {
553 const size_t data_curr_shrink_len = chunk_prev->
data_len - data_prev_len;
556 memcpy(data_prev, chunk_prev->
data, data_prev_len);
559 memcpy(data_curr, &chunk_prev->
data[data_prev_len], data_curr_shrink_len);
560 memcpy(&data_curr[data_curr_shrink_len], chunk_curr->
data, chunk_curr->
data_len);
563 BLI_assert(data_curr_len <= chunk_curr->data_len);
566 const size_t data_prev_grow_len = data_prev_len - chunk_prev->
data_len;
569 memcpy(data_prev, chunk_prev->
data, chunk_prev->
data_len);
570 memcpy(&data_prev[chunk_prev->
data_len], chunk_curr->
data, data_prev_grow_len);
573 memcpy(data_curr, &chunk_curr->
data[data_prev_grow_len], data_curr_len);
600 const size_t data_len,
601 size_t *r_data_trim_len,
602 size_t *r_data_last_chunk_len)
604 size_t data_last_chunk_len = 0;
605 size_t data_trim_len = data_len;
607#ifdef USE_MERGE_CHUNKS
611 data_trim_len = data_trim_len - data_last_chunk_len;
612 if (data_last_chunk_len) {
613 if (data_last_chunk_len < info->chunk_byte_size_min) {
622 data_last_chunk_len = data_len;
628 data_trim_len = data_trim_len - data_last_chunk_len;
631 BLI_assert(data_trim_len + data_last_chunk_len == data_len);
633 *r_data_trim_len = data_trim_len;
634 *r_data_last_chunk_len = data_last_chunk_len;
657 const size_t data_len)
661#ifdef USE_MERGE_CHUNKS
662 BLI_assert(data_len <= info->chunk_byte_size_max);
669 const size_t data_merge_len = chunk_prev->
data_len + data_len;
674 memcpy(&data_merge[chunk_prev->
data_len],
data, data_len);
680 memcpy(data_merge, chunk_prev->
data, chunk_prev->
data_len);
681 memcpy(&data_merge[chunk_prev->
data_len],
data, data_len);
698# ifdef USE_MERGE_CHUNKS
717 size_t data_trim_len, data_last_chunk_len;
720 if (data_trim_len != 0) {
729 while (i_prev != data_trim_len) {
736 if (data_last_chunk_len) {
744 if (data_last_chunk_len) {
750#ifdef USE_MERGE_CHUNKS
764#ifdef USE_MERGE_CHUNKS
775 const size_t data_len)
779 size_t data_trim_len, data_last_chunk_len;
783 while (i_prev != data_trim_len) {
790 if (data_last_chunk_len) {
796#ifdef USE_MERGE_CHUNKS
804# ifdef USE_MERGE_CHUNKS
842#define HASH_INIT (5381)
849#define HASH_VALUE_IMPL_ADD_BYTES(h, value) \
851 h = hash_key(int32_t((h << 5) + h) + (value)); \
855#define HASH_VALUE_IMPL_ADD(h, value) \
857 h = std::rotl(h, 5) + (value); \
866 static_assert(std::is_same<T, uint8_t>() || std::is_same<T, uint16_t>() ||
867 std::is_same<T, uint32_t>() || std::is_same<T, UInt64_Data>() ||
868 std::is_same<T, UInt96_Data>() || std::is_same<T, UInt128_Data>());
870 if constexpr (std::is_same_v<T, uint8_t>) {
873 else if constexpr (std::is_same_v<T, uint16_t>) {
876 else if constexpr (std::is_same_v<T, uint32_t>) {
879 else if constexpr (std::is_same_v<T, UInt64_Data>) {
883 else if constexpr (std::is_same_v<T, UInt96_Data>) {
888 else if constexpr (std::is_same_v<T, UInt128_Data>) {
915 for (
size_t i = 0; i < data_len; i++) {
923#ifdef USE_HASH_TABLE_ACCUMULATE
931 const size_t data_slice_len,
936 for (
size_t i = 0; i < data_slice_len; i++) {
942 for (
size_t i = 0, i_step = 0; i_step < data_slice_len; i++, i_step += stride) {
949 const uchar *data_slice,
950 const size_t data_slice_len,
956# define HASH_ARRAY_FROM_DATA_GENERIC(ty) \
958 const ty *data_slice_typed = reinterpret_cast<const ty *>(data_slice); \
959 hash_array_from_data_generic(info->chunk_stride / sizeof(*data_slice_typed), \
961 data_slice_len / sizeof(*data_slice_typed), \
992# undef HASH_ARRAY_FROM_DATA_GENERIC
1001 const size_t data_len,
1004 const size_t hash_array_len = data_len / info->
chunk_stride;
1007 size_t i_next = hash_array_len - i;
1013 BLI_assert(data_trim_len <= cref->link->data_len);
1017 }
while ((i < hash_array_len) && (cref !=
nullptr));
1029 hash_array[i_dst] = std::rotl(hash_array[i_dst], 3) + hash_array[i_ahead];
1035 if (iter_steps > hash_array_len) [[unlikely]] {
1036 iter_steps = hash_array_len;
1039 const size_t hash_array_search_len = hash_array_len - iter_steps;
1040 while (iter_steps != 0) {
1041 const size_t hash_offset = iter_steps;
1042 for (
size_t i = 0; i < hash_array_search_len; i++) {
1056 if (!(iter_steps <= hash_array_len)) [[unlikely]] {
1058 iter_steps = hash_array_len;
1062 size_t iter_steps_sub = iter_steps;
1064 while (iter_steps != 0) {
1065 const size_t hash_array_search_len = hash_array_len - iter_steps_sub;
1066 const size_t hash_offset = iter_steps;
1067 for (
uint i = 0; i < hash_array_search_len; i++) {
1071 iter_steps_sub += iter_steps;
1079 const size_t hash_store_len)
1088# ifdef USE_HASH_TABLE_KEY_CACHE
1097 key = hash_store[0];
1108 key = hash_store[0];
1118# ifdef USE_HASH_TABLE_KEY_CACHE
1128 const size_t table_len,
1129 const size_t i_table_start,
1131 const size_t data_len,
1132 const size_t offset,
1137 const BTableRef *tref = table[key_index];
1138 if (tref !=
nullptr) {
1139 const size_t size_left = data_len - offset;
1142# ifdef USE_HASH_TABLE_KEY_CACHE
1147 if (chunk_test->
data_len <= size_left) {
1154 }
while ((tref = tref->
next));
1168 const size_t data_len_for_type = data_len / size_t(hash_size);
1169 switch (hash_size) {
1196 BChunk *chunk = cref->link;
1197 const size_t data_hash_len = std::min(chunk->data_len, BCHUNK_HASH_LEN * info->chunk_stride);
1199# ifdef USE_HASH_TABLE_KEY_CACHE
1207 key = hash_data(chunk->data, data_hash_len, info->hash_size);
1214 key = hash_data(chunk->data, data_hash_len, info->hash_size);
1222 const size_t table_len,
1225 const size_t data_len,
1226 const size_t offset,
1229 const size_t data_hash_len = BCHUNK_HASH_LEN * info->chunk_stride;
1231 const size_t size_left = data_len - offset;
1233 &
data[offset], std::min(data_hash_len, size_left), info->hash_size);
1235 for (
BTableRef *tref = table[key_index]; tref; tref = tref->
next) {
1237# ifdef USE_HASH_TABLE_KEY_CACHE
1238 if (cref->link->key == key)
1241 BChunk *chunk_test = cref->link;
1242 if (chunk_test->data_len <= size_left) {
1283 const BChunkRef *cref_match_first =
nullptr;
1285 uint chunk_list_reference_skip_len = 0;
1286 size_t chunk_list_reference_skip_bytes = 0;
1289#ifdef USE_FASTPATH_CHUNKS_FIRST
1291 bool full_match =
true;
1296 cref_match_first = cref;
1297 chunk_list_reference_skip_len += 1;
1298 chunk_list_reference_skip_bytes += cref->
link->
data_len;
1310 return const_cast<BChunkList *
>(chunk_list_reference);
1322 if (cref_match_first !=
nullptr) {
1323 size_t chunk_size_step = 0;
1327 chunk_size_step += chunk->
data_len;
1331 if (cref == cref_match_first) {
1341 i_prev = chunk_size_step;
1358#define data_len_original invalid_usage
1359#ifdef data_len_original
1363 const BChunkRef *chunk_list_reference_last =
nullptr;
1365#ifdef USE_FASTPATH_CHUNKS_LAST
1366 if (!chunk_list_reference->
chunk_refs.is_empty()) {
1368 while ((cref->
prev !=
nullptr) && (cref != cref_match_first) &&
1372 size_t offset = data_len - chunk_test->
data_len;
1375 chunk_list_reference_last = cref;
1376 chunk_list_reference_skip_len += 1;
1377 chunk_list_reference_skip_bytes += cref->
link->
data_len;
1397 bool use_aligned =
false;
1399#ifdef USE_ALIGN_CHUNKS_TEST
1402 if (data_len - i_prev <= chunk_list->total_expanded_size / 4) {
1416 const BChunkRef *cref = cref_match_first ? cref_match_first->
next :
1419 while (i_prev != data_len) {
1423 if ((cref != chunk_list_reference_last) &&
1442 (chunk_list_reference->
chunk_refs_len >= chunk_list_reference_skip_len) &&
1443 (chunk_list_reference->
chunk_refs.first() !=
nullptr))
1454#ifdef USE_HASH_TABLE_ACCUMULATE
1455 size_t i_table_start = i_prev;
1456 const size_t table_hash_array_len = (data_len - i_prev) / info->
chunk_stride;
1464 uint i_table_start = 0;
1465 hash_key *table_hash_array =
nullptr;
1468 const uint chunk_list_reference_remaining_len = (chunk_list_reference->
chunk_refs_len -
1469 chunk_list_reference_skip_len) +
1472 chunk_list_reference_remaining_len, __func__);
1473 uint table_ref_stack_n = 0;
1481#ifdef USE_HASH_TABLE_ACCUMULATE
1488 chunk_list_reference_skip_bytes;
1490 if (cref_match_first) {
1491 cref = cref_match_first;
1492 chunk_list_reference_bytes_remaining += cref->
link->
data_len;
1495 cref = chunk_list_reference->
chunk_refs.first();
1498#ifdef USE_PARANOID_CHECKS
1500 size_t test_bytes_len = 0;
1502 while (cr != chunk_list_reference_last) {
1506 BLI_assert(test_bytes_len == chunk_list_reference_bytes_remaining);
1510 while ((cref != chunk_list_reference_last) &&
1523 BTableRef *tref_prev = table[key_index];
1524 BLI_assert(table_ref_stack_n < chunk_list_reference_remaining_len);
1525#ifdef USE_HASH_TABLE_DEDUPLICATE
1526 bool is_duplicate =
false;
1534# ifdef USE_HASH_TABLE_KEY_CACHE
1535 if (key == chunk_b->
key)
1538 if (chunk_a != chunk_b) {
1541 is_duplicate =
true;
1547 }
while ((tref = tref->
next));
1553 BTableRef *tref = &table_ref_stack[table_ref_stack_n++];
1555 tref->
next = tref_prev;
1556 table[key_index] = tref;
1559 chunk_list_reference_bytes_remaining -= cref->
link->
data_len;
1563 BLI_assert(table_ref_stack_n <= chunk_list_reference_remaining_len);
1565#ifdef USE_HASH_TABLE_ACCUMULATE
1566 MEM_delete(hash_store);
1572 for (
size_t i = i_prev; i < data_len;) {
1576 info, table, table_len, i_table_start,
data, data_len, i, table_hash_array);
1577 if (cref_found !=
nullptr) {
1596 while (!
ELEM(cref_found->
next,
nullptr, chunk_list_reference_last)) {
1597 cref_found = cref_found->
next;
1621#ifdef USE_HASH_TABLE_ACCUMULATE
1622 MEM_delete(table_hash_array);
1625 MEM_delete(table_ref_stack);
1639 if (i_prev != data_len) {
1647#ifdef USE_FASTPATH_CHUNKS_LAST
1648 if (chunk_list_reference_last !=
nullptr) {
1650 const BChunkRef *cref = chunk_list_reference_last;
1651 while (cref !=
nullptr) {
1663#undef data_len_original
1717#ifdef USE_MERGE_CHUNKS
1722#ifdef USE_HASH_TABLE_ACCUMULATE
1725 if (stride <=
sizeof(
int8_t)) {
1728 else if (stride <=
sizeof(
int16_t)) {
1731 else if (stride <=
sizeof(
int32_t)) {
1744 }
while (
UNLIKELY(chunk_count < bs->info.accum_read_ahead_len));
1771 MEM_delete(chunk->
data);
1777 state_next =
state->next;
1797 bs->
states.clear_no_delete();
1812 size_t size_accum = 0;
1814 size_accum +=
state.chunk_list->total_expanded_size;
1821 size_t size_total = 0;
1827 size_total += size_t(chunk->
data_len);
1840 const size_t data_len,
1846#ifdef USE_PARANOID_CHECKS
1847 if (state_reference) {
1853 if (state_reference) {
1867 chunk_list->
users += 1;
1870 state->chunk_list = chunk_list;
1874#ifdef USE_PARANOID_CHECKS
1876 size_t data_test_len;
1880 MEM_delete(data_test);
1889#ifdef USE_PARANOID_CHECKS
1901 return state->chunk_list->total_expanded_size;
1906#ifdef USE_PARANOID_CHECKS
1907 size_t data_test_len = 0;
1926 *r_data_len =
state->chunk_list->total_expanded_size;
1939 size_t total_expanded_size = 0;
1943 return total_expanded_size;
1963#ifdef USE_MERGE_CHUNKS
1986 for (
const auto &item : chunk_list_map.
items()) {
1988 const int users = item.value;
1989 if (!(chunk_list->
users == users)) {
2001 for (
const BChunkRef &cref : chunk_list->chunk_refs) {
2015 for (
const auto &item : chunk_map.
items()) {
2017 const int users = item.value;
2018 if (!(chunk->
users == users)) {
Efficient in-memory storage of multiple similar arrays.
Read Blender memory allocation and freeing.
#define BCHUNK_HASH_TABLE_MUL
#define USE_HASH_TABLE_ACCUMULATE
#define HASH_ARRAY_FROM_DATA_GENERIC(ty)
#define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_DEFAULT
#define ASSERT_CHUNKLIST_DATA(chunk_list, data)
#define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_8BITS
#define HASH_TABLE_KEY_UNSET
#define BCHUNK_SIZE_MAX_MUL
#define HASH_VALUE_IMPL_ADD_BYTES(h, value)
#define HASH_TABLE_KEY_FALLBACK
#define data_len_original
#define ASSERT_CHUNKLIST_SIZE(chunk_list, n)
#define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_32BITS
#define HASH_VALUE_IMPL_ADD(h, value)
#define BCHUNK_SIZE_MIN_DIV
#define BCHUNK_HASH_TABLE_ACCUMULATE_STEPS_16BITS
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define MEM_realloc_uninitialized(vmemh, len)
KeyIterator keys() const &
ItemIterator items() const &
Value & lookup_or_add(const Key &key, const Value &value)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static hash_key key_from_chunk_ref(const BArrayInfo *info, const BChunkRef *cref, hash_key *hash_store, const size_t hash_store_len)
static void hash_array_from_cref(const BArrayInfo *info, const BChunkRef *cref, const size_t data_len, hash_key *hash_array)
void BLI_array_store_state_remove(BArrayStore *bs, BArrayState *state)
static void hash_accum_single(hash_key *hash_array, const size_t hash_array_len, size_t iter_steps)
static void bchunk_list_append_data(const BArrayInfo *info, BArrayMemory *bs_mem, BChunkList *chunk_list, const uchar *data, const size_t data_len)
static size_t bchunk_list_size(const BChunkList *chunk_list)
static void bchunk_list_ensure_min_size_last(const BArrayInfo *info, BArrayMemory *bs_mem, BChunkList *chunk_list)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static void hash_array_from_data(const BArrayInfo *info, const uchar *data_slice, const size_t data_slice_len, hash_key *hash_array)
static hash_key hash_data_generic(const T *data, size_t data_len)
BArrayState * BLI_array_store_state_add(BArrayStore *bs, const void *data, size_t data_len, const BArrayState *state_reference)
static void array_store_free_data(BArrayStore *bs)
static void hash_accum(hash_key *hash_array, const size_t hash_array_len, size_t iter_steps)
void * BLI_array_store_state_data_get_alloc(const BArrayState *state, size_t *r_data_len)
static void hash_array_from_data_generic(const size_t stride, const T *data_slice, const size_t data_slice_len, hash_key *hash_array)
void BLI_mempool_free(BLI_mempool *pool, void *addr) ATTR_NONNULL(1
bool BLI_array_store_is_valid(BArrayStore *bs)
BLI_INLINE void hash_value_generic(hash_key &h, const T &value)
void BLI_mempool_destroy(BLI_mempool *pool) ATTR_NONNULL(1)
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
static const BChunkRef * table_lookup(const BArrayInfo *info, BTableRef **table, const size_t table_len, const size_t i_table_start, const uchar *data, const size_t data_len, const size_t offset, const hash_key *table_hash_array)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
BArrayStore * BLI_array_store_create(unsigned int stride, unsigned int chunk_count)
BMesh const char void * data
void BLI_array_store_clear(BArrayStore *bs)
BLI_mempool * BLI_mempool_create(unsigned int esize, unsigned int elem_num, unsigned int pchunk, unsigned int flag) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
static void bchunk_decref(BArrayMemory *bs_mem, BChunk *chunk)
static void bchunk_list_append_only(BArrayMemory *bs_mem, BChunkList *chunk_list, BChunk *chunk)
static BChunkList * bchunk_list_from_data_merge(const BArrayInfo *info, BArrayMemory *bs_mem, const uchar *data, const size_t data_len_original, const BChunkList *chunk_list_reference)
void BLI_mempool_iternew(BLI_mempool *pool, BLI_mempool_iter *iter) ATTR_NONNULL()
void BLI_mempool_clear(BLI_mempool *pool) ATTR_NONNULL(1)
void * BLI_mempool_iterstep(BLI_mempool_iter *iter) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BLI_array_store_state_data_get(const BArrayState *state, void *data)
static void bchunk_list_fill_from_array(const BArrayInfo *info, BArrayMemory *bs_mem, BChunkList *chunk_list, const uchar *data, const size_t data_len)
static void bchunk_list_decref(BArrayMemory *bs_mem, BChunkList *chunk_list)
size_t BLI_array_store_calc_size_expanded_get(const BArrayStore *bs)
static BChunk * bchunk_new_copydata(BArrayMemory *bs_mem, const uchar *data, const size_t data_len)
static void bchunk_list_calc_trim_len(const BArrayInfo *info, const size_t data_len, size_t *r_data_trim_len, size_t *r_data_last_chunk_len)
size_t BLI_array_store_state_size_get(const BArrayState *state)
size_t BLI_array_store_calc_size_compacted_get(const BArrayStore *bs)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
static void bchunk_list_append(const BArrayInfo *info, BArrayMemory *bs_mem, BChunkList *chunk_list, BChunk *chunk)
BLI_INLINE hash_key hash_data_single_generic(const T &value)
static BChunk * bchunk_new(BArrayMemory *bs_mem, const uchar *data, const size_t data_len)
void * BLI_mempool_alloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
static bool bchunk_data_compare(const BChunk *chunk, const uchar *data_base, const size_t data_base_len, const size_t offset)
int BLI_mempool_len(const BLI_mempool *pool) ATTR_NONNULL(1)
void BLI_array_store_destroy(BArrayStore *bs)
BLI_INLINE bool bchunk_data_compare_unchecked(const BChunk *chunk, const uchar *data_base, const size_t data_base_len, const size_t offset)
BLI_INLINE void hash_accum_impl(hash_key *hash_array, const size_t i_dst, const size_t i_ahead)
static void bchunk_list_append_data_n(const BArrayInfo *info, BArrayMemory *bs_mem, BChunkList *chunk_list, const uchar *data, size_t data_len)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static BChunkList * bchunk_list_new(BArrayMemory *bs_mem, size_t total_expanded_size)
size_t chunk_byte_size_max
size_t chunk_byte_size_min
size_t accum_read_ahead_len
size_t accum_read_ahead_bytes
ListBaseT< BArrayState > states
ListBaseT< BChunkRef > chunk_refs
size_t total_expanded_size