romenskiy2012/jemalloc
1
0
Fork 0
mirror of https://github.com/jemalloc/jemalloc.git synced 2026-08-24 08:03:32 +03:00
Code Issues Projects Releases Packages Wiki Activity

Add witness, a simple online locking validator.

Browse source 
This resolves #358.
This commit is contained in:
Jason Evans 2016-04-13 23:36:15 -07:00
parent 8413463f3a
commit b2c0d6322d
33 changed files with 2118 additions and 1302 deletions
Download patch file Download diff file Expand all files Collapse all files

46
src/chunk_dss.c
View file

@ -41,33 +41,33 @@ chunk_dss_sbrk(intptr_t increment)
}
dss_prec_t
chunk_dss_prec_get(void)
chunk_dss_prec_get(tsd_t *tsd)
{
dss_prec_t ret;
if (!have_dss)
return (dss_prec_disabled);
malloc_mutex_lock(&dss_mtx);
malloc_mutex_lock(tsd, &dss_mtx);
ret = dss_prec_default;
malloc_mutex_unlock(&dss_mtx);
malloc_mutex_unlock(tsd, &dss_mtx);
return (ret);
}
bool
chunk_dss_prec_set(dss_prec_t dss_prec)
chunk_dss_prec_set(tsd_t *tsd, dss_prec_t dss_prec)
{
if (!have_dss)
return (dss_prec != dss_prec_disabled);
malloc_mutex_lock(&dss_mtx);
malloc_mutex_lock(tsd, &dss_mtx);
dss_prec_default = dss_prec;
malloc_mutex_unlock(&dss_mtx);
malloc_mutex_unlock(tsd, &dss_mtx);
return (false);
}
void *
chunk_alloc_dss(arena_t *arena, void *new_addr, size_t size, size_t alignment,
bool *zero, bool *commit)
chunk_alloc_dss(tsd_t *tsd, arena_t *arena, void *new_addr, size_t size,
size_t alignment, bool *zero, bool *commit)
{
cassert(have_dss);
assert(size > 0 && (size & chunksize_mask) == 0);
@ -80,7 +80,7 @@ chunk_alloc_dss(arena_t *arena, void *new_addr, size_t size, size_t alignment,
if ((intptr_t)size < 0)
return (NULL);
malloc_mutex_lock(&dss_mtx);
malloc_mutex_lock(tsd, &dss_mtx);
if (dss_prev != (void *)-1) {
/*
@ -122,7 +122,7 @@ chunk_alloc_dss(arena_t *arena, void *new_addr, size_t size, size_t alignment,
if ((uintptr_t)ret < (uintptr_t)dss_max ||
(uintptr_t)dss_next < (uintptr_t)dss_max) {
/* Wrap-around. */
malloc_mutex_unlock(&dss_mtx);
malloc_mutex_unlock(tsd, &dss_mtx);
return (NULL);
}
incr = gap_size + cpad_size + size;
@ -130,11 +130,11 @@ chunk_alloc_dss(arena_t *arena, void *new_addr, size_t size, size_t alignment,
if (dss_prev == dss_max) {
/* Success. */
dss_max = dss_next;
malloc_mutex_unlock(&dss_mtx);
malloc_mutex_unlock(tsd, &dss_mtx);
if (cpad_size != 0) {
chunk_hooks_t chunk_hooks =
CHUNK_HOOKS_INITIALIZER;
chunk_dalloc_wrapper(arena,
chunk_dalloc_wrapper(tsd, arena,
&chunk_hooks, cpad, cpad_size,
false, true);
}
@ -149,25 +149,25 @@ chunk_alloc_dss(arena_t *arena, void *new_addr, size_t size, size_t alignment,
}
} while (dss_prev != (void *)-1);
}
malloc_mutex_unlock(&dss_mtx);
malloc_mutex_unlock(tsd, &dss_mtx);
return (NULL);
}
bool
chunk_in_dss(void *chunk)
chunk_in_dss(tsd_t *tsd, void *chunk)
{
bool ret;
cassert(have_dss);
malloc_mutex_lock(&dss_mtx);
malloc_mutex_lock(tsd, &dss_mtx);
if ((uintptr_t)chunk >= (uintptr_t)dss_base
&& (uintptr_t)chunk < (uintptr_t)dss_max)
ret = true;
else
ret = false;
malloc_mutex_unlock(&dss_mtx);
malloc_mutex_unlock(tsd, &dss_mtx);
return (ret);
}
@ -178,7 +178,7 @@ chunk_dss_boot(void)
cassert(have_dss);
if (malloc_mutex_init(&dss_mtx))
if (malloc_mutex_init(&dss_mtx, "dss", WITNESS_RANK_DSS))
return (true);
dss_base = chunk_dss_sbrk(0);
dss_prev = dss_base;
@ -188,27 +188,27 @@ chunk_dss_boot(void)
}
void
chunk_dss_prefork(void)
chunk_dss_prefork(tsd_t *tsd)
{
if (have_dss)
malloc_mutex_prefork(&dss_mtx);
malloc_mutex_prefork(tsd, &dss_mtx);
}
void
chunk_dss_postfork_parent(void)
chunk_dss_postfork_parent(tsd_t *tsd)
{
if (have_dss)
malloc_mutex_postfork_parent(&dss_mtx);
malloc_mutex_postfork_parent(tsd, &dss_mtx);
}
void
chunk_dss_postfork_child(void)
chunk_dss_postfork_child(tsd_t *tsd)
{
if (have_dss)
malloc_mutex_postfork_child(&dss_mtx);
malloc_mutex_postfork_child(tsd, &dss_mtx);
}
/******************************************************************************/