project-base/server-skynet-source-3rd-jemalloc
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e5acc35400
server-skynet-source-3rd-je.../src/stats.c

1225 lines
38 KiB
C
Raw Normal View History

Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define JEMALLOC_STATS_C_
Header refactoring: Split up jemalloc_internal.h This is a biggy. jemalloc_internal.h has been doing multiple jobs for a while now: - The source of system-wide definitions. - The catch-all include file. - The module header file for jemalloc.c This commit splits up this functionality. The system-wide definitions responsibility has moved to jemalloc_preamble.h. The catch-all include file is now jemalloc_internal_includes.h. The module headers for jemalloc.c are now in jemalloc_internal_[externs|inlines|types].h, just as they are for the other modules.
2017-04-11 09:17:55 +08:00
#include "jemalloc/internal/jemalloc_preamble.h"
#include "jemalloc/internal/jemalloc_internal_includes.h"
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
Header refactoring: move assert.h out of the catch-all
2017-04-12 05:43:12 +08:00
#include "jemalloc/internal/assert.h"
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
#include "jemalloc/internal/ctl.h"
Stats printing: Convert header and footer to use emitter.
2018-03-02 09:29:58 +08:00
#include "jemalloc/internal/emitter.h"
Header refactoring: unify and de-catchall mutex module
2017-05-24 03:28:19 +08:00
#include "jemalloc/internal/mutex.h"
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
#include "jemalloc/internal/mutex_prof.h"
Header refactoring: move assert.h out of the catch-all
2017-04-12 05:43:12 +08:00
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
const char *global_mutex_names[mutex_prof_num_global_mutexes] = {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#define OP(mtx) #mtx,
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
MUTEX_PROF_GLOBAL_MUTEXES
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#undef OP
};
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
const char *arena_mutex_names[mutex_prof_num_arena_mutexes] = {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#define OP(mtx) #mtx,
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
MUTEX_PROF_ARENA_MUTEXES
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#undef OP
};
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define CTL_GET(n, v, t) do { \
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
size_t sz = sizeof(t); \
Uniformly cast mallctl[bymib]() oldp/newp arguments to (void *). This avoids warnings in some cases, and is otherwise generally good hygiene.
2016-10-28 12:31:25 +08:00
xmallctl(n, (void *)v, &sz, NULL, 0); \
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
} while (0)
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define CTL_M2_GET(n, i, v, t) do { \
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
size_t mib[CTL_MAX_DEPTH]; \
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
size_t miblen = sizeof(mib) / sizeof(size_t); \
size_t sz = sizeof(t); \
xmallctlnametomib(n, mib, &miblen); \
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
mib[2] = (i); \
Uniformly cast mallctl[bymib]() oldp/newp arguments to (void *). This avoids warnings in some cases, and is otherwise generally good hygiene.
2016-10-28 12:31:25 +08:00
xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0); \
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
} while (0)
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define CTL_M2_M4_GET(n, i, j, v, t) do { \
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
size_t mib[CTL_MAX_DEPTH]; \
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
size_t miblen = sizeof(mib) / sizeof(size_t); \
size_t sz = sizeof(t); \
xmallctlnametomib(n, mib, &miblen); \
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
mib[2] = (i); \
mib[4] = (j); \
Uniformly cast mallctl[bymib]() oldp/newp arguments to (void *). This avoids warnings in some cases, and is otherwise generally good hygiene.
2016-10-28 12:31:25 +08:00
xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0); \
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
} while (0)
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
/******************************************************************************/
/* Data. */
Add opt.stats_print_opts. The value is passed to atexit(3)-triggered malloc_stats_print() calls.
2017-05-28 06:35:36 +08:00
bool opt_stats_print = false;
char opt_stats_print_opts[stats_print_tot_num_options+1] = "";
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
/******************************************************************************/
Output bin lock profiling results to malloc_stats. Two counters are included for the small bins: lock contention rate, and max lock waiting time.
2017-03-04 11:58:43 +08:00
/* 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;
}
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#define MUTEX_CTL_STR_MAX_LENGTH 128
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
static void
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
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);
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
}
static void
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
read_arena_bin_mutex_stats(unsigned arena_ind, unsigned bin_ind,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t results_uint64_t[mutex_prof_num_uint64_t_counters],
uint32_t results_uint32_t[mutex_prof_num_uint32_t_counters]) {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
char cmd[MUTEX_CTL_STR_MAX_LENGTH];
#define OP(c, t) \
gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH, \
"arenas.0.bins.0","mutex", #c); \
CTL_M2_M4_GET(cmd, arena_ind, bin_ind, \
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
(t *)&results_##t[mutex_counter_##c], t);
MUTEX_PROF_COUNTERS
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#undef OP
}
static void
mutex_stats_output_json(void (*write_cb)(void *, const char *), void *cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
const char *name, uint64_t stats_uint64_t[mutex_prof_num_uint64_t_counters],
uint32_t stats_uint32_t[mutex_prof_num_uint32_t_counters],
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
const char *json_indent, bool last) {
malloc_cprintf(write_cb, cbopaque, "%s\"%s\": {\n", json_indent, name);
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0;
mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0;
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
char *fmt_str[2] = {"%s\t\"%s\": %"FMTu32"%s\n",
"%s\t\"%s\": %"FMTu64"%s\n"};
#define OP(c, t) \
malloc_cprintf(write_cb, cbopaque, \
fmt_str[sizeof(t) / sizeof(uint32_t) - 1], \
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
json_indent, #c, (t)stats_##t[mutex_counter_##c], \
(++k_##t && k_uint32_t == mutex_prof_num_uint32_t_counters) ? "" : ",");
MUTEX_PROF_COUNTERS
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#undef OP
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
malloc_cprintf(write_cb, cbopaque, "%s}%s\n", json_indent,
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
last ? "" : ",");
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
static void
Simplify malloc_message(). Rather than passing four strings to malloc_message(), malloc_write4(), and all the functions that use them, only pass one string.
2010-03-04 09:45:38 +08:00
stats_arena_bins_print(void (*write_cb)(void *, const char *), void *cbopaque,
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
bool json, bool large, bool mutex, unsigned i) {
Finish renaming "arenas.pagesize" to "arenas.page".
2012-04-02 22:15:42 +08:00
size_t page;
Test JSON output of malloc_stats_print() and fix bugs. Implement and test a JSON validation parser. Use the parser to validate JSON output from malloc_stats_print(), with a significant subset of supported output options. This resolves #551.
2017-01-18 17:01:19 +08:00
bool in_gap, in_gap_prev;
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
unsigned nbins, j;
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Finish renaming "arenas.pagesize" to "arenas.page".
2012-04-02 22:15:42 +08:00
CTL_GET("arenas.page", &page, size_t);
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("arenas.nbins", &nbins, unsigned);
if (json) {
Simplify malloc_message(). Rather than passing four strings to malloc_message(), malloc_write4(), and all the functions that use them, only pass one string.
2010-03-04 09:45:38 +08:00
malloc_cprintf(write_cb, cbopaque,
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
"\t\t\t\t\"bins\": [\n");
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
} else {
Output 4 counters for bin mutexes instead of just 2.
2017-04-19 06:00:14 +08:00
char *mutex_counters = " n_lock_ops n_waiting"
Output all counters for bin mutex stats. The saved space is not worth the trouble of missing counters.
2017-10-20 03:01:20 +08:00
" n_spin_acq n_owner_switch total_wait_ns"
" max_wait_ns max_n_thds\n";
Remove --disable-tcache. Simplify configuration by removing the --disable-tcache option, but replace the testing for that configuration with --with-malloc-conf=tcache:false. Fix the thread.arena and thread.tcache.flush mallctls to work correctly if tcache is disabled. This partially resolves #580.
2017-04-21 08:21:37 +08:00
malloc_cprintf(write_cb, cbopaque,
"bins: size ind allocated nmalloc"
" ndalloc nrequests curregs curslabs regs"
" pgs util nfills nflushes newslabs"
" reslabs%s", mutex ? mutex_counters : "\n");
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
for (j = 0, in_gap = false; j < nbins; j++) {
Move slabs out of chunks.
2016-05-30 09:34:50 +08:00
uint64_t nslabs;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
size_t reg_size, slab_size, curregs;
size_t curslabs;
uint32_t nregs;
uint64_t nmalloc, ndalloc, nrequests, nfills, nflushes;
uint64_t nreslabs;
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Move slabs out of chunks.
2016-05-30 09:34:50 +08:00
CTL_M2_M4_GET("stats.arenas.0.bins.0.nslabs", i, j, &nslabs,
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
uint64_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
in_gap_prev = in_gap;
malloc_stats_print() fixes/cleanups. Fix and clean up various malloc_stats_print() issues caused by 0ba5b9b6189e16a983d8922d8c5cb6ab421906e8 (Add "J" (JSON) support to malloc_stats_print().).
2016-11-02 06:26:35 +08:00
in_gap = (nslabs == 0);
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (!json && in_gap_prev && !in_gap) {
malloc_cprintf(write_cb, cbopaque,
" ---\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_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);
Remove --disable-tcache. Simplify configuration by removing the --disable-tcache option, but replace the testing for that configuration with --with-malloc-conf=tcache:false. Fix the thread.arena and thread.tcache.flush mallctls to work correctly if tcache is disabled. This partially resolves #580.
2017-04-21 08:21:37 +08:00
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);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
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);
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t{\n"
"\t\t\t\t\t\t\"nmalloc\": %"FMTu64",\n"
"\t\t\t\t\t\t\"ndalloc\": %"FMTu64",\n"
"\t\t\t\t\t\t\"curregs\": %zu,\n"
Remove --disable-tcache. Simplify configuration by removing the --disable-tcache option, but replace the testing for that configuration with --with-malloc-conf=tcache:false. Fix the thread.arena and thread.tcache.flush mallctls to work correctly if tcache is disabled. This partially resolves #580.
2017-04-21 08:21:37 +08:00
"\t\t\t\t\t\t\"nrequests\": %"FMTu64",\n"
"\t\t\t\t\t\t\"nfills\": %"FMTu64",\n"
"\t\t\t\t\t\t\"nflushes\": %"FMTu64",\n"
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
"\t\t\t\t\t\t\"nreslabs\": %"FMTu64",\n"
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
"\t\t\t\t\t\t\"curslabs\": %zu%s\n",
Remove --disable-tcache. Simplify configuration by removing the --disable-tcache option, but replace the testing for that configuration with --with-malloc-conf=tcache:false. Fix the thread.arena and thread.tcache.flush mallctls to work correctly if tcache is disabled. This partially resolves #580.
2017-04-21 08:21:37 +08:00
nmalloc, ndalloc, curregs, nrequests, nfills,
nflushes, nreslabs, curslabs, mutex ? "," : "");
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
if (mutex) {
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t mutex_stats_64[mutex_prof_num_uint64_t_counters];
uint32_t mutex_stats_32[mutex_prof_num_uint32_t_counters];
read_arena_bin_mutex_stats(i, j, mutex_stats_64, mutex_stats_32);
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
mutex_stats_output_json(write_cb, cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
"mutex", mutex_stats_64, mutex_stats_32, "\t\t\t\t\t\t", true);
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
}
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t}%s\n",
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
(j + 1 < nbins) ? "," : "");
} else if (!in_gap) {
Output bin lock profiling results to malloc_stats. Two counters are included for the small bins: lock contention rate, and max lock waiting time.
2017-03-04 11:58:43 +08:00
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();
}
}
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t mutex_stats_64[mutex_prof_num_uint64_t_counters];
uint32_t mutex_stats_32[mutex_prof_num_uint32_t_counters];
Output 4 counters for bin mutexes instead of just 2.
2017-04-19 06:00:14 +08:00
if (mutex) {
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
read_arena_bin_mutex_stats(i, j, mutex_stats_64, mutex_stats_32);
Output 4 counters for bin mutexes instead of just 2.
2017-04-19 06:00:14 +08:00
}
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
Remove --disable-tcache. Simplify configuration by removing the --disable-tcache option, but replace the testing for that configuration with --with-malloc-conf=tcache:false. Fix the thread.arena and thread.tcache.flush mallctls to work correctly if tcache is disabled. This partially resolves #580.
2017-04-21 08:21:37 +08:00
malloc_cprintf(write_cb, cbopaque, "%20zu %3u %12zu %12"
FMTu64" %12"FMTu64" %12"FMTu64" %12zu %12zu %4u"
" %3zu %-5s %12"FMTu64" %12"FMTu64" %12"FMTu64
" %12"FMTu64, reg_size, j, curregs * reg_size,
nmalloc, ndalloc, nrequests, curregs, curslabs,
nregs, slab_size / page, util, nfills, nflushes,
nslabs, nreslabs);
Output total_wait_ns for bin mutexes.
2017-05-31 06:56:01 +08:00
Output 4 counters for bin mutexes instead of just 2.
2017-04-19 06:00:14 +08:00
if (mutex) {
malloc_cprintf(write_cb, cbopaque,
" %12"FMTu64" %12"FMTu64" %12"FMTu64
Output all counters for bin mutex stats. The saved space is not worth the trouble of missing counters.
2017-10-20 03:01:20 +08:00
" %14"FMTu64" %14"FMTu64" %12"FMTu64
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
" %10"FMTu32"\n",
mutex_stats_64[mutex_counter_num_ops],
mutex_stats_64[mutex_counter_num_wait],
mutex_stats_64[mutex_counter_num_spin_acq],
mutex_stats_64[mutex_counter_num_owner_switch],
mutex_stats_64[mutex_counter_total_wait_time],
mutex_stats_64[mutex_counter_max_wait_time],
mutex_stats_32[mutex_counter_max_num_thds]);
Output 4 counters for bin mutexes instead of just 2.
2017-04-19 06:00:14 +08:00
} else {
malloc_cprintf(write_cb, cbopaque, "\n");
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
}
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
malloc_cprintf(write_cb, cbopaque,
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
"\t\t\t\t]%s\n", large ? "," : "");
} else {
if (in_gap) {
malloc_cprintf(write_cb, cbopaque,
" ---\n");
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
}
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
static void
Rename huge to large.
2016-06-01 05:50:21 +08:00
stats_arena_lextents_print(void (*write_cb)(void *, const char *),
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
void *cbopaque, bool json, unsigned i) {
Rename huge to large.
2016-06-01 05:50:21 +08:00
unsigned nbins, nlextents, j;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
bool in_gap, in_gap_prev;
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
CTL_GET("arenas.nbins", &nbins, unsigned);
Rename huge to large.
2016-06-01 05:50:21 +08:00
CTL_GET("arenas.nlextents", &nlextents, unsigned);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"lextents\": [\n");
} else {
malloc_cprintf(write_cb, cbopaque,
"large: size ind allocated nmalloc"
" ndalloc nrequests curlextents\n");
}
Rename huge to large.
2016-06-01 05:50:21 +08:00
for (j = 0, in_gap = false; j < nlextents; j++) {
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
uint64_t nmalloc, ndalloc, nrequests;
Rename huge to large.
2016-06-01 05:50:21 +08:00
size_t lextent_size, curlextents;
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
Rename huge to large.
2016-06-01 05:50:21 +08:00
CTL_M2_M4_GET("stats.arenas.0.lextents.0.nmalloc", i, j,
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
&nmalloc, uint64_t);
Rename huge to large.
2016-06-01 05:50:21 +08:00
CTL_M2_M4_GET("stats.arenas.0.lextents.0.ndalloc", i, j,
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
&ndalloc, uint64_t);
Rename huge to large.
2016-06-01 05:50:21 +08:00
CTL_M2_M4_GET("stats.arenas.0.lextents.0.nrequests", i, j,
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
&nrequests, uint64_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
in_gap_prev = in_gap;
malloc_stats_print() fixes/cleanups. Fix and clean up various malloc_stats_print() issues caused by 0ba5b9b6189e16a983d8922d8c5cb6ab421906e8 (Add "J" (JSON) support to malloc_stats_print().).
2016-11-02 06:26:35 +08:00
in_gap = (nrequests == 0);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (!json && in_gap_prev && !in_gap) {
malloc_cprintf(write_cb, cbopaque,
" ---\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);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t{\n"
"\t\t\t\t\t\t\"curlextents\": %zu\n"
"\t\t\t\t\t}%s\n",
curlextents,
(j + 1 < nlextents) ? "," : "");
} else if (!in_gap) {
Simplify malloc_message(). Rather than passing four strings to malloc_message(), malloc_write4(), and all the functions that use them, only pass one string.
2010-03-04 09:45:38 +08:00
malloc_cprintf(write_cb, cbopaque,
Fix MinGW-related portability issues. Create and use FMT* macros that are equivalent to the PRI* macros that inttypes.h defines. This allows uniform use of the Unix-specific format specifiers, e.g. "%zu", as well as avoiding Windows-specific definitions of e.g. PRIu64. Add ffs()/ffsl() support for compiling with gcc. Extract compatibility definitions of ENOENT, EINVAL, EAGAIN, EPERM, ENOMEM, and ENORANGE into include/msvc_compat/windows_extra.h and use the file for tests as well as for core jemalloc code.
2015-07-24 04:56:25 +08:00
"%20zu %3u %12zu %12"FMTu64" %12"FMTu64
" %12"FMTu64" %12zu\n",
Rename huge to large.
2016-06-01 05:50:21 +08:00
lextent_size, nbins + j,
curlextents * lextent_size, nmalloc, ndalloc,
nrequests, curlextents);
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
malloc_cprintf(write_cb, cbopaque,
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
"\t\t\t\t]\n");
} else {
if (in_gap) {
malloc_cprintf(write_cb, cbopaque,
" ---\n");
}
Add per size class huge allocation statistics. Add per size class huge allocation statistics, and normalize various stats: - Change the arenas.nlruns type from size_t to unsigned. - Add the arenas.nhchunks and arenas.hchunks.<i>.size mallctl's. - Replace the stats.arenas.<i>.bins.<j>.allocated mallctl with stats.arenas.<i>.bins.<j>.curregs . - Add the stats.arenas.<i>.hchunks.<j>.nmalloc, stats.arenas.<i>.hchunks.<j>.ndalloc, stats.arenas.<i>.hchunks.<j>.nrequests, and stats.arenas.<i>.hchunks.<j>.curhchunks mallctl's.
2014-10-13 13:53:59 +08:00
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
static void
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
read_arena_mutex_stats(unsigned arena_ind,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t results_uint64_t[mutex_prof_num_arena_mutexes][mutex_prof_num_uint64_t_counters],
uint32_t results_uint32_t[mutex_prof_num_arena_mutexes][mutex_prof_num_uint32_t_counters]) {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
char cmd[MUTEX_CTL_STR_MAX_LENGTH];
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
mutex_prof_arena_ind_t i;
for (i = 0; i < mutex_prof_num_arena_mutexes; i++) {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#define OP(c, t) \
gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH, \
"arenas.0.mutexes", arena_mutex_names[i], #c); \
CTL_M2_GET(cmd, arena_ind, \
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
(t *)&results_##t[i][mutex_counter_##c], t);
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
MUTEX_PROF_COUNTERS
#undef OP
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
}
}
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
static void
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
mutex_stats_output(void (*write_cb)(void *, const char *), void *cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
const char *name, uint64_t stats_uint64_t[mutex_prof_num_uint64_t_counters],
uint32_t stats_uint32_t[mutex_prof_num_uint32_t_counters],
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
bool first_mutex) {
if (first_mutex) {
/* Print title. */
malloc_cprintf(write_cb, cbopaque,
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
" n_lock_ops n_waiting"
" n_spin_acq n_owner_switch total_wait_ns"
" max_wait_ns max_n_thds\n");
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
}
malloc_cprintf(write_cb, cbopaque, "%s", name);
malloc_cprintf(write_cb, cbopaque, ":%*c",
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
(int)(20 - strlen(name)), ' ');
char *fmt_str[2] = {"%12"FMTu32, "%16"FMTu64};
#define OP(c, t) \
malloc_cprintf(write_cb, cbopaque, \
fmt_str[sizeof(t) / sizeof(uint32_t) - 1], \
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
(t)stats_##t[mutex_counter_##c]);
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
MUTEX_PROF_COUNTERS
#undef OP
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
malloc_cprintf(write_cb, cbopaque, "\n");
}
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
static void
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
stats_arena_mutexes_print(void (*write_cb)(void *, const char *),
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
void *cbopaque, bool json, bool json_end, unsigned arena_ind) {
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t mutex_stats_64[mutex_prof_num_arena_mutexes][mutex_prof_num_uint64_t_counters];
uint32_t mutex_stats_32[mutex_prof_num_arena_mutexes][mutex_prof_num_uint32_t_counters];
read_arena_mutex_stats(arena_ind, mutex_stats_64, mutex_stats_32);
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
/* Output mutex stats. */
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
if (json) {
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
malloc_cprintf(write_cb, cbopaque, "\t\t\t\t\"mutexes\": {\n");
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
mutex_prof_arena_ind_t i, last_mutex;
last_mutex = mutex_prof_num_arena_mutexes - 1;
for (i = 0; i < mutex_prof_num_arena_mutexes; i++) {
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
mutex_stats_output_json(write_cb, cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
arena_mutex_names[i], mutex_stats_64[i], mutex_stats_32[i],
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
"\t\t\t\t\t", (i == last_mutex));
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
}
malloc_cprintf(write_cb, cbopaque, "\t\t\t\t}%s\n",
json_end ? "" : ",");
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
} else {
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
mutex_prof_arena_ind_t i;
for (i = 0; i < mutex_prof_num_arena_mutexes; i++) {
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
mutex_stats_output(write_cb, cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
arena_mutex_names[i], mutex_stats_64[i], mutex_stats_32[i], i == 0);
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
}
}
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
static void
Simplify malloc_message(). Rather than passing four strings to malloc_message(), malloc_write4(), and all the functions that use them, only pass one string.
2010-03-04 09:45:38 +08:00
stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
bool json, unsigned i, bool bins, bool large, bool mutex) {
Improve thread-->arena assignment. Rather than blindly assigning threads to arenas in round-robin fashion, choose the lowest-numbered arena that currently has the smallest number of threads assigned to it. Add the "stats.arenas.<i>.nthreads" mallctl.
2011-03-19 04:41:33 +08:00
unsigned nthreads;
Add arena-specific and selective dss allocation. Add the "arenas.extend" mallctl, so that it is possible to create new arenas that are outside the set that jemalloc automatically multiplexes threads onto. Add the ALLOCM_ARENA() flag for {,r,d}allocm(), so that it is possible to explicitly allocate from a particular arena. Add the "opt.dss" mallctl, which controls the default precedence of dss allocation relative to mmap allocation. Add the "arena.<i>.dss" mallctl, which makes it possible to set the default dss precedence on a per arena or global basis. Add the "arena.<i>.purge" mallctl, which obsoletes "arenas.purge". Add the "stats.arenas.<i>.dss" mallctl.
2012-10-12 04:53:15 +08:00
const char *dss;
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.
2017-05-18 01:47:00 +08:00
ssize_t dirty_decay_ms, muzzy_decay_ms;
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
size_t page, pactive, pdirty, pmuzzy, mapped, retained;
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
size_t base, internal, resident, metadata_thp;
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
uint64_t dirty_npurge, dirty_nmadvise, dirty_purged;
uint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged;
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
size_t small_allocated;
Push locks into arena bins. For bin-related allocation, protect data structures with bin locks rather than arena locks. Arena locks remain for run allocation/deallocation and other miscellaneous operations. Restructure statistics counters to maintain per bin allocated/nmalloc/ndalloc, but continue to provide arena-wide statistics via aggregation in the ctl code.
2010-03-14 12:32:56 +08:00
uint64_t small_nmalloc, small_ndalloc, small_nrequests;
Rename huge to large.
2016-06-01 05:50:21 +08:00
size_t large_allocated;
uint64_t large_nmalloc, large_ndalloc, large_nrequests;
Added stats about number of bytes cached in tcache currently.
2016-04-23 09:37:44 +08:00
size_t tcache_bytes;
Add stats: arena uptime.
2017-05-17 04:56:00 +08:00
uint64_t uptime;
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Finish renaming "arenas.pagesize" to "arenas.page".
2012-04-02 22:15:42 +08:00
CTL_GET("arenas.page", &page, size_t);
Statistics fixes and cleanup. Fix a type mismatch for "arenas.nlruns" mallctl access. This bug caused a crash during statistics printing on 64-bit systems. Fix the "stats.active" mallctl to include active memory in huge objects. Report active bytes for the whole application, as well as per arena. Remove several unused variables.
2010-01-30 03:24:19 +08:00
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
CTL_M2_GET("stats.arenas.0.nthreads", i, &nthreads, unsigned);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"nthreads\": %u,\n", nthreads);
} else {
malloc_cprintf(write_cb, cbopaque,
"assigned threads: %u\n", nthreads);
}
Add stats: arena uptime.
2017-05-17 04:56:00 +08:00
CTL_M2_GET("stats.arenas.0.uptime", i, &uptime, uint64_t);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"uptime_ns\": %"FMTu64",\n", uptime);
} else {
malloc_cprintf(write_cb, cbopaque,
"uptime: %"FMTu64"\n", uptime);
}
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
CTL_M2_GET("stats.arenas.0.dss", i, &dss, const char *);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"dss\": \"%s\",\n", dss);
} else {
malloc_cprintf(write_cb, cbopaque,
"dss allocation precedence: %s\n", dss);
}
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.
2017-05-18 01:47:00 +08:00
CTL_M2_GET("stats.arenas.0.dirty_decay_ms", i, &dirty_decay_ms,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
ssize_t);
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.
2017-05-18 01:47:00 +08:00
CTL_M2_GET("stats.arenas.0.muzzy_decay_ms", i, &muzzy_decay_ms,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
ssize_t);
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
CTL_M2_GET("stats.arenas.0.pactive", i, &pactive, size_t);
CTL_M2_GET("stats.arenas.0.pdirty", i, &pdirty, size_t);
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
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);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
malloc_cprintf(write_cb, cbopaque,
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.
2017-05-18 01:47:00 +08:00
"\t\t\t\t\"dirty_decay_ms\": %zd,\n", dirty_decay_ms);
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
malloc_cprintf(write_cb, cbopaque,
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.
2017-05-18 01:47:00 +08:00
"\t\t\t\t\"muzzy_decay_ms\": %zd,\n", muzzy_decay_ms);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"pactive\": %zu,\n", pactive);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"pdirty\": %zu,\n", pdirty);
malloc_cprintf(write_cb, cbopaque,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
"\t\t\t\t\"pmuzzy\": %zu,\n", pmuzzy);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"dirty_npurge\": %"FMTu64",\n", dirty_npurge);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
"\t\t\t\t\"dirty_nmadvise\": %"FMTu64",\n", dirty_nmadvise);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
"\t\t\t\t\"dirty_purged\": %"FMTu64",\n", dirty_purged);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"muzzy_npurge\": %"FMTu64",\n", muzzy_npurge);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"muzzy_nmadvise\": %"FMTu64",\n", muzzy_nmadvise);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"muzzy_purged\": %"FMTu64",\n", muzzy_purged);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} else {
malloc_cprintf(write_cb, cbopaque,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
"decaying: time npages sweeps madvises"
" purged\n");
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.
2017-05-18 01:47:00 +08:00
if (dirty_decay_ms >= 0) {
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
malloc_cprintf(write_cb, cbopaque,
" dirty: %5zd %12zu %12"FMTu64" %12"FMTu64" %12"
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.
2017-05-18 01:47:00 +08:00
FMTu64"\n", dirty_decay_ms, pdirty, dirty_npurge,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
dirty_nmadvise, dirty_purged);
} else {
malloc_cprintf(write_cb, cbopaque,
" dirty: N/A %12zu %12"FMTu64" %12"FMTu64" %12"
FMTu64"\n", pdirty, dirty_npurge, dirty_nmadvise,
dirty_purged);
}
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.
2017-05-18 01:47:00 +08:00
if (muzzy_decay_ms >= 0) {
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
malloc_cprintf(write_cb, cbopaque,
" muzzy: %5zd %12zu %12"FMTu64" %12"FMTu64" %12"
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.
2017-05-18 01:47:00 +08:00
FMTu64"\n", muzzy_decay_ms, pmuzzy, muzzy_npurge,
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
muzzy_nmadvise, muzzy_purged);
} else {
malloc_cprintf(write_cb, cbopaque,
" muzzy: N/A %12zu %12"FMTu64" %12"FMTu64" %12"
FMTu64"\n", pmuzzy, muzzy_npurge, muzzy_nmadvise,
muzzy_purged);
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
CTL_M2_GET("stats.arenas.0.small.allocated", i, &small_allocated,
size_t);
CTL_M2_GET("stats.arenas.0.small.nmalloc", i, &small_nmalloc, uint64_t);
CTL_M2_GET("stats.arenas.0.small.ndalloc", i, &small_ndalloc, uint64_t);
CTL_M2_GET("stats.arenas.0.small.nrequests", i, &small_nrequests,
uint64_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"small\": {\n");
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"allocated\": %zu,\n", small_allocated);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"nmalloc\": %"FMTu64",\n", small_nmalloc);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"ndalloc\": %"FMTu64",\n", small_ndalloc);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"nrequests\": %"FMTu64"\n", small_nrequests);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t},\n");
} else {
malloc_cprintf(write_cb, cbopaque,
" allocated nmalloc"
" ndalloc nrequests\n");
malloc_cprintf(write_cb, cbopaque,
"small: %12zu %12"FMTu64" %12"FMTu64
" %12"FMTu64"\n",
small_allocated, small_nmalloc, small_ndalloc,
small_nrequests);
}
Rename huge to large.
2016-06-01 05:50:21 +08:00
CTL_M2_GET("stats.arenas.0.large.allocated", i, &large_allocated,
size_t);
CTL_M2_GET("stats.arenas.0.large.nmalloc", i, &large_nmalloc, uint64_t);
CTL_M2_GET("stats.arenas.0.large.ndalloc", i, &large_ndalloc, uint64_t);
CTL_M2_GET("stats.arenas.0.large.nrequests", i, &large_nrequests,
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
uint64_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"large\": {\n");
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"allocated\": %zu,\n", large_allocated);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"nmalloc\": %"FMTu64",\n", large_nmalloc);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"ndalloc\": %"FMTu64",\n", large_ndalloc);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"nrequests\": %"FMTu64"\n", large_nrequests);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t},\n");
} else {
malloc_cprintf(write_cb, cbopaque,
"large: %12zu %12"FMTu64" %12"FMTu64
" %12"FMTu64"\n",
large_allocated, large_nmalloc, large_ndalloc,
large_nrequests);
malloc_cprintf(write_cb, cbopaque,
"total: %12zu %12"FMTu64" %12"FMTu64
" %12"FMTu64"\n",
small_allocated + large_allocated, small_nmalloc +
large_nmalloc, small_ndalloc + large_ndalloc,
small_nrequests + large_nrequests);
}
if (!json) {
malloc_cprintf(write_cb, cbopaque,
"active: %12zu\n", pactive * page);
}
Fix lg_dirty_mult-related stats printing. This regression was introduced by 8d6a3e8321a7767cb2ca0930b85d5d488a8cc659 (Implement dynamic per arena control over dirty page purging.). This resolves #215.
2015-03-21 09:08:10 +08:00
CTL_M2_GET("stats.arenas.0.mapped", i, &mapped, size_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"mapped\": %zu,\n", mapped);
} else {
malloc_cprintf(write_cb, cbopaque,
"mapped: %12zu\n", mapped);
}
Add the stats.retained and stats.arenas.<i>.retained statistics. This resolves #367.
2016-05-04 13:11:35 +08:00
CTL_M2_GET("stats.arenas.0.retained", i, &retained, size_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"retained\": %zu,\n", retained);
} else {
malloc_cprintf(write_cb, cbopaque,
"retained: %12zu\n", retained);
}
Implement per arena base allocators. Add/rename related mallctls: - Add stats.arenas.<i>.base . - Rename stats.arenas.<i>.metadata to stats.arenas.<i>.internal . - Add stats.arenas.<i>.resident . Modify the arenas.extend mallctl to take an optional (extent_hooks_t *) argument so that it is possible for all base allocations to be serviced by the specified extent hooks. This resolves #463.
2016-12-23 06:39:10 +08:00
CTL_M2_GET("stats.arenas.0.base", i, &base, size_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
Implement per arena base allocators. Add/rename related mallctls: - Add stats.arenas.<i>.base . - Rename stats.arenas.<i>.metadata to stats.arenas.<i>.internal . - Add stats.arenas.<i>.resident . Modify the arenas.extend mallctl to take an optional (extent_hooks_t *) argument so that it is possible for all base allocations to be serviced by the specified extent hooks. This resolves #463.
2016-12-23 06:39:10 +08:00
"\t\t\t\t\"base\": %zu,\n", base);
} else {
malloc_cprintf(write_cb, cbopaque,
"base: %12zu\n", base);
}
CTL_M2_GET("stats.arenas.0.internal", i, &internal, size_t);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"internal\": %zu,\n", internal);
} else {
malloc_cprintf(write_cb, cbopaque,
"internal: %12zu\n", internal);
}
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
CTL_M2_GET("stats.arenas.0.metadata_thp", i, &metadata_thp, size_t);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"metadata_thp\": %zu,\n", metadata_thp);
} else {
malloc_cprintf(write_cb, cbopaque,
"metadata_thp: %12zu\n", metadata_thp);
}
Remove --disable-tcache. Simplify configuration by removing the --disable-tcache option, but replace the testing for that configuration with --with-malloc-conf=tcache:false. Fix the thread.arena and thread.tcache.flush mallctls to work correctly if tcache is disabled. This partially resolves #580.
2017-04-21 08:21:37 +08:00
CTL_M2_GET("stats.arenas.0.tcache_bytes", i, &tcache_bytes, size_t);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"tcache\": %zu,\n", tcache_bytes);
} else {
malloc_cprintf(write_cb, cbopaque,
"tcache: %12zu\n", tcache_bytes);
Added stats about number of bytes cached in tcache currently.
2016-04-23 09:37:44 +08:00
}
Implement per arena base allocators. Add/rename related mallctls: - Add stats.arenas.<i>.base . - Rename stats.arenas.<i>.metadata to stats.arenas.<i>.internal . - Add stats.arenas.<i>.resident . Modify the arenas.extend mallctl to take an optional (extent_hooks_t *) argument so that it is possible for all base allocations to be serviced by the specified extent hooks. This resolves #463.
2016-12-23 06:39:10 +08:00
CTL_M2_GET("stats.arenas.0.resident", i, &resident, size_t);
if (json) {
malloc_cprintf(write_cb, cbopaque,
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
"\t\t\t\t\"resident\": %zu%s\n", resident,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
(bins || large || mutex) ? "," : "");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} else {
malloc_cprintf(write_cb, cbopaque,
Implement per arena base allocators. Add/rename related mallctls: - Add stats.arenas.<i>.base . - Rename stats.arenas.<i>.metadata to stats.arenas.<i>.internal . - Add stats.arenas.<i>.resident . Modify the arenas.extend mallctl to take an optional (extent_hooks_t *) argument so that it is possible for all base allocations to be serviced by the specified extent hooks. This resolves #463.
2016-12-23 06:39:10 +08:00
"resident: %12zu\n", resident);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
if (mutex) {
stats_arena_mutexes_print(write_cb, cbopaque, json,
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
!(bins || large), i);
}
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
if (bins) {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
stats_arena_bins_print(write_cb, cbopaque, json, large, mutex,
i);
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
}
if (large) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
stats_arena_lextents_print(write_cb, cbopaque, json, i);
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
static void
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
stats_general_print(emitter_t *emitter, bool more) {
/*
* These should eventually be deleted; they are useful in converting
* from manual to emitter-based stats output, though.
*/
void (*write_cb)(void *, const char *) = emitter->write_cb;
void *cbopaque = emitter->cbopaque;
bool json = (emitter->output == emitter_output_json);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
const char *cpv;
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
bool bv, bv2;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
unsigned uv;
uint32_t u32v;
uint64_t u64v;
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
ssize_t ssv, ssv2;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
size_t sv, bsz, usz, ssz, sssz, cpsz;
bsz = sizeof(bool);
usz = sizeof(unsigned);
ssz = sizeof(size_t);
sssz = sizeof(ssize_t);
cpsz = sizeof(const char *);
CTL_GET("version", &cpv, const char *);
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
emitter_kv(emitter, "version", "Version", emitter_type_string, &cpv);
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/* config. */
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
emitter_dict_begin(emitter, "config", "Build-time option settings");
#define CONFIG_WRITE_BOOL(name) \
do { \
CTL_GET("config."#name, &bv, bool); \
emitter_kv(emitter, #name, "config."#name, \
emitter_type_bool, &bv); \
} while (0)
CONFIG_WRITE_BOOL(cache_oblivious);
CONFIG_WRITE_BOOL(debug);
CONFIG_WRITE_BOOL(fill);
CONFIG_WRITE_BOOL(lazy_lock);
emitter_kv(emitter, "malloc_conf", "config.malloc_conf",
emitter_type_string, &config_malloc_conf);
CONFIG_WRITE_BOOL(prof);
CONFIG_WRITE_BOOL(prof_libgcc);
CONFIG_WRITE_BOOL(prof_libunwind);
CONFIG_WRITE_BOOL(stats);
CONFIG_WRITE_BOOL(utrace);
CONFIG_WRITE_BOOL(xmalloc);
#undef CONFIG_WRITE_BOOL
emitter_dict_end(emitter); /* Close "config" dict. */
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/* opt. */
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
#define OPT_WRITE(name, var, size, emitter_type) \
if (je_mallctl("opt."#name, (void *)&var, &size, NULL, 0) == \
0) { \
emitter_kv(emitter, #name, "opt."#name, emitter_type, \
&var); \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Replace JEMALLOC_OPTIONS with MALLOC_CONF. Replace the single-character run-time flags with key/value pairs, which can be set via the malloc_conf global, /etc/malloc.conf, and the MALLOC_CONF environment variable. Replace the JEMALLOC_PROF_PREFIX environment variable with the "opt.prof_prefix" option. Replace umax2s() with u2s().
2010-10-24 09:37:06 +08:00
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
#define OPT_WRITE_MUTABLE(name, var1, var2, size, emitter_type, \
altname) \
if (je_mallctl("opt."#name, (void *)&var1, &size, NULL, 0) == \
0 && je_mallctl(#altname, (void *)&var2, &size, NULL, 0) \
== 0) { \
emitter_kv_note(emitter, #name, "opt."#name, \
emitter_type, &var1, #altname, emitter_type, \
&var2); \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Replace JEMALLOC_OPTIONS with MALLOC_CONF. Replace the single-character run-time flags with key/value pairs, which can be set via the malloc_conf global, /etc/malloc.conf, and the MALLOC_CONF environment variable. Replace the JEMALLOC_PROF_PREFIX environment variable with the "opt.prof_prefix" option. Replace umax2s() with u2s().
2010-10-24 09:37:06 +08:00
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
#define OPT_WRITE_BOOL(name) OPT_WRITE(name, bv, bsz, emitter_type_bool)
#define OPT_WRITE_BOOL_MUTABLE(name, altname) \
OPT_WRITE_MUTABLE(name, bv, bv2, bsz, emitter_type_bool, altname)
#define OPT_WRITE_UNSIGNED(name) \
OPT_WRITE(name, uv, usz, emitter_type_unsigned)
#define OPT_WRITE_SSIZE_T(name) \
OPT_WRITE(name, ssv, sssz, emitter_type_ssize)
#define OPT_WRITE_SSIZE_T_MUTABLE(name, altname) \
OPT_WRITE_MUTABLE(name, ssv, ssv2, sssz, emitter_type_ssize, \
altname)
#define OPT_WRITE_CHAR_P(name) \
OPT_WRITE(name, cpv, cpsz, emitter_type_string)
emitter_dict_begin(emitter, "opt", "Run-time option settings");
OPT_WRITE_BOOL(abort)
OPT_WRITE_BOOL(abort_conf)
OPT_WRITE_BOOL(retain)
OPT_WRITE_CHAR_P(dss)
OPT_WRITE_UNSIGNED(narenas)
OPT_WRITE_CHAR_P(percpu_arena)
OPT_WRITE_CHAR_P(metadata_thp)
OPT_WRITE_BOOL_MUTABLE(background_thread, background_thread)
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_UNSIGNED(lg_extent_max_active_fit)
OPT_WRITE_CHAR_P(junk)
OPT_WRITE_BOOL(zero)
OPT_WRITE_BOOL(utrace)
OPT_WRITE_BOOL(xmalloc)
OPT_WRITE_BOOL(tcache)
OPT_WRITE_SSIZE_T(lg_tcache_max)
OPT_WRITE_CHAR_P(thp)
OPT_WRITE_BOOL(prof)
OPT_WRITE_CHAR_P(prof_prefix)
OPT_WRITE_BOOL_MUTABLE(prof_active, prof.active)
OPT_WRITE_BOOL_MUTABLE(prof_thread_active_init, prof.thread_active_init)
OPT_WRITE_SSIZE_T_MUTABLE(lg_prof_sample, prof.lg_sample)
OPT_WRITE_BOOL(prof_accum)
OPT_WRITE_SSIZE_T(lg_prof_interval)
OPT_WRITE_BOOL(prof_gdump)
OPT_WRITE_BOOL(prof_final)
OPT_WRITE_BOOL(prof_leak)
OPT_WRITE_BOOL(stats_print)
OPT_WRITE_CHAR_P(stats_print_opts)
emitter_dict_end(emitter);
#undef OPT_WRITE
#undef OPT_WRITE_MUTABLE
Replace JEMALLOC_OPTIONS with MALLOC_CONF. Replace the single-character run-time flags with key/value pairs, which can be set via the malloc_conf global, /etc/malloc.conf, and the MALLOC_CONF environment variable. Replace the JEMALLOC_PROF_PREFIX environment variable with the "opt.prof_prefix" option. Replace umax2s() with u2s().
2010-10-24 09:37:06 +08:00
#undef OPT_WRITE_BOOL
Implement/test/fix prof-related mallctl's. Implement/test/fix the opt.prof_thread_active_init, prof.thread_active_init, and thread.prof.active mallctl's. Test/fix the thread.prof.name mallctl. Refactor opt_prof_active to be read-only and move mutable state into the prof_active variable. Stop leaning on ctl-related locking for protection.
2014-10-04 14:25:30 +08:00
#undef OPT_WRITE_BOOL_MUTABLE
Output opt.lg_extent_max_active_fit in stats.
2017-12-15 03:14:08 +08:00
#undef OPT_WRITE_UNSIGNED
Replace JEMALLOC_OPTIONS with MALLOC_CONF. Replace the single-character run-time flags with key/value pairs, which can be set via the malloc_conf global, /etc/malloc.conf, and the MALLOC_CONF environment variable. Replace the JEMALLOC_PROF_PREFIX environment variable with the "opt.prof_prefix" option. Replace umax2s() with u2s().
2010-10-24 09:37:06 +08:00
#undef OPT_WRITE_SSIZE_T
Output opt.lg_extent_max_active_fit in stats.
2017-12-15 03:14:08 +08:00
#undef OPT_WRITE_SSIZE_T_MUTABLE
Replace JEMALLOC_OPTIONS with MALLOC_CONF. Replace the single-character run-time flags with key/value pairs, which can be set via the malloc_conf global, /etc/malloc.conf, and the MALLOC_CONF environment variable. Replace the JEMALLOC_PROF_PREFIX environment variable with the "opt.prof_prefix" option. Replace umax2s() with u2s().
2010-10-24 09:37:06 +08:00
#undef OPT_WRITE_CHAR_P
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/* arenas. */
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
/*
* The json output sticks arena info into an "arenas" dict; the table
* output puts them at the top-level.
*/
emitter_json_dict_begin(emitter, "arenas");
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("arenas.narenas", &uv, unsigned);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_kv(emitter, "narenas", "Arenas", emitter_type_unsigned, &uv);
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
/*
* Decay settings are emitted only in json mode; in table mode, they're
* emitted as notes with the opt output, above.
*/
CTL_GET("arenas.dirty_decay_ms", &ssv, ssize_t);
emitter_json_kv(emitter, "dirty_decay_ms", emitter_type_ssize, &ssv);
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
CTL_GET("arenas.muzzy_decay_ms", &ssv, ssize_t);
emitter_json_kv(emitter, "muzzy_decay_ms", emitter_type_ssize, &ssv);
Implement two-phase decay-based purging. Split decay-based purging into two phases, the first of which uses lazy purging to convert dirty pages to "muzzy", and the second of which uses forced purging, decommit, or unmapping to convert pages to clean or destroy them altogether. Not all operating systems support lazy purging, yet the application may provide extent hooks that implement lazy purging, so care must be taken to dynamically omit the first phase when necessary. The mallctl interfaces change as follows: - opt.decay_time --> opt.{dirty,muzzy}_decay_time - arena.<i>.decay_time --> arena.<i>.{dirty,muzzy}_decay_time - arenas.decay_time --> arenas.{dirty,muzzy}_decay_time - stats.arenas.<i>.pdirty --> stats.arenas.<i>.p{dirty,muzzy} - stats.arenas.<i>.{npurge,nmadvise,purged} --> stats.arenas.<i>.{dirty,muzzy}_{npurge,nmadvise,purged} This resolves #521.
2017-03-09 14:42:57 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("arenas.quantum", &sv, size_t);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_kv(emitter, "quantum", "Quantum size", emitter_type_size, &sv);
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("arenas.page", &sv, size_t);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_kv(emitter, "page", "Page size", emitter_type_size, &sv);
Clean up *PAGE* macros. s/PAGE_SHIFT/LG_PAGE/g and s/PAGE_SIZE/PAGE/g. Remove remnants of the dynamic-page-shift code. Rename the "arenas.pagesize" mallctl to "arenas.page". Remove the "arenas.chunksize" mallctl, which is redundant with "opt.lg_chunk".
2012-04-02 22:04:34 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (je_mallctl("arenas.tcache_max", (void *)&sv, &ssz, NULL, 0) == 0) {
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_kv(emitter, "tcache_max",
"Maximum thread-cached size class", emitter_type_size, &sv);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
unsigned nbins;
CTL_GET("arenas.nbins", &nbins, unsigned);
emitter_kv(emitter, "nbins", "Number of bin size classes",
emitter_type_unsigned, &nbins);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
unsigned nhbins;
CTL_GET("arenas.nhbins", &nhbins, unsigned);
emitter_kv(emitter, "nhbins", "Number of thread-cache bin size classes",
emitter_type_unsigned, &nhbins);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
/*
* We do enough mallctls in a loop that we actually want to omit them
* (not just omit the printing).
*/
if (emitter->output == emitter_output_json) {
emitter_json_arr_begin(emitter, "bin");
for (unsigned i = 0; i < nbins; i++) {
emitter_json_arr_obj_begin(emitter);
Implement sampling for heap profiling.
2010-03-02 12:15:26 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_M2_GET("arenas.bin.0.size", i, &sv, size_t);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_kv(emitter, "size", emitter_type_size,
&sv);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_M2_GET("arenas.bin.0.nregs", i, &u32v, uint32_t);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_kv(emitter, "nregs", emitter_type_uint32,
&u32v);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_M2_GET("arenas.bin.0.slab_size", i, &sv, size_t);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_kv(emitter, "slab_size", emitter_type_size,
&sv);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_arr_obj_end(emitter);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_arr_end(emitter); /* Close "bin". */
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
unsigned nlextents;
CTL_GET("arenas.nlextents", &nlextents, unsigned);
emitter_kv(emitter, "nlextents", "Number of large size classes",
emitter_type_unsigned, &nlextents);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
if (emitter->output == emitter_output_json) {
emitter_json_arr_begin(emitter, "lextent");
for (unsigned i = 0; i < nlextents; i++) {
emitter_json_arr_obj_begin(emitter);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_M2_GET("arenas.lextent.0.size", i, &sv, size_t);
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_kv(emitter, "size", emitter_type_size,
&sv);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_arr_obj_end(emitter);
Implement interval-based heap profile dumping. Add mallctl interfaces for profiling parameters. Fix a file descriptor leak in heap profile dumping.
2010-02-12 05:19:21 +08:00
}
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_arr_end(emitter); /* Close "lextent". */
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert general arena stats to use the emitter.
2018-03-02 10:02:42 +08:00
emitter_json_dict_end(emitter); /* Close "arenas" */
if (json) {
if (more || config_prof) {
malloc_cprintf(write_cb, cbopaque, ",\n");
} else {
malloc_cprintf(write_cb, cbopaque, "\n");
}
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/* prof. */
Fix JSON-mode output for !config_stats and/or !config_prof cases. These bugs were introduced by 0ba5b9b6189e16a983d8922d8c5cb6ab421906e8 (Add "J" (JSON) support to malloc_stats_print().), which was backported as b599b32280e1142856b0b96293a71e1684b1ccfb (with the same bugs except the inapplicable "metatata" misspelling) and first released in 4.3.0.
2016-12-24 03:15:44 +08:00
if (config_prof && json) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque,
"\t\t\"prof\": {\n");
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("prof.thread_active_init", &bv, bool);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"thread_active_init\": %s,\n", bv ? "true" :
"false");
CTL_GET("prof.active", &bv, bool);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"active\": %s,\n", bv ? "true" : "false");
CTL_GET("prof.gdump", &bv, bool);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"gdump\": %s,\n", bv ? "true" : "false");
CTL_GET("prof.interval", &u64v, uint64_t);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"interval\": %"FMTu64",\n", u64v);
CTL_GET("prof.lg_sample", &ssv, ssize_t);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"lg_sample\": %zd\n", ssv);
malloc_cprintf(write_cb, cbopaque,
Fix JSON-mode output for !config_stats and/or !config_prof cases. These bugs were introduced by 0ba5b9b6189e16a983d8922d8c5cb6ab421906e8 (Add "J" (JSON) support to malloc_stats_print().), which was backported as b599b32280e1142856b0b96293a71e1684b1ccfb (with the same bugs except the inapplicable "metatata" misspelling) and first released in 4.3.0.
2016-12-24 03:15:44 +08:00
"\t\t}%s\n", more ? "," : "");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
}
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
static void
read_global_mutex_stats(
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t results_uint64_t[mutex_prof_num_global_mutexes][mutex_prof_num_uint64_t_counters],
uint32_t results_uint32_t[mutex_prof_num_global_mutexes][mutex_prof_num_uint32_t_counters]) {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
char cmd[MUTEX_CTL_STR_MAX_LENGTH];
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
mutex_prof_global_ind_t i;
for (i = 0; i < mutex_prof_num_global_mutexes; i++) {
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
#define OP(c, t) \
gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH, \
"mutexes", global_mutex_names[i], #c); \
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
CTL_GET(cmd, (t *)&results_##t[i][mutex_counter_##c], t);
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
MUTEX_PROF_COUNTERS
#undef OP
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
}
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
static void
stats_print_helper(void (*write_cb)(void *, const char *), void *cbopaque,
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
bool json, bool merged, bool destroyed, bool unmerged, bool bins,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
bool large, bool mutex) {
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
size_t allocated, active, metadata, metadata_thp, resident, mapped,
retained;
Add background thread related stats.
2017-05-13 03:30:33 +08:00
size_t num_background_threads;
uint64_t background_thread_num_runs, background_thread_run_interval;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("stats.allocated", &allocated, size_t);
CTL_GET("stats.active", &active, size_t);
CTL_GET("stats.metadata", &metadata, size_t);
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
CTL_GET("stats.metadata_thp", &metadata_thp, size_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("stats.resident", &resident, size_t);
CTL_GET("stats.mapped", &mapped, size_t);
CTL_GET("stats.retained", &retained, size_t);
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
uint64_t mutex_stats_uint64_t[mutex_prof_num_global_mutexes][mutex_prof_num_uint64_t_counters];
uint32_t mutex_stats_uint32_t[mutex_prof_num_global_mutexes][mutex_prof_num_uint32_t_counters];
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
if (mutex) {
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
read_global_mutex_stats(mutex_stats_uint64_t, mutex_stats_uint32_t);
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
}
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
Add background thread related stats.
2017-05-13 03:30:33 +08:00
if (have_background_thread) {
CTL_GET("stats.background_thread.num_threads",
&num_background_threads, size_t);
CTL_GET("stats.background_thread.num_runs",
&background_thread_num_runs, uint64_t);
CTL_GET("stats.background_thread.run_interval",
&background_thread_run_interval, uint64_t);
} else {
num_background_threads = 0;
background_thread_num_runs = 0;
background_thread_run_interval = 0;
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\"stats\": {\n");
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"allocated\": %zu,\n", allocated);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"active\": %zu,\n", active);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"metadata\": %zu,\n", metadata);
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"metadata_thp\": %zu,\n", metadata_thp);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"resident\": %zu,\n", resident);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"mapped\": %zu,\n", mapped);
malloc_cprintf(write_cb, cbopaque,
Add background thread related stats.
2017-05-13 03:30:33 +08:00
"\t\t\t\"retained\": %zu,\n", retained);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"background_thread\": {\n");
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"num_threads\": %zu,\n", num_background_threads);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"num_runs\": %"FMTu64",\n",
background_thread_num_runs);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\"run_interval\": %"FMTu64"\n",
background_thread_run_interval);
malloc_cprintf(write_cb, cbopaque, "\t\t\t}%s\n",
mutex ? "," : "");
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
if (mutex) {
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
malloc_cprintf(write_cb, cbopaque,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
"\t\t\t\"mutexes\": {\n");
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
mutex_prof_global_ind_t i;
for (i = 0; i < mutex_prof_num_global_mutexes; i++) {
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
mutex_stats_output_json(write_cb, cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
global_mutex_names[i], mutex_stats_uint64_t[i], mutex_stats_uint32_t[i],
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
"\t\t\t\t",
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
i == mutex_prof_num_global_mutexes - 1);
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
}
malloc_cprintf(write_cb, cbopaque, "\t\t\t}\n");
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque,
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
"\t\t}%s\n", (merged || unmerged || destroyed) ? "," : "");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} else {
Simplify malloc_message(). Rather than passing four strings to malloc_message(), malloc_write4(), and all the functions that use them, only pass one string.
2010-03-04 09:45:38 +08:00
malloc_cprintf(write_cb, cbopaque,
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
"Allocated: %zu, active: %zu, metadata: %zu (n_thp %zu),"
Add the stats.retained and stats.arenas.<i>.retained statistics. This resolves #367.
2016-05-04 13:11:35 +08:00
" resident: %zu, mapped: %zu, retained: %zu\n",
Add stats for metadata_thp. Report number of THPs used in arena and aggregated stats.
2017-08-26 04:24:49 +08:00
allocated, active, metadata, metadata_thp, resident, mapped,
retained);
Add background thread related stats.
2017-05-13 03:30:33 +08:00
if (have_background_thread && num_background_threads > 0) {
malloc_cprintf(write_cb, cbopaque,
"Background threads: %zu, num_runs: %"FMTu64", "
"run_interval: %"FMTu64" ns\n",
num_background_threads,
background_thread_num_runs,
background_thread_run_interval);
}
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
if (mutex) {
Header refactoring: ctl - unify and remove from catchall. In order to do this, we introduce the mutex_prof module, which breaks a circular dependency between ctl and prof.
2017-04-25 08:09:56 +08:00
mutex_prof_global_ind_t i;
for (i = 0; i < mutex_prof_num_global_mutexes; i++) {
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
mutex_stats_output(write_cb, cbopaque,
handle 32 bit mutex counters
2017-12-31 06:31:34 +08:00
global_mutex_names[i], mutex_stats_uint64_t[i], mutex_stats_uint32_t[i],
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
i == 0);
}
Added lock profiling and output for global locks (ctl, prof and base).
2017-03-12 12:28:31 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
if (merged || destroyed || unmerged) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
unsigned narenas;
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\"stats.arenas\": {\n");
}
Print merged arena stats iff multiple arenas.
2010-01-25 09:21:47 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
CTL_GET("arenas.narenas", &narenas, unsigned);
{
Replace the arenas.initialized mallctl with arena.<i>.initialized .
2017-01-05 02:21:53 +08:00
size_t mib[3];
size_t miblen = sizeof(mib) / sizeof(size_t);
size_t sz;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
VARIABLE_ARRAY(bool, initialized, narenas);
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
bool destroyed_initialized;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
unsigned i, j, ninitialized;
Replace the arenas.initialized mallctl with arena.<i>.initialized .
2017-01-05 02:21:53 +08:00
xmallctlnametomib("arena.0.initialized", mib, &miblen);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
for (i = ninitialized = 0; i < narenas; i++) {
Replace the arenas.initialized mallctl with arena.<i>.initialized .
2017-01-05 02:21:53 +08:00
mib[1] = i;
sz = sizeof(bool);
xmallctlbymib(mib, miblen, &initialized[i], &sz,
NULL, 0);
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
if (initialized[i]) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
ninitialized++;
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
mib[1] = MALLCTL_ARENAS_DESTROYED;
sz = sizeof(bool);
xmallctlbymib(mib, miblen, &destroyed_initialized, &sz,
NULL, 0);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/* Merged stats. */
if (merged && (ninitialized > 1 || !unmerged)) {
/* Print merged arena stats. */
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"merged\": {\n");
} else {
Simplify malloc_message(). Rather than passing four strings to malloc_message(), malloc_write4(), and all the functions that use them, only pass one string.
2010-03-04 09:45:38 +08:00
malloc_cprintf(write_cb, cbopaque,
Fix some comments and whitespace.
2010-01-31 19:57:29 +08:00
"\nMerged arenas stats:\n");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
stats_arena_print(write_cb, cbopaque, json,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
MALLCTL_ARENAS_ALL, bins, large, mutex);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
Test JSON output of malloc_stats_print() and fix bugs. Implement and test a JSON validation parser. Use the parser to validate JSON output from malloc_stats_print(), with a significant subset of supported output options. This resolves #551.
2017-01-18 17:01:19 +08:00
"\t\t\t}%s\n",
((destroyed_initialized &&
destroyed) || unmerged) ? "," :
"");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
}
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
/* Destroyed stats. */
if (destroyed_initialized && destroyed) {
/* Print destroyed arena stats. */
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"destroyed\": {\n");
} else {
malloc_cprintf(write_cb, cbopaque,
"\nDestroyed arenas stats:\n");
}
stats_arena_print(write_cb, cbopaque, json,
Added JSON output for lock stats. Also added option 'x' to malloc_stats() to bypass lock section.
2017-03-12 17:28:52 +08:00
MALLCTL_ARENAS_DESTROYED, bins, large,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
mutex);
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
Test JSON output of malloc_stats_print() and fix bugs. Implement and test a JSON validation parser. Use the parser to validate JSON output from malloc_stats_print(), with a significant subset of supported output options. This resolves #551.
2017-01-18 17:01:19 +08:00
"\t\t\t}%s\n", unmerged ? "," :
"");
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
}
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/* Unmerged stats. */
Test JSON output of malloc_stats_print() and fix bugs. Implement and test a JSON validation parser. Use the parser to validate JSON output from malloc_stats_print(), with a significant subset of supported output options. This resolves #551.
2017-01-18 17:01:19 +08:00
if (unmerged) {
for (i = j = 0; i < narenas; i++) {
if (initialized[i]) {
if (json) {
j++;
malloc_cprintf(write_cb,
cbopaque,
"\t\t\t\"%u\": {\n",
i);
} else {
malloc_cprintf(write_cb,
cbopaque,
"\narenas[%u]:\n",
i);
}
stats_arena_print(write_cb,
cbopaque, json, i, bins,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
large, mutex);
Test JSON output of malloc_stats_print() and fix bugs. Implement and test a JSON validation parser. Use the parser to validate JSON output from malloc_stats_print(), with a significant subset of supported output options. This resolves #551.
2017-01-18 17:01:19 +08:00
if (json) {
malloc_cprintf(write_cb,
cbopaque,
"\t\t\t}%s\n", (j <
ninitialized) ? ","
: "");
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
}
Print merged arena stats iff multiple arenas.
2010-01-25 09:21:47 +08:00
}
Add merged arena stats printing. Add the "m" and "a" opts flags for malloc_stats_print().
2010-01-18 09:35:19 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t}\n");
}
}
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
void
stats_print(void (*write_cb)(void *, const char *), void *cbopaque,
Update brace style. Add braces around single-line blocks, and remove line breaks before function-opening braces. This resolves #537.
2017-01-16 08:56:30 +08:00
const char *opts) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
int err;
uint64_t epoch;
size_t u64sz;
Add opt.stats_print_opts. The value is passed to atexit(3)-triggered malloc_stats_print() calls.
2017-05-28 06:35:36 +08:00
#define OPTION(o, v, d, s) bool v = d;
STATS_PRINT_OPTIONS
#undef OPTION
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
/*
* Refresh stats, in case mallctl() was called by the application.
*
* Check for OOM here, since refreshing the ctl cache can trigger
* allocation. In practice, none of the subsequent mallctl()-related
* calls in this function will cause OOM if this one succeeds.
* */
epoch = 1;
u64sz = sizeof(uint64_t);
Uniformly cast mallctl[bymib]() oldp/newp arguments to (void *). This avoids warnings in some cases, and is otherwise generally good hygiene.
2016-11-16 07:01:03 +08:00
err = je_mallctl("epoch", (void *)&epoch, &u64sz, (void *)&epoch,
sizeof(uint64_t));
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (err != 0) {
if (err == EAGAIN) {
malloc_write("<jemalloc>: Memory allocation failure in "
"mallctl(\"epoch\", ...)\n");
return;
}
malloc_write("<jemalloc>: Failure in mallctl(\"epoch\", "
"...)\n");
abort();
}
Implement mallctl{nametomib,bymib}(). Replace chunk stats code that was missing locking; this fixes a race condition that could corrupt chunk statistics. Converting malloc_stats_print() to use mallctl*(). Add a missing semicolon in th DSS code. Convert malloc_tcache_flush() to a mallctl. Convert malloc_swap_enable() to a set of mallctl's.
2010-01-28 05:10:55 +08:00
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (opts != NULL) {
Add opt.stats_print_opts. The value is passed to atexit(3)-triggered malloc_stats_print() calls.
2017-05-28 06:35:36 +08:00
for (unsigned i = 0; opts[i] != '\0'; i++) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
switch (opts[i]) {
Add opt.stats_print_opts. The value is passed to atexit(3)-triggered malloc_stats_print() calls.
2017-05-28 06:35:36 +08:00
#define OPTION(o, v, d, s) case o: v = s; break;
STATS_PRINT_OPTIONS
#undef OPTION
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
default:;
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
}
}
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
Stats printing: Convert header and footer to use emitter.
2018-03-02 09:29:58 +08:00
emitter_t emitter;
emitter_init(&emitter,
json ? emitter_output_json : emitter_output_table, write_cb,
cbopaque);
emitter_begin(&emitter);
emitter_table_printf(&emitter, "___ Begin jemalloc statistics ___\n");
emitter_json_dict_begin(&emitter, "jemalloc");
Fix JSON-mode output for !config_stats and/or !config_prof cases. These bugs were introduced by 0ba5b9b6189e16a983d8922d8c5cb6ab421906e8 (Add "J" (JSON) support to malloc_stats_print().), which was backported as b599b32280e1142856b0b96293a71e1684b1ccfb (with the same bugs except the inapplicable "metatata" misspelling) and first released in 4.3.0.
2016-12-24 03:15:44 +08:00
if (general) {
Stats printing: convert config and opt output to use emitter. This is a step along the path towards using the emitter for all stats output.
2018-03-02 09:38:15 +08:00
stats_general_print(&emitter, config_stats);
Fix JSON-mode output for !config_stats and/or !config_prof cases. These bugs were introduced by 0ba5b9b6189e16a983d8922d8c5cb6ab421906e8 (Add "J" (JSON) support to malloc_stats_print().), which was backported as b599b32280e1142856b0b96293a71e1684b1ccfb (with the same bugs except the inapplicable "metatata" misspelling) and first released in 4.3.0.
2016-12-24 03:15:44 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (config_stats) {
Implement arena.<i>.destroy . Add MALLCTL_ARENAS_DESTROYED for accessing destroyed arena stats as an analogue to MALLCTL_ARENAS_ALL. This resolves #382.
2017-01-04 09:21:59 +08:00
stats_print_helper(write_cb, cbopaque, json, merged, destroyed,
Added "stats.mutexes.reset" mallctl to reset all mutex stats. Also switched from the term "lock" to "mutex".
2017-03-14 08:29:03 +08:00
unmerged, bins, large, mutex);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
Stats printing: Convert header and footer to use emitter.
2018-03-02 09:29:58 +08:00
emitter_json_dict_end(&emitter); /* Closes the "jemalloc" dict. */
emitter_table_printf(&emitter, "--- End jemalloc statistics ---\n");
emitter_end(&emitter);
Refactor jemalloc.c into multiple source files. Fix a stats bug in large object curruns accounting. Replace tcache_bin_fill() with arena_tcache_fill(), and fix a bug in an OOM error path. Fix API name mangling to coexist with __attribute__((malloc)).
2010-01-17 01:53:50 +08:00
}
Reference in New Issue Copy Permalink