From 6e62c6286258e340308b4a989b4bd80232fed8e1 Mon Sep 17 00:00:00 2001 From: Jason Evans Date: Wed, 17 May 2017 10:47:00 -0700 Subject: [PATCH] Refactor *decay_time into *decay_ms. Support millisecond resolution for decay times. Among other use cases this makes it possible to specify a short initial dirty-->muzzy decay phase, followed by a longer muzzy-->clean decay phase. This resolves #812. --- INSTALL.md | 2 +- Makefile.in | 4 +- doc/jemalloc.xml.in | 118 ++++++------ include/jemalloc/internal/arena_externs.h | 28 ++- include/jemalloc/internal/arena_structs_b.h | 4 +- include/jemalloc/internal/arena_types.h | 6 +- include/jemalloc/internal/ctl.h | 4 +- .../internal/jemalloc_internal_decls.h | 3 + src/arena.c | 130 ++++++------- src/ctl.c | 95 +++++----- src/jemalloc.c | 12 +- src/stats.c | 42 ++--- test/unit/decay.c | 24 +-- test/unit/decay.sh | 2 +- test/unit/mallctl.c | 172 +++++++++--------- test/unit/pack.sh | 2 +- 16 files changed, 320 insertions(+), 328 deletions(-) diff --git a/INSTALL.md b/INSTALL.md index e0cfc0be..25f625af 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -116,7 +116,7 @@ any of the following arguments (not a definitive list) to 'configure': MALLOC_CONF environment variable. For example, to change the default decay time to 30 seconds: - --with-malloc-conf=decay_time:30 + --with-malloc-conf=decay_ms:30000 * `--enable-debug` diff --git a/Makefile.in b/Makefile.in index 370ead58..2f16fbf3 100644 --- a/Makefile.in +++ b/Makefile.in @@ -479,8 +479,8 @@ ifeq ($(enable_prof), 1) $(MALLOC_CONF)="prof:true,prof_active:false" $(SHELL) $(objroot)test/test.sh $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%) $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%) endif check_integration_decay: tests_integration check_integration_dir - $(MALLOC_CONF)="dirty_decay_time:-1,muzzy_decay_time:-1" $(SHELL) $(objroot)test/test.sh $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%) $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%) - $(MALLOC_CONF)="dirty_decay_time:0,muzzy_decay_time:0" $(SHELL) $(objroot)test/test.sh $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%) $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%) + $(MALLOC_CONF)="dirty_decay_ms:-1,muzzy_decay_ms:-1" $(SHELL) $(objroot)test/test.sh $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%) $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%) + $(MALLOC_CONF)="dirty_decay_ms:0,muzzy_decay_ms:0" $(SHELL) $(objroot)test/test.sh $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%) $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%) check_integration: tests_integration check_integration_dir $(SHELL) $(objroot)test/test.sh $(TESTS_INTEGRATION:$(srcroot)%.c=$(objroot)%) $(TESTS_INTEGRATION_CPP:$(srcroot)%.cpp=$(objroot)%) stress: tests_stress stress_dir diff --git a/doc/jemalloc.xml.in b/doc/jemalloc.xml.in index 1efc9163..be018bfb 100644 --- a/doc/jemalloc.xml.in +++ b/doc/jemalloc.xml.in @@ -937,15 +937,15 @@ mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".decay", percpu. - + - opt.dirty_decay_time + opt.dirty_decay_ms (ssize_t) r- - Approximate time in seconds from the creation of a set - of unused dirty pages until an equivalent set of unused dirty pages is - purged (i.e. converted to muzzy via e.g. + Approximate time in milliseconds from the creation of a + set of unused dirty pages until an equivalent set of unused dirty pages + is purged (i.e. converted to muzzy via e.g. madvise(...MADV_FREE) if supported by the operating system, or converted to clean otherwise) and/or reused. Dirty pages are defined as previously having been @@ -955,35 +955,35 @@ mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".decay", zero purge rate. A decay time of 0 causes all unused dirty pages to be purged immediately upon creation. A decay time of -1 disables purging. The default decay time is 10 seconds. See arenas.dirty_decay_time + linkend="arenas.dirty_decay_ms">arenas.dirty_decay_ms and arena.<i>.muzzy_decay_time + linkend="arena.i.muzzy_decay_ms">arena.<i>.muzzy_decay_ms for related dynamic control options. See opt.muzzy_decay_time + linkend="opt.muzzy_decay_ms">opt.muzzy_decay_ms for a description of muzzy pages. - + - opt.muzzy_decay_time + opt.muzzy_decay_ms (ssize_t) r- - Approximate time in seconds from the creation of a set - of unused muzzy pages until an equivalent set of unused muzzy pages is - purged (i.e. converted to clean) and/or reused. Muzzy pages are defined - as previously having been unused dirty pages that were subsequently - purged in a manner that left them subject to the reclamation whims of - the operating system (e.g. + Approximate time in milliseconds from the creation of a + set of unused muzzy pages until an equivalent set of unused muzzy pages + is purged (i.e. converted to clean) and/or reused. Muzzy pages are + defined as previously having been unused dirty pages that were + subsequently purged in a manner that left them subject to the + reclamation whims of the operating system (e.g. madvise(...MADV_FREE)), and therefore in an indeterminate state. The pages are incrementally purged according to a sigmoidal decay curve that starts and ends with zero purge rate. A decay time of 0 causes all unused muzzy pages to be purged immediately upon creation. A decay time of -1 disables purging. The default decay time is 10 seconds. See arenas.muzzy_decay_time + linkend="arenas.muzzy_decay_ms">arenas.muzzy_decay_ms and arena.<i>.muzzy_decay_time + linkend="arena.i.muzzy_decay_ms">arena.<i>.muzzy_decay_ms for related dynamic control options. @@ -1486,9 +1486,9 @@ malloc_conf = "xmalloc:true";]]> for arena <i>, or for all arenas if <i> equals MALLCTL_ARENAS_ALL. The proportion of unused dirty/muzzy pages to be purged depends on the current time; see opt.dirty_decay_time + linkend="opt.dirty_decay_ms">opt.dirty_decay_ms and opt.muzy_decay_time + linkend="opt.muzzy_decay_ms">opt.muzy_decay_ms for details. @@ -1550,35 +1550,35 @@ malloc_conf = "xmalloc:true";]]> settings. - + - arena.<i>.dirty_decay_time + arena.<i>.dirty_decay_ms (ssize_t) rw - Current per-arena approximate time in seconds from the - creation of a set of unused dirty pages until an equivalent set of + Current per-arena approximate time in milliseconds from + the creation of a set of unused dirty pages until an equivalent set of unused dirty pages is purged and/or reused. Each time this interface is set, all currently unused dirty pages are considered to have fully decayed, which causes immediate purging of all unused dirty pages unless the decay time is set to -1 (i.e. purging disabled). See opt.dirty_decay_time + linkend="opt.dirty_decay_ms">opt.dirty_decay_ms for additional information. - + - arena.<i>.muzzy_decay_time + arena.<i>.muzzy_decay_ms (ssize_t) rw - Current per-arena approximate time in seconds from the - creation of a set of unused muzzy pages until an equivalent set of + Current per-arena approximate time in milliseconds from + the creation of a set of unused muzzy pages until an equivalent set of unused muzzy pages is purged and/or reused. Each time this interface is set, all currently unused muzzy pages are considered to have fully decayed, which causes immediate purging of all unused muzzy pages unless the decay time is set to -1 (i.e. purging disabled). See opt.muzzy_decay_time + linkend="opt.muzzy_decay_ms">opt.muzzy_decay_ms for additional information. @@ -1825,33 +1825,35 @@ struct extent_hooks_s { Current limit on number of arenas. - + - arenas.dirty_decay_time + arenas.dirty_decay_ms (ssize_t) rw - Current default per-arena approximate time in seconds - from the creation of a set of unused dirty pages until an equivalent set - of unused dirty pages is purged and/or reused, used to initialize arena.<i>.dirty_decay_time + Current default per-arena approximate time in + milliseconds from the creation of a set of unused dirty pages until an + equivalent set of unused dirty pages is purged and/or reused, used to + initialize arena.<i>.dirty_decay_ms during arena creation. See opt.dirty_decay_time + linkend="opt.dirty_decay_ms">opt.dirty_decay_ms for additional information. - + - arenas.muzzy_decay_time + arenas.muzzy_decay_ms (ssize_t) rw - Current default per-arena approximate time in seconds - from the creation of a set of unused muzzy pages until an equivalent set - of unused muzzy pages is purged and/or reused, used to initialize arena.<i>.muzzy_decay_time + Current default per-arena approximate time in + milliseconds from the creation of a set of unused muzzy pages until an + equivalent set of unused muzzy pages is purged and/or reused, used to + initialize arena.<i>.muzzy_decay_ms during arena creation. See opt.muzzy_decay_time + linkend="opt.muzzy_decay_ms">opt.muzzy_decay_ms for additional information. @@ -2244,29 +2246,29 @@ struct extent_hooks_s { - + - stats.arenas.<i>.dirty_decay_time + stats.arenas.<i>.dirty_decay_ms (ssize_t) r- - Approximate time in seconds from the creation of a set - of unused dirty pages until an equivalent set of unused dirty pages is - purged and/or reused. See opt.dirty_decay_time + Approximate time in milliseconds from the creation of a + set of unused dirty pages until an equivalent set of unused dirty pages + is purged and/or reused. See opt.dirty_decay_ms for details. - + - stats.arenas.<i>.muzzy_decay_time + stats.arenas.<i>.muzzy_decay_ms (ssize_t) r- - Approximate time in seconds from the creation of a set - of unused muzzy pages until an equivalent set of unused muzzy pages is - purged and/or reused. See opt.muzzy_decay_time + Approximate time in milliseconds from the creation of a + set of unused muzzy pages until an equivalent set of unused muzzy pages + is purged and/or reused. See opt.muzzy_decay_ms for details. @@ -2310,7 +2312,7 @@ struct extent_hooks_s { Number of pages within unused extents that are potentially dirty, and for which madvise() or similar has not been called. See opt.dirty_decay_time + linkend="opt.dirty_decay_ms">opt.dirty_decay_ms for a description of dirty pages. @@ -2322,7 +2324,7 @@ struct extent_hooks_s { Number of pages within unused extents that are muzzy. See opt.muzzy_decay_time + linkend="opt.muzzy_decay_ms">opt.muzzy_decay_ms for a description of muzzy pages. diff --git a/include/jemalloc/internal/arena_externs.h b/include/jemalloc/internal/arena_externs.h index 410709c6..292b8d6d 100644 --- a/include/jemalloc/internal/arena_externs.h +++ b/include/jemalloc/internal/arena_externs.h @@ -13,8 +13,8 @@ static const size_t large_pad = #endif ; -extern ssize_t opt_dirty_decay_time; -extern ssize_t opt_muzzy_decay_time; +extern ssize_t opt_dirty_decay_ms; +extern ssize_t opt_muzzy_decay_ms; extern const arena_bin_info_t arena_bin_info[NBINS]; @@ -27,10 +27,10 @@ void arena_stats_large_nrequests_add(tsdn_t *tsdn, arena_stats_t *arena_stats, void arena_stats_mapped_add(tsdn_t *tsdn, arena_stats_t *arena_stats, size_t size); void arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, - unsigned *nthreads, const char **dss, ssize_t *dirty_decay_time, - ssize_t *muzzy_decay_time, size_t *nactive, size_t *ndirty, size_t *nmuzzy); + unsigned *nthreads, const char **dss, ssize_t *dirty_decay_ms, + ssize_t *muzzy_decay_ms, size_t *nactive, size_t *ndirty, size_t *nmuzzy); void arena_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads, - const char **dss, ssize_t *dirty_decay_time, ssize_t *muzzy_decay_time, + const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms, size_t *nactive, size_t *ndirty, size_t *nmuzzy, arena_stats_t *astats, malloc_bin_stats_t *bstats, malloc_large_stats_t *lstats); void arena_extents_dirty_dalloc(tsdn_t *tsdn, arena_t *arena, @@ -46,12 +46,10 @@ void arena_extent_ralloc_large_shrink(tsdn_t *tsdn, arena_t *arena, extent_t *extent, size_t oldsize); void arena_extent_ralloc_large_expand(tsdn_t *tsdn, arena_t *arena, extent_t *extent, size_t oldsize); -ssize_t arena_dirty_decay_time_get(arena_t *arena); -bool arena_dirty_decay_time_set(tsdn_t *tsdn, arena_t *arena, - ssize_t decay_time); -ssize_t arena_muzzy_decay_time_get(arena_t *arena); -bool arena_muzzy_decay_time_set(tsdn_t *tsdn, arena_t *arena, - ssize_t decay_time); +ssize_t arena_dirty_decay_ms_get(arena_t *arena); +bool arena_dirty_decay_ms_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_ms); +ssize_t arena_muzzy_decay_ms_get(arena_t *arena); +bool arena_muzzy_decay_ms_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_ms); void arena_decay(tsdn_t *tsdn, arena_t *arena, bool all); void arena_reset(tsd_t *tsd, arena_t *arena); void arena_destroy(tsd_t *tsd, arena_t *arena); @@ -79,10 +77,10 @@ void *arena_ralloc(tsdn_t *tsdn, arena_t *arena, void *ptr, size_t oldsize, size_t size, size_t alignment, bool zero, tcache_t *tcache); dss_prec_t arena_dss_prec_get(arena_t *arena); bool arena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec); -ssize_t arena_dirty_decay_time_default_get(void); -bool arena_dirty_decay_time_default_set(ssize_t decay_time); -ssize_t arena_muzzy_decay_time_default_get(void); -bool arena_muzzy_decay_time_default_set(ssize_t decay_time); +ssize_t arena_dirty_decay_ms_default_get(void); +bool arena_dirty_decay_ms_default_set(ssize_t decay_ms); +ssize_t arena_muzzy_decay_ms_default_get(void); +bool arena_muzzy_decay_ms_default_set(ssize_t decay_ms); unsigned arena_nthreads_get(arena_t *arena, bool internal); void arena_nthreads_inc(arena_t *arena, bool internal); void arena_nthreads_dec(arena_t *arena, bool internal); diff --git a/include/jemalloc/internal/arena_structs_b.h b/include/jemalloc/internal/arena_structs_b.h index 99e5f6a0..459dd89d 100644 --- a/include/jemalloc/internal/arena_structs_b.h +++ b/include/jemalloc/internal/arena_structs_b.h @@ -56,11 +56,11 @@ struct arena_decay_s { */ bool purging; /* - * Approximate time in seconds from the creation of a set of unused + * Approximate time in milliseconds from the creation of a set of unused * dirty pages until an equivalent set of unused dirty pages is purged * and/or reused. */ - atomic_zd_t time; + atomic_zd_t time_ms; /* time / SMOOTHSTEP_NSTEPS. */ nstime_t interval; /* diff --git a/include/jemalloc/internal/arena_types.h b/include/jemalloc/internal/arena_types.h index e243aabf..34d4f6f2 100644 --- a/include/jemalloc/internal/arena_types.h +++ b/include/jemalloc/internal/arena_types.h @@ -7,9 +7,9 @@ #define LG_SLAB_MAXREGS (LG_PAGE - LG_TINY_MIN) #define SLAB_MAXREGS (1U << LG_SLAB_MAXREGS) -/* Default decay times in seconds. */ -#define DIRTY_DECAY_TIME_DEFAULT 10 -#define MUZZY_DECAY_TIME_DEFAULT 10 +/* Default decay times in milliseconds. */ +#define DIRTY_DECAY_MS_DEFAULT ZD(10 * 1000) +#define MUZZY_DECAY_MS_DEFAULT ZD(10 * 1000) /* Number of event ticks between time checks. */ #define DECAY_NTICKS_PER_UPDATE 1000 diff --git a/include/jemalloc/internal/ctl.h b/include/jemalloc/internal/ctl.h index 23c95510..60b3979f 100644 --- a/include/jemalloc/internal/ctl.h +++ b/include/jemalloc/internal/ctl.h @@ -64,8 +64,8 @@ struct ctl_arena_s { /* Basic stats, supported even if !config_stats. */ unsigned nthreads; const char *dss; - ssize_t dirty_decay_time; - ssize_t muzzy_decay_time; + ssize_t dirty_decay_ms; + ssize_t muzzy_decay_ms; size_t pactive; size_t pdirty; size_t pmuzzy; diff --git a/include/jemalloc/internal/jemalloc_internal_decls.h b/include/jemalloc/internal/jemalloc_internal_decls.h index d75de0b9..1efdb56b 100644 --- a/include/jemalloc/internal/jemalloc_internal_decls.h +++ b/include/jemalloc/internal/jemalloc_internal_decls.h @@ -41,6 +41,9 @@ #ifndef SIZE_T_MAX # define SIZE_T_MAX SIZE_MAX #endif +#ifndef SSIZE_MAX +# define SSIZE_MAX ((ssize_t)(SIZE_T_MAX >> 1)) +#endif #include #include #include diff --git a/src/arena.c b/src/arena.c index 03680e00..42bfc6b1 100644 --- a/src/arena.c +++ b/src/arena.c @@ -18,11 +18,11 @@ const char *percpu_arena_mode_names[] = { const char *opt_percpu_arena = OPT_PERCPU_ARENA_DEFAULT; percpu_arena_mode_t percpu_arena_mode = PERCPU_ARENA_MODE_DEFAULT; -ssize_t opt_dirty_decay_time = DIRTY_DECAY_TIME_DEFAULT; -ssize_t opt_muzzy_decay_time = MUZZY_DECAY_TIME_DEFAULT; +ssize_t opt_dirty_decay_ms = DIRTY_DECAY_MS_DEFAULT; +ssize_t opt_muzzy_decay_ms = MUZZY_DECAY_MS_DEFAULT; -static atomic_zd_t dirty_decay_time_default; -static atomic_zd_t muzzy_decay_time_default; +static atomic_zd_t dirty_decay_ms_default; +static atomic_zd_t muzzy_decay_ms_default; const arena_bin_info_t arena_bin_info[NBINS] = { #define BIN_INFO_bin_yes(reg_size, slab_size, nregs) \ @@ -196,13 +196,12 @@ arena_stats_mapped_add(tsdn_t *tsdn, arena_stats_t *arena_stats, size_t size) { void arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads, - const char **dss, ssize_t *dirty_decay_time, ssize_t *muzzy_decay_time, - size_t *nactive, size_t *ndirty, - size_t *nmuzzy) { + const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms, + size_t *nactive, size_t *ndirty, size_t *nmuzzy) { *nthreads += arena_nthreads_get(arena, false); *dss = dss_prec_names[arena_dss_prec_get(arena)]; - *dirty_decay_time = arena_dirty_decay_time_get(arena); - *muzzy_decay_time = arena_muzzy_decay_time_get(arena); + *dirty_decay_ms = arena_dirty_decay_ms_get(arena); + *muzzy_decay_ms = arena_muzzy_decay_ms_get(arena); *nactive += atomic_load_zu(&arena->nactive, ATOMIC_RELAXED); *ndirty += extents_npages_get(&arena->extents_dirty); *nmuzzy += extents_npages_get(&arena->extents_muzzy); @@ -210,13 +209,13 @@ arena_basic_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads, void arena_stats_merge(tsdn_t *tsdn, arena_t *arena, unsigned *nthreads, - const char **dss, ssize_t *dirty_decay_time, ssize_t *muzzy_decay_time, + const char **dss, ssize_t *dirty_decay_ms, ssize_t *muzzy_decay_ms, size_t *nactive, size_t *ndirty, size_t *nmuzzy, arena_stats_t *astats, malloc_bin_stats_t *bstats, malloc_large_stats_t *lstats) { cassert(config_stats); - arena_basic_stats_merge(tsdn, arena, nthreads, dss, dirty_decay_time, - muzzy_decay_time, nactive, ndirty, nmuzzy); + arena_basic_stats_merge(tsdn, arena, nthreads, dss, dirty_decay_ms, + muzzy_decay_ms, nactive, ndirty, nmuzzy); size_t base_allocated, base_resident, base_mapped; base_stats_get(tsdn, arena->base, &base_allocated, &base_resident, @@ -359,7 +358,7 @@ arena_extents_dirty_dalloc(tsdn_t *tsdn, arena_t *arena, extents_dalloc(tsdn, arena, r_extent_hooks, &arena->extents_dirty, extent); - if (arena_dirty_decay_time_get(arena) == 0) { + if (arena_dirty_decay_ms_get(arena) == 0) { arena_decay_dirty(tsdn, arena, true); } } @@ -574,13 +573,13 @@ arena_extent_ralloc_large_expand(tsdn_t *tsdn, arena_t *arena, extent_t *extent, } static ssize_t -arena_decay_time_read(arena_decay_t *decay) { - return atomic_load_zd(&decay->time, ATOMIC_RELAXED); +arena_decay_ms_read(arena_decay_t *decay) { + return atomic_load_zd(&decay->time_ms, ATOMIC_RELAXED); } static void -arena_decay_time_write(arena_decay_t *decay, ssize_t decay_time) { - atomic_store_zd(&decay->time, decay_time, ATOMIC_RELAXED); +arena_decay_ms_write(arena_decay_t *decay, ssize_t decay_ms) { + atomic_store_zd(&decay->time_ms, decay_ms, ATOMIC_RELAXED); } static void @@ -591,7 +590,7 @@ arena_decay_deadline_init(arena_decay_t *decay) { */ nstime_copy(&decay->deadline, &decay->epoch); nstime_add(&decay->deadline, &decay->interval); - if (arena_decay_time_read(decay) > 0) { + if (arena_decay_ms_read(decay) > 0) { nstime_t jitter; nstime_init(&jitter, prng_range_u64(&decay->jitter_state, @@ -711,11 +710,11 @@ arena_decay_epoch_advance(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, } static void -arena_decay_reinit(arena_decay_t *decay, extents_t *extents, - ssize_t decay_time) { - arena_decay_time_write(decay, decay_time); - if (decay_time > 0) { - nstime_init2(&decay->interval, decay_time, 0); +arena_decay_reinit(arena_decay_t *decay, extents_t *extents, ssize_t decay_ms) { + arena_decay_ms_write(decay, decay_ms); + if (decay_ms > 0) { + nstime_init(&decay->interval, (uint64_t)decay_ms * + KQU(1000000)); nstime_idivide(&decay->interval, SMOOTHSTEP_NSTEPS); } @@ -728,7 +727,7 @@ arena_decay_reinit(arena_decay_t *decay, extents_t *extents, } static bool -arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_time, +arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_ms, decay_stats_t *stats) { if (config_debug) { for (size_t i = 0; i < sizeof(arena_decay_t); i++) { @@ -739,7 +738,7 @@ arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_time, return true; } decay->purging = false; - arena_decay_reinit(decay, extents, decay_time); + arena_decay_reinit(decay, extents, decay_ms); /* Memory is zeroed, so there is no need to clear stats. */ if (config_stats) { decay->stats = stats; @@ -748,11 +747,12 @@ arena_decay_init(arena_decay_t *decay, extents_t *extents, ssize_t decay_time, } static bool -arena_decay_time_valid(ssize_t decay_time) { - if (decay_time < -1) { +arena_decay_ms_valid(ssize_t decay_ms) { + if (decay_ms < -1) { return false; } - if (decay_time == -1 || (uint64_t)decay_time <= NSTIME_SEC_MAX) { + if (decay_ms == -1 || (uint64_t)decay_ms <= NSTIME_SEC_MAX * + KQU(1000)) { return true; } return false; @@ -764,9 +764,9 @@ arena_maybe_decay(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, malloc_mutex_assert_owner(tsdn, &decay->mtx); /* Purge all or nothing if the option is disabled. */ - ssize_t decay_time = arena_decay_time_read(decay); - if (decay_time <= 0) { - if (decay_time == 0) { + ssize_t decay_ms = arena_decay_ms_read(decay); + if (decay_ms <= 0) { + if (decay_ms == 0) { arena_decay_to_limit(tsdn, arena, decay, extents, false, 0); } @@ -806,24 +806,24 @@ arena_maybe_decay(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, } static ssize_t -arena_decay_time_get(arena_decay_t *decay) { - return arena_decay_time_read(decay); +arena_decay_ms_get(arena_decay_t *decay) { + return arena_decay_ms_read(decay); } ssize_t -arena_dirty_decay_time_get(arena_t *arena) { - return arena_decay_time_get(&arena->decay_dirty); +arena_dirty_decay_ms_get(arena_t *arena) { + return arena_decay_ms_get(&arena->decay_dirty); } ssize_t -arena_muzzy_decay_time_get(arena_t *arena) { - return arena_decay_time_get(&arena->decay_muzzy); +arena_muzzy_decay_ms_get(arena_t *arena) { + return arena_decay_ms_get(&arena->decay_muzzy); } static bool -arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, - extents_t *extents, ssize_t decay_time) { - if (!arena_decay_time_valid(decay_time)) { +arena_decay_ms_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, + extents_t *extents, ssize_t decay_ms) { + if (!arena_decay_ms_valid(decay_ms)) { return true; } @@ -832,11 +832,11 @@ arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, * Restart decay backlog from scratch, which may cause many dirty pages * to be immediately purged. It would conceptually be possible to map * the old backlog onto the new backlog, but there is no justification - * for such complexity since decay_time changes are intended to be + * for such complexity since decay_ms changes are intended to be * infrequent, either between the {-1, 0, >0} states, or a one-time * arbitrary change during initial arena configuration. */ - arena_decay_reinit(decay, extents, decay_time); + arena_decay_reinit(decay, extents, decay_ms); arena_maybe_decay(tsdn, arena, decay, extents); malloc_mutex_unlock(tsdn, &decay->mtx); @@ -844,15 +844,17 @@ arena_decay_time_set(tsdn_t *tsdn, arena_t *arena, arena_decay_t *decay, } bool -arena_dirty_decay_time_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_time) { - return arena_decay_time_set(tsdn, arena, &arena->decay_dirty, - &arena->extents_dirty, decay_time); +arena_dirty_decay_ms_set(tsdn_t *tsdn, arena_t *arena, + ssize_t decay_ms) { + return arena_decay_ms_set(tsdn, arena, &arena->decay_dirty, + &arena->extents_dirty, decay_ms); } bool -arena_muzzy_decay_time_set(tsdn_t *tsdn, arena_t *arena, ssize_t decay_time) { - return arena_decay_time_set(tsdn, arena, &arena->decay_muzzy, - &arena->extents_muzzy, decay_time); +arena_muzzy_decay_ms_set(tsdn_t *tsdn, arena_t *arena, + ssize_t decay_ms) { + return arena_decay_ms_set(tsdn, arena, &arena->decay_muzzy, + &arena->extents_muzzy, decay_ms); } static size_t @@ -885,7 +887,7 @@ arena_decay_stashed(tsdn_t *tsdn, arena_t *arena, } npurged = 0; - ssize_t muzzy_decay_time = arena_muzzy_decay_time_get(arena); + ssize_t muzzy_decay_ms = arena_muzzy_decay_ms_get(arena); for (extent_t *extent = extent_list_first(decay_extents); extent != NULL; extent = extent_list_first(decay_extents)) { if (config_stats) { @@ -898,7 +900,7 @@ arena_decay_stashed(tsdn_t *tsdn, arena_t *arena, case extent_state_active: not_reached(); case extent_state_dirty: - if (!all && muzzy_decay_time != 0 && + if (!all && muzzy_decay_ms != 0 && !extent_purge_lazy_wrapper(tsdn, arena, r_extent_hooks, extent, 0, extent_size_get(extent))) { @@ -1789,30 +1791,30 @@ arena_dss_prec_set(arena_t *arena, dss_prec_t dss_prec) { } ssize_t -arena_dirty_decay_time_default_get(void) { - return atomic_load_zd(&dirty_decay_time_default, ATOMIC_RELAXED); +arena_dirty_decay_ms_default_get(void) { + return atomic_load_zd(&dirty_decay_ms_default, ATOMIC_RELAXED); } bool -arena_dirty_decay_time_default_set(ssize_t decay_time) { - if (!arena_decay_time_valid(decay_time)) { +arena_dirty_decay_ms_default_set(ssize_t decay_ms) { + if (!arena_decay_ms_valid(decay_ms)) { return true; } - atomic_store_zd(&dirty_decay_time_default, decay_time, ATOMIC_RELAXED); + atomic_store_zd(&dirty_decay_ms_default, decay_ms, ATOMIC_RELAXED); return false; } ssize_t -arena_muzzy_decay_time_default_get(void) { - return atomic_load_zd(&muzzy_decay_time_default, ATOMIC_RELAXED); +arena_muzzy_decay_ms_default_get(void) { + return atomic_load_zd(&muzzy_decay_ms_default, ATOMIC_RELAXED); } bool -arena_muzzy_decay_time_default_set(ssize_t decay_time) { - if (!arena_decay_time_valid(decay_time)) { +arena_muzzy_decay_ms_default_set(ssize_t decay_ms) { + if (!arena_decay_ms_valid(decay_ms)) { return true; } - atomic_store_zd(&muzzy_decay_time_default, decay_time, ATOMIC_RELAXED); + atomic_store_zd(&muzzy_decay_ms_default, decay_ms, ATOMIC_RELAXED); return false; } @@ -1933,11 +1935,11 @@ arena_new(tsdn_t *tsdn, unsigned ind, extent_hooks_t *extent_hooks) { } if (arena_decay_init(&arena->decay_dirty, &arena->extents_dirty, - arena_dirty_decay_time_default_get(), &arena->stats.decay_dirty)) { + arena_dirty_decay_ms_default_get(), &arena->stats.decay_dirty)) { goto label_error; } if (arena_decay_init(&arena->decay_muzzy, &arena->extents_muzzy, - arena_muzzy_decay_time_default_get(), &arena->stats.decay_muzzy)) { + arena_muzzy_decay_ms_default_get(), &arena->stats.decay_muzzy)) { goto label_error; } @@ -1993,8 +1995,8 @@ label_error: void arena_boot(void) { - arena_dirty_decay_time_default_set(opt_dirty_decay_time); - arena_muzzy_decay_time_default_set(opt_muzzy_decay_time); + arena_dirty_decay_ms_default_set(opt_dirty_decay_ms); + arena_muzzy_decay_ms_default_set(opt_muzzy_decay_ms); } void diff --git a/src/ctl.c b/src/ctl.c index 79f2447f..296e74f2 100644 --- a/src/ctl.c +++ b/src/ctl.c @@ -78,8 +78,8 @@ CTL_PROTO(opt_retain) CTL_PROTO(opt_dss) CTL_PROTO(opt_narenas) CTL_PROTO(opt_percpu_arena) -CTL_PROTO(opt_dirty_decay_time) -CTL_PROTO(opt_muzzy_decay_time) +CTL_PROTO(opt_dirty_decay_ms) +CTL_PROTO(opt_muzzy_decay_ms) CTL_PROTO(opt_stats_print) CTL_PROTO(opt_junk) CTL_PROTO(opt_zero) @@ -106,8 +106,8 @@ CTL_PROTO(arena_i_purge) CTL_PROTO(arena_i_reset) CTL_PROTO(arena_i_destroy) CTL_PROTO(arena_i_dss) -CTL_PROTO(arena_i_dirty_decay_time) -CTL_PROTO(arena_i_muzzy_decay_time) +CTL_PROTO(arena_i_dirty_decay_ms) +CTL_PROTO(arena_i_muzzy_decay_ms) CTL_PROTO(arena_i_extent_hooks) INDEX_PROTO(arena_i) CTL_PROTO(arenas_bin_i_size) @@ -117,8 +117,8 @@ INDEX_PROTO(arenas_bin_i) CTL_PROTO(arenas_lextent_i_size) INDEX_PROTO(arenas_lextent_i) CTL_PROTO(arenas_narenas) -CTL_PROTO(arenas_dirty_decay_time) -CTL_PROTO(arenas_muzzy_decay_time) +CTL_PROTO(arenas_dirty_decay_ms) +CTL_PROTO(arenas_muzzy_decay_ms) CTL_PROTO(arenas_quantum) CTL_PROTO(arenas_page) CTL_PROTO(arenas_tcache_max) @@ -159,8 +159,8 @@ INDEX_PROTO(stats_arenas_i_lextents_j) CTL_PROTO(stats_arenas_i_nthreads) CTL_PROTO(stats_arenas_i_uptime) CTL_PROTO(stats_arenas_i_dss) -CTL_PROTO(stats_arenas_i_dirty_decay_time) -CTL_PROTO(stats_arenas_i_muzzy_decay_time) +CTL_PROTO(stats_arenas_i_dirty_decay_ms) +CTL_PROTO(stats_arenas_i_muzzy_decay_ms) CTL_PROTO(stats_arenas_i_pactive) CTL_PROTO(stats_arenas_i_pdirty) CTL_PROTO(stats_arenas_i_pmuzzy) @@ -265,8 +265,8 @@ static const ctl_named_node_t opt_node[] = { {NAME("dss"), CTL(opt_dss)}, {NAME("narenas"), CTL(opt_narenas)}, {NAME("percpu_arena"), CTL(opt_percpu_arena)}, - {NAME("dirty_decay_time"), CTL(opt_dirty_decay_time)}, - {NAME("muzzy_decay_time"), CTL(opt_muzzy_decay_time)}, + {NAME("dirty_decay_ms"), CTL(opt_dirty_decay_ms)}, + {NAME("muzzy_decay_ms"), CTL(opt_muzzy_decay_ms)}, {NAME("stats_print"), CTL(opt_stats_print)}, {NAME("junk"), CTL(opt_junk)}, {NAME("zero"), CTL(opt_zero)}, @@ -299,8 +299,8 @@ static const ctl_named_node_t arena_i_node[] = { {NAME("reset"), CTL(arena_i_reset)}, {NAME("destroy"), CTL(arena_i_destroy)}, {NAME("dss"), CTL(arena_i_dss)}, - {NAME("dirty_decay_time"), CTL(arena_i_dirty_decay_time)}, - {NAME("muzzy_decay_time"), CTL(arena_i_muzzy_decay_time)}, + {NAME("dirty_decay_ms"), CTL(arena_i_dirty_decay_ms)}, + {NAME("muzzy_decay_ms"), CTL(arena_i_muzzy_decay_ms)}, {NAME("extent_hooks"), CTL(arena_i_extent_hooks)} }; static const ctl_named_node_t super_arena_i_node[] = { @@ -337,8 +337,8 @@ static const ctl_indexed_node_t arenas_lextent_node[] = { static const ctl_named_node_t arenas_node[] = { {NAME("narenas"), CTL(arenas_narenas)}, - {NAME("dirty_decay_time"), CTL(arenas_dirty_decay_time)}, - {NAME("muzzy_decay_time"), CTL(arenas_muzzy_decay_time)}, + {NAME("dirty_decay_ms"), CTL(arenas_dirty_decay_ms)}, + {NAME("muzzy_decay_ms"), CTL(arenas_muzzy_decay_ms)}, {NAME("quantum"), CTL(arenas_quantum)}, {NAME("page"), CTL(arenas_page)}, {NAME("tcache_max"), CTL(arenas_tcache_max)}, @@ -444,8 +444,8 @@ static const ctl_named_node_t stats_arenas_i_node[] = { {NAME("nthreads"), CTL(stats_arenas_i_nthreads)}, {NAME("uptime"), CTL(stats_arenas_i_uptime)}, {NAME("dss"), CTL(stats_arenas_i_dss)}, - {NAME("dirty_decay_time"), CTL(stats_arenas_i_dirty_decay_time)}, - {NAME("muzzy_decay_time"), CTL(stats_arenas_i_muzzy_decay_time)}, + {NAME("dirty_decay_ms"), CTL(stats_arenas_i_dirty_decay_ms)}, + {NAME("muzzy_decay_ms"), CTL(stats_arenas_i_muzzy_decay_ms)}, {NAME("pactive"), CTL(stats_arenas_i_pactive)}, {NAME("pdirty"), CTL(stats_arenas_i_pdirty)}, {NAME("pmuzzy"), CTL(stats_arenas_i_pmuzzy)}, @@ -644,8 +644,8 @@ static void ctl_arena_clear(ctl_arena_t *ctl_arena) { ctl_arena->nthreads = 0; ctl_arena->dss = dss_prec_names[dss_prec_limit]; - ctl_arena->dirty_decay_time = -1; - ctl_arena->muzzy_decay_time = -1; + ctl_arena->dirty_decay_ms = -1; + ctl_arena->muzzy_decay_ms = -1; ctl_arena->pactive = 0; ctl_arena->pdirty = 0; ctl_arena->pmuzzy = 0; @@ -668,8 +668,8 @@ ctl_arena_stats_amerge(tsdn_t *tsdn, ctl_arena_t *ctl_arena, arena_t *arena) { if (config_stats) { arena_stats_merge(tsdn, arena, &ctl_arena->nthreads, - &ctl_arena->dss, &ctl_arena->dirty_decay_time, - &ctl_arena->muzzy_decay_time, &ctl_arena->pactive, + &ctl_arena->dss, &ctl_arena->dirty_decay_ms, + &ctl_arena->muzzy_decay_ms, &ctl_arena->pactive, &ctl_arena->pdirty, &ctl_arena->pmuzzy, &ctl_arena->astats->astats, ctl_arena->astats->bstats, ctl_arena->astats->lstats); @@ -687,8 +687,8 @@ ctl_arena_stats_amerge(tsdn_t *tsdn, ctl_arena_t *ctl_arena, arena_t *arena) { } } else { arena_basic_stats_merge(tsdn, arena, &ctl_arena->nthreads, - &ctl_arena->dss, &ctl_arena->dirty_decay_time, - &ctl_arena->muzzy_decay_time, &ctl_arena->pactive, + &ctl_arena->dss, &ctl_arena->dirty_decay_ms, + &ctl_arena->muzzy_decay_ms, &ctl_arena->pactive, &ctl_arena->pdirty, &ctl_arena->pmuzzy); } } @@ -1465,8 +1465,8 @@ CTL_RO_NL_GEN(opt_retain, opt_retain, bool) CTL_RO_NL_GEN(opt_dss, opt_dss, const char *) CTL_RO_NL_GEN(opt_narenas, opt_narenas, unsigned) CTL_RO_NL_GEN(opt_percpu_arena, opt_percpu_arena, const char *) -CTL_RO_NL_GEN(opt_dirty_decay_time, opt_dirty_decay_time, ssize_t) -CTL_RO_NL_GEN(opt_muzzy_decay_time, opt_muzzy_decay_time, ssize_t) +CTL_RO_NL_GEN(opt_dirty_decay_ms, opt_dirty_decay_ms, ssize_t) +CTL_RO_NL_GEN(opt_muzzy_decay_ms, opt_muzzy_decay_ms, ssize_t) CTL_RO_NL_GEN(opt_stats_print, opt_stats_print, bool) CTL_RO_NL_CGEN(config_fill, opt_junk, opt_junk, const char *) CTL_RO_NL_CGEN(config_fill, opt_zero, opt_zero, bool) @@ -1955,7 +1955,7 @@ label_return: } static int -arena_i_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, +arena_i_decay_ms_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen, bool dirty) { int ret; unsigned arena_ind; @@ -1969,8 +1969,8 @@ arena_i_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, } if (oldp != NULL && oldlenp != NULL) { - size_t oldval = dirty ? arena_dirty_decay_time_get(arena) : - arena_muzzy_decay_time_get(arena); + size_t oldval = dirty ? arena_dirty_decay_ms_get(arena) : + arena_muzzy_decay_ms_get(arena); READ(oldval, ssize_t); } if (newp != NULL) { @@ -1978,10 +1978,9 @@ arena_i_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, ret = EINVAL; goto label_return; } - if (dirty ? arena_dirty_decay_time_set(tsd_tsdn(tsd), arena, - *(ssize_t *)newp) : - arena_muzzy_decay_time_set(tsd_tsdn(tsd), arena, - *(ssize_t *)newp)) { + if (dirty ? arena_dirty_decay_ms_set(tsd_tsdn(tsd), arena, + *(ssize_t *)newp) : arena_muzzy_decay_ms_set(tsd_tsdn(tsd), + arena, *(ssize_t *)newp)) { ret = EFAULT; goto label_return; } @@ -1993,17 +1992,17 @@ label_return: } static int -arena_i_dirty_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, +arena_i_dirty_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { - return arena_i_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp, - newp, newlen, true); + return arena_i_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp, + newlen, true); } static int -arena_i_muzzy_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, +arena_i_muzzy_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { - return arena_i_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp, - newp, newlen, false); + return arena_i_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp, + newlen, false); } static int @@ -2087,13 +2086,13 @@ label_return: } static int -arenas_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, +arenas_decay_ms_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen, bool dirty) { int ret; if (oldp != NULL && oldlenp != NULL) { - size_t oldval = (dirty ? arena_dirty_decay_time_default_get() : - arena_muzzy_decay_time_default_get()); + size_t oldval = (dirty ? arena_dirty_decay_ms_default_get() : + arena_muzzy_decay_ms_default_get()); READ(oldval, ssize_t); } if (newp != NULL) { @@ -2101,8 +2100,8 @@ arenas_decay_time_ctl_impl(tsd_t *tsd, const size_t *mib, size_t miblen, ret = EINVAL; goto label_return; } - if (dirty ? arena_dirty_decay_time_default_set(*(ssize_t *)newp) - : arena_muzzy_decay_time_default_set(*(ssize_t *)newp)) { + if (dirty ? arena_dirty_decay_ms_default_set(*(ssize_t *)newp) + : arena_muzzy_decay_ms_default_set(*(ssize_t *)newp)) { ret = EFAULT; goto label_return; } @@ -2114,16 +2113,16 @@ label_return: } static int -arenas_dirty_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, +arenas_dirty_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { - return arenas_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp, + return arenas_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp, newlen, true); } static int -arenas_muzzy_decay_time_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, +arenas_muzzy_decay_ms_ctl(tsd_t *tsd, const size_t *mib, size_t miblen, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { - return arenas_decay_time_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp, + return arenas_decay_ms_ctl_impl(tsd, mib, miblen, oldp, oldlenp, newp, newlen, false); } @@ -2318,9 +2317,9 @@ CTL_RO_CGEN(config_stats, stats_mapped, ctl_stats->mapped, size_t) CTL_RO_CGEN(config_stats, stats_retained, ctl_stats->retained, size_t) CTL_RO_GEN(stats_arenas_i_dss, arenas_i(mib[2])->dss, const char *) -CTL_RO_GEN(stats_arenas_i_dirty_decay_time, arenas_i(mib[2])->dirty_decay_time, +CTL_RO_GEN(stats_arenas_i_dirty_decay_ms, arenas_i(mib[2])->dirty_decay_ms, ssize_t) -CTL_RO_GEN(stats_arenas_i_muzzy_decay_time, arenas_i(mib[2])->muzzy_decay_time, +CTL_RO_GEN(stats_arenas_i_muzzy_decay_ms, arenas_i(mib[2])->muzzy_decay_ms, ssize_t) CTL_RO_GEN(stats_arenas_i_nthreads, arenas_i(mib[2])->nthreads, unsigned) CTL_RO_GEN(stats_arenas_i_uptime, diff --git a/src/jemalloc.c b/src/jemalloc.c index 13218449..47133edf 100644 --- a/src/jemalloc.c +++ b/src/jemalloc.c @@ -1070,10 +1070,14 @@ malloc_conf_init(void) { } CONF_HANDLE_UNSIGNED(opt_narenas, "narenas", 1, UINT_MAX, yes, no, false) - CONF_HANDLE_SSIZE_T(opt_dirty_decay_time, - "dirty_decay_time", -1, NSTIME_SEC_MAX); - CONF_HANDLE_SSIZE_T(opt_muzzy_decay_time, - "muzzy_decay_time", -1, NSTIME_SEC_MAX); + CONF_HANDLE_SSIZE_T(opt_dirty_decay_ms, + "dirty_decay_ms", -1, NSTIME_SEC_MAX * KQU(1000) < + QU(SSIZE_MAX) ? NSTIME_SEC_MAX * KQU(1000) : + SSIZE_MAX); + CONF_HANDLE_SSIZE_T(opt_muzzy_decay_ms, + "muzzy_decay_ms", -1, NSTIME_SEC_MAX * KQU(1000) < + QU(SSIZE_MAX) ? NSTIME_SEC_MAX * KQU(1000) : + SSIZE_MAX); CONF_HANDLE_BOOL(opt_stats_print, "stats_print") if (config_fill) { if (CONF_MATCH("junk")) { diff --git a/src/stats.c b/src/stats.c index 883c7d14..3c9eb35a 100644 --- a/src/stats.c +++ b/src/stats.c @@ -411,7 +411,7 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, bool json, unsigned i, bool bins, bool large, bool mutex) { unsigned nthreads; const char *dss; - ssize_t dirty_decay_time, muzzy_decay_time; + ssize_t dirty_decay_ms, muzzy_decay_ms; size_t page, pactive, pdirty, pmuzzy, mapped, retained; size_t base, internal, resident; uint64_t dirty_npurge, dirty_nmadvise, dirty_purged; @@ -452,9 +452,9 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, "dss allocation precedence: %s\n", dss); } - CTL_M2_GET("stats.arenas.0.dirty_decay_time", i, &dirty_decay_time, + CTL_M2_GET("stats.arenas.0.dirty_decay_ms", i, &dirty_decay_ms, ssize_t); - CTL_M2_GET("stats.arenas.0.muzzy_decay_time", i, &muzzy_decay_time, + CTL_M2_GET("stats.arenas.0.muzzy_decay_ms", i, &muzzy_decay_ms, ssize_t); CTL_M2_GET("stats.arenas.0.pactive", i, &pactive, size_t); CTL_M2_GET("stats.arenas.0.pdirty", i, &pdirty, size_t); @@ -469,9 +469,9 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, CTL_M2_GET("stats.arenas.0.muzzy_purged", i, &muzzy_purged, uint64_t); if (json) { malloc_cprintf(write_cb, cbopaque, - "\t\t\t\t\"dirty_decay_time\": %zd,\n", dirty_decay_time); + "\t\t\t\t\"dirty_decay_ms\": %zd,\n", dirty_decay_ms); malloc_cprintf(write_cb, cbopaque, - "\t\t\t\t\"muzzy_decay_time\": %zd,\n", muzzy_decay_time); + "\t\t\t\t\"muzzy_decay_ms\": %zd,\n", muzzy_decay_ms); malloc_cprintf(write_cb, cbopaque, "\t\t\t\t\"pactive\": %zu,\n", pactive); malloc_cprintf(write_cb, cbopaque, @@ -494,10 +494,10 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, malloc_cprintf(write_cb, cbopaque, "decaying: time npages sweeps madvises" " purged\n"); - if (dirty_decay_time >= 0) { + if (dirty_decay_ms >= 0) { malloc_cprintf(write_cb, cbopaque, " dirty: %5zd %12zu %12"FMTu64" %12"FMTu64" %12" - FMTu64"\n", dirty_decay_time, pdirty, dirty_npurge, + FMTu64"\n", dirty_decay_ms, pdirty, dirty_npurge, dirty_nmadvise, dirty_purged); } else { malloc_cprintf(write_cb, cbopaque, @@ -505,10 +505,10 @@ stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, FMTu64"\n", pdirty, dirty_npurge, dirty_nmadvise, dirty_purged); } - if (muzzy_decay_time >= 0) { + if (muzzy_decay_ms >= 0) { malloc_cprintf(write_cb, cbopaque, " muzzy: %5zd %12zu %12"FMTu64" %12"FMTu64" %12" - FMTu64"\n", muzzy_decay_time, pmuzzy, muzzy_npurge, + FMTu64"\n", muzzy_decay_ms, pmuzzy, muzzy_npurge, muzzy_nmadvise, muzzy_purged); } else { malloc_cprintf(write_cb, cbopaque, @@ -816,10 +816,8 @@ stats_general_print(void (*write_cb)(void *, const char *), void *cbopaque, OPT_WRITE_CHAR_P(dss, ",") OPT_WRITE_UNSIGNED(narenas, ",") OPT_WRITE_CHAR_P(percpu_arena, ",") - OPT_WRITE_SSIZE_T_MUTABLE(dirty_decay_time, arenas.dirty_decay_time, - ",") - OPT_WRITE_SSIZE_T_MUTABLE(muzzy_decay_time, arenas.muzzy_decay_time, - ",") + OPT_WRITE_SSIZE_T_MUTABLE(dirty_decay_ms, arenas.dirty_decay_ms, ",") + OPT_WRITE_SSIZE_T_MUTABLE(muzzy_decay_ms, arenas.muzzy_decay_ms, ",") OPT_WRITE_CHAR_P(junk, ",") OPT_WRITE_BOOL(zero, ",") OPT_WRITE_BOOL(utrace, ",") @@ -867,24 +865,14 @@ stats_general_print(void (*write_cb)(void *, const char *), void *cbopaque, malloc_cprintf(write_cb, cbopaque, "Arenas: %u\n", uv); } - CTL_GET("arenas.dirty_decay_time", &ssv, ssize_t); if (json) { + CTL_GET("arenas.dirty_decay_ms", &ssv, ssize_t); malloc_cprintf(write_cb, cbopaque, - "\t\t\t\"dirty_decay_time\": %zd,\n", ssv); - } else { - malloc_cprintf(write_cb, cbopaque, - "Unused dirty page decay time: %zd%s\n", ssv, (ssv < 0) ? - " (no decay)" : ""); - } + "\t\t\t\"dirty_decay_ms\": %zd,\n", ssv); - CTL_GET("arenas.muzzy_decay_time", &ssv, ssize_t); - if (json) { + CTL_GET("arenas.muzzy_decay_ms", &ssv, ssize_t); malloc_cprintf(write_cb, cbopaque, - "\t\t\t\"muzzy_decay_time\": %zd,\n", ssv); - } else { - malloc_cprintf(write_cb, cbopaque, - "Unused muzzy page decay time: %zd%s\n", ssv, (ssv < 0) ? - " (no decay)" : ""); + "\t\t\t\"muzzy_decay_ms\": %zd,\n", ssv); } CTL_GET("arenas.quantum", &sv, size_t); diff --git a/test/unit/decay.c b/test/unit/decay.c index 389f6e06..19f76fa5 100644 --- a/test/unit/decay.c +++ b/test/unit/decay.c @@ -24,7 +24,7 @@ nstime_update_mock(nstime_t *time) { } static unsigned -do_arena_create(ssize_t dirty_decay_time, ssize_t muzzy_decay_time) { +do_arena_create(ssize_t dirty_decay_ms, ssize_t muzzy_decay_ms) { unsigned arena_ind; size_t sz = sizeof(unsigned); assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0), @@ -32,19 +32,19 @@ do_arena_create(ssize_t dirty_decay_time, ssize_t muzzy_decay_time) { size_t mib[3]; size_t miblen = sizeof(mib)/sizeof(size_t); - assert_d_eq(mallctlnametomib("arena.0.dirty_decay_time", mib, &miblen), + assert_d_eq(mallctlnametomib("arena.0.dirty_decay_ms", mib, &miblen), 0, "Unexpected mallctlnametomib() failure"); mib[1] = (size_t)arena_ind; assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL, - (void *)&dirty_decay_time, - sizeof(dirty_decay_time)), 0, "Unexpected mallctlbymib() failure"); + (void *)&dirty_decay_ms, sizeof(dirty_decay_ms)), 0, + "Unexpected mallctlbymib() failure"); - assert_d_eq(mallctlnametomib("arena.0.muzzy_decay_time", mib, &miblen), + assert_d_eq(mallctlnametomib("arena.0.muzzy_decay_ms", mib, &miblen), 0, "Unexpected mallctlnametomib() failure"); mib[1] = (size_t)arena_ind; assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL, - (void *)&muzzy_decay_time, - sizeof(muzzy_decay_time)), 0, "Unexpected mallctlbymib() failure"); + (void *)&muzzy_decay_ms, sizeof(muzzy_decay_ms)), 0, + "Unexpected mallctlbymib() failure"); return arena_ind; } @@ -362,14 +362,14 @@ static void decay_ticker_helper(unsigned arena_ind, int flags, bool dirty, ssize_t dt, uint64_t dirty_npurge0, uint64_t muzzy_npurge0, bool terminate_asap) { #define NINTERVALS 101 - nstime_t time, update_interval, decay_time, deadline; + nstime_t time, update_interval, decay_ms, deadline; nstime_init(&time, 0); nstime_update(&time); - nstime_init2(&decay_time, dt, 0); + nstime_init2(&decay_ms, dt, 0); nstime_copy(&deadline, &time); - nstime_add(&deadline, &decay_time); + nstime_add(&deadline, &decay_ms); nstime_init2(&update_interval, dt, 0); nstime_idivide(&update_interval, NINTERVALS); @@ -406,8 +406,8 @@ decay_ticker_helper(unsigned arena_ind, int flags, bool dirty, ssize_t dt, TEST_BEGIN(test_decay_ticker) { #define NPS 2048 - ssize_t ddt = opt_dirty_decay_time; - ssize_t mdt = opt_muzzy_decay_time; + ssize_t ddt = opt_dirty_decay_ms; + ssize_t mdt = opt_muzzy_decay_ms; unsigned arena_ind = do_arena_create(ddt, mdt); int flags = (MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE); void *ps[NPS]; diff --git a/test/unit/decay.sh b/test/unit/decay.sh index a41489b0..45aeccf4 100644 --- a/test/unit/decay.sh +++ b/test/unit/decay.sh @@ -1,3 +1,3 @@ #!/bin/sh -export MALLOC_CONF="dirty_decay_time:1,muzzy_decay_time:1,lg_tcache_max:0" +export MALLOC_CONF="dirty_decay_ms:1000,muzzy_decay_ms:1000,lg_tcache_max:0" diff --git a/test/unit/mallctl.c b/test/unit/mallctl.c index b07a6d04..f721c21d 100644 --- a/test/unit/mallctl.c +++ b/test/unit/mallctl.c @@ -161,8 +161,8 @@ TEST_BEGIN(test_mallctl_opt) { TEST_MALLCTL_OPT(const char *, dss, always); TEST_MALLCTL_OPT(unsigned, narenas, always); TEST_MALLCTL_OPT(const char *, percpu_arena, always); - TEST_MALLCTL_OPT(ssize_t, dirty_decay_time, always); - TEST_MALLCTL_OPT(ssize_t, muzzy_decay_time, always); + TEST_MALLCTL_OPT(ssize_t, dirty_decay_ms, always); + TEST_MALLCTL_OPT(ssize_t, muzzy_decay_ms, always); TEST_MALLCTL_OPT(bool, stats_print, always); TEST_MALLCTL_OPT(const char *, junk, fill); TEST_MALLCTL_OPT(bool, zero, fill); @@ -398,68 +398,66 @@ TEST_BEGIN(test_arena_i_initialized) { } TEST_END -TEST_BEGIN(test_arena_i_dirty_decay_time) { - ssize_t dirty_decay_time, orig_dirty_decay_time, prev_dirty_decay_time; +TEST_BEGIN(test_arena_i_dirty_decay_ms) { + ssize_t dirty_decay_ms, orig_dirty_decay_ms, prev_dirty_decay_ms; size_t sz = sizeof(ssize_t); - assert_d_eq(mallctl("arena.0.dirty_decay_time", - (void *)&orig_dirty_decay_time, &sz, NULL, 0), 0, + assert_d_eq(mallctl("arena.0.dirty_decay_ms", + (void *)&orig_dirty_decay_ms, &sz, NULL, 0), 0, "Unexpected mallctl() failure"); - dirty_decay_time = -2; - assert_d_eq(mallctl("arena.0.dirty_decay_time", NULL, NULL, - (void *)&dirty_decay_time, sizeof(ssize_t)), EFAULT, + dirty_decay_ms = -2; + assert_d_eq(mallctl("arena.0.dirty_decay_ms", NULL, NULL, + (void *)&dirty_decay_ms, sizeof(ssize_t)), EFAULT, "Unexpected mallctl() success"); - dirty_decay_time = 0x7fffffff; - assert_d_eq(mallctl("arena.0.dirty_decay_time", NULL, NULL, - (void *)&dirty_decay_time, sizeof(ssize_t)), 0, + dirty_decay_ms = 0x7fffffff; + assert_d_eq(mallctl("arena.0.dirty_decay_ms", NULL, NULL, + (void *)&dirty_decay_ms, sizeof(ssize_t)), 0, "Unexpected mallctl() failure"); - for (prev_dirty_decay_time = dirty_decay_time, dirty_decay_time = -1; - dirty_decay_time < 20; prev_dirty_decay_time = dirty_decay_time, - dirty_decay_time++) { - ssize_t old_dirty_decay_time; + for (prev_dirty_decay_ms = dirty_decay_ms, dirty_decay_ms = -1; + dirty_decay_ms < 20; prev_dirty_decay_ms = dirty_decay_ms, + dirty_decay_ms++) { + ssize_t old_dirty_decay_ms; - assert_d_eq(mallctl("arena.0.dirty_decay_time", - (void *)&old_dirty_decay_time, &sz, - (void *)&dirty_decay_time, sizeof(ssize_t)), 0, - "Unexpected mallctl() failure"); - assert_zd_eq(old_dirty_decay_time, prev_dirty_decay_time, - "Unexpected old arena.0.dirty_decay_time"); + assert_d_eq(mallctl("arena.0.dirty_decay_ms", + (void *)&old_dirty_decay_ms, &sz, (void *)&dirty_decay_ms, + sizeof(ssize_t)), 0, "Unexpected mallctl() failure"); + assert_zd_eq(old_dirty_decay_ms, prev_dirty_decay_ms, + "Unexpected old arena.0.dirty_decay_ms"); } } TEST_END -TEST_BEGIN(test_arena_i_muzzy_decay_time) { - ssize_t muzzy_decay_time, orig_muzzy_decay_time, prev_muzzy_decay_time; +TEST_BEGIN(test_arena_i_muzzy_decay_ms) { + ssize_t muzzy_decay_ms, orig_muzzy_decay_ms, prev_muzzy_decay_ms; size_t sz = sizeof(ssize_t); - assert_d_eq(mallctl("arena.0.muzzy_decay_time", - (void *)&orig_muzzy_decay_time, &sz, NULL, 0), 0, + assert_d_eq(mallctl("arena.0.muzzy_decay_ms", + (void *)&orig_muzzy_decay_ms, &sz, NULL, 0), 0, "Unexpected mallctl() failure"); - muzzy_decay_time = -2; - assert_d_eq(mallctl("arena.0.muzzy_decay_time", NULL, NULL, - (void *)&muzzy_decay_time, sizeof(ssize_t)), EFAULT, + muzzy_decay_ms = -2; + assert_d_eq(mallctl("arena.0.muzzy_decay_ms", NULL, NULL, + (void *)&muzzy_decay_ms, sizeof(ssize_t)), EFAULT, "Unexpected mallctl() success"); - muzzy_decay_time = 0x7fffffff; - assert_d_eq(mallctl("arena.0.muzzy_decay_time", NULL, NULL, - (void *)&muzzy_decay_time, sizeof(ssize_t)), 0, + muzzy_decay_ms = 0x7fffffff; + assert_d_eq(mallctl("arena.0.muzzy_decay_ms", NULL, NULL, + (void *)&muzzy_decay_ms, sizeof(ssize_t)), 0, "Unexpected mallctl() failure"); - for (prev_muzzy_decay_time = muzzy_decay_time, muzzy_decay_time = -1; - muzzy_decay_time < 20; prev_muzzy_decay_time = muzzy_decay_time, - muzzy_decay_time++) { - ssize_t old_muzzy_decay_time; + for (prev_muzzy_decay_ms = muzzy_decay_ms, muzzy_decay_ms = -1; + muzzy_decay_ms < 20; prev_muzzy_decay_ms = muzzy_decay_ms, + muzzy_decay_ms++) { + ssize_t old_muzzy_decay_ms; - assert_d_eq(mallctl("arena.0.muzzy_decay_time", - (void *)&old_muzzy_decay_time, &sz, - (void *)&muzzy_decay_time, sizeof(ssize_t)), 0, - "Unexpected mallctl() failure"); - assert_zd_eq(old_muzzy_decay_time, prev_muzzy_decay_time, - "Unexpected old arena.0.muzzy_decay_time"); + assert_d_eq(mallctl("arena.0.muzzy_decay_ms", + (void *)&old_muzzy_decay_ms, &sz, (void *)&muzzy_decay_ms, + sizeof(ssize_t)), 0, "Unexpected mallctl() failure"); + assert_zd_eq(old_muzzy_decay_ms, prev_muzzy_decay_ms, + "Unexpected old arena.0.muzzy_decay_ms"); } } TEST_END @@ -555,68 +553,66 @@ TEST_BEGIN(test_arena_i_dss) { } TEST_END -TEST_BEGIN(test_arenas_dirty_decay_time) { - ssize_t dirty_decay_time, orig_dirty_decay_time, prev_dirty_decay_time; +TEST_BEGIN(test_arenas_dirty_decay_ms) { + ssize_t dirty_decay_ms, orig_dirty_decay_ms, prev_dirty_decay_ms; size_t sz = sizeof(ssize_t); - assert_d_eq(mallctl("arenas.dirty_decay_time", - (void *)&orig_dirty_decay_time, &sz, NULL, 0), 0, + assert_d_eq(mallctl("arenas.dirty_decay_ms", + (void *)&orig_dirty_decay_ms, &sz, NULL, 0), 0, "Unexpected mallctl() failure"); - dirty_decay_time = -2; - assert_d_eq(mallctl("arenas.dirty_decay_time", NULL, NULL, - (void *)&dirty_decay_time, sizeof(ssize_t)), EFAULT, + dirty_decay_ms = -2; + assert_d_eq(mallctl("arenas.dirty_decay_ms", NULL, NULL, + (void *)&dirty_decay_ms, sizeof(ssize_t)), EFAULT, "Unexpected mallctl() success"); - dirty_decay_time = 0x7fffffff; - assert_d_eq(mallctl("arenas.dirty_decay_time", NULL, NULL, - (void *)&dirty_decay_time, sizeof(ssize_t)), 0, + dirty_decay_ms = 0x7fffffff; + assert_d_eq(mallctl("arenas.dirty_decay_ms", NULL, NULL, + (void *)&dirty_decay_ms, sizeof(ssize_t)), 0, "Expected mallctl() failure"); - for (prev_dirty_decay_time = dirty_decay_time, dirty_decay_time = -1; - dirty_decay_time < 20; prev_dirty_decay_time = dirty_decay_time, - dirty_decay_time++) { - ssize_t old_dirty_decay_time; + for (prev_dirty_decay_ms = dirty_decay_ms, dirty_decay_ms = -1; + dirty_decay_ms < 20; prev_dirty_decay_ms = dirty_decay_ms, + dirty_decay_ms++) { + ssize_t old_dirty_decay_ms; - assert_d_eq(mallctl("arenas.dirty_decay_time", - (void *)&old_dirty_decay_time, &sz, - (void *)&dirty_decay_time, sizeof(ssize_t)), 0, - "Unexpected mallctl() failure"); - assert_zd_eq(old_dirty_decay_time, prev_dirty_decay_time, - "Unexpected old arenas.dirty_decay_time"); + assert_d_eq(mallctl("arenas.dirty_decay_ms", + (void *)&old_dirty_decay_ms, &sz, (void *)&dirty_decay_ms, + sizeof(ssize_t)), 0, "Unexpected mallctl() failure"); + assert_zd_eq(old_dirty_decay_ms, prev_dirty_decay_ms, + "Unexpected old arenas.dirty_decay_ms"); } } TEST_END -TEST_BEGIN(test_arenas_muzzy_decay_time) { - ssize_t muzzy_decay_time, orig_muzzy_decay_time, prev_muzzy_decay_time; +TEST_BEGIN(test_arenas_muzzy_decay_ms) { + ssize_t muzzy_decay_ms, orig_muzzy_decay_ms, prev_muzzy_decay_ms; size_t sz = sizeof(ssize_t); - assert_d_eq(mallctl("arenas.muzzy_decay_time", - (void *)&orig_muzzy_decay_time, &sz, NULL, 0), 0, + assert_d_eq(mallctl("arenas.muzzy_decay_ms", + (void *)&orig_muzzy_decay_ms, &sz, NULL, 0), 0, "Unexpected mallctl() failure"); - muzzy_decay_time = -2; - assert_d_eq(mallctl("arenas.muzzy_decay_time", NULL, NULL, - (void *)&muzzy_decay_time, sizeof(ssize_t)), EFAULT, + muzzy_decay_ms = -2; + assert_d_eq(mallctl("arenas.muzzy_decay_ms", NULL, NULL, + (void *)&muzzy_decay_ms, sizeof(ssize_t)), EFAULT, "Unexpected mallctl() success"); - muzzy_decay_time = 0x7fffffff; - assert_d_eq(mallctl("arenas.muzzy_decay_time", NULL, NULL, - (void *)&muzzy_decay_time, sizeof(ssize_t)), 0, + muzzy_decay_ms = 0x7fffffff; + assert_d_eq(mallctl("arenas.muzzy_decay_ms", NULL, NULL, + (void *)&muzzy_decay_ms, sizeof(ssize_t)), 0, "Expected mallctl() failure"); - for (prev_muzzy_decay_time = muzzy_decay_time, muzzy_decay_time = -1; - muzzy_decay_time < 20; prev_muzzy_decay_time = muzzy_decay_time, - muzzy_decay_time++) { - ssize_t old_muzzy_decay_time; + for (prev_muzzy_decay_ms = muzzy_decay_ms, muzzy_decay_ms = -1; + muzzy_decay_ms < 20; prev_muzzy_decay_ms = muzzy_decay_ms, + muzzy_decay_ms++) { + ssize_t old_muzzy_decay_ms; - assert_d_eq(mallctl("arenas.muzzy_decay_time", - (void *)&old_muzzy_decay_time, &sz, - (void *)&muzzy_decay_time, sizeof(ssize_t)), 0, - "Unexpected mallctl() failure"); - assert_zd_eq(old_muzzy_decay_time, prev_muzzy_decay_time, - "Unexpected old arenas.muzzy_decay_time"); + assert_d_eq(mallctl("arenas.muzzy_decay_ms", + (void *)&old_muzzy_decay_ms, &sz, (void *)&muzzy_decay_ms, + sizeof(ssize_t)), 0, "Unexpected mallctl() failure"); + assert_zd_eq(old_muzzy_decay_ms, prev_muzzy_decay_ms, + "Unexpected old arenas.muzzy_decay_ms"); } } TEST_END @@ -699,8 +695,8 @@ TEST_BEGIN(test_stats_arenas) { TEST_STATS_ARENAS(unsigned, nthreads); TEST_STATS_ARENAS(const char *, dss); - TEST_STATS_ARENAS(ssize_t, dirty_decay_time); - TEST_STATS_ARENAS(ssize_t, muzzy_decay_time); + TEST_STATS_ARENAS(ssize_t, dirty_decay_ms); + TEST_STATS_ARENAS(ssize_t, muzzy_decay_ms); TEST_STATS_ARENAS(size_t, pactive); TEST_STATS_ARENAS(size_t, pdirty); @@ -723,13 +719,13 @@ main(void) { test_tcache, test_thread_arena, test_arena_i_initialized, - test_arena_i_dirty_decay_time, - test_arena_i_muzzy_decay_time, + test_arena_i_dirty_decay_ms, + test_arena_i_muzzy_decay_ms, test_arena_i_purge, test_arena_i_decay, test_arena_i_dss, - test_arenas_dirty_decay_time, - test_arenas_muzzy_decay_time, + test_arenas_dirty_decay_ms, + test_arenas_muzzy_decay_ms, test_arenas_constants, test_arenas_bin_constants, test_arenas_lextent_constants, diff --git a/test/unit/pack.sh b/test/unit/pack.sh index 76757ac3..6f451480 100644 --- a/test/unit/pack.sh +++ b/test/unit/pack.sh @@ -1,4 +1,4 @@ #!/bin/sh # Immediately purge to minimize fragmentation. -export MALLOC_CONF="dirty_decay_time:0,muzzy_decay_time:0" +export MALLOC_CONF="dirty_decay_ms:0,muzzy_decay_ms:0"