diff options
Diffstat (limited to 'examples/redis-unstable/deps/jemalloc/src/prof.c')
| -rw-r--r-- | examples/redis-unstable/deps/jemalloc/src/prof.c | 789 |
1 files changed, 0 insertions, 789 deletions
diff --git a/examples/redis-unstable/deps/jemalloc/src/prof.c b/examples/redis-unstable/deps/jemalloc/src/prof.c deleted file mode 100644 index 7a6d5d5..0000000 --- a/examples/redis-unstable/deps/jemalloc/src/prof.c +++ /dev/null @@ -1,789 +0,0 @@ -#include "jemalloc/internal/jemalloc_preamble.h" -#include "jemalloc/internal/jemalloc_internal_includes.h" - -#include "jemalloc/internal/ctl.h" -#include "jemalloc/internal/assert.h" -#include "jemalloc/internal/mutex.h" -#include "jemalloc/internal/counter.h" -#include "jemalloc/internal/prof_data.h" -#include "jemalloc/internal/prof_log.h" -#include "jemalloc/internal/prof_recent.h" -#include "jemalloc/internal/prof_stats.h" -#include "jemalloc/internal/prof_sys.h" -#include "jemalloc/internal/prof_hook.h" -#include "jemalloc/internal/thread_event.h" - -/* - * This file implements the profiling "APIs" needed by other parts of jemalloc, - * and also manages the relevant "operational" data, mainly options and mutexes; - * the core profiling data structures are encapsulated in prof_data.c. - */ - -/******************************************************************************/ - -/* Data. */ - -bool opt_prof = false; -bool opt_prof_active = true; -bool opt_prof_thread_active_init = true; -size_t opt_lg_prof_sample = LG_PROF_SAMPLE_DEFAULT; -ssize_t opt_lg_prof_interval = LG_PROF_INTERVAL_DEFAULT; -bool opt_prof_gdump = false; -bool opt_prof_final = false; -bool opt_prof_leak = false; -bool opt_prof_leak_error = false; -bool opt_prof_accum = false; -char opt_prof_prefix[PROF_DUMP_FILENAME_LEN]; -bool opt_prof_sys_thread_name = false; -bool opt_prof_unbias = true; - -/* Accessed via prof_sample_event_handler(). */ -static counter_accum_t prof_idump_accumulated; - -/* - * Initialized as opt_prof_active, and accessed via - * prof_active_[gs]et{_unlocked,}(). - */ -bool prof_active_state; -static malloc_mutex_t prof_active_mtx; - -/* - * Initialized as opt_prof_thread_active_init, and accessed via - * prof_thread_active_init_[gs]et(). - */ -static bool prof_thread_active_init; -static malloc_mutex_t prof_thread_active_init_mtx; - -/* - * Initialized as opt_prof_gdump, and accessed via - * prof_gdump_[gs]et{_unlocked,}(). - */ -bool prof_gdump_val; -static malloc_mutex_t prof_gdump_mtx; - -uint64_t prof_interval = 0; - -size_t lg_prof_sample; - -static uint64_t next_thr_uid; -static malloc_mutex_t next_thr_uid_mtx; - -/* Do not dump any profiles until bootstrapping is complete. */ -bool prof_booted = false; - -/* Logically a prof_backtrace_hook_t. */ -atomic_p_t prof_backtrace_hook; - -/* Logically a prof_dump_hook_t. */ -atomic_p_t prof_dump_hook; - -/******************************************************************************/ - -void -prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx) { - cassert(config_prof); - - if (tsd_reentrancy_level_get(tsd) > 0) { - assert((uintptr_t)tctx == (uintptr_t)1U); - return; - } - - if ((uintptr_t)tctx > (uintptr_t)1U) { - malloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock); - tctx->prepared = false; - prof_tctx_try_destroy(tsd, tctx); - } -} - -void -prof_malloc_sample_object(tsd_t *tsd, const void *ptr, size_t size, - size_t usize, prof_tctx_t *tctx) { - cassert(config_prof); - - if (opt_prof_sys_thread_name) { - prof_sys_thread_name_fetch(tsd); - } - - edata_t *edata = emap_edata_lookup(tsd_tsdn(tsd), &arena_emap_global, - ptr); - prof_info_set(tsd, edata, tctx, size); - - szind_t szind = sz_size2index(usize); - - malloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock); - /* - * We need to do these map lookups while holding the lock, to avoid the - * possibility of races with prof_reset calls, which update the map and - * then acquire the lock. This actually still leaves a data race on the - * contents of the unbias map, but we have not yet gone through and - * atomic-ified the prof module, and compilers are not yet causing us - * issues. The key thing is to make sure that, if we read garbage data, - * the prof_reset call is about to mark our tctx as expired before any - * dumping of our corrupted output is attempted. - */ - size_t shifted_unbiased_cnt = prof_shifted_unbiased_cnt[szind]; - size_t unbiased_bytes = prof_unbiased_sz[szind]; - tctx->cnts.curobjs++; - tctx->cnts.curobjs_shifted_unbiased += shifted_unbiased_cnt; - tctx->cnts.curbytes += usize; - tctx->cnts.curbytes_unbiased += unbiased_bytes; - if (opt_prof_accum) { - tctx->cnts.accumobjs++; - tctx->cnts.accumobjs_shifted_unbiased += shifted_unbiased_cnt; - tctx->cnts.accumbytes += usize; - tctx->cnts.accumbytes_unbiased += unbiased_bytes; - } - bool record_recent = prof_recent_alloc_prepare(tsd, tctx); - tctx->prepared = false; - malloc_mutex_unlock(tsd_tsdn(tsd), tctx->tdata->lock); - if (record_recent) { - assert(tctx == edata_prof_tctx_get(edata)); - prof_recent_alloc(tsd, edata, size, usize); - } - - if (opt_prof_stats) { - prof_stats_inc(tsd, szind, size); - } -} - -void -prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_info_t *prof_info) { - cassert(config_prof); - - assert(prof_info != NULL); - prof_tctx_t *tctx = prof_info->alloc_tctx; - assert((uintptr_t)tctx > (uintptr_t)1U); - - szind_t szind = sz_size2index(usize); - malloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock); - - assert(tctx->cnts.curobjs > 0); - assert(tctx->cnts.curbytes >= usize); - /* - * It's not correct to do equivalent asserts for unbiased bytes, because - * of the potential for races with prof.reset calls. The map contents - * should really be atomic, but we have not atomic-ified the prof module - * yet. - */ - tctx->cnts.curobjs--; - tctx->cnts.curobjs_shifted_unbiased -= prof_shifted_unbiased_cnt[szind]; - tctx->cnts.curbytes -= usize; - tctx->cnts.curbytes_unbiased -= prof_unbiased_sz[szind]; - - prof_try_log(tsd, usize, prof_info); - - prof_tctx_try_destroy(tsd, tctx); - - if (opt_prof_stats) { - prof_stats_dec(tsd, szind, prof_info->alloc_size); - } -} - -prof_tctx_t * -prof_tctx_create(tsd_t *tsd) { - if (!tsd_nominal(tsd) || tsd_reentrancy_level_get(tsd) > 0) { - return NULL; - } - - prof_tdata_t *tdata = prof_tdata_get(tsd, true); - if (tdata == NULL) { - return NULL; - } - - prof_bt_t bt; - bt_init(&bt, tdata->vec); - prof_backtrace(tsd, &bt); - return prof_lookup(tsd, &bt); -} - -/* - * The bodies of this function and prof_leakcheck() are compiled out unless heap - * profiling is enabled, so that it is possible to compile jemalloc with - * floating point support completely disabled. Avoiding floating point code is - * important on memory-constrained systems, but it also enables a workaround for - * versions of glibc that don't properly save/restore floating point registers - * during dynamic lazy symbol loading (which internally calls into whatever - * malloc implementation happens to be integrated into the application). Note - * that some compilers (e.g. gcc 4.8) may use floating point registers for fast - * memory moves, so jemalloc must be compiled with such optimizations disabled - * (e.g. - * -mno-sse) in order for the workaround to be complete. - */ -uint64_t -prof_sample_new_event_wait(tsd_t *tsd) { -#ifdef JEMALLOC_PROF - if (lg_prof_sample == 0) { - return TE_MIN_START_WAIT; - } - - /* - * Compute sample interval as a geometrically distributed random - * variable with mean (2^lg_prof_sample). - * - * __ __ - * | log(u) | 1 - * bytes_until_sample = | -------- |, where p = --------------- - * | log(1-p) | lg_prof_sample - * 2 - * - * For more information on the math, see: - * - * Non-Uniform Random Variate Generation - * Luc Devroye - * Springer-Verlag, New York, 1986 - * pp 500 - * (http://luc.devroye.org/rnbookindex.html) - * - * In the actual computation, there's a non-zero probability that our - * pseudo random number generator generates an exact 0, and to avoid - * log(0), we set u to 1.0 in case r is 0. Therefore u effectively is - * uniformly distributed in (0, 1] instead of [0, 1). Further, rather - * than taking the ceiling, we take the floor and then add 1, since - * otherwise bytes_until_sample would be 0 if u is exactly 1.0. - */ - uint64_t r = prng_lg_range_u64(tsd_prng_statep_get(tsd), 53); - double u = (r == 0U) ? 1.0 : (double)r * (1.0/9007199254740992.0L); - return (uint64_t)(log(u) / - log(1.0 - (1.0 / (double)((uint64_t)1U << lg_prof_sample)))) - + (uint64_t)1U; -#else - not_reached(); - return TE_MAX_START_WAIT; -#endif -} - -uint64_t -prof_sample_postponed_event_wait(tsd_t *tsd) { - /* - * The postponed wait time for prof sample event is computed as if we - * want a new wait time (i.e. as if the event were triggered). If we - * instead postpone to the immediate next allocation, like how we're - * handling the other events, then we can have sampling bias, if e.g. - * the allocation immediately following a reentrancy always comes from - * the same stack trace. - */ - return prof_sample_new_event_wait(tsd); -} - -void -prof_sample_event_handler(tsd_t *tsd, uint64_t elapsed) { - cassert(config_prof); - assert(elapsed > 0 && elapsed != TE_INVALID_ELAPSED); - if (prof_interval == 0 || !prof_active_get_unlocked()) { - return; - } - if (counter_accum(tsd_tsdn(tsd), &prof_idump_accumulated, elapsed)) { - prof_idump(tsd_tsdn(tsd)); - } -} - -static void -prof_fdump(void) { - tsd_t *tsd; - - cassert(config_prof); - assert(opt_prof_final); - - if (!prof_booted) { - return; - } - tsd = tsd_fetch(); - assert(tsd_reentrancy_level_get(tsd) == 0); - - prof_fdump_impl(tsd); -} - -static bool -prof_idump_accum_init(void) { - cassert(config_prof); - - return counter_accum_init(&prof_idump_accumulated, prof_interval); -} - -void -prof_idump(tsdn_t *tsdn) { - tsd_t *tsd; - prof_tdata_t *tdata; - - cassert(config_prof); - - if (!prof_booted || tsdn_null(tsdn) || !prof_active_get_unlocked()) { - return; - } - tsd = tsdn_tsd(tsdn); - if (tsd_reentrancy_level_get(tsd) > 0) { - return; - } - - tdata = prof_tdata_get(tsd, true); - if (tdata == NULL) { - return; - } - if (tdata->enq) { - tdata->enq_idump = true; - return; - } - - prof_idump_impl(tsd); -} - -bool -prof_mdump(tsd_t *tsd, const char *filename) { - cassert(config_prof); - assert(tsd_reentrancy_level_get(tsd) == 0); - - if (!opt_prof || !prof_booted) { - return true; - } - - return prof_mdump_impl(tsd, filename); -} - -void -prof_gdump(tsdn_t *tsdn) { - tsd_t *tsd; - prof_tdata_t *tdata; - - cassert(config_prof); - - if (!prof_booted || tsdn_null(tsdn) || !prof_active_get_unlocked()) { - return; - } - tsd = tsdn_tsd(tsdn); - if (tsd_reentrancy_level_get(tsd) > 0) { - return; - } - - tdata = prof_tdata_get(tsd, false); - if (tdata == NULL) { - return; - } - if (tdata->enq) { - tdata->enq_gdump = true; - return; - } - - prof_gdump_impl(tsd); -} - -static uint64_t -prof_thr_uid_alloc(tsdn_t *tsdn) { - uint64_t thr_uid; - - malloc_mutex_lock(tsdn, &next_thr_uid_mtx); - thr_uid = next_thr_uid; - next_thr_uid++; - malloc_mutex_unlock(tsdn, &next_thr_uid_mtx); - - return thr_uid; -} - -prof_tdata_t * -prof_tdata_init(tsd_t *tsd) { - return prof_tdata_init_impl(tsd, prof_thr_uid_alloc(tsd_tsdn(tsd)), 0, - NULL, prof_thread_active_init_get(tsd_tsdn(tsd))); -} - -prof_tdata_t * -prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata) { - uint64_t thr_uid = tdata->thr_uid; - uint64_t thr_discrim = tdata->thr_discrim + 1; - char *thread_name = (tdata->thread_name != NULL) ? - prof_thread_name_alloc(tsd, tdata->thread_name) : NULL; - bool active = tdata->active; - - prof_tdata_detach(tsd, tdata); - return prof_tdata_init_impl(tsd, thr_uid, thr_discrim, thread_name, - active); -} - -void -prof_tdata_cleanup(tsd_t *tsd) { - prof_tdata_t *tdata; - - if (!config_prof) { - return; - } - - tdata = tsd_prof_tdata_get(tsd); - if (tdata != NULL) { - prof_tdata_detach(tsd, tdata); - } -} - -bool -prof_active_get(tsdn_t *tsdn) { - bool prof_active_current; - - prof_active_assert(); - malloc_mutex_lock(tsdn, &prof_active_mtx); - prof_active_current = prof_active_state; - malloc_mutex_unlock(tsdn, &prof_active_mtx); - return prof_active_current; -} - -bool -prof_active_set(tsdn_t *tsdn, bool active) { - bool prof_active_old; - - prof_active_assert(); - malloc_mutex_lock(tsdn, &prof_active_mtx); - prof_active_old = prof_active_state; - prof_active_state = active; - malloc_mutex_unlock(tsdn, &prof_active_mtx); - prof_active_assert(); - return prof_active_old; -} - -const char * -prof_thread_name_get(tsd_t *tsd) { - assert(tsd_reentrancy_level_get(tsd) == 0); - - prof_tdata_t *tdata; - - tdata = prof_tdata_get(tsd, true); - if (tdata == NULL) { - return ""; - } - return (tdata->thread_name != NULL ? tdata->thread_name : ""); -} - -int -prof_thread_name_set(tsd_t *tsd, const char *thread_name) { - if (opt_prof_sys_thread_name) { - return ENOENT; - } else { - return prof_thread_name_set_impl(tsd, thread_name); - } -} - -bool -prof_thread_active_get(tsd_t *tsd) { - assert(tsd_reentrancy_level_get(tsd) == 0); - - prof_tdata_t *tdata; - - tdata = prof_tdata_get(tsd, true); - if (tdata == NULL) { - return false; - } - return tdata->active; -} - -bool -prof_thread_active_set(tsd_t *tsd, bool active) { - assert(tsd_reentrancy_level_get(tsd) == 0); - - prof_tdata_t *tdata; - - tdata = prof_tdata_get(tsd, true); - if (tdata == NULL) { - return true; - } - tdata->active = active; - return false; -} - -bool -prof_thread_active_init_get(tsdn_t *tsdn) { - bool active_init; - - malloc_mutex_lock(tsdn, &prof_thread_active_init_mtx); - active_init = prof_thread_active_init; - malloc_mutex_unlock(tsdn, &prof_thread_active_init_mtx); - return active_init; -} - -bool -prof_thread_active_init_set(tsdn_t *tsdn, bool active_init) { - bool active_init_old; - - malloc_mutex_lock(tsdn, &prof_thread_active_init_mtx); - active_init_old = prof_thread_active_init; - prof_thread_active_init = active_init; - malloc_mutex_unlock(tsdn, &prof_thread_active_init_mtx); - return active_init_old; -} - -bool -prof_gdump_get(tsdn_t *tsdn) { - bool prof_gdump_current; - - malloc_mutex_lock(tsdn, &prof_gdump_mtx); - prof_gdump_current = prof_gdump_val; - malloc_mutex_unlock(tsdn, &prof_gdump_mtx); - return prof_gdump_current; -} - -bool -prof_gdump_set(tsdn_t *tsdn, bool gdump) { - bool prof_gdump_old; - - malloc_mutex_lock(tsdn, &prof_gdump_mtx); - prof_gdump_old = prof_gdump_val; - prof_gdump_val = gdump; - malloc_mutex_unlock(tsdn, &prof_gdump_mtx); - return prof_gdump_old; -} - -void -prof_backtrace_hook_set(prof_backtrace_hook_t hook) { - atomic_store_p(&prof_backtrace_hook, hook, ATOMIC_RELEASE); -} - -prof_backtrace_hook_t -prof_backtrace_hook_get() { - return (prof_backtrace_hook_t)atomic_load_p(&prof_backtrace_hook, - ATOMIC_ACQUIRE); -} - -void -prof_dump_hook_set(prof_dump_hook_t hook) { - atomic_store_p(&prof_dump_hook, hook, ATOMIC_RELEASE); -} - -prof_dump_hook_t -prof_dump_hook_get() { - return (prof_dump_hook_t)atomic_load_p(&prof_dump_hook, - ATOMIC_ACQUIRE); -} - -void -prof_boot0(void) { - cassert(config_prof); - - memcpy(opt_prof_prefix, PROF_PREFIX_DEFAULT, - sizeof(PROF_PREFIX_DEFAULT)); -} - -void -prof_boot1(void) { - cassert(config_prof); - - /* - * opt_prof must be in its final state before any arenas are - * initialized, so this function must be executed early. - */ - if (opt_prof_leak_error && !opt_prof_leak) { - opt_prof_leak = true; - } - - if (opt_prof_leak && !opt_prof) { - /* - * Enable opt_prof, but in such a way that profiles are never - * automatically dumped. - */ - opt_prof = true; - opt_prof_gdump = false; - } else if (opt_prof) { - if (opt_lg_prof_interval >= 0) { - prof_interval = (((uint64_t)1U) << - opt_lg_prof_interval); - } - } -} - -bool -prof_boot2(tsd_t *tsd, base_t *base) { - cassert(config_prof); - - /* - * Initialize the global mutexes unconditionally to maintain correct - * stats when opt_prof is false. - */ - if (malloc_mutex_init(&prof_active_mtx, "prof_active", - WITNESS_RANK_PROF_ACTIVE, malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&prof_gdump_mtx, "prof_gdump", - WITNESS_RANK_PROF_GDUMP, malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&prof_thread_active_init_mtx, - "prof_thread_active_init", WITNESS_RANK_PROF_THREAD_ACTIVE_INIT, - malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&bt2gctx_mtx, "prof_bt2gctx", - WITNESS_RANK_PROF_BT2GCTX, malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&tdatas_mtx, "prof_tdatas", - WITNESS_RANK_PROF_TDATAS, malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&next_thr_uid_mtx, "prof_next_thr_uid", - WITNESS_RANK_PROF_NEXT_THR_UID, malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&prof_stats_mtx, "prof_stats", - WITNESS_RANK_PROF_STATS, malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&prof_dump_filename_mtx, - "prof_dump_filename", WITNESS_RANK_PROF_DUMP_FILENAME, - malloc_mutex_rank_exclusive)) { - return true; - } - if (malloc_mutex_init(&prof_dump_mtx, "prof_dump", - WITNESS_RANK_PROF_DUMP, malloc_mutex_rank_exclusive)) { - return true; - } - - if (opt_prof) { - lg_prof_sample = opt_lg_prof_sample; - prof_unbias_map_init(); - prof_active_state = opt_prof_active; - prof_gdump_val = opt_prof_gdump; - prof_thread_active_init = opt_prof_thread_active_init; - - if (prof_data_init(tsd)) { - return true; - } - - next_thr_uid = 0; - if (prof_idump_accum_init()) { - return true; - } - - if (opt_prof_final && opt_prof_prefix[0] != '\0' && - atexit(prof_fdump) != 0) { - malloc_write("<jemalloc>: Error in atexit()\n"); - if (opt_abort) { - abort(); - } - } - - if (prof_log_init(tsd)) { - return true; - } - - if (prof_recent_init()) { - return true; - } - - prof_base = base; - - gctx_locks = (malloc_mutex_t *)base_alloc(tsd_tsdn(tsd), base, - PROF_NCTX_LOCKS * sizeof(malloc_mutex_t), CACHELINE); - if (gctx_locks == NULL) { - return true; - } - for (unsigned i = 0; i < PROF_NCTX_LOCKS; i++) { - if (malloc_mutex_init(&gctx_locks[i], "prof_gctx", - WITNESS_RANK_PROF_GCTX, - malloc_mutex_rank_exclusive)) { - return true; - } - } - - tdata_locks = (malloc_mutex_t *)base_alloc(tsd_tsdn(tsd), base, - PROF_NTDATA_LOCKS * sizeof(malloc_mutex_t), CACHELINE); - if (tdata_locks == NULL) { - return true; - } - for (unsigned i = 0; i < PROF_NTDATA_LOCKS; i++) { - if (malloc_mutex_init(&tdata_locks[i], "prof_tdata", - WITNESS_RANK_PROF_TDATA, - malloc_mutex_rank_exclusive)) { - return true; - } - } - - prof_unwind_init(); - prof_hooks_init(); - } - prof_booted = true; - - return false; -} - -void -prof_prefork0(tsdn_t *tsdn) { - if (config_prof && opt_prof) { - unsigned i; - - malloc_mutex_prefork(tsdn, &prof_dump_mtx); - malloc_mutex_prefork(tsdn, &bt2gctx_mtx); - malloc_mutex_prefork(tsdn, &tdatas_mtx); - for (i = 0; i < PROF_NTDATA_LOCKS; i++) { - malloc_mutex_prefork(tsdn, &tdata_locks[i]); - } - malloc_mutex_prefork(tsdn, &log_mtx); - for (i = 0; i < PROF_NCTX_LOCKS; i++) { - malloc_mutex_prefork(tsdn, &gctx_locks[i]); - } - malloc_mutex_prefork(tsdn, &prof_recent_dump_mtx); - } -} - -void -prof_prefork1(tsdn_t *tsdn) { - if (config_prof && opt_prof) { - counter_prefork(tsdn, &prof_idump_accumulated); - malloc_mutex_prefork(tsdn, &prof_active_mtx); - malloc_mutex_prefork(tsdn, &prof_dump_filename_mtx); - malloc_mutex_prefork(tsdn, &prof_gdump_mtx); - malloc_mutex_prefork(tsdn, &prof_recent_alloc_mtx); - malloc_mutex_prefork(tsdn, &prof_stats_mtx); - malloc_mutex_prefork(tsdn, &next_thr_uid_mtx); - malloc_mutex_prefork(tsdn, &prof_thread_active_init_mtx); - } -} - -void -prof_postfork_parent(tsdn_t *tsdn) { - if (config_prof && opt_prof) { - unsigned i; - - malloc_mutex_postfork_parent(tsdn, - &prof_thread_active_init_mtx); - malloc_mutex_postfork_parent(tsdn, &next_thr_uid_mtx); - malloc_mutex_postfork_parent(tsdn, &prof_stats_mtx); - malloc_mutex_postfork_parent(tsdn, &prof_recent_alloc_mtx); - malloc_mutex_postfork_parent(tsdn, &prof_gdump_mtx); - malloc_mutex_postfork_parent(tsdn, &prof_dump_filename_mtx); - malloc_mutex_postfork_parent(tsdn, &prof_active_mtx); - counter_postfork_parent(tsdn, &prof_idump_accumulated); - malloc_mutex_postfork_parent(tsdn, &prof_recent_dump_mtx); - for (i = 0; i < PROF_NCTX_LOCKS; i++) { - malloc_mutex_postfork_parent(tsdn, &gctx_locks[i]); - } - malloc_mutex_postfork_parent(tsdn, &log_mtx); - for (i = 0; i < PROF_NTDATA_LOCKS; i++) { - malloc_mutex_postfork_parent(tsdn, &tdata_locks[i]); - } - malloc_mutex_postfork_parent(tsdn, &tdatas_mtx); - malloc_mutex_postfork_parent(tsdn, &bt2gctx_mtx); - malloc_mutex_postfork_parent(tsdn, &prof_dump_mtx); - } -} - -void -prof_postfork_child(tsdn_t *tsdn) { - if (config_prof && opt_prof) { - unsigned i; - - malloc_mutex_postfork_child(tsdn, &prof_thread_active_init_mtx); - malloc_mutex_postfork_child(tsdn, &next_thr_uid_mtx); - malloc_mutex_postfork_child(tsdn, &prof_stats_mtx); - malloc_mutex_postfork_child(tsdn, &prof_recent_alloc_mtx); - malloc_mutex_postfork_child(tsdn, &prof_gdump_mtx); - malloc_mutex_postfork_child(tsdn, &prof_dump_filename_mtx); - malloc_mutex_postfork_child(tsdn, &prof_active_mtx); - counter_postfork_child(tsdn, &prof_idump_accumulated); - malloc_mutex_postfork_child(tsdn, &prof_recent_dump_mtx); - for (i = 0; i < PROF_NCTX_LOCKS; i++) { - malloc_mutex_postfork_child(tsdn, &gctx_locks[i]); - } - malloc_mutex_postfork_child(tsdn, &log_mtx); - for (i = 0; i < PROF_NTDATA_LOCKS; i++) { - malloc_mutex_postfork_child(tsdn, &tdata_locks[i]); - } - malloc_mutex_postfork_child(tsdn, &tdatas_mtx); - malloc_mutex_postfork_child(tsdn, &bt2gctx_mtx); - malloc_mutex_postfork_child(tsdn, &prof_dump_mtx); - } -} - -/******************************************************************************/ |