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

1321 lines
39 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"
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. */
bool opt_stats_print = false;
/******************************************************************************/
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,
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
uint64_t results[mutex_prof_num_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, \
(t *)&results[mutex_counter_##c], t);
MUTEX_PROF_COUNTERS
#undef OP
}
static void
mutex_stats_output_json(void (*write_cb)(void *, const char *), void *cbopaque,
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 *name, uint64_t stats[mutex_prof_num_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);
mutex_prof_counter_ind_t k = 0;
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], \
json_indent, #c, (t)stats[mutex_counter_##c], \
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
(++k == mutex_prof_num_counters) ? "" : ",");
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
MUTEX_PROF_COUNTERS
#undef OP
malloc_cprintf(write_cb, cbopaque, "%s}%s\n", json_indent,
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"
" n_spin_acq max_wait_ns\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) {
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
uint64_t mutex_stats[mutex_prof_num_counters];
Refactor mutex profiling code with x-macros.
2017-03-22 02:56:38 +08:00
read_arena_bin_mutex_stats(i, j, mutex_stats);
mutex_stats_output_json(write_cb, cbopaque,
"mutex", mutex_stats, "\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();
}
}
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 less info for bin mutexes to save space. */
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
uint64_t num_ops, num_wait, max_wait;
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
CTL_M2_M4_GET("stats.arenas.0.bins.0.mutex.num_wait",
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, j, &num_wait, uint64_t);
CTL_M2_M4_GET(
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.arenas.0.bins.0.mutex.max_wait_time", i, j,
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
&max_wait, uint64_t);
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
CTL_M2_M4_GET("stats.arenas.0.bins.0.mutex.num_ops",
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, j, &num_ops, uint64_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
uint64_t mutex_stats[mutex_prof_num_counters];
Output 4 counters for bin mutexes instead of just 2.
2017-04-19 06:00:14 +08:00
if (mutex) {
read_arena_bin_mutex_stats(i, j, mutex_stats);
}
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
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
char rate[6];
Add arena lock stats output.
2017-03-11 04:14:05 +08:00
if (get_rate_str(num_wait, num_ops, rate)) {
if (num_ops == 0) {
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
malloc_snprintf(rate, sizeof(rate),
"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
}
Add small run utilization to stats output. Add the 'util' column, which reports the proportion of available regions that are currently in use for each small size class. Small run utilization is the complement of external fragmentation. For example, utilization of 0.75 indicates that 25% of small run memory is consumed by external fragmentation, in other (more obtuse) words, 33% external fragmentation overhead. This resolves #27.
2014-10-16 07:18:42 +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 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
" %12"FMTu64"\n",
mutex_stats[mutex_counter_num_ops],
mutex_stats[mutex_counter_num_wait],
mutex_stats[mutex_counter_num_spin_acq],
mutex_stats[mutex_counter_max_wait_time]);
} 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,
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
uint64_t results[mutex_prof_num_arena_mutexes][mutex_prof_num_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, \
(t *)&results[i][mutex_counter_##c], t);
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,
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 *name, uint64_t stats[mutex_prof_num_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], \
(t)stats[mutex_counter_##c]);
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) {
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
uint64_t mutex_stats[mutex_prof_num_arena_mutexes][mutex_prof_num_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
read_arena_mutex_stats(arena_ind, mutex_stats);
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,
arena_mutex_names[i], mutex_stats[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,
arena_mutex_names[i], mutex_stats[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;
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
size_t base, internal, resident;
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);
}
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_general_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
bool json, bool more) {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
const char *cpv;
bool bv;
unsigned uv;
uint32_t u32v;
uint64_t u64v;
ssize_t ssv;
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 *);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\"version\": \"%s\",\n", cpv);
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
} else {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque, "Version: %s\n", cpv);
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
}
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. */
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define CONFIG_WRITE_BOOL_JSON(n, c) \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (json) { \
CTL_GET("config."#n, &bv, bool); \
malloc_cprintf(write_cb, cbopaque, \
"\t\t\t\""#n"\": %s%s\n", bv ? "true" : "false", \
(c)); \
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
}
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) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\"config\": {\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
CONFIG_WRITE_BOOL_JSON(cache_oblivious, ",")
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("config.debug", &bv, bool);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"debug\": %s,\n", bv ? "true" : "false");
} else {
Implement malloc_vsnprintf(). Implement malloc_vsnprintf() (a subset of vsnprintf(3)) as well as several other printing functions based on it, so that formatted printing can be relied upon without concern for inducing a dependency on floating point runtime support. Replace malloc_write() calls with malloc_*printf() where doing so simplifies the code. Add name mangling for library-private symbols in the data and BSS sections. Adjust CONF_HANDLE_*() macros in malloc_conf_init() to expose all opt_* variable use to cpp so that proper mangling occurs.
2012-03-07 06:57:45 +08:00
malloc_cprintf(write_cb, cbopaque, "Assertions %s\n",
bv ? "enabled" : "disabled");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
CONFIG_WRITE_BOOL_JSON(fill, ",")
CONFIG_WRITE_BOOL_JSON(lazy_lock, ",")
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"malloc_conf\": \"%s\",\n",
config_malloc_conf);
} else {
Add --with-malloc-conf. Add --with-malloc-conf, which makes it possible to embed a default options string during configuration.
2016-02-08 06:23:22 +08:00
malloc_cprintf(write_cb, cbopaque,
"config.malloc_conf: \"%s\"\n", config_malloc_conf);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
CONFIG_WRITE_BOOL_JSON(prof, ",")
CONFIG_WRITE_BOOL_JSON(prof_libgcc, ",")
CONFIG_WRITE_BOOL_JSON(prof_libunwind, ",")
CONFIG_WRITE_BOOL_JSON(stats, ",")
CONFIG_WRITE_BOOL_JSON(utrace, ",")
CONFIG_WRITE_BOOL_JSON(xmalloc, "")
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t},\n");
}
#undef CONFIG_WRITE_BOOL_JSON
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. */
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define OPT_WRITE_BOOL(n, c) \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (je_mallctl("opt."#n, (void *)&bv, &bsz, NULL, 0) == 0) { \
if (json) { \
malloc_cprintf(write_cb, cbopaque, \
"\t\t\t\""#n"\": %s%s\n", bv ? "true" : \
"false", (c)); \
} else { \
Implement malloc_vsnprintf(). Implement malloc_vsnprintf() (a subset of vsnprintf(3)) as well as several other printing functions based on it, so that formatted printing can be relied upon without concern for inducing a dependency on floating point runtime support. Replace malloc_write() calls with malloc_*printf() where doing so simplifies the code. Add name mangling for library-private symbols in the data and BSS sections. Adjust CONF_HANDLE_*() macros in malloc_conf_init() to expose all opt_* variable use to cpp so that proper mangling occurs.
2012-03-07 06:57:45 +08:00
malloc_cprintf(write_cb, cbopaque, \
" opt."#n": %s\n", bv ? "true" : "false"); \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} \
}
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define OPT_WRITE_BOOL_MUTABLE(n, m, c) { \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
bool bv2; \
if (je_mallctl("opt."#n, (void *)&bv, &bsz, NULL, 0) == 0 && \
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
je_mallctl(#m, (void *)&bv2, &bsz, NULL, 0) == 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\t\""#n"\": %s%s\n", bv ? "true" : \
"false", (c)); \
} else { \
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
malloc_cprintf(write_cb, cbopaque, \
" opt."#n": %s ("#m": %s)\n", bv ? "true" \
: "false", bv2 ? "true" : "false"); \
} \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} \
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
}
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define OPT_WRITE_UNSIGNED(n, c) \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (je_mallctl("opt."#n, (void *)&uv, &usz, NULL, 0) == 0) { \
if (json) { \
malloc_cprintf(write_cb, cbopaque, \
"\t\t\t\""#n"\": %u%s\n", uv, (c)); \
} else { \
Make opt_narenas unsigned rather than size_t.
2016-02-25 03:03:40 +08:00
malloc_cprintf(write_cb, cbopaque, \
Fix malloc_stats_print() to print correct opt.narenas value. This regression was caused by 8f683b94a751c65af8f9fa25970ccf2917b96bb8 (Make opt_narenas unsigned rather than size_t.).
2016-04-12 09:47:18 +08:00
" opt."#n": %u\n", uv); \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} \
}
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define OPT_WRITE_SSIZE_T(n, c) \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (je_mallctl("opt."#n, (void *)&ssv, &sssz, NULL, 0) == 0) { \
if (json) { \
malloc_cprintf(write_cb, cbopaque, \
"\t\t\t\""#n"\": %zd%s\n", ssv, (c)); \
} else { \
Implement malloc_vsnprintf(). Implement malloc_vsnprintf() (a subset of vsnprintf(3)) as well as several other printing functions based on it, so that formatted printing can be relied upon without concern for inducing a dependency on floating point runtime support. Replace malloc_write() calls with malloc_*printf() where doing so simplifies the code. Add name mangling for library-private symbols in the data and BSS sections. Adjust CONF_HANDLE_*() macros in malloc_conf_init() to expose all opt_* variable use to cpp so that proper mangling occurs.
2012-03-07 06:57:45 +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
" opt."#n": %zd\n", ssv); \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} \
}
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define OPT_WRITE_SSIZE_T_MUTABLE(n, m, c) { \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
ssize_t ssv2; \
if (je_mallctl("opt."#n, (void *)&ssv, &sssz, NULL, 0) == 0 && \
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
je_mallctl(#m, (void *)&ssv2, &sssz, NULL, 0) == 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\t\""#n"\": %zd%s\n", ssv, (c)); \
} else { \
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
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
" opt."#n": %zd ("#m": %zd)\n", \
Fix MinGW build warnings. Conditionally define ENOENT, EINVAL, etc. (was unconditional). Add/use PRIzu, PRIzd, and PRIzx for use in malloc_printf() calls. gcc issued (harmless) warnings since e.g. "%zu" should be "%Iu" on Windows, and the alternative to this workaround would have been to disable the function attributes which cause gcc to look for type mismatches in formatted printing function calls.
2015-07-08 04:12:05 +08:00
ssv, ssv2); \
Fix a compile error caused by mixed declarations and code.
2015-03-22 01:18:39 +08:00
} \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
} \
Fix a compile error caused by mixed declarations and code.
2015-03-22 01:18:39 +08:00
}
Replace tabs following #define with spaces. This resolves #564.
2017-01-20 13:41:41 +08:00
#define OPT_WRITE_CHAR_P(n, c) \
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
if (je_mallctl("opt."#n, (void *)&cpv, &cpsz, NULL, 0) == 0) { \
if (json) { \
malloc_cprintf(write_cb, cbopaque, \
"\t\t\t\""#n"\": \"%s\"%s\n", cpv, (c)); \
} else { \
Implement malloc_vsnprintf(). Implement malloc_vsnprintf() (a subset of vsnprintf(3)) as well as several other printing functions based on it, so that formatted printing can be relied upon without concern for inducing a dependency on floating point runtime support. Replace malloc_write() calls with malloc_*printf() where doing so simplifies the code. Add name mangling for library-private symbols in the data and BSS sections. Adjust CONF_HANDLE_*() macros in malloc_conf_init() to expose all opt_* variable use to cpp so that proper mangling occurs.
2012-03-07 06:57:45 +08:00
malloc_cprintf(write_cb, cbopaque, \
" opt."#n": \"%s\"\n", cpv); \
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
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\"opt\": {\n");
} else {
Allow je_malloc_message to be overridden when linking statically If an application wants to override je_malloc_message, it is better to define the symbol locally than to change its value in main(), which might be too late for various reasons. Due to je_malloc_message being initialized in util.c, statically linking jemalloc with an application defining je_malloc_message fails due to "multiple definition of" the symbol. Defining it without a value (like je_malloc_conf) makes it more easily overridable.
2012-05-02 19:15:00 +08:00
malloc_cprintf(write_cb, cbopaque,
"Run-time option settings:\n");
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
OPT_WRITE_BOOL(abort, ",")
Refactor !opt.munmap to opt.retain.
2017-04-27 07:26:12 +08:00
OPT_WRITE_BOOL(retain, ",")
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
OPT_WRITE_CHAR_P(dss, ",")
OPT_WRITE_UNSIGNED(narenas, ",")
Implement per-CPU arena. The new feature, opt.percpu_arena, determines thread-arena association dynamically based CPU id. Three modes are supported: "percpu", "phycpu" and disabled. "percpu" uses the current core id (with help from sched_getcpu()) directly as the arena index, while "phycpu" will assign threads on the same physical CPU to the same arena. In other words, "percpu" means # of arenas == # of CPUs, while "phycpu" has # of arenas == 1/2 * (# of CPUs). Note that no runtime check on whether hyper threading is enabled is added yet. When enabled, threads will be migrated between arenas when a CPU change is detected. In the current design, to reduce overhead from reading CPU id, each arena tracks the thread accessed most recently. When a new thread comes in, we will read CPU id and update arena if necessary.
2017-02-03 09:02:05 +08:00
OPT_WRITE_CHAR_P(percpu_arena, ",")
Implementing opt.background_thread. Added opt.background_thread to enable background threads, which handles purging currently. When enabled, decay ticks will not trigger purging (which will be left to the background threads). We limit the max number of threads to NCPUs. When percpu arena is enabled, set CPU affinity for the background threads as well. The sleep interval of background threads is dynamic and determined by computing number of pages to purge in the future (based on backlog).
2017-03-18 03:42:33 +08:00
OPT_WRITE_BOOL_MUTABLE(background_thread, background_thread, ",")
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
OPT_WRITE_SSIZE_T_MUTABLE(dirty_decay_ms, arenas.dirty_decay_ms, ",")
OPT_WRITE_SSIZE_T_MUTABLE(muzzy_decay_ms, arenas.muzzy_decay_ms, ",")
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
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_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, ",")
/*
* stats_print is always emitted, so as long as stats_print comes last
* it's safe to unconditionally omit the comma here (rather than having
* to conditionally omit it elsewhere depending on configuration).
*/
OPT_WRITE_BOOL(stats_print, "")
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t},\n");
}
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
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
#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. */
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\"arenas\": {\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
CTL_GET("arenas.narenas", &uv, unsigned);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"narenas\": %u,\n", uv);
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
} else {
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
malloc_cprintf(write_cb, cbopaque, "Arenas: %u\n", uv);
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
if (json) {
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_GET("arenas.dirty_decay_ms", &ssv, ssize_t);
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +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\"dirty_decay_ms\": %zd,\n", 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
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_GET("arenas.muzzy_decay_ms", &ssv, ssize_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
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\"muzzy_decay_ms\": %zd,\n", 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);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"quantum\": %zu,\n", sv);
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
} else {
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
malloc_cprintf(write_cb, cbopaque, "Quantum size: %zu\n", sv);
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
CTL_GET("arenas.page", &sv, size_t);
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"page\": %zu,\n", sv);
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
} else {
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
malloc_cprintf(write_cb, cbopaque, "Page size: %zu\n", sv);
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
}
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) {
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"tcache_max\": %zu,\n", sv);
} else {
Implement malloc_vsnprintf(). Implement malloc_vsnprintf() (a subset of vsnprintf(3)) as well as several other printing functions based on it, so that formatted printing can be relied upon without concern for inducing a dependency on floating point runtime support. Replace malloc_write() calls with malloc_*printf() where doing so simplifies the code. Add name mangling for library-private symbols in the data and BSS sections. Adjust CONF_HANDLE_*() macros in malloc_conf_init() to expose all opt_* variable use to cpp so that proper mangling occurs.
2012-03-07 06:57:45 +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
"Maximum thread-cached size class: %zu\n", sv);
Remove medium size classes. Remove medium size classes, because concurrent dirty page purging is no longer capable of purging inactive dirty pages inside active runs (due to recent arena/bin locking changes). Enhance tcache to support caching large objects, so that the same range of size classes is still cached, despite the removal of medium size class support.
2010-03-18 07:27:39 +08:00
}
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
}
if (json) {
unsigned nbins, nlextents, i;
CTL_GET("arenas.nbins", &nbins, unsigned);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"nbins\": %u,\n", nbins);
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_GET("arenas.nhbins", &uv, unsigned);
malloc_cprintf(write_cb, cbopaque, "\t\t\t\"nhbins\": %u,\n",
uv);
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\"bin\": [\n");
for (i = 0; i < nbins; i++) {
Implement malloc_vsnprintf(). Implement malloc_vsnprintf() (a subset of vsnprintf(3)) as well as several other printing functions based on it, so that formatted printing can be relied upon without concern for inducing a dependency on floating point runtime support. Replace malloc_write() calls with malloc_*printf() where doing so simplifies the code. Add name mangling for library-private symbols in the data and BSS sections. Adjust CONF_HANDLE_*() macros in malloc_conf_init() to expose all opt_* variable use to cpp so that proper mangling occurs.
2012-03-07 06:57:45 +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");
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);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"size\": %zu,\n", sv);
CTL_M2_GET("arenas.bin.0.nregs", i, &u32v, uint32_t);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"nregs\": %"FMTu32",\n", u32v);
CTL_M2_GET("arenas.bin.0.slab_size", i, &sv, size_t);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"slab_size\": %zu\n", sv);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t}%s\n", (i + 1 < nbins) ? "," : "");
}
malloc_cprintf(write_cb, cbopaque,
"\t\t\t],\n");
CTL_GET("arenas.nlextents", &nlextents, unsigned);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"nlextents\": %u,\n", nlextents);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\"lextent\": [\n");
for (i = 0; i < nlextents; i++) {
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t{\n");
CTL_M2_GET("arenas.lextent.0.size", i, &sv, size_t);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t\t\"size\": %zu\n", sv);
malloc_cprintf(write_cb, cbopaque,
"\t\t\t\t}%s\n", (i + 1 < nlextents) ? "," : "");
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
}
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]\n");
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", (config_prof || more) ? "," : "");
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(
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
uint64_t results[mutex_prof_num_global_mutexes][mutex_prof_num_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); \
CTL_GET(cmd, (t *)&results[i][mutex_counter_##c], t);
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 "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
size_t allocated, active, metadata, 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);
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
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
uint64_t mutex_stats[mutex_prof_num_global_mutexes][mutex_prof_num_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) {
read_global_mutex_stats(mutex_stats);
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);
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,
global_mutex_names[i], mutex_stats[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,
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
"Allocated: %zu, active: %zu, metadata: %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",
allocated, active, metadata, 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,
global_mutex_names[i], mutex_stats[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;
bool json = false;
bool general = true;
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
bool merged = 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
bool destroyed = 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
bool unmerged = config_stats;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
bool bins = true;
bool large = true;
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 mutex = true;
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) {
unsigned i;
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
for (i = 0; opts[i] != '\0'; i++) {
switch (opts[i]) {
case 'J':
json = true;
break;
case 'g':
general = false;
break;
case 'm':
merged = false;
break;
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
case 'd':
destroyed = false;
break;
Add "J" (JSON) support to malloc_stats_print(). This resolves #474.
2016-11-01 13:30:49 +08:00
case 'a':
unmerged = false;
break;
case 'b':
bins = false;
break;
case 'l':
large = false;
break;
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
case 'x':
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 = false;
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
break;
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
if (json) {
malloc_cprintf(write_cb, cbopaque,
"{\n"
"\t\"jemalloc\": {\n");
} else {
malloc_cprintf(write_cb, cbopaque,
"___ Begin jemalloc statistics ___\n");
}
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) {
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
stats_general_print(write_cb, cbopaque, json, 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
}
if (json) {
malloc_cprintf(write_cb, cbopaque,
"\t}\n"
"}\n");
} else {
malloc_cprintf(write_cb, cbopaque,
"--- End jemalloc statistics ---\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
}
Reference in New Issue Copy Permalink