#define JEMALLOC_STATS_C_

#include "jemalloc/internal/jemalloc_preamble.h"

#include "jemalloc/internal/jemalloc_internal_includes.h"

#include "jemalloc/internal/assert.h"

#include "jemalloc/internal/ctl.h"

#include "jemalloc/internal/emitter.h"

#include "jemalloc/internal/mutex.h"

#include "jemalloc/internal/mutex_prof.h"

const char *global_mutex_names[mutex_prof_num_global_mutexes] = {

#define OP(mtx) #mtx,

	MUTEX_PROF_GLOBAL_MUTEXES

#undef OP

};

const char *arena_mutex_names[mutex_prof_num_arena_mutexes] = {

#define OP(mtx) #mtx,

	MUTEX_PROF_ARENA_MUTEXES

#undef OP

};

#define CTL_GET(n, v, t) do {						\

	size_t sz = sizeof(t);						\

	xmallctl(n, (void *)v, &sz, NULL, 0);				\

} while (0)

#define CTL_M2_GET(n, i, v, t) do {					\

	size_t mib[CTL_MAX_DEPTH];					\

	size_t miblen = sizeof(mib) / sizeof(size_t);			\

	size_t sz = sizeof(t);						\

	xmallctlnametomib(n, mib, &miblen);				\

	mib[2] = (i);							\

	xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0);		\

} while (0)

#define CTL_M2_M4_GET(n, i, j, v, t) do {				\

	size_t mib[CTL_MAX_DEPTH];					\

	size_t miblen = sizeof(mib) / sizeof(size_t);			\

	size_t sz = sizeof(t);						\

	xmallctlnametomib(n, mib, &miblen);				\

	mib[2] = (i);							\

	mib[4] = (j);							\

	xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0);		\

} while (0)

/******************************************************************************/

/* Data. */

bool opt_stats_print = false;

char opt_stats_print_opts[stats_print_tot_num_options+1] = "";

/******************************************************************************/

static uint64_t

rate_per_second(uint64_t value, uint64_t uptime_ns) {

	uint64_t billion = 1000000000;

	if (uptime_ns == 0 || value == 0) {

		return 0;

	}

	if (uptime_ns < billion) {

		return value;

	} else {

		uint64_t uptime_s = uptime_ns / billion;

		return value / uptime_s;

	}

}

/* Calculate x.yyy and output a string (takes a fixed sized char array). */

static bool

get_rate_str(uint64_t dividend, uint64_t divisor, char str[6]) {

	if (divisor == 0 || dividend > divisor) {

		/* The rate is not supposed to be greater than 1. */

		return true;

	}

	if (dividend > 0) {

		assert(UINT64_MAX / dividend >= 1000);

	}

	unsigned n = (unsigned)((dividend * 1000) / divisor);

	if (n < 10) {

		malloc_snprintf(str, 6, "0.00%u", n);

	} else if (n < 100) {

		malloc_snprintf(str, 6, "0.0%u", n);

	} else if (n < 1000) {

		malloc_snprintf(str, 6, "0.%u", n);

	} else {

		malloc_snprintf(str, 6, "1");

	}

	return false;

}

#define MUTEX_CTL_STR_MAX_LENGTH 128

static void

gen_mutex_ctl_str(char *str, size_t buf_len, const char *prefix,

    const char *mutex, const char *counter) {

	malloc_snprintf(str, buf_len, "stats.%s.%s.%s", prefix, mutex, counter);

}

static void

mutex_stats_init_cols(emitter_row_t *row, const char *table_name,

    emitter_col_t *name,

    emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],

    emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) {

	mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;

	mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;

	emitter_col_t *col;

	if (name != NULL) {

		emitter_col_init(name, row);

		name->justify = emitter_justify_left;

		name->width = 21;

		name->type = emitter_type_title;

		name->str_val = table_name;

	}

#define WIDTH_uint32_t 12

#define WIDTH_uint64_t 16

#define OP(counter, counter_type, human, derived, base_counter)	\

	col = &col_##counter_type[k_##counter_type];			\

	++k_##counter_type;						\

	emitter_col_init(col, row);					\

	col->justify = emitter_justify_right;				\

	col->width = derived ? 8 : WIDTH_##counter_type;		\

	col->type = emitter_type_title;					\

	col->str_val = human;

	MUTEX_PROF_COUNTERS

#undef OP

#undef WIDTH_uint32_t

#undef WIDTH_uint64_t

	col_uint64_t[mutex_counter_total_wait_time_ps].width = 10;

}

static void

mutex_stats_read_global(const char *name, emitter_col_t *col_name,

    emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],

    emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],

    uint64_t uptime) {

	char cmd[MUTEX_CTL_STR_MAX_LENGTH];

	col_name->str_val = name;

	emitter_col_t *dst;

#define EMITTER_TYPE_uint32_t emitter_type_uint32

#define EMITTER_TYPE_uint64_t emitter_type_uint64

#define OP(counter, counter_type, human, derived, base_counter)	\

	dst = &col_##counter_type[mutex_counter_##counter];		\

	dst->type = EMITTER_TYPE_##counter_type;			\

	if (!derived) {							\

		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,	\

		    "mutexes", name, #counter);				\

		CTL_GET(cmd, (counter_type *)&dst->bool_val, counter_type);	\

	} else { \

	    emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter];	\

	    dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \

	}

	MUTEX_PROF_COUNTERS

#undef OP

#undef EMITTER_TYPE_uint32_t

#undef EMITTER_TYPE_uint64_t

}

static void

mutex_stats_read_arena(unsigned arena_ind, mutex_prof_arena_ind_t mutex_ind,

    const char *name, emitter_col_t *col_name,

    emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],

    emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],

    uint64_t uptime) {

	char cmd[MUTEX_CTL_STR_MAX_LENGTH];

	col_name->str_val = name;

	emitter_col_t *dst;

#define EMITTER_TYPE_uint32_t emitter_type_uint32

#define EMITTER_TYPE_uint64_t emitter_type_uint64

#define OP(counter, counter_type, human, derived, base_counter)	\

	dst = &col_##counter_type[mutex_counter_##counter];		\

	dst->type = EMITTER_TYPE_##counter_type;			\

	if (!derived) {                                   \

		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,        \

		    "arenas.0.mutexes", arena_mutex_names[mutex_ind], #counter);\

		CTL_M2_GET(cmd, arena_ind, (counter_type *)&dst->bool_val, counter_type); \

	} else {                      \

		emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter];	\

		dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \

	}

	MUTEX_PROF_COUNTERS

#undef OP

#undef EMITTER_TYPE_uint32_t

#undef EMITTER_TYPE_uint64_t

}

static void

mutex_stats_read_arena_bin(unsigned arena_ind, unsigned bin_ind,

    emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],

    emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters],

    uint64_t uptime) {

	char cmd[MUTEX_CTL_STR_MAX_LENGTH];

	emitter_col_t *dst;

#define EMITTER_TYPE_uint32_t emitter_type_uint32

#define EMITTER_TYPE_uint64_t emitter_type_uint64

#define OP(counter, counter_type, human, derived, base_counter)	\

	dst = &col_##counter_type[mutex_counter_##counter];		\

	dst->type = EMITTER_TYPE_##counter_type;			\

	if (!derived) {                                   \

		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,        \

		    "arenas.0.bins.0","mutex", #counter);            \

		CTL_M2_M4_GET(cmd, arena_ind, bin_ind,                \

		    (counter_type *)&dst->bool_val, counter_type);  \

	} else {                      \

		emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter]; \

		dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \

	}

	MUTEX_PROF_COUNTERS

#undef OP

#undef EMITTER_TYPE_uint32_t

#undef EMITTER_TYPE_uint64_t

}

/* "row" can be NULL to avoid emitting in table mode. */

static void

mutex_stats_emit(emitter_t *emitter, emitter_row_t *row,

    emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters],

    emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) {

	if (row != NULL) {

		emitter_table_row(emitter, row);

	}

	mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;

	mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;

	emitter_col_t *col;

#define EMITTER_TYPE_uint32_t emitter_type_uint32

#define EMITTER_TYPE_uint64_t emitter_type_uint64

#define OP(counter, type, human, derived, base_counter)		\

	if (!derived) {                    \

		col = &col_##type[k_##type];                        \

		++k_##type;                            \

		emitter_json_kv(emitter, #counter, EMITTER_TYPE_##type,        \

		    (const void *)&col->bool_val); \

	}

	MUTEX_PROF_COUNTERS;

#undef OP

#undef EMITTER_TYPE_uint32_t

#undef EMITTER_TYPE_uint64_t

}

#define COL(row_name, column_name, left_or_right, col_width, etype)      \

	emitter_col_t col_##column_name;                                     \

	emitter_col_init(&col_##column_name, &row_name);                     \

	col_##column_name.justify = emitter_justify_##left_or_right;         \

	col_##column_name.width = col_width;                                 \

	col_##column_name.type = emitter_type_##etype;

#define COL_HDR(row_name, column_name, human, left_or_right, col_width, etype)  \

	COL(row_name, column_name, left_or_right, col_width, etype)	         \

	emitter_col_t header_##column_name;                                  \

	emitter_col_init(&header_##column_name, &header_##row_name);         \

	header_##column_name.justify = emitter_justify_##left_or_right;      \

	header_##column_name.width = col_width;                              \

	header_##column_name.type = emitter_type_title;                      \

	header_##column_name.str_val = human ? human : #column_name;

static void

stats_arena_bins_print(emitter_t *emitter, bool mutex, unsigned i, uint64_t uptime) {

	size_t page;

	bool in_gap, in_gap_prev;

	unsigned nbins, j;

	CTL_GET("arenas.page", &page, size_t);

	CTL_GET("arenas.nbins", &nbins, unsigned);

	emitter_row_t header_row;

	emitter_row_init(&header_row);

	emitter_row_t row;

	emitter_row_init(&row;;

	COL_HDR(row, size, NULL, right, 20, size)

	COL_HDR(row, ind, NULL, right, 4, unsigned)

	COL_HDR(row, allocated, NULL, right, 13, uint64)

	COL_HDR(row, nmalloc, NULL, right, 13, uint64)

	COL_HDR(row, nmalloc_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, ndalloc, NULL, right, 13, uint64)

	COL_HDR(row, ndalloc_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, nrequests, NULL, right, 13, uint64)

	COL_HDR(row, nrequests_ps, "(#/sec)", right, 10, uint64)

	COL_HDR(row, nshards, NULL, right, 9, unsigned)

	COL_HDR(row, curregs, NULL, right, 13, size)

	COL_HDR(row, curslabs, NULL, right, 13, size)

	COL_HDR(row, nonfull_slabs, NULL, right, 15, size)

	COL_HDR(row, regs, NULL, right, 5, unsigned)

	COL_HDR(row, pgs, NULL, right, 4, size)

	/* To buffer a right- and left-justified column. */

	COL_HDR(row, justify_spacer, NULL, right, 1, title)

	COL_HDR(row, util, NULL, right, 6, title)

	COL_HDR(row, nfills, NULL, right, 13, uint64)

	COL_HDR(row, nfills_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, nflushes, NULL, right, 13, uint64)

	COL_HDR(row, nflushes_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, nslabs, NULL, right, 13, uint64)

	COL_HDR(row, nreslabs, NULL, right, 13, uint64)

	COL_HDR(row, nreslabs_ps, "(#/sec)", right, 8, uint64)

	/* Don't want to actually print the name. */

	header_justify_spacer.str_val = " ";

	col_justify_spacer.str_val = " ";

	emitter_col_t col_mutex64[mutex_prof_num_uint64_t_counters];

	emitter_col_t col_mutex32[mutex_prof_num_uint32_t_counters];

	emitter_col_t header_mutex64[mutex_prof_num_uint64_t_counters];

	emitter_col_t header_mutex32[mutex_prof_num_uint32_t_counters];

	if (mutex) {

		mutex_stats_init_cols(&row, NULL, NULL, col_mutex64,

		    col_mutex32);

		mutex_stats_init_cols(&header_row, NULL, NULL, header_mutex64,

		    header_mutex32);

	}

	/*

	 * We print a "bins:" header as part of the table row; we need to adjust

	 * the header size column to compensate.

	 */

	header_size.width -=5;

	emitter_table_printf(emitter, "bins:");

	emitter_table_row(emitter, &header_row);

	emitter_json_array_kv_begin(emitter, "bins");

	for (j = 0, in_gap = false; j < nbins; j++) {

		uint64_t nslabs;

		size_t reg_size, slab_size, curregs;

		size_t curslabs;

		size_t nonfull_slabs;

		uint32_t nregs, nshards;

		uint64_t nmalloc, ndalloc, nrequests, nfills, nflushes;

		uint64_t nreslabs;

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nslabs", i, j, &nslabs,

		    uint64_t);

		in_gap_prev = in_gap;

		in_gap = (nslabs == 0);

		if (in_gap_prev && !in_gap) {

			emitter_table_printf(emitter,

			    "                     ---\n");

		}

		CTL_M2_GET("arenas.bin.0.size", j, &reg_size, size_t);

		CTL_M2_GET("arenas.bin.0.nregs", j, &nregs, uint32_t);

		CTL_M2_GET("arenas.bin.0.slab_size", j, &slab_size, size_t);

		CTL_M2_GET("arenas.bin.0.nshards", j, &nshards, uint32_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nmalloc", i, j, &nmalloc,

		    uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.ndalloc", i, j, &ndalloc,

		    uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.curregs", i, j, &curregs,

		    size_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nrequests", i, j,

		    &nrequests, uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nfills", i, j, &nfills,

		    uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nflushes", i, j, &nflushes,

		    uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nreslabs", i, j, &nreslabs,

		    uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.curslabs", i, j, &curslabs,

		    size_t);

		CTL_M2_M4_GET("stats.arenas.0.bins.0.nonfull_slabs", i, j, &nonfull_slabs,

		    size_t);

		if (mutex) {

			mutex_stats_read_arena_bin(i, j, col_mutex64,

			    col_mutex32, uptime);

		}

		emitter_json_object_begin(emitter);

		emitter_json_kv(emitter, "nmalloc", emitter_type_uint64,

		    &nmalloc);

		emitter_json_kv(emitter, "ndalloc", emitter_type_uint64,

		    &ndalloc);

		emitter_json_kv(emitter, "curregs", emitter_type_size,

		    &curregs);

		emitter_json_kv(emitter, "nrequests", emitter_type_uint64,

		    &nrequests);

		emitter_json_kv(emitter, "nfills", emitter_type_uint64,

		    &nfills);

		emitter_json_kv(emitter, "nflushes", emitter_type_uint64,

		    &nflushes);

		emitter_json_kv(emitter, "nreslabs", emitter_type_uint64,

		    &nreslabs);

		emitter_json_kv(emitter, "curslabs", emitter_type_size,

		    &curslabs);

		emitter_json_kv(emitter, "nonfull_slabs", emitter_type_size,

		    &nonfull_slabs);

		if (mutex) {

			emitter_json_object_kv_begin(emitter, "mutex");

			mutex_stats_emit(emitter, NULL, col_mutex64,

			    col_mutex32);

			emitter_json_object_end(emitter);

		}

		emitter_json_object_end(emitter);

		size_t availregs = nregs * curslabs;

		char util[6];

		if (get_rate_str((uint64_t)curregs, (uint64_t)availregs, util))

		{

			if (availregs == 0) {

				malloc_snprintf(util, sizeof(util), "1");

			} else if (curregs > availregs) {

				/*

				 * Race detected: the counters were read in

				 * separate mallctl calls and concurrent

				 * operations happened in between.  In this case

				 * no meaningful utilization can be computed.

				 */

				malloc_snprintf(util, sizeof(util), " race");

			} else {

				not_reached();

			}

		}

		col_size.size_val = reg_size;

		col_ind.unsigned_val = j;

		col_allocated.size_val = curregs * reg_size;

		col_nmalloc.uint64_val = nmalloc;

		col_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime);

		col_ndalloc.uint64_val = ndalloc;

		col_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime);

		col_nrequests.uint64_val = nrequests;

		col_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime);

		col_nshards.unsigned_val = nshards;

		col_curregs.size_val = curregs;

		col_curslabs.size_val = curslabs;

		col_nonfull_slabs.size_val = nonfull_slabs;

		col_regs.unsigned_val = nregs;

		col_pgs.size_val = slab_size / page;

		col_util.str_val = util;

		col_nfills.uint64_val = nfills;

		col_nfills_ps.uint64_val = rate_per_second(nfills, uptime);

		col_nflushes.uint64_val = nflushes;

		col_nflushes_ps.uint64_val = rate_per_second(nflushes, uptime);

		col_nslabs.uint64_val = nslabs;

		col_nreslabs.uint64_val = nreslabs;

		col_nreslabs_ps.uint64_val = rate_per_second(nreslabs, uptime);

		/*

		 * Note that mutex columns were initialized above, if mutex ==

		 * true.

		 */

		emitter_table_row(emitter, &row;;

	}

	emitter_json_array_end(emitter); /* Close "bins". */

	if (in_gap) {

		emitter_table_printf(emitter, "                     ---\n");

	}

}

static void

stats_arena_lextents_print(emitter_t *emitter, unsigned i, uint64_t uptime) {

	unsigned nbins, nlextents, j;

	bool in_gap, in_gap_prev;

	CTL_GET("arenas.nbins", &nbins, unsigned);

	CTL_GET("arenas.nlextents", &nlextents, unsigned);

	emitter_row_t header_row;

	emitter_row_init(&header_row);

	emitter_row_t row;

	emitter_row_init(&row;;

	COL_HDR(row, size, NULL, right, 20, size)

	COL_HDR(row, ind, NULL, right, 4, unsigned)

	COL_HDR(row, allocated, NULL, right, 13, size)

	COL_HDR(row, nmalloc, NULL, right, 13, uint64)

	COL_HDR(row, nmalloc_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, ndalloc, NULL, right, 13, uint64)

	COL_HDR(row, ndalloc_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, nrequests, NULL, right, 13, uint64)

	COL_HDR(row, nrequests_ps, "(#/sec)", right, 8, uint64)

	COL_HDR(row, curlextents, NULL, right, 13, size)

	/* As with bins, we label the large extents table. */

	header_size.width -= 6;

	emitter_table_printf(emitter, "large:");

	emitter_table_row(emitter, &header_row);

	emitter_json_array_kv_begin(emitter, "lextents");

	for (j = 0, in_gap = false; j < nlextents; j++) {

		uint64_t nmalloc, ndalloc, nrequests;

		size_t lextent_size, curlextents;

		CTL_M2_M4_GET("stats.arenas.0.lextents.0.nmalloc", i, j,

		    &nmalloc, uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.lextents.0.ndalloc", i, j,

		    &ndalloc, uint64_t);

		CTL_M2_M4_GET("stats.arenas.0.lextents.0.nrequests", i, j,

		    &nrequests, uint64_t);

		in_gap_prev = in_gap;

		in_gap = (nrequests == 0);

		if (in_gap_prev && !in_gap) {

			emitter_table_printf(emitter,

			    "                     ---\n");

		}

		CTL_M2_GET("arenas.lextent.0.size", j, &lextent_size, size_t);

		CTL_M2_M4_GET("stats.arenas.0.lextents.0.curlextents", i, j,

		    &curlextents, size_t);

		emitter_json_object_begin(emitter);

		emitter_json_kv(emitter, "curlextents", emitter_type_size,

		    &curlextents);

		emitter_json_object_end(emitter);

		col_size.size_val = lextent_size;

		col_ind.unsigned_val = nbins + j;

		col_allocated.size_val = curlextents * lextent_size;

		col_nmalloc.uint64_val = nmalloc;

		col_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime);

		col_ndalloc.uint64_val = ndalloc;

		col_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime);

		col_nrequests.uint64_val = nrequests;

		col_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime);

		col_curlextents.size_val = curlextents;

		if (!in_gap) {

			emitter_table_row(emitter, &row;;

		}

	}

	emitter_json_array_end(emitter); /* Close "lextents". */

	if (in_gap) {

		emitter_table_printf(emitter, "                     ---\n");

	}

}

static void

stats_arena_extents_print(emitter_t *emitter, unsigned i) {

	unsigned j;

	bool in_gap, in_gap_prev;

	emitter_row_t header_row;

	emitter_row_init(&header_row);

	emitter_row_t row;

	emitter_row_init(&row;;

	COL_HDR(row, size, NULL, right, 20, size)

	COL_HDR(row, ind, NULL, right, 4, unsigned)

	COL_HDR(row, ndirty, NULL, right, 13, size)

	COL_HDR(row, dirty, NULL, right, 13, size)

	COL_HDR(row, nmuzzy, NULL, right, 13, size)

	COL_HDR(row, muzzy, NULL, right, 13, size)

	COL_HDR(row, nretained, NULL, right, 13, size)

	COL_HDR(row, retained, NULL, right, 13, size)

	COL_HDR(row, ntotal, NULL, right, 13, size)

	COL_HDR(row, total, NULL, right, 13, size)

	/* Label this section. */

	header_size.width -= 8;

	emitter_table_printf(emitter, "extents:");

	emitter_table_row(emitter, &header_row);

	emitter_json_array_kv_begin(emitter, "extents");

	in_gap = false;

	for (j = 0; j < SC_NPSIZES; j++) {

		size_t ndirty, nmuzzy, nretained, total, dirty_bytes,

		    muzzy_bytes, retained_bytes, total_bytes;

		CTL_M2_M4_GET("stats.arenas.0.extents.0.ndirty", i, j,

		    &ndirty, size_t);

		CTL_M2_M4_GET("stats.arenas.0.extents.0.nmuzzy", i, j,

		    &nmuzzy, size_t);

		CTL_M2_M4_GET("stats.arenas.0.extents.0.nretained", i, j,

		    &nretained, size_t);

		CTL_M2_M4_GET("stats.arenas.0.extents.0.dirty_bytes", i, j,

		    &dirty_bytes, size_t);

		CTL_M2_M4_GET("stats.arenas.0.extents.0.muzzy_bytes", i, j,

		    &muzzy_bytes, size_t);

		CTL_M2_M4_GET("stats.arenas.0.extents.0.retained_bytes", i, j,

		    &retained_bytes, size_t);

		total = ndirty + nmuzzy + nretained;

		total_bytes = dirty_bytes + muzzy_bytes + retained_bytes;

		in_gap_prev = in_gap;

		in_gap = (total == 0);

		if (in_gap_prev && !in_gap) {

			emitter_table_printf(emitter,

			    "                     ---\n");

		}

		emitter_json_object_begin(emitter);

		emitter_json_kv(emitter, "ndirty", emitter_type_size, &ndirty);

		emitter_json_kv(emitter, "nmuzzy", emitter_type_size, &nmuzzy);

		emitter_json_kv(emitter, "nretained", emitter_type_size,

		    &nretained);

		emitter_json_kv(emitter, "dirty_bytes", emitter_type_size,

		    &dirty_bytes);

		emitter_json_kv(emitter, "muzzy_bytes", emitter_type_size,

		    &muzzy_bytes);

		emitter_json_kv(emitter, "retained_bytes", emitter_type_size,

		    &retained_bytes);

		emitter_json_object_end(emitter);

		col_size.size_val = sz_pind2sz(j);

		col_ind.size_val = j;

		col_ndirty.size_val = ndirty;

		col_dirty.size_val = dirty_bytes;

		col_nmuzzy.size_val = nmuzzy;

		col_muzzy.size_val = muzzy_bytes;

		col_nretained.size_val = nretained;

		col_retained.size_val = retained_bytes;

		col_ntotal.size_val = total;

		col_total.size_val = total_bytes;

		if (!in_gap) {

			emitter_table_row(emitter, &row;;

		}

	}

	emitter_json_array_end(emitter); /* Close "extents". */

	if (in_gap) {

		emitter_table_printf(emitter, "                     ---\n");

	}

}

static void

stats_arena_mutexes_print(emitter_t *emitter, unsigned arena_ind, uint64_t uptime) {

	emitter_row_t row;

	emitter_col_t col_name;

	emitter_col_t col64[mutex_prof_num_uint64_t_counters];

	emitter_col_t col32[mutex_prof_num_uint32_t_counters];

	emitter_row_init(&row;;

	mutex_stats_init_cols(&row, "", &col_name, col64, col32);

	emitter_json_object_kv_begin(emitter, "mutexes");

	emitter_table_row(emitter, &row;;

	for (mutex_prof_arena_ind_t i = 0; i < mutex_prof_num_arena_mutexes;

	    i++) {

		const char *name = arena_mutex_names[i];

		emitter_json_object_kv_begin(emitter, name);

		mutex_stats_read_arena(arena_ind, i, name, &col_name, col64,

		    col32, uptime);

		mutex_stats_emit(emitter, &row, col64, col32);

		emitter_json_object_end(emitter); /* Close the mutex dict. */

	}

	emitter_json_object_end(emitter); /* End "mutexes". */

}

static void

stats_arena_print(emitter_t *emitter, unsigned i, bool bins, bool large,

    bool mutex, bool extents) {

	unsigned nthreads;

	const char *dss;

	ssize_t dirty_decay_ms, muzzy_decay_ms;

	size_t page, pactive, pdirty, pmuzzy, mapped, retained;

	size_t base, internal, resident, metadata_thp, extent_avail;

	uint64_t dirty_npurge, dirty_nmadvise, dirty_purged;

	uint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged;

	size_t small_allocated;

	uint64_t small_nmalloc, small_ndalloc, small_nrequests, small_nfills,

	    small_nflushes;

	size_t large_allocated;

	uint64_t large_nmalloc, large_ndalloc, large_nrequests, large_nfills,

	    large_nflushes;

	size_t tcache_bytes, abandoned_vm;

	uint64_t uptime;

	CTL_GET("arenas.page", &page, size_t);

	CTL_M2_GET("stats.arenas.0.nthreads", i, &nthreads, unsigned);

	emitter_kv(emitter, "nthreads", "assigned threads",

	    emitter_type_unsigned, &nthreads);

	CTL_M2_GET("stats.arenas.0.uptime", i, &uptime, uint64_t);

	emitter_kv(emitter, "uptime_ns", "uptime", emitter_type_uint64,

	    &uptime);

	CTL_M2_GET("stats.arenas.0.dss", i, &dss, const char *);

	emitter_kv(emitter, "dss", "dss allocation precedence",

	    emitter_type_string, &dss;;

	CTL_M2_GET("stats.arenas.0.dirty_decay_ms", i, &dirty_decay_ms,

	    ssize_t);

	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);

	CTL_M2_GET("stats.arenas.0.pmuzzy", i, &pmuzzy, size_t);

	CTL_M2_GET("stats.arenas.0.dirty_npurge", i, &dirty_npurge, uint64_t);

	CTL_M2_GET("stats.arenas.0.dirty_nmadvise", i, &dirty_nmadvise,

	    uint64_t);

	CTL_M2_GET("stats.arenas.0.dirty_purged", i, &dirty_purged, uint64_t);

	CTL_M2_GET("stats.arenas.0.muzzy_npurge", i, &muzzy_npurge, uint64_t);

	CTL_M2_GET("stats.arenas.0.muzzy_nmadvise", i, &muzzy_nmadvise,

	    uint64_t);

	CTL_M2_GET("stats.arenas.0.muzzy_purged", i, &muzzy_purged, uint64_t);

	emitter_row_t decay_row;

	emitter_row_init(&decay_row);

	/* JSON-style emission. */

	emitter_json_kv(emitter, "dirty_decay_ms", emitter_type_ssize,

	    &dirty_decay_ms);

	emitter_json_kv(emitter, "muzzy_decay_ms", emitter_type_ssize,

	    &muzzy_decay_ms);

	emitter_json_kv(emitter, "pactive", emitter_type_size, &pactive);

	emitter_json_kv(emitter, "pdirty", emitter_type_size, &pdirty);

	emitter_json_kv(emitter, "pmuzzy", emitter_type_size, &pmuzzy);

	emitter_json_kv(emitter, "dirty_npurge", emitter_type_uint64,

	    &dirty_npurge);

	emitter_json_kv(emitter, "dirty_nmadvise", emitter_type_uint64,

	    &dirty_nmadvise);

	emitter_json_kv(emitter, "dirty_purged", emitter_type_uint64,

	    &dirty_purged);

	emitter_json_kv(emitter, "muzzy_npurge", emitter_type_uint64,

	    &muzzy_npurge);

	emitter_json_kv(emitter, "muzzy_nmadvise", emitter_type_uint64,

	    &muzzy_nmadvise);

	emitter_json_kv(emitter, "muzzy_purged", emitter_type_uint64,

	    &muzzy_purged);

	/* Table-style emission. */

	COL(decay_row, decay_type, right, 9, title);

	col_decay_type.str_val = "decaying:";

	COL(decay_row, decay_time, right, 6, title);

	col_decay_time.str_val = "time";

	COL(decay_row, decay_npages, right, 13, title);

	col_decay_npages.str_val = "npages";

	COL(decay_row, decay_sweeps, right, 13, title);

	col_decay_sweeps.str_val = "sweeps";

	COL(decay_row, decay_madvises, right, 13, title);

	col_decay_madvises.str_val = "madvises";

	COL(decay_row, decay_purged, right, 13, title);

	col_decay_purged.str_val = "purged";

	/* Title row. */

	emitter_table_row(emitter, &decay_row);

	/* Dirty row. */

	col_decay_type.str_val = "dirty:";

	if (dirty_decay_ms >= 0) {

		col_decay_time.type = emitter_type_ssize;

		col_decay_time.ssize_val = dirty_decay_ms;

	} else {

		col_decay_time.type = emitter_type_title;

		col_decay_time.str_val = "N/A";

	}

	col_decay_npages.type = emitter_type_size;

	col_decay_npages.size_val = pdirty;

	col_decay_sweeps.type = emitter_type_uint64;

	col_decay_sweeps.uint64_val = dirty_npurge;

	col_decay_madvises.type = emitter_type_uint64;

	col_decay_madvises.uint64_val = dirty_nmadvise;

	col_decay_purged.type = emitter_type_uint64;

	col_decay_purged.uint64_val = dirty_purged;

	emitter_table_row(emitter, &decay_row);

	/* Muzzy row. */

	col_decay_type.str_val = "muzzy:";

	if (muzzy_decay_ms >= 0) {

		col_decay_time.type = emitter_type_ssize;

		col_decay_time.ssize_val = muzzy_decay_ms;

	} else {

		col_decay_time.type = emitter_type_title;

		col_decay_time.str_val = "N/A";

	}

	col_decay_npages.type = emitter_type_size;

	col_decay_npages.size_val = pmuzzy;

	col_decay_sweeps.type = emitter_type_uint64;

	col_decay_sweeps.uint64_val = muzzy_npurge;

	col_decay_madvises.type = emitter_type_uint64;

	col_decay_madvises.uint64_val = muzzy_nmadvise;

	col_decay_purged.type = emitter_type_uint64;

	col_decay_purged.uint64_val = muzzy_purged;

	emitter_table_row(emitter, &decay_row);

	/* Small / large / total allocation counts. */

	emitter_row_t alloc_count_row;

	emitter_row_init(&alloc_count_row);

	COL(alloc_count_row, count_title, left, 21, title);

	col_count_title.str_val = "";

	COL(alloc_count_row, count_allocated, right, 16, title);

	col_count_allocated.str_val = "allocated";

	COL(alloc_count_row, count_nmalloc, right, 16, title);

	col_count_nmalloc.str_val = "nmalloc";

	COL(alloc_count_row, count_nmalloc_ps, right, 8, title);

	col_count_nmalloc_ps.str_val = "(#/sec)";

	COL(alloc_count_row, count_ndalloc, right, 16, title);

	col_count_ndalloc.str_val = "ndalloc";

	COL(alloc_count_row, count_ndalloc_ps, right, 8, title);

	col_count_ndalloc_ps.str_val = "(#/sec)";

	COL(alloc_count_row, count_nrequests, right, 16, title);

	col_count_nrequests.str_val = "nrequests";

	COL(alloc_count_row, count_nrequests_ps, right, 10, title);

	col_count_nrequests_ps.str_val = "(#/sec)";

	COL(alloc_count_row, count_nfills, right, 16, title);

	col_count_nfills.str_val = "nfill";

	COL(alloc_count_row, count_nfills_ps, right, 10, title);

	col_count_nfills_ps.str_val = "(#/sec)";

	COL(alloc_count_row, count_nflushes, right, 16, title);

	col_count_nflushes.str_val = "nflush";

	COL(alloc_count_row, count_nflushes_ps, right, 10, title);

	col_count_nflushes_ps.str_val = "(#/sec)";

	emitter_table_row(emitter, &alloc_count_row);

	col_count_nmalloc_ps.type = emitter_type_uint64;

	col_count_ndalloc_ps.type = emitter_type_uint64;

	col_count_nrequests_ps.type = emitter_type_uint64;

	col_count_nfills_ps.type = emitter_type_uint64;

	col_count_nflushes_ps.type = emitter_type_uint64;

#define GET_AND_EMIT_ALLOC_STAT(small_or_large, name, valtype)		\

	CTL_M2_GET("stats.arenas.0." #small_or_large "." #name, i,	\

	    &small_or_large##_##name, valtype##_t);			\

	emitter_json_kv(emitter, #name, emitter_type_##valtype,		\

	    &small_or_large##_##name);					\

	col_count_##name.type = emitter_type_##valtype;		\

	col_count_##name.valtype##_val = small_or_large##_##name;

	emitter_json_object_kv_begin(emitter, "small");

	col_count_title.str_val = "small:";

	GET_AND_EMIT_ALLOC_STAT(small, allocated, size)

	GET_AND_EMIT_ALLOC_STAT(small, nmalloc, uint64)

	col_count_nmalloc_ps.uint64_val =

	    rate_per_second(col_count_nmalloc.uint64_val, uptime);

	GET_AND_EMIT_ALLOC_STAT(small, ndalloc, uint64)

	col_count_ndalloc_ps.uint64_val =

	    rate_per_second(col_count_ndalloc.uint64_val, uptime);

	GET_AND_EMIT_ALLOC_STAT(small, nrequests, uint64)

	col_count_nrequests_ps.uint64_val =

	    rate_per_second(col_count_nrequests.uint64_val, uptime);

	GET_AND_EMIT_ALLOC_STAT(small, nfills, uint64)

	col_count_nfills_ps.uint64_val =

	    rate_per_second(col_count_nfills.uint64_val, uptime);

	GET_AND_EMIT_ALLOC_STAT(small, nflushes, uint64)

	col_count_nflushes_ps.uint64_val =

	    rate_per_second(col_count_nflushes.uint64_val, uptime);

	emitter_table_row(emitter, &alloc_count_row);

	emitter_json_object_end(emitter); /* Close "small". */