]>
Commit | Line | Data |
---|---|---|
4934f93d | 1 | #define JEMALLOC_STATS_C_ |
2 | #include "jemalloc/internal/jemalloc_internal.h" | |
3 | ||
4 | #define CTL_GET(n, v, t) do { \ | |
5 | size_t sz = sizeof(t); \ | |
6 | xmallctl(n, v, &sz, NULL, 0); \ | |
7 | } while (0) | |
8 | ||
9 | #define CTL_I_GET(n, v, t) do { \ | |
10 | size_t mib[6]; \ | |
11 | size_t miblen = sizeof(mib) / sizeof(size_t); \ | |
12 | size_t sz = sizeof(t); \ | |
13 | xmallctlnametomib(n, mib, &miblen); \ | |
14 | mib[2] = i; \ | |
15 | xmallctlbymib(mib, miblen, v, &sz, NULL, 0); \ | |
16 | } while (0) | |
17 | ||
18 | #define CTL_J_GET(n, v, t) do { \ | |
19 | size_t mib[6]; \ | |
20 | size_t miblen = sizeof(mib) / sizeof(size_t); \ | |
21 | size_t sz = sizeof(t); \ | |
22 | xmallctlnametomib(n, mib, &miblen); \ | |
23 | mib[2] = j; \ | |
24 | xmallctlbymib(mib, miblen, v, &sz, NULL, 0); \ | |
25 | } while (0) | |
26 | ||
27 | #define CTL_IJ_GET(n, v, t) do { \ | |
28 | size_t mib[6]; \ | |
29 | size_t miblen = sizeof(mib) / sizeof(size_t); \ | |
30 | size_t sz = sizeof(t); \ | |
31 | xmallctlnametomib(n, mib, &miblen); \ | |
32 | mib[2] = i; \ | |
33 | mib[4] = j; \ | |
34 | xmallctlbymib(mib, miblen, v, &sz, NULL, 0); \ | |
35 | } while (0) | |
36 | ||
37 | /******************************************************************************/ | |
38 | /* Data. */ | |
39 | ||
40 | bool opt_stats_print = false; | |
41 | ||
42 | #ifdef JEMALLOC_STATS | |
43 | size_t stats_cactive = 0; | |
44 | #endif | |
45 | ||
46 | /******************************************************************************/ | |
47 | /* Function prototypes for non-inline static functions. */ | |
48 | ||
49 | #ifdef JEMALLOC_STATS | |
50 | static void malloc_vcprintf(void (*write_cb)(void *, const char *), | |
51 | void *cbopaque, const char *format, va_list ap); | |
52 | static void stats_arena_bins_print(void (*write_cb)(void *, const char *), | |
53 | void *cbopaque, unsigned i); | |
54 | static void stats_arena_lruns_print(void (*write_cb)(void *, const char *), | |
55 | void *cbopaque, unsigned i); | |
56 | static void stats_arena_print(void (*write_cb)(void *, const char *), | |
57 | void *cbopaque, unsigned i); | |
58 | #endif | |
59 | ||
60 | /******************************************************************************/ | |
61 | ||
62 | /* | |
63 | * We don't want to depend on vsnprintf() for production builds, since that can | |
64 | * cause unnecessary bloat for static binaries. u2s() provides minimal integer | |
65 | * printing functionality, so that malloc_printf() use can be limited to | |
66 | * JEMALLOC_STATS code. | |
67 | */ | |
68 | char * | |
69 | u2s(uint64_t x, unsigned base, char *s) | |
70 | { | |
71 | unsigned i; | |
72 | ||
73 | i = UMAX2S_BUFSIZE - 1; | |
74 | s[i] = '\0'; | |
75 | switch (base) { | |
76 | case 10: | |
77 | do { | |
78 | i--; | |
79 | s[i] = "0123456789"[x % (uint64_t)10]; | |
80 | x /= (uint64_t)10; | |
81 | } while (x > 0); | |
82 | break; | |
83 | case 16: | |
84 | do { | |
85 | i--; | |
86 | s[i] = "0123456789abcdef"[x & 0xf]; | |
87 | x >>= 4; | |
88 | } while (x > 0); | |
89 | break; | |
90 | default: | |
91 | do { | |
92 | i--; | |
93 | s[i] = "0123456789abcdefghijklmnopqrstuvwxyz"[x % | |
94 | (uint64_t)base]; | |
95 | x /= (uint64_t)base; | |
96 | } while (x > 0); | |
97 | } | |
98 | ||
99 | return (&s[i]); | |
100 | } | |
101 | ||
102 | #ifdef JEMALLOC_STATS | |
103 | static void | |
104 | malloc_vcprintf(void (*write_cb)(void *, const char *), void *cbopaque, | |
105 | const char *format, va_list ap) | |
106 | { | |
107 | char buf[4096]; | |
108 | ||
109 | if (write_cb == NULL) { | |
110 | /* | |
111 | * The caller did not provide an alternate write_cb callback | |
112 | * function, so use the default one. malloc_write() is an | |
113 | * inline function, so use malloc_message() directly here. | |
114 | */ | |
115 | write_cb = JEMALLOC_P(malloc_message); | |
116 | cbopaque = NULL; | |
117 | } | |
118 | ||
119 | vsnprintf(buf, sizeof(buf), format, ap); | |
120 | write_cb(cbopaque, buf); | |
121 | } | |
122 | ||
123 | /* | |
124 | * Print to a callback function in such a way as to (hopefully) avoid memory | |
125 | * allocation. | |
126 | */ | |
127 | JEMALLOC_ATTR(format(printf, 3, 4)) | |
128 | void | |
129 | malloc_cprintf(void (*write_cb)(void *, const char *), void *cbopaque, | |
130 | const char *format, ...) | |
131 | { | |
132 | va_list ap; | |
133 | ||
134 | va_start(ap, format); | |
135 | malloc_vcprintf(write_cb, cbopaque, format, ap); | |
136 | va_end(ap); | |
137 | } | |
138 | ||
139 | /* | |
140 | * Print to stderr in such a way as to (hopefully) avoid memory allocation. | |
141 | */ | |
142 | JEMALLOC_ATTR(format(printf, 1, 2)) | |
143 | void | |
144 | malloc_printf(const char *format, ...) | |
145 | { | |
146 | va_list ap; | |
147 | ||
148 | va_start(ap, format); | |
149 | malloc_vcprintf(NULL, NULL, format, ap); | |
150 | va_end(ap); | |
151 | } | |
152 | #endif | |
153 | ||
154 | #ifdef JEMALLOC_STATS | |
155 | static void | |
156 | stats_arena_bins_print(void (*write_cb)(void *, const char *), void *cbopaque, | |
157 | unsigned i) | |
158 | { | |
159 | size_t pagesize; | |
160 | bool config_tcache; | |
161 | unsigned nbins, j, gap_start; | |
162 | ||
163 | CTL_GET("arenas.pagesize", &pagesize, size_t); | |
164 | ||
165 | CTL_GET("config.tcache", &config_tcache, bool); | |
166 | if (config_tcache) { | |
167 | malloc_cprintf(write_cb, cbopaque, | |
168 | "bins: bin size regs pgs allocated nmalloc" | |
169 | " ndalloc nrequests nfills nflushes" | |
170 | " newruns reruns maxruns curruns\n"); | |
171 | } else { | |
172 | malloc_cprintf(write_cb, cbopaque, | |
173 | "bins: bin size regs pgs allocated nmalloc" | |
174 | " ndalloc newruns reruns maxruns" | |
175 | " curruns\n"); | |
176 | } | |
177 | CTL_GET("arenas.nbins", &nbins, unsigned); | |
178 | for (j = 0, gap_start = UINT_MAX; j < nbins; j++) { | |
179 | uint64_t nruns; | |
180 | ||
181 | CTL_IJ_GET("stats.arenas.0.bins.0.nruns", &nruns, uint64_t); | |
182 | if (nruns == 0) { | |
183 | if (gap_start == UINT_MAX) | |
184 | gap_start = j; | |
185 | } else { | |
186 | unsigned ntbins_, nqbins, ncbins, nsbins; | |
187 | size_t reg_size, run_size, allocated; | |
188 | uint32_t nregs; | |
189 | uint64_t nmalloc, ndalloc, nrequests, nfills, nflushes; | |
190 | uint64_t reruns; | |
191 | size_t highruns, curruns; | |
192 | ||
193 | if (gap_start != UINT_MAX) { | |
194 | if (j > gap_start + 1) { | |
195 | /* Gap of more than one size class. */ | |
196 | malloc_cprintf(write_cb, cbopaque, | |
197 | "[%u..%u]\n", gap_start, | |
198 | j - 1); | |
199 | } else { | |
200 | /* Gap of one size class. */ | |
201 | malloc_cprintf(write_cb, cbopaque, | |
202 | "[%u]\n", gap_start); | |
203 | } | |
204 | gap_start = UINT_MAX; | |
205 | } | |
206 | CTL_GET("arenas.ntbins", &ntbins_, unsigned); | |
207 | CTL_GET("arenas.nqbins", &nqbins, unsigned); | |
208 | CTL_GET("arenas.ncbins", &ncbins, unsigned); | |
209 | CTL_GET("arenas.nsbins", &nsbins, unsigned); | |
210 | CTL_J_GET("arenas.bin.0.size", ®_size, size_t); | |
211 | CTL_J_GET("arenas.bin.0.nregs", &nregs, uint32_t); | |
212 | CTL_J_GET("arenas.bin.0.run_size", &run_size, size_t); | |
213 | CTL_IJ_GET("stats.arenas.0.bins.0.allocated", | |
214 | &allocated, size_t); | |
215 | CTL_IJ_GET("stats.arenas.0.bins.0.nmalloc", | |
216 | &nmalloc, uint64_t); | |
217 | CTL_IJ_GET("stats.arenas.0.bins.0.ndalloc", | |
218 | &ndalloc, uint64_t); | |
219 | if (config_tcache) { | |
220 | CTL_IJ_GET("stats.arenas.0.bins.0.nrequests", | |
221 | &nrequests, uint64_t); | |
222 | CTL_IJ_GET("stats.arenas.0.bins.0.nfills", | |
223 | &nfills, uint64_t); | |
224 | CTL_IJ_GET("stats.arenas.0.bins.0.nflushes", | |
225 | &nflushes, uint64_t); | |
226 | } | |
227 | CTL_IJ_GET("stats.arenas.0.bins.0.nreruns", &reruns, | |
228 | uint64_t); | |
229 | CTL_IJ_GET("stats.arenas.0.bins.0.highruns", &highruns, | |
230 | size_t); | |
231 | CTL_IJ_GET("stats.arenas.0.bins.0.curruns", &curruns, | |
232 | size_t); | |
233 | if (config_tcache) { | |
234 | malloc_cprintf(write_cb, cbopaque, | |
235 | "%13u %1s %5zu %4u %3zu %12zu %12"PRIu64 | |
236 | " %12"PRIu64" %12"PRIu64" %12"PRIu64 | |
237 | " %12"PRIu64" %12"PRIu64" %12"PRIu64 | |
238 | " %12zu %12zu\n", | |
239 | j, | |
240 | j < ntbins_ ? "T" : j < ntbins_ + nqbins ? | |
241 | "Q" : j < ntbins_ + nqbins + ncbins ? "C" : | |
242 | "S", | |
243 | reg_size, nregs, run_size / pagesize, | |
244 | allocated, nmalloc, ndalloc, nrequests, | |
245 | nfills, nflushes, nruns, reruns, highruns, | |
246 | curruns); | |
247 | } else { | |
248 | malloc_cprintf(write_cb, cbopaque, | |
249 | "%13u %1s %5zu %4u %3zu %12zu %12"PRIu64 | |
250 | " %12"PRIu64" %12"PRIu64" %12"PRIu64 | |
251 | " %12zu %12zu\n", | |
252 | j, | |
253 | j < ntbins_ ? "T" : j < ntbins_ + nqbins ? | |
254 | "Q" : j < ntbins_ + nqbins + ncbins ? "C" : | |
255 | "S", | |
256 | reg_size, nregs, run_size / pagesize, | |
257 | allocated, nmalloc, ndalloc, nruns, reruns, | |
258 | highruns, curruns); | |
259 | } | |
260 | } | |
261 | } | |
262 | if (gap_start != UINT_MAX) { | |
263 | if (j > gap_start + 1) { | |
264 | /* Gap of more than one size class. */ | |
265 | malloc_cprintf(write_cb, cbopaque, "[%u..%u]\n", | |
266 | gap_start, j - 1); | |
267 | } else { | |
268 | /* Gap of one size class. */ | |
269 | malloc_cprintf(write_cb, cbopaque, "[%u]\n", gap_start); | |
270 | } | |
271 | } | |
272 | } | |
273 | ||
274 | static void | |
275 | stats_arena_lruns_print(void (*write_cb)(void *, const char *), void *cbopaque, | |
276 | unsigned i) | |
277 | { | |
278 | size_t pagesize, nlruns, j; | |
279 | ssize_t gap_start; | |
280 | ||
281 | CTL_GET("arenas.pagesize", &pagesize, size_t); | |
282 | ||
283 | malloc_cprintf(write_cb, cbopaque, | |
284 | "large: size pages nmalloc ndalloc nrequests" | |
285 | " maxruns curruns\n"); | |
286 | CTL_GET("arenas.nlruns", &nlruns, size_t); | |
287 | for (j = 0, gap_start = -1; j < nlruns; j++) { | |
288 | uint64_t nmalloc, ndalloc, nrequests; | |
289 | size_t run_size, highruns, curruns; | |
290 | ||
291 | CTL_IJ_GET("stats.arenas.0.lruns.0.nmalloc", &nmalloc, | |
292 | uint64_t); | |
293 | CTL_IJ_GET("stats.arenas.0.lruns.0.ndalloc", &ndalloc, | |
294 | uint64_t); | |
295 | CTL_IJ_GET("stats.arenas.0.lruns.0.nrequests", &nrequests, | |
296 | uint64_t); | |
297 | if (nrequests == 0) { | |
298 | if (gap_start == -1) | |
299 | gap_start = j; | |
300 | } else { | |
301 | CTL_J_GET("arenas.lrun.0.size", &run_size, size_t); | |
302 | CTL_IJ_GET("stats.arenas.0.lruns.0.highruns", &highruns, | |
303 | size_t); | |
304 | CTL_IJ_GET("stats.arenas.0.lruns.0.curruns", &curruns, | |
305 | size_t); | |
306 | if (gap_start != -1) { | |
307 | malloc_cprintf(write_cb, cbopaque, "[%zu]\n", | |
308 | j - gap_start); | |
309 | gap_start = -1; | |
310 | } | |
311 | malloc_cprintf(write_cb, cbopaque, | |
312 | "%13zu %5zu %12"PRIu64" %12"PRIu64" %12"PRIu64 | |
313 | " %12zu %12zu\n", | |
314 | run_size, run_size / pagesize, nmalloc, ndalloc, | |
315 | nrequests, highruns, curruns); | |
316 | } | |
317 | } | |
318 | if (gap_start != -1) | |
319 | malloc_cprintf(write_cb, cbopaque, "[%zu]\n", j - gap_start); | |
320 | } | |
321 | ||
322 | static void | |
323 | stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, | |
324 | unsigned i) | |
325 | { | |
326 | unsigned nthreads; | |
327 | size_t pagesize, pactive, pdirty, mapped; | |
328 | uint64_t npurge, nmadvise, purged; | |
329 | size_t small_allocated; | |
330 | uint64_t small_nmalloc, small_ndalloc, small_nrequests; | |
331 | size_t large_allocated; | |
332 | uint64_t large_nmalloc, large_ndalloc, large_nrequests; | |
333 | ||
334 | CTL_GET("arenas.pagesize", &pagesize, size_t); | |
335 | ||
336 | CTL_I_GET("stats.arenas.0.nthreads", &nthreads, unsigned); | |
337 | malloc_cprintf(write_cb, cbopaque, | |
338 | "assigned threads: %u\n", nthreads); | |
339 | CTL_I_GET("stats.arenas.0.pactive", &pactive, size_t); | |
340 | CTL_I_GET("stats.arenas.0.pdirty", &pdirty, size_t); | |
341 | CTL_I_GET("stats.arenas.0.npurge", &npurge, uint64_t); | |
342 | CTL_I_GET("stats.arenas.0.nmadvise", &nmadvise, uint64_t); | |
343 | CTL_I_GET("stats.arenas.0.purged", &purged, uint64_t); | |
344 | malloc_cprintf(write_cb, cbopaque, | |
345 | "dirty pages: %zu:%zu active:dirty, %"PRIu64" sweep%s," | |
346 | " %"PRIu64" madvise%s, %"PRIu64" purged\n", | |
347 | pactive, pdirty, npurge, npurge == 1 ? "" : "s", | |
348 | nmadvise, nmadvise == 1 ? "" : "s", purged); | |
349 | ||
350 | malloc_cprintf(write_cb, cbopaque, | |
351 | " allocated nmalloc ndalloc nrequests\n"); | |
352 | CTL_I_GET("stats.arenas.0.small.allocated", &small_allocated, size_t); | |
353 | CTL_I_GET("stats.arenas.0.small.nmalloc", &small_nmalloc, uint64_t); | |
354 | CTL_I_GET("stats.arenas.0.small.ndalloc", &small_ndalloc, uint64_t); | |
355 | CTL_I_GET("stats.arenas.0.small.nrequests", &small_nrequests, uint64_t); | |
356 | malloc_cprintf(write_cb, cbopaque, | |
357 | "small: %12zu %12"PRIu64" %12"PRIu64" %12"PRIu64"\n", | |
358 | small_allocated, small_nmalloc, small_ndalloc, small_nrequests); | |
359 | CTL_I_GET("stats.arenas.0.large.allocated", &large_allocated, size_t); | |
360 | CTL_I_GET("stats.arenas.0.large.nmalloc", &large_nmalloc, uint64_t); | |
361 | CTL_I_GET("stats.arenas.0.large.ndalloc", &large_ndalloc, uint64_t); | |
362 | CTL_I_GET("stats.arenas.0.large.nrequests", &large_nrequests, uint64_t); | |
363 | malloc_cprintf(write_cb, cbopaque, | |
364 | "large: %12zu %12"PRIu64" %12"PRIu64" %12"PRIu64"\n", | |
365 | large_allocated, large_nmalloc, large_ndalloc, large_nrequests); | |
366 | malloc_cprintf(write_cb, cbopaque, | |
367 | "total: %12zu %12"PRIu64" %12"PRIu64" %12"PRIu64"\n", | |
368 | small_allocated + large_allocated, | |
369 | small_nmalloc + large_nmalloc, | |
370 | small_ndalloc + large_ndalloc, | |
371 | small_nrequests + large_nrequests); | |
372 | malloc_cprintf(write_cb, cbopaque, "active: %12zu\n", | |
373 | pactive * pagesize ); | |
374 | CTL_I_GET("stats.arenas.0.mapped", &mapped, size_t); | |
375 | malloc_cprintf(write_cb, cbopaque, "mapped: %12zu\n", mapped); | |
376 | ||
377 | stats_arena_bins_print(write_cb, cbopaque, i); | |
378 | stats_arena_lruns_print(write_cb, cbopaque, i); | |
379 | } | |
380 | #endif | |
381 | ||
382 | void | |
383 | stats_print(void (*write_cb)(void *, const char *), void *cbopaque, | |
384 | const char *opts) | |
385 | { | |
386 | int err; | |
387 | uint64_t epoch; | |
388 | size_t u64sz; | |
389 | char s[UMAX2S_BUFSIZE]; | |
390 | bool general = true; | |
391 | bool merged = true; | |
392 | bool unmerged = true; | |
393 | bool bins = true; | |
394 | bool large = true; | |
395 | ||
396 | /* | |
397 | * Refresh stats, in case mallctl() was called by the application. | |
398 | * | |
399 | * Check for OOM here, since refreshing the ctl cache can trigger | |
400 | * allocation. In practice, none of the subsequent mallctl()-related | |
401 | * calls in this function will cause OOM if this one succeeds. | |
402 | * */ | |
403 | epoch = 1; | |
404 | u64sz = sizeof(uint64_t); | |
405 | err = JEMALLOC_P(mallctl)("epoch", &epoch, &u64sz, &epoch, | |
406 | sizeof(uint64_t)); | |
407 | if (err != 0) { | |
408 | if (err == EAGAIN) { | |
409 | malloc_write("<jemalloc>: Memory allocation failure in " | |
410 | "mallctl(\"epoch\", ...)\n"); | |
411 | return; | |
412 | } | |
413 | malloc_write("<jemalloc>: Failure in mallctl(\"epoch\", " | |
414 | "...)\n"); | |
415 | abort(); | |
416 | } | |
417 | ||
418 | if (write_cb == NULL) { | |
419 | /* | |
420 | * The caller did not provide an alternate write_cb callback | |
421 | * function, so use the default one. malloc_write() is an | |
422 | * inline function, so use malloc_message() directly here. | |
423 | */ | |
424 | write_cb = JEMALLOC_P(malloc_message); | |
425 | cbopaque = NULL; | |
426 | } | |
427 | ||
428 | if (opts != NULL) { | |
429 | unsigned i; | |
430 | ||
431 | for (i = 0; opts[i] != '\0'; i++) { | |
432 | switch (opts[i]) { | |
433 | case 'g': | |
434 | general = false; | |
435 | break; | |
436 | case 'm': | |
437 | merged = false; | |
438 | break; | |
439 | case 'a': | |
440 | unmerged = false; | |
441 | break; | |
442 | case 'b': | |
443 | bins = false; | |
444 | break; | |
445 | case 'l': | |
446 | large = false; | |
447 | break; | |
448 | default:; | |
449 | } | |
450 | } | |
451 | } | |
452 | ||
453 | write_cb(cbopaque, "___ Begin jemalloc statistics ___\n"); | |
454 | if (general) { | |
455 | int err; | |
456 | const char *cpv; | |
457 | bool bv; | |
458 | unsigned uv; | |
459 | ssize_t ssv; | |
460 | size_t sv, bsz, ssz, sssz, cpsz; | |
461 | ||
462 | bsz = sizeof(bool); | |
463 | ssz = sizeof(size_t); | |
464 | sssz = sizeof(ssize_t); | |
465 | cpsz = sizeof(const char *); | |
466 | ||
467 | CTL_GET("version", &cpv, const char *); | |
468 | write_cb(cbopaque, "Version: "); | |
469 | write_cb(cbopaque, cpv); | |
470 | write_cb(cbopaque, "\n"); | |
471 | CTL_GET("config.debug", &bv, bool); | |
472 | write_cb(cbopaque, "Assertions "); | |
473 | write_cb(cbopaque, bv ? "enabled" : "disabled"); | |
474 | write_cb(cbopaque, "\n"); | |
475 | ||
476 | #define OPT_WRITE_BOOL(n) \ | |
477 | if ((err = JEMALLOC_P(mallctl)("opt."#n, &bv, &bsz, \ | |
478 | NULL, 0)) == 0) { \ | |
479 | write_cb(cbopaque, " opt."#n": "); \ | |
480 | write_cb(cbopaque, bv ? "true" : "false"); \ | |
481 | write_cb(cbopaque, "\n"); \ | |
482 | } | |
483 | #define OPT_WRITE_SIZE_T(n) \ | |
484 | if ((err = JEMALLOC_P(mallctl)("opt."#n, &sv, &ssz, \ | |
485 | NULL, 0)) == 0) { \ | |
486 | write_cb(cbopaque, " opt."#n": "); \ | |
487 | write_cb(cbopaque, u2s(sv, 10, s)); \ | |
488 | write_cb(cbopaque, "\n"); \ | |
489 | } | |
490 | #define OPT_WRITE_SSIZE_T(n) \ | |
491 | if ((err = JEMALLOC_P(mallctl)("opt."#n, &ssv, &sssz, \ | |
492 | NULL, 0)) == 0) { \ | |
493 | if (ssv >= 0) { \ | |
494 | write_cb(cbopaque, " opt."#n": "); \ | |
495 | write_cb(cbopaque, u2s(ssv, 10, s)); \ | |
496 | } else { \ | |
497 | write_cb(cbopaque, " opt."#n": -"); \ | |
498 | write_cb(cbopaque, u2s(-ssv, 10, s)); \ | |
499 | } \ | |
500 | write_cb(cbopaque, "\n"); \ | |
501 | } | |
502 | #define OPT_WRITE_CHAR_P(n) \ | |
503 | if ((err = JEMALLOC_P(mallctl)("opt."#n, &cpv, &cpsz, \ | |
504 | NULL, 0)) == 0) { \ | |
505 | write_cb(cbopaque, " opt."#n": \""); \ | |
506 | write_cb(cbopaque, cpv); \ | |
507 | write_cb(cbopaque, "\"\n"); \ | |
508 | } | |
509 | ||
510 | write_cb(cbopaque, "Run-time option settings:\n"); | |
511 | OPT_WRITE_BOOL(abort) | |
512 | OPT_WRITE_SIZE_T(lg_qspace_max) | |
513 | OPT_WRITE_SIZE_T(lg_cspace_max) | |
514 | OPT_WRITE_SIZE_T(lg_chunk) | |
515 | OPT_WRITE_SIZE_T(narenas) | |
516 | OPT_WRITE_SSIZE_T(lg_dirty_mult) | |
517 | OPT_WRITE_BOOL(stats_print) | |
518 | OPT_WRITE_BOOL(junk) | |
519 | OPT_WRITE_BOOL(zero) | |
520 | OPT_WRITE_BOOL(sysv) | |
521 | OPT_WRITE_BOOL(xmalloc) | |
522 | OPT_WRITE_BOOL(tcache) | |
523 | OPT_WRITE_SSIZE_T(lg_tcache_gc_sweep) | |
524 | OPT_WRITE_SSIZE_T(lg_tcache_max) | |
525 | OPT_WRITE_BOOL(prof) | |
526 | OPT_WRITE_CHAR_P(prof_prefix) | |
527 | OPT_WRITE_SIZE_T(lg_prof_bt_max) | |
528 | OPT_WRITE_BOOL(prof_active) | |
529 | OPT_WRITE_SSIZE_T(lg_prof_sample) | |
530 | OPT_WRITE_BOOL(prof_accum) | |
531 | OPT_WRITE_SSIZE_T(lg_prof_tcmax) | |
532 | OPT_WRITE_SSIZE_T(lg_prof_interval) | |
533 | OPT_WRITE_BOOL(prof_gdump) | |
534 | OPT_WRITE_BOOL(prof_leak) | |
535 | OPT_WRITE_BOOL(overcommit) | |
536 | ||
537 | #undef OPT_WRITE_BOOL | |
538 | #undef OPT_WRITE_SIZE_T | |
539 | #undef OPT_WRITE_SSIZE_T | |
540 | #undef OPT_WRITE_CHAR_P | |
541 | ||
542 | write_cb(cbopaque, "CPUs: "); | |
543 | write_cb(cbopaque, u2s(ncpus, 10, s)); | |
544 | write_cb(cbopaque, "\n"); | |
545 | ||
546 | CTL_GET("arenas.narenas", &uv, unsigned); | |
547 | write_cb(cbopaque, "Max arenas: "); | |
548 | write_cb(cbopaque, u2s(uv, 10, s)); | |
549 | write_cb(cbopaque, "\n"); | |
550 | ||
551 | write_cb(cbopaque, "Pointer size: "); | |
552 | write_cb(cbopaque, u2s(sizeof(void *), 10, s)); | |
553 | write_cb(cbopaque, "\n"); | |
554 | ||
555 | CTL_GET("arenas.quantum", &sv, size_t); | |
556 | write_cb(cbopaque, "Quantum size: "); | |
557 | write_cb(cbopaque, u2s(sv, 10, s)); | |
558 | write_cb(cbopaque, "\n"); | |
559 | ||
560 | CTL_GET("arenas.cacheline", &sv, size_t); | |
561 | write_cb(cbopaque, "Cacheline size (assumed): "); | |
562 | write_cb(cbopaque, u2s(sv, 10, s)); | |
563 | write_cb(cbopaque, "\n"); | |
564 | ||
565 | CTL_GET("arenas.subpage", &sv, size_t); | |
566 | write_cb(cbopaque, "Subpage spacing: "); | |
567 | write_cb(cbopaque, u2s(sv, 10, s)); | |
568 | write_cb(cbopaque, "\n"); | |
569 | ||
570 | if ((err = JEMALLOC_P(mallctl)("arenas.tspace_min", &sv, &ssz, | |
571 | NULL, 0)) == 0) { | |
572 | write_cb(cbopaque, "Tiny 2^n-spaced sizes: ["); | |
573 | write_cb(cbopaque, u2s(sv, 10, s)); | |
574 | write_cb(cbopaque, ".."); | |
575 | ||
576 | CTL_GET("arenas.tspace_max", &sv, size_t); | |
577 | write_cb(cbopaque, u2s(sv, 10, s)); | |
578 | write_cb(cbopaque, "]\n"); | |
579 | } | |
580 | ||
581 | CTL_GET("arenas.qspace_min", &sv, size_t); | |
582 | write_cb(cbopaque, "Quantum-spaced sizes: ["); | |
583 | write_cb(cbopaque, u2s(sv, 10, s)); | |
584 | write_cb(cbopaque, ".."); | |
585 | CTL_GET("arenas.qspace_max", &sv, size_t); | |
586 | write_cb(cbopaque, u2s(sv, 10, s)); | |
587 | write_cb(cbopaque, "]\n"); | |
588 | ||
589 | CTL_GET("arenas.cspace_min", &sv, size_t); | |
590 | write_cb(cbopaque, "Cacheline-spaced sizes: ["); | |
591 | write_cb(cbopaque, u2s(sv, 10, s)); | |
592 | write_cb(cbopaque, ".."); | |
593 | CTL_GET("arenas.cspace_max", &sv, size_t); | |
594 | write_cb(cbopaque, u2s(sv, 10, s)); | |
595 | write_cb(cbopaque, "]\n"); | |
596 | ||
597 | CTL_GET("arenas.sspace_min", &sv, size_t); | |
598 | write_cb(cbopaque, "Subpage-spaced sizes: ["); | |
599 | write_cb(cbopaque, u2s(sv, 10, s)); | |
600 | write_cb(cbopaque, ".."); | |
601 | CTL_GET("arenas.sspace_max", &sv, size_t); | |
602 | write_cb(cbopaque, u2s(sv, 10, s)); | |
603 | write_cb(cbopaque, "]\n"); | |
604 | ||
605 | CTL_GET("opt.lg_dirty_mult", &ssv, ssize_t); | |
606 | if (ssv >= 0) { | |
607 | write_cb(cbopaque, | |
608 | "Min active:dirty page ratio per arena: "); | |
609 | write_cb(cbopaque, u2s((1U << ssv), 10, s)); | |
610 | write_cb(cbopaque, ":1\n"); | |
611 | } else { | |
612 | write_cb(cbopaque, | |
613 | "Min active:dirty page ratio per arena: N/A\n"); | |
614 | } | |
615 | if ((err = JEMALLOC_P(mallctl)("arenas.tcache_max", &sv, | |
616 | &ssz, NULL, 0)) == 0) { | |
617 | write_cb(cbopaque, | |
618 | "Maximum thread-cached size class: "); | |
619 | write_cb(cbopaque, u2s(sv, 10, s)); | |
620 | write_cb(cbopaque, "\n"); | |
621 | } | |
622 | if ((err = JEMALLOC_P(mallctl)("opt.lg_tcache_gc_sweep", &ssv, | |
623 | &ssz, NULL, 0)) == 0) { | |
624 | size_t tcache_gc_sweep = (1U << ssv); | |
625 | bool tcache_enabled; | |
626 | CTL_GET("opt.tcache", &tcache_enabled, bool); | |
627 | write_cb(cbopaque, "Thread cache GC sweep interval: "); | |
628 | write_cb(cbopaque, tcache_enabled && ssv >= 0 ? | |
629 | u2s(tcache_gc_sweep, 10, s) : "N/A"); | |
630 | write_cb(cbopaque, "\n"); | |
631 | } | |
632 | if ((err = JEMALLOC_P(mallctl)("opt.prof", &bv, &bsz, NULL, 0)) | |
633 | == 0 && bv) { | |
634 | CTL_GET("opt.lg_prof_bt_max", &sv, size_t); | |
635 | write_cb(cbopaque, "Maximum profile backtrace depth: "); | |
636 | write_cb(cbopaque, u2s((1U << sv), 10, s)); | |
637 | write_cb(cbopaque, "\n"); | |
638 | ||
639 | CTL_GET("opt.lg_prof_tcmax", &ssv, ssize_t); | |
640 | write_cb(cbopaque, | |
641 | "Maximum per thread backtrace cache: "); | |
642 | if (ssv >= 0) { | |
643 | write_cb(cbopaque, u2s((1U << ssv), 10, s)); | |
644 | write_cb(cbopaque, " (2^"); | |
645 | write_cb(cbopaque, u2s(ssv, 10, s)); | |
646 | write_cb(cbopaque, ")\n"); | |
647 | } else | |
648 | write_cb(cbopaque, "N/A\n"); | |
649 | ||
650 | CTL_GET("opt.lg_prof_sample", &sv, size_t); | |
651 | write_cb(cbopaque, "Average profile sample interval: "); | |
652 | write_cb(cbopaque, u2s((((uint64_t)1U) << sv), 10, s)); | |
653 | write_cb(cbopaque, " (2^"); | |
654 | write_cb(cbopaque, u2s(sv, 10, s)); | |
655 | write_cb(cbopaque, ")\n"); | |
656 | ||
657 | CTL_GET("opt.lg_prof_interval", &ssv, ssize_t); | |
658 | write_cb(cbopaque, "Average profile dump interval: "); | |
659 | if (ssv >= 0) { | |
660 | write_cb(cbopaque, u2s((((uint64_t)1U) << ssv), | |
661 | 10, s)); | |
662 | write_cb(cbopaque, " (2^"); | |
663 | write_cb(cbopaque, u2s(ssv, 10, s)); | |
664 | write_cb(cbopaque, ")\n"); | |
665 | } else | |
666 | write_cb(cbopaque, "N/A\n"); | |
667 | } | |
668 | CTL_GET("arenas.chunksize", &sv, size_t); | |
669 | write_cb(cbopaque, "Chunk size: "); | |
670 | write_cb(cbopaque, u2s(sv, 10, s)); | |
671 | CTL_GET("opt.lg_chunk", &sv, size_t); | |
672 | write_cb(cbopaque, " (2^"); | |
673 | write_cb(cbopaque, u2s(sv, 10, s)); | |
674 | write_cb(cbopaque, ")\n"); | |
675 | } | |
676 | ||
677 | #ifdef JEMALLOC_STATS | |
678 | { | |
679 | int err; | |
680 | size_t sszp, ssz; | |
681 | size_t *cactive; | |
682 | size_t allocated, active, mapped; | |
683 | size_t chunks_current, chunks_high, swap_avail; | |
684 | uint64_t chunks_total; | |
685 | size_t huge_allocated; | |
686 | uint64_t huge_nmalloc, huge_ndalloc; | |
687 | ||
688 | sszp = sizeof(size_t *); | |
689 | ssz = sizeof(size_t); | |
690 | ||
691 | CTL_GET("stats.cactive", &cactive, size_t *); | |
692 | CTL_GET("stats.allocated", &allocated, size_t); | |
693 | CTL_GET("stats.active", &active, size_t); | |
694 | CTL_GET("stats.mapped", &mapped, size_t); | |
695 | malloc_cprintf(write_cb, cbopaque, | |
696 | "Allocated: %zu, active: %zu, mapped: %zu\n", | |
697 | allocated, active, mapped); | |
698 | malloc_cprintf(write_cb, cbopaque, | |
699 | "Current active ceiling: %zu\n", atomic_read_z(cactive)); | |
700 | ||
701 | /* Print chunk stats. */ | |
702 | CTL_GET("stats.chunks.total", &chunks_total, uint64_t); | |
703 | CTL_GET("stats.chunks.high", &chunks_high, size_t); | |
704 | CTL_GET("stats.chunks.current", &chunks_current, size_t); | |
705 | if ((err = JEMALLOC_P(mallctl)("swap.avail", &swap_avail, &ssz, | |
706 | NULL, 0)) == 0) { | |
707 | size_t lg_chunk; | |
708 | ||
709 | malloc_cprintf(write_cb, cbopaque, "chunks: nchunks " | |
710 | "highchunks curchunks swap_avail\n"); | |
711 | CTL_GET("opt.lg_chunk", &lg_chunk, size_t); | |
712 | malloc_cprintf(write_cb, cbopaque, | |
713 | " %13"PRIu64"%13zu%13zu%13zu\n", | |
714 | chunks_total, chunks_high, chunks_current, | |
715 | swap_avail << lg_chunk); | |
716 | } else { | |
717 | malloc_cprintf(write_cb, cbopaque, "chunks: nchunks " | |
718 | "highchunks curchunks\n"); | |
719 | malloc_cprintf(write_cb, cbopaque, | |
720 | " %13"PRIu64"%13zu%13zu\n", | |
721 | chunks_total, chunks_high, chunks_current); | |
722 | } | |
723 | ||
724 | /* Print huge stats. */ | |
725 | CTL_GET("stats.huge.nmalloc", &huge_nmalloc, uint64_t); | |
726 | CTL_GET("stats.huge.ndalloc", &huge_ndalloc, uint64_t); | |
727 | CTL_GET("stats.huge.allocated", &huge_allocated, size_t); | |
728 | malloc_cprintf(write_cb, cbopaque, | |
729 | "huge: nmalloc ndalloc allocated\n"); | |
730 | malloc_cprintf(write_cb, cbopaque, | |
731 | " %12"PRIu64" %12"PRIu64" %12zu\n", | |
732 | huge_nmalloc, huge_ndalloc, huge_allocated); | |
733 | ||
734 | if (merged) { | |
735 | unsigned narenas; | |
736 | ||
737 | CTL_GET("arenas.narenas", &narenas, unsigned); | |
738 | { | |
739 | bool initialized[narenas]; | |
740 | size_t isz; | |
741 | unsigned i, ninitialized; | |
742 | ||
743 | isz = sizeof(initialized); | |
744 | xmallctl("arenas.initialized", initialized, | |
745 | &isz, NULL, 0); | |
746 | for (i = ninitialized = 0; i < narenas; i++) { | |
747 | if (initialized[i]) | |
748 | ninitialized++; | |
749 | } | |
750 | ||
751 | if (ninitialized > 1 || unmerged == false) { | |
752 | /* Print merged arena stats. */ | |
753 | malloc_cprintf(write_cb, cbopaque, | |
754 | "\nMerged arenas stats:\n"); | |
755 | stats_arena_print(write_cb, cbopaque, | |
756 | narenas); | |
757 | } | |
758 | } | |
759 | } | |
760 | ||
761 | if (unmerged) { | |
762 | unsigned narenas; | |
763 | ||
764 | /* Print stats for each arena. */ | |
765 | ||
766 | CTL_GET("arenas.narenas", &narenas, unsigned); | |
767 | { | |
768 | bool initialized[narenas]; | |
769 | size_t isz; | |
770 | unsigned i; | |
771 | ||
772 | isz = sizeof(initialized); | |
773 | xmallctl("arenas.initialized", initialized, | |
774 | &isz, NULL, 0); | |
775 | ||
776 | for (i = 0; i < narenas; i++) { | |
777 | if (initialized[i]) { | |
778 | malloc_cprintf(write_cb, | |
779 | cbopaque, | |
780 | "\narenas[%u]:\n", i); | |
781 | stats_arena_print(write_cb, | |
782 | cbopaque, i); | |
783 | } | |
784 | } | |
785 | } | |
786 | } | |
787 | } | |
788 | #endif /* #ifdef JEMALLOC_STATS */ | |
789 | write_cb(cbopaque, "--- End jemalloc statistics ---\n"); | |
790 | } |