Fix stats.arenas.<i>.[...] for --disable-stats case.

Add missing stats.arenas.<i>.{dss,lg_dirty_mult,decay_time}
initialization.

Fix stats.arenas.<i>.{pactive,pdirty} to read under the protection of
the arena mutex.

include/jemalloc/internal/arena.h

@@ -572,7 +572,10 @@ ssize_t	arena_lg_dirty_mult_default_get(void);
 bool	arena_lg_dirty_mult_default_set(ssize_t lg_dirty_mult);
 ssize_t	arena_decay_time_default_get(void);
 bool	arena_decay_time_default_set(ssize_t decay_time);
-void	arena_stats_merge(arena_t *arena, const char **dss,
+void	arena_basic_stats_merge(arena_t *arena, unsigned *nthreads,
+    const char **dss, ssize_t *lg_dirty_mult, ssize_t *decay_time,
+    size_t *nactive, size_t *ndirty);
+void	arena_stats_merge(arena_t *arena, unsigned *nthreads, const char **dss,
     ssize_t *lg_dirty_mult, ssize_t *decay_time, size_t *nactive,
     size_t *ndirty, arena_stats_t *astats, malloc_bin_stats_t *bstats,
     malloc_large_stats_t *lstats, malloc_huge_stats_t *hstats);

include/jemalloc/internal/ctl.h

@@ -38,6 +38,9 @@ struct ctl_arena_stats_s {
 	ssize_t			decay_time;
 	size_t			pactive;
 	size_t			pdirty;
+
+	/* The remainder are only populated if config_stats is true. */
+
 	arena_stats_t		astats;
 
 	/* Aggregate stats for small size classes, based on bin stats. */

include/jemalloc/internal/private_symbols.txt

@@ -2,6 +2,7 @@ a0dalloc
 a0malloc
 arena_aalloc
 arena_alloc_junk_small
+arena_basic_stats_merge
 arena_bin_index
 arena_bin_info
 arena_bitselm_get

src/arena.c

@@ -3202,20 +3202,45 @@ arena_decay_time_default_set(ssize_t decay_time)
 	return (false);
 }
 
-void
+static void
-arena_stats_merge(arena_t *arena, const char **dss, ssize_t *lg_dirty_mult,
+arena_basic_stats_merge_locked(arena_t *arena, unsigned *nthreads,
-    ssize_t *decay_time, size_t *nactive, size_t *ndirty, arena_stats_t *astats,
+    const char **dss, ssize_t *lg_dirty_mult, ssize_t *decay_time,
-    malloc_bin_stats_t *bstats, malloc_large_stats_t *lstats,
+    size_t *nactive, size_t *ndirty)
-    malloc_huge_stats_t *hstats)
 {
-	unsigned i;
 
-	malloc_mutex_lock(&arena->lock);
+	*nthreads += arena_nthreads_get(arena);
 	*dss = dss_prec_names[arena->dss_prec];
 	*lg_dirty_mult = arena->lg_dirty_mult;
 	*decay_time = arena->decay_time;
 	*nactive += arena->nactive;
 	*ndirty += arena->ndirty;
+}
+
+void
+arena_basic_stats_merge(arena_t *arena, unsigned *nthreads, const char **dss,
+    ssize_t *lg_dirty_mult, ssize_t *decay_time, size_t *nactive,
+    size_t *ndirty)
+{
+
+	malloc_mutex_lock(&arena->lock);
+	arena_basic_stats_merge_locked(arena, nthreads, dss, lg_dirty_mult,
+	    decay_time, nactive, ndirty);
+	malloc_mutex_unlock(&arena->lock);
+}
+
+void
+arena_stats_merge(arena_t *arena, unsigned *nthreads, const char **dss,
+    ssize_t *lg_dirty_mult, ssize_t *decay_time, size_t *nactive,
+    size_t *ndirty, arena_stats_t *astats, malloc_bin_stats_t *bstats,
+    malloc_large_stats_t *lstats, malloc_huge_stats_t *hstats)
+{
+	unsigned i;
+
+	cassert(config_stats);
+
+	malloc_mutex_lock(&arena->lock);
+	arena_basic_stats_merge_locked(arena, nthreads, dss, lg_dirty_mult,
+	    decay_time, nactive, ndirty);
 
 	astats->mapped += arena->stats.mapped;
 	astats->npurge += arena->stats.npurge;

src/ctl.c

@@ -533,6 +533,7 @@ static void
 ctl_arena_clear(ctl_arena_stats_t *astats)
 {
 
+	astats->nthreads = 0;
 	astats->dss = dss_prec_names[dss_prec_limit];
 	astats->lg_dirty_mult = -1;
 	astats->decay_time = -1;
@@ -557,9 +558,11 @@ ctl_arena_stats_amerge(ctl_arena_stats_t *cstats, arena_t *arena)
 {
 	unsigned i;
 
-	arena_stats_merge(arena, &cstats->dss, &cstats->lg_dirty_mult,
+	if (config_stats) {
-	    &cstats->decay_time, &cstats->pactive, &cstats->pdirty,
+		arena_stats_merge(arena, &cstats->nthreads, &cstats->dss,
-	    &cstats->astats, cstats->bstats, cstats->lstats, cstats->hstats);
+		    &cstats->lg_dirty_mult, &cstats->decay_time,
+		    &cstats->pactive, &cstats->pdirty, &cstats->astats,
+		    cstats->bstats, cstats->lstats, cstats->hstats);
 
 		for (i = 0; i < NBINS; i++) {
 			cstats->allocated_small += cstats->bstats[i].curregs *
@@ -568,6 +571,11 @@ ctl_arena_stats_amerge(ctl_arena_stats_t *cstats, arena_t *arena)
 			cstats->ndalloc_small += cstats->bstats[i].ndalloc;
 			cstats->nrequests_small += cstats->bstats[i].nrequests;
 		}
+	} else {
+		arena_basic_stats_merge(arena, &cstats->nthreads, &cstats->dss,
+		    &cstats->lg_dirty_mult, &cstats->decay_time,
+		    &cstats->pactive, &cstats->pdirty);
+	}
 }
 
 static void
@@ -575,26 +583,32 @@ ctl_arena_stats_smerge(ctl_arena_stats_t *sstats, ctl_arena_stats_t *astats)
 {
 	unsigned i;
 
+	sstats->nthreads += astats->nthreads;
 	sstats->pactive += astats->pactive;
 	sstats->pdirty += astats->pdirty;
 
+	if (config_stats) {
 		sstats->astats.mapped += astats->astats.mapped;
 		sstats->astats.npurge += astats->astats.npurge;
 		sstats->astats.nmadvise += astats->astats.nmadvise;
 		sstats->astats.purged += astats->astats.purged;
 
-	sstats->astats.metadata_mapped += astats->astats.metadata_mapped;
+		sstats->astats.metadata_mapped +=
-	sstats->astats.metadata_allocated += astats->astats.metadata_allocated;
+		    astats->astats.metadata_mapped;
+		sstats->astats.metadata_allocated +=
+		    astats->astats.metadata_allocated;
 
 		sstats->allocated_small += astats->allocated_small;
 		sstats->nmalloc_small += astats->nmalloc_small;
 		sstats->ndalloc_small += astats->ndalloc_small;
 		sstats->nrequests_small += astats->nrequests_small;
 
-	sstats->astats.allocated_large += astats->astats.allocated_large;
+		sstats->astats.allocated_large +=
+		    astats->astats.allocated_large;
 		sstats->astats.nmalloc_large += astats->astats.nmalloc_large;
 		sstats->astats.ndalloc_large += astats->astats.ndalloc_large;
-	sstats->astats.nrequests_large += astats->astats.nrequests_large;
+		sstats->astats.nrequests_large +=
+		    astats->astats.nrequests_large;
 
 		sstats->astats.allocated_huge += astats->astats.allocated_huge;
 		sstats->astats.nmalloc_huge += astats->astats.nmalloc_huge;
@@ -603,10 +617,12 @@ ctl_arena_stats_smerge(ctl_arena_stats_t *sstats, ctl_arena_stats_t *astats)
 		for (i = 0; i < NBINS; i++) {
 			sstats->bstats[i].nmalloc += astats->bstats[i].nmalloc;
 			sstats->bstats[i].ndalloc += astats->bstats[i].ndalloc;
-		sstats->bstats[i].nrequests += astats->bstats[i].nrequests;
+			sstats->bstats[i].nrequests +=
+			    astats->bstats[i].nrequests;
 			sstats->bstats[i].curregs += astats->bstats[i].curregs;
 			if (config_tcache) {
-			sstats->bstats[i].nfills += astats->bstats[i].nfills;
+				sstats->bstats[i].nfills +=
+				    astats->bstats[i].nfills;
 				sstats->bstats[i].nflushes +=
 				    astats->bstats[i].nflushes;
 			}
@@ -618,14 +634,17 @@ ctl_arena_stats_smerge(ctl_arena_stats_t *sstats, ctl_arena_stats_t *astats)
 		for (i = 0; i < nlclasses; i++) {
 			sstats->lstats[i].nmalloc += astats->lstats[i].nmalloc;
 			sstats->lstats[i].ndalloc += astats->lstats[i].ndalloc;
-		sstats->lstats[i].nrequests += astats->lstats[i].nrequests;
+			sstats->lstats[i].nrequests +=
+			    astats->lstats[i].nrequests;
 			sstats->lstats[i].curruns += astats->lstats[i].curruns;
 		}
 
 		for (i = 0; i < nhclasses; i++) {
 			sstats->hstats[i].nmalloc += astats->hstats[i].nmalloc;
 			sstats->hstats[i].ndalloc += astats->hstats[i].ndalloc;
-		sstats->hstats[i].curhchunks += astats->hstats[i].curhchunks;
+			sstats->hstats[i].curhchunks +=
+			    astats->hstats[i].curhchunks;
+		}
 	}
 }
 
@@ -636,19 +655,9 @@ ctl_arena_refresh(arena_t *arena, unsigned i)
 	ctl_arena_stats_t *sstats = &ctl_stats.arenas[ctl_stats.narenas];
 
 	ctl_arena_clear(astats);
-
-	sstats->nthreads += astats->nthreads;
-	if (config_stats) {
 	ctl_arena_stats_amerge(astats, arena);
 	/* Merge into sum stats as well. */
 	ctl_arena_stats_smerge(sstats, astats);
-	} else {
-		astats->pactive += arena->nactive;
-		astats->pdirty += arena->ndirty;
-		/* Merge into sum stats as well. */
-		sstats->pactive += arena->nactive;
-		sstats->pdirty += arena->ndirty;
-	}
 }
 
 static bool
@@ -701,20 +710,11 @@ ctl_refresh(void)
 	 * Clear sum stats, since they will be merged into by
 	 * ctl_arena_refresh().
 	 */
-	ctl_stats.arenas[ctl_stats.narenas].nthreads = 0;
 	ctl_arena_clear(&ctl_stats.arenas[ctl_stats.narenas]);
 
 	for (i = 0; i < ctl_stats.narenas; i++)
 		tarenas[i] = arena_get(i, false);
 
-	for (i = 0; i < ctl_stats.narenas; i++) {
-		if (tarenas[i] != NULL) {
-			ctl_stats.arenas[i].nthreads =
-			    arena_nthreads_get(arena_get(i, false));
-		} else
-			ctl_stats.arenas[i].nthreads = 0;
-	}
-
 	for (i = 0; i < ctl_stats.narenas; i++) {
 		bool initialized = (tarenas[i] != NULL);
 

test/unit/mallctl.c

@@ -687,8 +687,10 @@ TEST_BEGIN(test_stats_arenas)
 	    0), 0, "Unexpected mallctl() failure");			\
 } while (0)
 
-	TEST_STATS_ARENAS(const char *, dss);
 	TEST_STATS_ARENAS(unsigned, nthreads);
+	TEST_STATS_ARENAS(const char *, dss);
+	TEST_STATS_ARENAS(ssize_t, lg_dirty_mult);
+	TEST_STATS_ARENAS(ssize_t, decay_time);
 	TEST_STATS_ARENAS(size_t, pactive);
 	TEST_STATS_ARENAS(size_t, pdirty);