fluencelabs/redis
1
0
Fork 0
mirror of https://github.com/fluencelabs/redis synced 2025-06-13 17:21:20 +00:00
Code Issues Projects Releases Wiki Activity

Revert "Jemalloc updated to 4.4.0."

Browse Source 
This reverts commit 36c1acc222.
This commit is contained in:
antirez
2017-04-22 13:12:42 +02:00
parent 238cebdd5e
commit e3b8492e83
150 changed files with 6355 additions and 17238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
deps/jemalloc/src/base.c vendored
View File

@ -5,8 +5,7 @@
/* Data. */
static malloc_mutex_t base_mtx;
static size_t base_extent_sn_next;
static extent_tree_t base_avail_szsnad;
static extent_tree_t base_avail_szad;
static extent_node_t *base_nodes;
static size_t base_allocated;
static size_t base_resident;
@ -14,13 +13,12 @@ static size_t base_mapped;
/******************************************************************************/
/* base_mtx must be held. */
static extent_node_t *
base_node_try_alloc(tsdn_t *tsdn)
base_node_try_alloc(void)
{
extent_node_t *node;
malloc_mutex_assert_owner(tsdn, &base_mtx);
if (base_nodes == NULL)
return (NULL);
node = base_nodes;
@ -29,42 +27,33 @@ base_node_try_alloc(tsdn_t *tsdn)
return (node);
}
/* base_mtx must be held. */
static void
base_node_dalloc(tsdn_t *tsdn, extent_node_t *node)
base_node_dalloc(extent_node_t *node)
{
malloc_mutex_assert_owner(tsdn, &base_mtx);
JEMALLOC_VALGRIND_MAKE_MEM_UNDEFINED(node, sizeof(extent_node_t));
*(extent_node_t **)node = base_nodes;
base_nodes = node;
}
static void
base_extent_node_init(extent_node_t *node, void *addr, size_t size)
{
size_t sn = atomic_add_z(&base_extent_sn_next, 1) - 1;
extent_node_init(node, NULL, addr, size, sn, true, true);
}
/* base_mtx must be held. */
static extent_node_t *
base_chunk_alloc(tsdn_t *tsdn, size_t minsize)
base_chunk_alloc(size_t minsize)
{
extent_node_t *node;
size_t csize, nsize;
void *addr;
malloc_mutex_assert_owner(tsdn, &base_mtx);
assert(minsize != 0);
node = base_node_try_alloc(tsdn);
node = base_node_try_alloc();
/* Allocate enough space to also carve a node out if necessary. */
nsize = (node == NULL) ? CACHELINE_CEILING(sizeof(extent_node_t)) : 0;
csize = CHUNK_CEILING(minsize + nsize);
addr = chunk_alloc_base(csize);
if (addr == NULL) {
if (node != NULL)
base_node_dalloc(tsdn, node);
base_node_dalloc(node);
return (NULL);
}
base_mapped += csize;
@ -77,7 +66,7 @@ base_chunk_alloc(tsdn_t *tsdn, size_t minsize)
base_resident += PAGE_CEILING(nsize);
}
}
base_extent_node_init(node, addr, csize);
extent_node_init(node, NULL, addr, csize, true, true);
return (node);
}
@ -87,7 +76,7 @@ base_chunk_alloc(tsdn_t *tsdn, size_t minsize)
* physical memory usage.
*/
void *
base_alloc(tsdn_t *tsdn, size_t size)
base_alloc(size_t size)
{
void *ret;
size_t csize, usize;
@ -101,15 +90,15 @@ base_alloc(tsdn_t *tsdn, size_t size)
csize = CACHELINE_CEILING(size);
usize = s2u(csize);
extent_node_init(&key, NULL, NULL, usize, 0, false, false);
malloc_mutex_lock(tsdn, &base_mtx);
node = extent_tree_szsnad_nsearch(&base_avail_szsnad, &key);
extent_node_init(&key, NULL, NULL, usize, false, false);
malloc_mutex_lock(&base_mtx);
node = extent_tree_szad_nsearch(&base_avail_szad, &key);
if (node != NULL) {
/* Use existing space. */
extent_tree_szsnad_remove(&base_avail_szsnad, node);
extent_tree_szad_remove(&base_avail_szad, node);
} else {
/* Try to allocate more space. */
node = base_chunk_alloc(tsdn, csize);
node = base_chunk_alloc(csize);
}
if (node == NULL) {
ret = NULL;
@ -120,9 +109,9 @@ base_alloc(tsdn_t *tsdn, size_t size)
if (extent_node_size_get(node) > csize) {
extent_node_addr_set(node, (void *)((uintptr_t)ret + csize));
extent_node_size_set(node, extent_node_size_get(node) - csize);
extent_tree_szsnad_insert(&base_avail_szsnad, node);
extent_tree_szad_insert(&base_avail_szad, node);
} else
base_node_dalloc(tsdn, node);
base_node_dalloc(node);
if (config_stats) {
base_allocated += csize;
/*
@ -134,54 +123,52 @@ base_alloc(tsdn_t *tsdn, size_t size)
}
JEMALLOC_VALGRIND_MAKE_MEM_DEFINED(ret, csize);
label_return:
malloc_mutex_unlock(tsdn, &base_mtx);
malloc_mutex_unlock(&base_mtx);
return (ret);
}
void
base_stats_get(tsdn_t *tsdn, size_t *allocated, size_t *resident,
size_t *mapped)
base_stats_get(size_t *allocated, size_t *resident, size_t *mapped)
{
malloc_mutex_lock(tsdn, &base_mtx);
malloc_mutex_lock(&base_mtx);
assert(base_allocated <= base_resident);
assert(base_resident <= base_mapped);
*allocated = base_allocated;
*resident = base_resident;
*mapped = base_mapped;
malloc_mutex_unlock(tsdn, &base_mtx);
malloc_mutex_unlock(&base_mtx);
}
bool
base_boot(void)
{
if (malloc_mutex_init(&base_mtx, "base", WITNESS_RANK_BASE))
if (malloc_mutex_init(&base_mtx))
return (true);
base_extent_sn_next = 0;
extent_tree_szsnad_new(&base_avail_szsnad);
extent_tree_szad_new(&base_avail_szad);
base_nodes = NULL;
return (false);
}
void
base_prefork(tsdn_t *tsdn)
base_prefork(void)
{
malloc_mutex_prefork(tsdn, &base_mtx);
malloc_mutex_prefork(&base_mtx);
}
void
base_postfork_parent(tsdn_t *tsdn)
base_postfork_parent(void)
{
malloc_mutex_postfork_parent(tsdn, &base_mtx);
malloc_mutex_postfork_parent(&base_mtx);
}
void
base_postfork_child(tsdn_t *tsdn)
base_postfork_child(void)
{
malloc_mutex_postfork_child(tsdn, &base_mtx);
malloc_mutex_postfork_child(&base_mtx);
}