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, (void *)v, &sz, NULL, 0); \ 7 } while (0) 8 9 #define CTL_M2_GET(n, i, 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, (void *)v, &sz, NULL, 0); \ 16 } while (0) 17 18 #define CTL_M2_M4_GET(n, i, j, 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] = (i); \ 24 mib[4] = (j); \ 25 xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0); \ 26 } while (0) 27 28 /******************************************************************************/ 29 /* Data. */ 30 31 bool opt_stats_print = false; 32 33 size_t stats_cactive = 0; 34 35 /******************************************************************************/ 36 37 static void 38 stats_arena_bins_print(void (*write_cb)(void *, const char *), void *cbopaque, 39 bool json, bool large, bool huge, unsigned i) 40 { 41 size_t page; 42 bool in_gap, in_gap_prev; 43 unsigned nbins, j; 44 45 CTL_GET("arenas.page", &page, size_t); 46 47 CTL_GET("arenas.nbins", &nbins, unsigned); 48 if (json) { 49 malloc_cprintf(write_cb, cbopaque, 50 "\t\t\t\t\"bins\": [\n"); 51 } else { 52 if (config_tcache) { 53 malloc_cprintf(write_cb, cbopaque, 54 "bins: size ind allocated nmalloc" 55 " ndalloc nrequests curregs" 56 " curruns regs pgs util nfills" 57 " nflushes newruns reruns\n"); 58 } else { 59 malloc_cprintf(write_cb, cbopaque, 60 "bins: size ind allocated nmalloc" 61 " ndalloc nrequests curregs" 62 " curruns regs pgs util newruns" 63 " reruns\n"); 64 } 65 } 66 for (j = 0, in_gap = false; j < nbins; j++) { 67 uint64_t nruns; 68 size_t reg_size, run_size, curregs; 69 size_t curruns; 70 uint32_t nregs; 71 uint64_t nmalloc, ndalloc, nrequests, nfills, nflushes; 72 uint64_t nreruns; 73 74 CTL_M2_M4_GET("stats.arenas.0.bins.0.nruns", i, j, &nruns, 75 uint64_t); 76 in_gap_prev = in_gap; 77 in_gap = (nruns == 0); 78 79 if (!json && in_gap_prev && !in_gap) { 80 malloc_cprintf(write_cb, cbopaque, 81 " ---\n"); 82 } 83 84 CTL_M2_GET("arenas.bin.0.size", j, ®_size, size_t); 85 CTL_M2_GET("arenas.bin.0.nregs", j, &nregs, uint32_t); 86 CTL_M2_GET("arenas.bin.0.run_size", j, &run_size, size_t); 87 88 CTL_M2_M4_GET("stats.arenas.0.bins.0.nmalloc", i, j, &nmalloc, 89 uint64_t); 90 CTL_M2_M4_GET("stats.arenas.0.bins.0.ndalloc", i, j, &ndalloc, 91 uint64_t); 92 CTL_M2_M4_GET("stats.arenas.0.bins.0.curregs", i, j, &curregs, 93 size_t); 94 CTL_M2_M4_GET("stats.arenas.0.bins.0.nrequests", i, j, 95 &nrequests, uint64_t); 96 if (config_tcache) { 97 CTL_M2_M4_GET("stats.arenas.0.bins.0.nfills", i, j, 98 &nfills, uint64_t); 99 CTL_M2_M4_GET("stats.arenas.0.bins.0.nflushes", i, j, 100 &nflushes, uint64_t); 101 } 102 CTL_M2_M4_GET("stats.arenas.0.bins.0.nreruns", i, j, &nreruns, 103 uint64_t); 104 CTL_M2_M4_GET("stats.arenas.0.bins.0.curruns", i, j, &curruns, 105 size_t); 106 107 if (json) { 108 malloc_cprintf(write_cb, cbopaque, 109 "\t\t\t\t\t{\n" 110 "\t\t\t\t\t\t\"nmalloc\": %"FMTu64",\n" 111 "\t\t\t\t\t\t\"ndalloc\": %"FMTu64",\n" 112 "\t\t\t\t\t\t\"curregs\": %zu,\n" 113 "\t\t\t\t\t\t\"nrequests\": %"FMTu64",\n", 114 nmalloc, 115 ndalloc, 116 curregs, 117 nrequests); 118 if (config_tcache) { 119 malloc_cprintf(write_cb, cbopaque, 120 "\t\t\t\t\t\t\"nfills\": %"FMTu64",\n" 121 "\t\t\t\t\t\t\"nflushes\": %"FMTu64",\n", 122 nfills, 123 nflushes); 124 } 125 malloc_cprintf(write_cb, cbopaque, 126 "\t\t\t\t\t\t\"nreruns\": %"FMTu64",\n" 127 "\t\t\t\t\t\t\"curruns\": %zu\n" 128 "\t\t\t\t\t}%s\n", 129 nreruns, 130 curruns, 131 (j + 1 < nbins) ? "," : ""); 132 } else if (!in_gap) { 133 size_t availregs, milli; 134 char util[6]; /* "x.yyy". */ 135 136 availregs = nregs * curruns; 137 milli = (availregs != 0) ? (1000 * curregs) / availregs 138 : 1000; 139 140 if (milli > 1000) { 141 /* 142 * Race detected: the counters were read in 143 * separate mallctl calls and concurrent 144 * operations happened in between. In this case 145 * no meaningful utilization can be computed. 146 */ 147 malloc_snprintf(util, sizeof(util), " race"); 148 } else if (milli < 10) { 149 malloc_snprintf(util, sizeof(util), 150 "0.00%zu", milli); 151 } else if (milli < 100) { 152 malloc_snprintf(util, sizeof(util), "0.0%zu", 153 milli); 154 } else if (milli < 1000) { 155 malloc_snprintf(util, sizeof(util), "0.%zu", 156 milli); 157 } else { 158 assert(milli == 1000); 159 malloc_snprintf(util, sizeof(util), "1"); 160 } 161 162 if (config_tcache) { 163 malloc_cprintf(write_cb, cbopaque, 164 "%20zu %3u %12zu %12"FMTu64 165 " %12"FMTu64" %12"FMTu64" %12zu" 166 " %12zu %4u %3zu %-5s %12"FMTu64 167 " %12"FMTu64" %12"FMTu64" %12"FMTu64"\n", 168 reg_size, j, curregs * reg_size, nmalloc, 169 ndalloc, nrequests, curregs, curruns, nregs, 170 run_size / page, util, nfills, nflushes, 171 nruns, nreruns); 172 } else { 173 malloc_cprintf(write_cb, cbopaque, 174 "%20zu %3u %12zu %12"FMTu64 175 " %12"FMTu64" %12"FMTu64" %12zu" 176 " %12zu %4u %3zu %-5s %12"FMTu64 177 " %12"FMTu64"\n", 178 reg_size, j, curregs * reg_size, nmalloc, 179 ndalloc, nrequests, curregs, curruns, nregs, 180 run_size / page, util, nruns, nreruns); 181 } 182 } 183 } 184 if (json) { 185 malloc_cprintf(write_cb, cbopaque, 186 "\t\t\t\t]%s\n", (large || huge) ? "," : ""); 187 } else { 188 if (in_gap) { 189 malloc_cprintf(write_cb, cbopaque, 190 " ---\n"); 191 } 192 } 193 } 194 195 static void 196 stats_arena_lruns_print(void (*write_cb)(void *, const char *), void *cbopaque, 197 bool json, bool huge, unsigned i) 198 { 199 unsigned nbins, nlruns, j; 200 bool in_gap, in_gap_prev; 201 202 CTL_GET("arenas.nbins", &nbins, unsigned); 203 CTL_GET("arenas.nlruns", &nlruns, unsigned); 204 if (json) { 205 malloc_cprintf(write_cb, cbopaque, 206 "\t\t\t\t\"lruns\": [\n"); 207 } else { 208 malloc_cprintf(write_cb, cbopaque, 209 "large: size ind allocated nmalloc" 210 " ndalloc nrequests curruns\n"); 211 } 212 for (j = 0, in_gap = false; j < nlruns; j++) { 213 uint64_t nmalloc, ndalloc, nrequests; 214 size_t run_size, curruns; 215 216 CTL_M2_M4_GET("stats.arenas.0.lruns.0.nmalloc", i, j, &nmalloc, 217 uint64_t); 218 CTL_M2_M4_GET("stats.arenas.0.lruns.0.ndalloc", i, j, &ndalloc, 219 uint64_t); 220 CTL_M2_M4_GET("stats.arenas.0.lruns.0.nrequests", i, j, 221 &nrequests, uint64_t); 222 in_gap_prev = in_gap; 223 in_gap = (nrequests == 0); 224 225 if (!json && in_gap_prev && !in_gap) { 226 malloc_cprintf(write_cb, cbopaque, 227 " ---\n"); 228 } 229 230 CTL_M2_GET("arenas.lrun.0.size", j, &run_size, size_t); 231 CTL_M2_M4_GET("stats.arenas.0.lruns.0.curruns", i, j, &curruns, 232 size_t); 233 if (json) { 234 malloc_cprintf(write_cb, cbopaque, 235 "\t\t\t\t\t{\n" 236 "\t\t\t\t\t\t\"curruns\": %zu\n" 237 "\t\t\t\t\t}%s\n", 238 curruns, 239 (j + 1 < nlruns) ? "," : ""); 240 } else if (!in_gap) { 241 malloc_cprintf(write_cb, cbopaque, 242 "%20zu %3u %12zu %12"FMTu64" %12"FMTu64 243 " %12"FMTu64" %12zu\n", 244 run_size, nbins + j, curruns * run_size, nmalloc, 245 ndalloc, nrequests, curruns); 246 } 247 } 248 if (json) { 249 malloc_cprintf(write_cb, cbopaque, 250 "\t\t\t\t]%s\n", huge ? "," : ""); 251 } else { 252 if (in_gap) { 253 malloc_cprintf(write_cb, cbopaque, 254 " ---\n"); 255 } 256 } 257 } 258 259 static void 260 stats_arena_hchunks_print(void (*write_cb)(void *, const char *), 261 void *cbopaque, bool json, unsigned i) 262 { 263 unsigned nbins, nlruns, nhchunks, j; 264 bool in_gap, in_gap_prev; 265 266 CTL_GET("arenas.nbins", &nbins, unsigned); 267 CTL_GET("arenas.nlruns", &nlruns, unsigned); 268 CTL_GET("arenas.nhchunks", &nhchunks, unsigned); 269 if (json) { 270 malloc_cprintf(write_cb, cbopaque, 271 "\t\t\t\t\"hchunks\": [\n"); 272 } else { 273 malloc_cprintf(write_cb, cbopaque, 274 "huge: size ind allocated nmalloc" 275 " ndalloc nrequests curhchunks\n"); 276 } 277 for (j = 0, in_gap = false; j < nhchunks; j++) { 278 uint64_t nmalloc, ndalloc, nrequests; 279 size_t hchunk_size, curhchunks; 280 281 CTL_M2_M4_GET("stats.arenas.0.hchunks.0.nmalloc", i, j, 282 &nmalloc, uint64_t); 283 CTL_M2_M4_GET("stats.arenas.0.hchunks.0.ndalloc", i, j, 284 &ndalloc, uint64_t); 285 CTL_M2_M4_GET("stats.arenas.0.hchunks.0.nrequests", i, j, 286 &nrequests, uint64_t); 287 in_gap_prev = in_gap; 288 in_gap = (nrequests == 0); 289 290 if (!json && in_gap_prev && !in_gap) { 291 malloc_cprintf(write_cb, cbopaque, 292 " ---\n"); 293 } 294 295 CTL_M2_GET("arenas.hchunk.0.size", j, &hchunk_size, size_t); 296 CTL_M2_M4_GET("stats.arenas.0.hchunks.0.curhchunks", i, j, 297 &curhchunks, size_t); 298 if (json) { 299 malloc_cprintf(write_cb, cbopaque, 300 "\t\t\t\t\t{\n" 301 "\t\t\t\t\t\t\"curhchunks\": %zu\n" 302 "\t\t\t\t\t}%s\n", 303 curhchunks, 304 (j + 1 < nhchunks) ? "," : ""); 305 } else if (!in_gap) { 306 malloc_cprintf(write_cb, cbopaque, 307 "%20zu %3u %12zu %12"FMTu64" %12"FMTu64 308 " %12"FMTu64" %12zu\n", 309 hchunk_size, nbins + nlruns + j, 310 curhchunks * hchunk_size, nmalloc, ndalloc, 311 nrequests, curhchunks); 312 } 313 } 314 if (json) { 315 malloc_cprintf(write_cb, cbopaque, 316 "\t\t\t\t]\n"); 317 } else { 318 if (in_gap) { 319 malloc_cprintf(write_cb, cbopaque, 320 " ---\n"); 321 } 322 } 323 } 324 325 static void 326 stats_arena_print(void (*write_cb)(void *, const char *), void *cbopaque, 327 bool json, unsigned i, bool bins, bool large, bool huge) 328 { 329 unsigned nthreads; 330 const char *dss; 331 ssize_t lg_dirty_mult, decay_time; 332 size_t page, pactive, pdirty, mapped, retained; 333 size_t metadata_mapped, metadata_allocated; 334 uint64_t npurge, nmadvise, purged; 335 size_t small_allocated; 336 uint64_t small_nmalloc, small_ndalloc, small_nrequests; 337 size_t large_allocated; 338 uint64_t large_nmalloc, large_ndalloc, large_nrequests; 339 size_t huge_allocated; 340 uint64_t huge_nmalloc, huge_ndalloc, huge_nrequests; 341 342 CTL_GET("arenas.page", &page, size_t); 343 344 CTL_M2_GET("stats.arenas.0.nthreads", i, &nthreads, unsigned); 345 if (json) { 346 malloc_cprintf(write_cb, cbopaque, 347 "\t\t\t\t\"nthreads\": %u,\n", nthreads); 348 } else { 349 malloc_cprintf(write_cb, cbopaque, 350 "assigned threads: %u\n", nthreads); 351 } 352 353 CTL_M2_GET("stats.arenas.0.dss", i, &dss, const char *); 354 if (json) { 355 malloc_cprintf(write_cb, cbopaque, 356 "\t\t\t\t\"dss\": \"%s\",\n", dss); 357 } else { 358 malloc_cprintf(write_cb, cbopaque, 359 "dss allocation precedence: %s\n", dss); 360 } 361 362 CTL_M2_GET("stats.arenas.0.lg_dirty_mult", i, &lg_dirty_mult, ssize_t); 363 if (json) { 364 malloc_cprintf(write_cb, cbopaque, 365 "\t\t\t\t\"lg_dirty_mult\": %zd,\n", lg_dirty_mult); 366 } else { 367 if (opt_purge == purge_mode_ratio) { 368 if (lg_dirty_mult >= 0) { 369 malloc_cprintf(write_cb, cbopaque, 370 "min active:dirty page ratio: %u:1\n", 371 (1U << lg_dirty_mult)); 372 } else { 373 malloc_cprintf(write_cb, cbopaque, 374 "min active:dirty page ratio: N/A\n"); 375 } 376 } 377 } 378 379 CTL_M2_GET("stats.arenas.0.decay_time", i, &decay_time, ssize_t); 380 if (json) { 381 malloc_cprintf(write_cb, cbopaque, 382 "\t\t\t\t\"decay_time\": %zd,\n", decay_time); 383 } else { 384 if (opt_purge == purge_mode_decay) { 385 if (decay_time >= 0) { 386 malloc_cprintf(write_cb, cbopaque, 387 "decay time: %zd\n", decay_time); 388 } else { 389 malloc_cprintf(write_cb, cbopaque, 390 "decay time: N/A\n"); 391 } 392 } 393 } 394 395 CTL_M2_GET("stats.arenas.0.pactive", i, &pactive, size_t); 396 CTL_M2_GET("stats.arenas.0.pdirty", i, &pdirty, size_t); 397 CTL_M2_GET("stats.arenas.0.npurge", i, &npurge, uint64_t); 398 CTL_M2_GET("stats.arenas.0.nmadvise", i, &nmadvise, uint64_t); 399 CTL_M2_GET("stats.arenas.0.purged", i, &purged, uint64_t); 400 if (json) { 401 malloc_cprintf(write_cb, cbopaque, 402 "\t\t\t\t\"pactive\": %zu,\n", pactive); 403 malloc_cprintf(write_cb, cbopaque, 404 "\t\t\t\t\"pdirty\": %zu,\n", pdirty); 405 malloc_cprintf(write_cb, cbopaque, 406 "\t\t\t\t\"npurge\": %"FMTu64",\n", npurge); 407 malloc_cprintf(write_cb, cbopaque, 408 "\t\t\t\t\"nmadvise\": %"FMTu64",\n", nmadvise); 409 malloc_cprintf(write_cb, cbopaque, 410 "\t\t\t\t\"purged\": %"FMTu64",\n", purged); 411 } else { 412 malloc_cprintf(write_cb, cbopaque, 413 "purging: dirty: %zu, sweeps: %"FMTu64", madvises: %"FMTu64 414 ", purged: %"FMTu64"\n", pdirty, npurge, nmadvise, purged); 415 } 416 417 CTL_M2_GET("stats.arenas.0.small.allocated", i, &small_allocated, 418 size_t); 419 CTL_M2_GET("stats.arenas.0.small.nmalloc", i, &small_nmalloc, uint64_t); 420 CTL_M2_GET("stats.arenas.0.small.ndalloc", i, &small_ndalloc, uint64_t); 421 CTL_M2_GET("stats.arenas.0.small.nrequests", i, &small_nrequests, 422 uint64_t); 423 if (json) { 424 malloc_cprintf(write_cb, cbopaque, 425 "\t\t\t\t\"small\": {\n"); 426 427 malloc_cprintf(write_cb, cbopaque, 428 "\t\t\t\t\t\"allocated\": %zu,\n", small_allocated); 429 malloc_cprintf(write_cb, cbopaque, 430 "\t\t\t\t\t\"nmalloc\": %"FMTu64",\n", small_nmalloc); 431 malloc_cprintf(write_cb, cbopaque, 432 "\t\t\t\t\t\"ndalloc\": %"FMTu64",\n", small_ndalloc); 433 malloc_cprintf(write_cb, cbopaque, 434 "\t\t\t\t\t\"nrequests\": %"FMTu64"\n", small_nrequests); 435 436 malloc_cprintf(write_cb, cbopaque, 437 "\t\t\t\t},\n"); 438 } else { 439 malloc_cprintf(write_cb, cbopaque, 440 " allocated nmalloc" 441 " ndalloc nrequests\n"); 442 malloc_cprintf(write_cb, cbopaque, 443 "small: %12zu %12"FMTu64" %12"FMTu64 444 " %12"FMTu64"\n", 445 small_allocated, small_nmalloc, small_ndalloc, 446 small_nrequests); 447 } 448 449 CTL_M2_GET("stats.arenas.0.large.allocated", i, &large_allocated, 450 size_t); 451 CTL_M2_GET("stats.arenas.0.large.nmalloc", i, &large_nmalloc, uint64_t); 452 CTL_M2_GET("stats.arenas.0.large.ndalloc", i, &large_ndalloc, uint64_t); 453 CTL_M2_GET("stats.arenas.0.large.nrequests", i, &large_nrequests, 454 uint64_t); 455 if (json) { 456 malloc_cprintf(write_cb, cbopaque, 457 "\t\t\t\t\"large\": {\n"); 458 459 malloc_cprintf(write_cb, cbopaque, 460 "\t\t\t\t\t\"allocated\": %zu,\n", large_allocated); 461 malloc_cprintf(write_cb, cbopaque, 462 "\t\t\t\t\t\"nmalloc\": %"FMTu64",\n", large_nmalloc); 463 malloc_cprintf(write_cb, cbopaque, 464 "\t\t\t\t\t\"ndalloc\": %"FMTu64",\n", large_ndalloc); 465 malloc_cprintf(write_cb, cbopaque, 466 "\t\t\t\t\t\"nrequests\": %"FMTu64"\n", large_nrequests); 467 468 malloc_cprintf(write_cb, cbopaque, 469 "\t\t\t\t},\n"); 470 } else { 471 malloc_cprintf(write_cb, cbopaque, 472 "large: %12zu %12"FMTu64" %12"FMTu64 473 " %12"FMTu64"\n", 474 large_allocated, large_nmalloc, large_ndalloc, 475 large_nrequests); 476 } 477 478 CTL_M2_GET("stats.arenas.0.huge.allocated", i, &huge_allocated, size_t); 479 CTL_M2_GET("stats.arenas.0.huge.nmalloc", i, &huge_nmalloc, uint64_t); 480 CTL_M2_GET("stats.arenas.0.huge.ndalloc", i, &huge_ndalloc, uint64_t); 481 CTL_M2_GET("stats.arenas.0.huge.nrequests", i, &huge_nrequests, 482 uint64_t); 483 if (json) { 484 malloc_cprintf(write_cb, cbopaque, 485 "\t\t\t\t\"huge\": {\n"); 486 487 malloc_cprintf(write_cb, cbopaque, 488 "\t\t\t\t\t\"allocated\": %zu,\n", huge_allocated); 489 malloc_cprintf(write_cb, cbopaque, 490 "\t\t\t\t\t\"nmalloc\": %"FMTu64",\n", huge_nmalloc); 491 malloc_cprintf(write_cb, cbopaque, 492 "\t\t\t\t\t\"ndalloc\": %"FMTu64",\n", huge_ndalloc); 493 malloc_cprintf(write_cb, cbopaque, 494 "\t\t\t\t\t\"nrequests\": %"FMTu64"\n", huge_nrequests); 495 496 malloc_cprintf(write_cb, cbopaque, 497 "\t\t\t\t},\n"); 498 } else { 499 malloc_cprintf(write_cb, cbopaque, 500 "huge: %12zu %12"FMTu64" %12"FMTu64 501 " %12"FMTu64"\n", 502 huge_allocated, huge_nmalloc, huge_ndalloc, huge_nrequests); 503 malloc_cprintf(write_cb, cbopaque, 504 "total: %12zu %12"FMTu64" %12"FMTu64 505 " %12"FMTu64"\n", 506 small_allocated + large_allocated + huge_allocated, 507 small_nmalloc + large_nmalloc + huge_nmalloc, 508 small_ndalloc + large_ndalloc + huge_ndalloc, 509 small_nrequests + large_nrequests + huge_nrequests); 510 } 511 if (!json) { 512 malloc_cprintf(write_cb, cbopaque, 513 "active: %12zu\n", pactive * page); 514 } 515 516 CTL_M2_GET("stats.arenas.0.mapped", i, &mapped, size_t); 517 if (json) { 518 malloc_cprintf(write_cb, cbopaque, 519 "\t\t\t\t\"mapped\": %zu,\n", mapped); 520 } else { 521 malloc_cprintf(write_cb, cbopaque, 522 "mapped: %12zu\n", mapped); 523 } 524 525 CTL_M2_GET("stats.arenas.0.retained", i, &retained, size_t); 526 if (json) { 527 malloc_cprintf(write_cb, cbopaque, 528 "\t\t\t\t\"retained\": %zu,\n", retained); 529 } else { 530 malloc_cprintf(write_cb, cbopaque, 531 "retained: %12zu\n", retained); 532 } 533 534 CTL_M2_GET("stats.arenas.0.metadata.mapped", i, &metadata_mapped, 535 size_t); 536 CTL_M2_GET("stats.arenas.0.metadata.allocated", i, &metadata_allocated, 537 size_t); 538 if (json) { 539 malloc_cprintf(write_cb, cbopaque, 540 "\t\t\t\t\"metadata\": {\n"); 541 542 malloc_cprintf(write_cb, cbopaque, 543 "\t\t\t\t\t\"mapped\": %zu,\n", metadata_mapped); 544 malloc_cprintf(write_cb, cbopaque, 545 "\t\t\t\t\t\"allocated\": %zu\n", metadata_allocated); 546 547 malloc_cprintf(write_cb, cbopaque, 548 "\t\t\t\t}%s\n", (bins || large || huge) ? "," : ""); 549 } else { 550 malloc_cprintf(write_cb, cbopaque, 551 "metadata: mapped: %zu, allocated: %zu\n", 552 metadata_mapped, metadata_allocated); 553 } 554 555 if (bins) { 556 stats_arena_bins_print(write_cb, cbopaque, json, large, huge, 557 i); 558 } 559 if (large) 560 stats_arena_lruns_print(write_cb, cbopaque, json, huge, i); 561 if (huge) 562 stats_arena_hchunks_print(write_cb, cbopaque, json, i); 563 } 564 565 static void 566 stats_general_print(void (*write_cb)(void *, const char *), void *cbopaque, 567 bool json, bool more) 568 { 569 const char *cpv; 570 bool bv; 571 unsigned uv; 572 uint32_t u32v; 573 uint64_t u64v; 574 ssize_t ssv; 575 size_t sv, bsz, usz, ssz, sssz, cpsz; 576 577 bsz = sizeof(bool); 578 usz = sizeof(unsigned); 579 ssz = sizeof(size_t); 580 sssz = sizeof(ssize_t); 581 cpsz = sizeof(const char *); 582 583 CTL_GET("version", &cpv, const char *); 584 if (json) { 585 malloc_cprintf(write_cb, cbopaque, 586 "\t\t\"version\": \"%s\",\n", cpv); 587 } else 588 malloc_cprintf(write_cb, cbopaque, "Version: %s\n", cpv); 589 590 /* config. */ 591 #define CONFIG_WRITE_BOOL_JSON(n, c) \ 592 if (json) { \ 593 CTL_GET("config."#n, &bv, bool); \ 594 malloc_cprintf(write_cb, cbopaque, \ 595 "\t\t\t\""#n"\": %s%s\n", bv ? "true" : "false", \ 596 (c)); \ 597 } 598 599 if (json) { 600 malloc_cprintf(write_cb, cbopaque, 601 "\t\t\"config\": {\n"); 602 } 603 604 CONFIG_WRITE_BOOL_JSON(cache_oblivious, ",") 605 606 CTL_GET("config.debug", &bv, bool); 607 if (json) { 608 malloc_cprintf(write_cb, cbopaque, 609 "\t\t\t\"debug\": %s,\n", bv ? "true" : "false"); 610 } else { 611 malloc_cprintf(write_cb, cbopaque, "Assertions %s\n", 612 bv ? "enabled" : "disabled"); 613 } 614 615 CONFIG_WRITE_BOOL_JSON(fill, ",") 616 CONFIG_WRITE_BOOL_JSON(lazy_lock, ",") 617 618 if (json) { 619 malloc_cprintf(write_cb, cbopaque, 620 "\t\t\t\"malloc_conf\": \"%s\",\n", 621 config_malloc_conf); 622 } else { 623 malloc_cprintf(write_cb, cbopaque, 624 "config.malloc_conf: \"%s\"\n", config_malloc_conf); 625 } 626 627 CONFIG_WRITE_BOOL_JSON(munmap, ",") 628 CONFIG_WRITE_BOOL_JSON(prof, ",") 629 CONFIG_WRITE_BOOL_JSON(prof_libgcc, ",") 630 CONFIG_WRITE_BOOL_JSON(prof_libunwind, ",") 631 CONFIG_WRITE_BOOL_JSON(stats, ",") 632 CONFIG_WRITE_BOOL_JSON(tcache, ",") 633 CONFIG_WRITE_BOOL_JSON(tls, ",") 634 CONFIG_WRITE_BOOL_JSON(utrace, ",") 635 CONFIG_WRITE_BOOL_JSON(valgrind, ",") 636 CONFIG_WRITE_BOOL_JSON(xmalloc, "") 637 638 if (json) { 639 malloc_cprintf(write_cb, cbopaque, 640 "\t\t},\n"); 641 } 642 #undef CONFIG_WRITE_BOOL_JSON 643 644 /* opt. */ 645 #define OPT_WRITE_BOOL(n, c) \ 646 if (je_mallctl("opt."#n, (void *)&bv, &bsz, NULL, 0) == 0) { \ 647 if (json) { \ 648 malloc_cprintf(write_cb, cbopaque, \ 649 "\t\t\t\""#n"\": %s%s\n", bv ? "true" : \ 650 "false", (c)); \ 651 } else { \ 652 malloc_cprintf(write_cb, cbopaque, \ 653 " opt."#n": %s\n", bv ? "true" : "false"); \ 654 } \ 655 } 656 #define OPT_WRITE_BOOL_MUTABLE(n, m, c) { \ 657 bool bv2; \ 658 if (je_mallctl("opt."#n, (void *)&bv, &bsz, NULL, 0) == 0 && \ 659 je_mallctl(#m, &bv2, (void *)&bsz, NULL, 0) == 0) { \ 660 if (json) { \ 661 malloc_cprintf(write_cb, cbopaque, \ 662 "\t\t\t\""#n"\": %s%s\n", bv ? "true" : \ 663 "false", (c)); \ 664 } else { \ 665 malloc_cprintf(write_cb, cbopaque, \ 666 " opt."#n": %s ("#m": %s)\n", bv ? "true" \ 667 : "false", bv2 ? "true" : "false"); \ 668 } \ 669 } \ 670 } 671 #define OPT_WRITE_UNSIGNED(n, c) \ 672 if (je_mallctl("opt."#n, (void *)&uv, &usz, NULL, 0) == 0) { \ 673 if (json) { \ 674 malloc_cprintf(write_cb, cbopaque, \ 675 "\t\t\t\""#n"\": %u%s\n", uv, (c)); \ 676 } else { \ 677 malloc_cprintf(write_cb, cbopaque, \ 678 " opt."#n": %u\n", uv); \ 679 } \ 680 } 681 #define OPT_WRITE_SIZE_T(n, c) \ 682 if (je_mallctl("opt."#n, (void *)&sv, &ssz, NULL, 0) == 0) { \ 683 if (json) { \ 684 malloc_cprintf(write_cb, cbopaque, \ 685 "\t\t\t\""#n"\": %zu%s\n", sv, (c)); \ 686 } else { \ 687 malloc_cprintf(write_cb, cbopaque, \ 688 " opt."#n": %zu\n", sv); \ 689 } \ 690 } 691 #define OPT_WRITE_SSIZE_T(n, c) \ 692 if (je_mallctl("opt."#n, (void *)&ssv, &sssz, NULL, 0) == 0) { \ 693 if (json) { \ 694 malloc_cprintf(write_cb, cbopaque, \ 695 "\t\t\t\""#n"\": %zd%s\n", ssv, (c)); \ 696 } else { \ 697 malloc_cprintf(write_cb, cbopaque, \ 698 " opt."#n": %zd\n", ssv); \ 699 } \ 700 } 701 #define OPT_WRITE_SSIZE_T_MUTABLE(n, m, c) { \ 702 ssize_t ssv2; \ 703 if (je_mallctl("opt."#n, (void *)&ssv, &sssz, NULL, 0) == 0 && \ 704 je_mallctl(#m, (void *)&ssv2, &sssz, NULL, 0) == 0) { \ 705 if (json) { \ 706 malloc_cprintf(write_cb, cbopaque, \ 707 "\t\t\t\""#n"\": %zd%s\n", ssv, (c)); \ 708 } else { \ 709 malloc_cprintf(write_cb, cbopaque, \ 710 " opt."#n": %zd ("#m": %zd)\n", \ 711 ssv, ssv2); \ 712 } \ 713 } \ 714 } 715 #define OPT_WRITE_CHAR_P(n, c) \ 716 if (je_mallctl("opt."#n, (void *)&cpv, &cpsz, NULL, 0) == 0) { \ 717 if (json) { \ 718 malloc_cprintf(write_cb, cbopaque, \ 719 "\t\t\t\""#n"\": \"%s\"%s\n", cpv, (c)); \ 720 } else { \ 721 malloc_cprintf(write_cb, cbopaque, \ 722 " opt."#n": \"%s\"\n", cpv); \ 723 } \ 724 } 725 726 if (json) { 727 malloc_cprintf(write_cb, cbopaque, 728 "\t\t\"opt\": {\n"); 729 } else { 730 malloc_cprintf(write_cb, cbopaque, 731 "Run-time option settings:\n"); 732 } 733 OPT_WRITE_BOOL(abort, ",") 734 OPT_WRITE_SIZE_T(lg_chunk, ",") 735 OPT_WRITE_CHAR_P(dss, ",") 736 OPT_WRITE_UNSIGNED(narenas, ",") 737 OPT_WRITE_CHAR_P(purge, ",") 738 if (json || opt_purge == purge_mode_ratio) { 739 OPT_WRITE_SSIZE_T_MUTABLE(lg_dirty_mult, 740 arenas.lg_dirty_mult, ",") 741 } 742 if (json || opt_purge == purge_mode_decay) { 743 OPT_WRITE_SSIZE_T_MUTABLE(decay_time, arenas.decay_time, ",") 744 } 745 OPT_WRITE_CHAR_P(junk, ",") 746 OPT_WRITE_SIZE_T(quarantine, ",") 747 OPT_WRITE_BOOL(redzone, ",") 748 OPT_WRITE_BOOL(zero, ",") 749 OPT_WRITE_BOOL(utrace, ",") 750 OPT_WRITE_BOOL(xmalloc, ",") 751 OPT_WRITE_BOOL(tcache, ",") 752 OPT_WRITE_SSIZE_T(lg_tcache_max, ",") 753 OPT_WRITE_BOOL(thp, ",") 754 OPT_WRITE_BOOL(prof, ",") 755 OPT_WRITE_CHAR_P(prof_prefix, ",") 756 OPT_WRITE_BOOL_MUTABLE(prof_active, prof.active, ",") 757 OPT_WRITE_BOOL_MUTABLE(prof_thread_active_init, prof.thread_active_init, 758 ",") 759 OPT_WRITE_SSIZE_T_MUTABLE(lg_prof_sample, prof.lg_sample, ",") 760 OPT_WRITE_BOOL(prof_accum, ",") 761 OPT_WRITE_SSIZE_T(lg_prof_interval, ",") 762 OPT_WRITE_BOOL(prof_gdump, ",") 763 OPT_WRITE_BOOL(prof_final, ",") 764 OPT_WRITE_BOOL(prof_leak, ",") 765 /* 766 * stats_print is always emitted, so as long as stats_print comes last 767 * it's safe to unconditionally omit the comma here (rather than having 768 * to conditionally omit it elsewhere depending on configuration). 769 */ 770 OPT_WRITE_BOOL(stats_print, "") 771 if (json) { 772 malloc_cprintf(write_cb, cbopaque, 773 "\t\t},\n"); 774 } 775 776 #undef OPT_WRITE_BOOL 777 #undef OPT_WRITE_BOOL_MUTABLE 778 #undef OPT_WRITE_SIZE_T 779 #undef OPT_WRITE_SSIZE_T 780 #undef OPT_WRITE_CHAR_P 781 782 /* arenas. */ 783 if (json) { 784 malloc_cprintf(write_cb, cbopaque, 785 "\t\t\"arenas\": {\n"); 786 } 787 788 CTL_GET("arenas.narenas", &uv, unsigned); 789 if (json) { 790 malloc_cprintf(write_cb, cbopaque, 791 "\t\t\t\"narenas\": %u,\n", uv); 792 } else 793 malloc_cprintf(write_cb, cbopaque, "Arenas: %u\n", uv); 794 795 CTL_GET("arenas.lg_dirty_mult", &ssv, ssize_t); 796 if (json) { 797 malloc_cprintf(write_cb, cbopaque, 798 "\t\t\t\"lg_dirty_mult\": %zd,\n", ssv); 799 } else if (opt_purge == purge_mode_ratio) { 800 if (ssv >= 0) { 801 malloc_cprintf(write_cb, cbopaque, 802 "Min active:dirty page ratio per arena: " 803 "%u:1\n", (1U << ssv)); 804 } else { 805 malloc_cprintf(write_cb, cbopaque, 806 "Min active:dirty page ratio per arena: " 807 "N/A\n"); 808 } 809 } 810 CTL_GET("arenas.decay_time", &ssv, ssize_t); 811 if (json) { 812 malloc_cprintf(write_cb, cbopaque, 813 "\t\t\t\"decay_time\": %zd,\n", ssv); 814 } else if (opt_purge == purge_mode_decay) { 815 malloc_cprintf(write_cb, cbopaque, 816 "Unused dirty page decay time: %zd%s\n", 817 ssv, (ssv < 0) ? " (no decay)" : ""); 818 } 819 820 CTL_GET("arenas.quantum", &sv, size_t); 821 if (json) { 822 malloc_cprintf(write_cb, cbopaque, 823 "\t\t\t\"quantum\": %zu,\n", sv); 824 } else 825 malloc_cprintf(write_cb, cbopaque, "Quantum size: %zu\n", sv); 826 827 CTL_GET("arenas.page", &sv, size_t); 828 if (json) { 829 malloc_cprintf(write_cb, cbopaque, 830 "\t\t\t\"page\": %zu,\n", sv); 831 } else 832 malloc_cprintf(write_cb, cbopaque, "Page size: %zu\n", sv); 833 834 if (je_mallctl("arenas.tcache_max", (void *)&sv, &ssz, NULL, 0) == 0) { 835 if (json) { 836 malloc_cprintf(write_cb, cbopaque, 837 "\t\t\t\"tcache_max\": %zu,\n", sv); 838 } else { 839 malloc_cprintf(write_cb, cbopaque, 840 "Maximum thread-cached size class: %zu\n", sv); 841 } 842 } 843 844 if (json) { 845 unsigned nbins, nlruns, nhchunks, i; 846 847 CTL_GET("arenas.nbins", &nbins, unsigned); 848 malloc_cprintf(write_cb, cbopaque, 849 "\t\t\t\"nbins\": %u,\n", nbins); 850 851 if (config_tcache) { 852 CTL_GET("arenas.nhbins", &uv, unsigned); 853 malloc_cprintf(write_cb, cbopaque, 854 "\t\t\t\"nhbins\": %u,\n", uv); 855 } 856 857 malloc_cprintf(write_cb, cbopaque, 858 "\t\t\t\"bin\": [\n"); 859 for (i = 0; i < nbins; i++) { 860 malloc_cprintf(write_cb, cbopaque, 861 "\t\t\t\t{\n"); 862 863 CTL_M2_GET("arenas.bin.0.size", i, &sv, size_t); 864 malloc_cprintf(write_cb, cbopaque, 865 "\t\t\t\t\t\"size\": %zu,\n", sv); 866 867 CTL_M2_GET("arenas.bin.0.nregs", i, &u32v, uint32_t); 868 malloc_cprintf(write_cb, cbopaque, 869 "\t\t\t\t\t\"nregs\": %"FMTu32",\n", u32v); 870 871 CTL_M2_GET("arenas.bin.0.run_size", i, &sv, size_t); 872 malloc_cprintf(write_cb, cbopaque, 873 "\t\t\t\t\t\"run_size\": %zu\n", sv); 874 875 malloc_cprintf(write_cb, cbopaque, 876 "\t\t\t\t}%s\n", (i + 1 < nbins) ? "," : ""); 877 } 878 malloc_cprintf(write_cb, cbopaque, 879 "\t\t\t],\n"); 880 881 CTL_GET("arenas.nlruns", &nlruns, unsigned); 882 malloc_cprintf(write_cb, cbopaque, 883 "\t\t\t\"nlruns\": %u,\n", nlruns); 884 885 malloc_cprintf(write_cb, cbopaque, 886 "\t\t\t\"lrun\": [\n"); 887 for (i = 0; i < nlruns; i++) { 888 malloc_cprintf(write_cb, cbopaque, 889 "\t\t\t\t{\n"); 890 891 CTL_M2_GET("arenas.lrun.0.size", i, &sv, size_t); 892 malloc_cprintf(write_cb, cbopaque, 893 "\t\t\t\t\t\"size\": %zu\n", sv); 894 895 malloc_cprintf(write_cb, cbopaque, 896 "\t\t\t\t}%s\n", (i + 1 < nlruns) ? "," : ""); 897 } 898 malloc_cprintf(write_cb, cbopaque, 899 "\t\t\t],\n"); 900 901 CTL_GET("arenas.nhchunks", &nhchunks, unsigned); 902 malloc_cprintf(write_cb, cbopaque, 903 "\t\t\t\"nhchunks\": %u,\n", nhchunks); 904 905 malloc_cprintf(write_cb, cbopaque, 906 "\t\t\t\"hchunk\": [\n"); 907 for (i = 0; i < nhchunks; i++) { 908 malloc_cprintf(write_cb, cbopaque, 909 "\t\t\t\t{\n"); 910 911 CTL_M2_GET("arenas.hchunk.0.size", i, &sv, size_t); 912 malloc_cprintf(write_cb, cbopaque, 913 "\t\t\t\t\t\"size\": %zu\n", sv); 914 915 malloc_cprintf(write_cb, cbopaque, 916 "\t\t\t\t}%s\n", (i + 1 < nhchunks) ? "," : ""); 917 } 918 malloc_cprintf(write_cb, cbopaque, 919 "\t\t\t]\n"); 920 921 malloc_cprintf(write_cb, cbopaque, 922 "\t\t}%s\n", (config_prof || more) ? "," : ""); 923 } 924 925 /* prof. */ 926 if (config_prof && json) { 927 malloc_cprintf(write_cb, cbopaque, 928 "\t\t\"prof\": {\n"); 929 930 CTL_GET("prof.thread_active_init", &bv, bool); 931 malloc_cprintf(write_cb, cbopaque, 932 "\t\t\t\"thread_active_init\": %s,\n", bv ? "true" : 933 "false"); 934 935 CTL_GET("prof.active", &bv, bool); 936 malloc_cprintf(write_cb, cbopaque, 937 "\t\t\t\"active\": %s,\n", bv ? "true" : "false"); 938 939 CTL_GET("prof.gdump", &bv, bool); 940 malloc_cprintf(write_cb, cbopaque, 941 "\t\t\t\"gdump\": %s,\n", bv ? "true" : "false"); 942 943 CTL_GET("prof.interval", &u64v, uint64_t); 944 malloc_cprintf(write_cb, cbopaque, 945 "\t\t\t\"interval\": %"FMTu64",\n", u64v); 946 947 CTL_GET("prof.lg_sample", &ssv, ssize_t); 948 malloc_cprintf(write_cb, cbopaque, 949 "\t\t\t\"lg_sample\": %zd\n", ssv); 950 951 malloc_cprintf(write_cb, cbopaque, 952 "\t\t}%s\n", more ? "," : ""); 953 } 954 } 955 956 static void 957 stats_print_helper(void (*write_cb)(void *, const char *), void *cbopaque, 958 bool json, bool merged, bool unmerged, bool bins, bool large, bool huge) 959 { 960 size_t *cactive; 961 size_t allocated, active, metadata, resident, mapped, retained; 962 963 CTL_GET("stats.cactive", &cactive, size_t *); 964 CTL_GET("stats.allocated", &allocated, size_t); 965 CTL_GET("stats.active", &active, size_t); 966 CTL_GET("stats.metadata", &metadata, size_t); 967 CTL_GET("stats.resident", &resident, size_t); 968 CTL_GET("stats.mapped", &mapped, size_t); 969 CTL_GET("stats.retained", &retained, size_t); 970 if (json) { 971 malloc_cprintf(write_cb, cbopaque, 972 "\t\t\"stats\": {\n"); 973 974 malloc_cprintf(write_cb, cbopaque, 975 "\t\t\t\"cactive\": %zu,\n", atomic_read_z(cactive)); 976 malloc_cprintf(write_cb, cbopaque, 977 "\t\t\t\"allocated\": %zu,\n", allocated); 978 malloc_cprintf(write_cb, cbopaque, 979 "\t\t\t\"active\": %zu,\n", active); 980 malloc_cprintf(write_cb, cbopaque, 981 "\t\t\t\"metadata\": %zu,\n", metadata); 982 malloc_cprintf(write_cb, cbopaque, 983 "\t\t\t\"resident\": %zu,\n", resident); 984 malloc_cprintf(write_cb, cbopaque, 985 "\t\t\t\"mapped\": %zu,\n", mapped); 986 malloc_cprintf(write_cb, cbopaque, 987 "\t\t\t\"retained\": %zu\n", retained); 988 989 malloc_cprintf(write_cb, cbopaque, 990 "\t\t}%s\n", (merged || unmerged) ? "," : ""); 991 } else { 992 malloc_cprintf(write_cb, cbopaque, 993 "Allocated: %zu, active: %zu, metadata: %zu," 994 " resident: %zu, mapped: %zu, retained: %zu\n", 995 allocated, active, metadata, resident, mapped, retained); 996 malloc_cprintf(write_cb, cbopaque, 997 "Current active ceiling: %zu\n", 998 atomic_read_z(cactive)); 999 } 1000 1001 if (merged || unmerged) { 1002 unsigned narenas; 1003 1004 if (json) { 1005 malloc_cprintf(write_cb, cbopaque, 1006 "\t\t\"stats.arenas\": {\n"); 1007 } 1008 1009 CTL_GET("arenas.narenas", &narenas, unsigned); 1010 { 1011 VARIABLE_ARRAY(bool, initialized, narenas); 1012 size_t isz; 1013 unsigned i, j, ninitialized; 1014 1015 isz = sizeof(bool) * narenas; 1016 xmallctl("arenas.initialized", (void *)initialized, 1017 &isz, NULL, 0); 1018 for (i = ninitialized = 0; i < narenas; i++) { 1019 if (initialized[i]) 1020 ninitialized++; 1021 } 1022 1023 /* Merged stats. */ 1024 if (merged && (ninitialized > 1 || !unmerged)) { 1025 /* Print merged arena stats. */ 1026 if (json) { 1027 malloc_cprintf(write_cb, cbopaque, 1028 "\t\t\t\"merged\": {\n"); 1029 } else { 1030 malloc_cprintf(write_cb, cbopaque, 1031 "\nMerged arenas stats:\n"); 1032 } 1033 stats_arena_print(write_cb, cbopaque, json, 1034 narenas, bins, large, huge); 1035 if (json) { 1036 malloc_cprintf(write_cb, cbopaque, 1037 "\t\t\t}%s\n", unmerged ? "," : 1038 ""); 1039 } 1040 } 1041 1042 /* Unmerged stats. */ 1043 if (unmerged) { 1044 for (i = j = 0; i < narenas; i++) { 1045 if (initialized[i]) { 1046 if (json) { 1047 j++; 1048 malloc_cprintf(write_cb, 1049 cbopaque, 1050 "\t\t\t\"%u\": {\n", 1051 i); 1052 } else { 1053 malloc_cprintf(write_cb, 1054 cbopaque, 1055 "\narenas[%u]:\n", 1056 i); 1057 } 1058 stats_arena_print(write_cb, 1059 cbopaque, json, i, bins, 1060 large, huge); 1061 if (json) { 1062 malloc_cprintf(write_cb, 1063 cbopaque, 1064 "\t\t\t}%s\n", (j < 1065 ninitialized) ? "," 1066 : ""); 1067 } 1068 } 1069 } 1070 } 1071 } 1072 1073 if (json) { 1074 malloc_cprintf(write_cb, cbopaque, 1075 "\t\t}\n"); 1076 } 1077 } 1078 } 1079 1080 void 1081 stats_print(void (*write_cb)(void *, const char *), void *cbopaque, 1082 const char *opts) 1083 { 1084 int err; 1085 uint64_t epoch; 1086 size_t u64sz; 1087 bool json = false; 1088 bool general = true; 1089 bool merged = config_stats; 1090 bool unmerged = config_stats; 1091 bool bins = true; 1092 bool large = true; 1093 bool huge = true; 1094 1095 /* 1096 * Refresh stats, in case mallctl() was called by the application. 1097 * 1098 * Check for OOM here, since refreshing the ctl cache can trigger 1099 * allocation. In practice, none of the subsequent mallctl()-related 1100 * calls in this function will cause OOM if this one succeeds. 1101 * */ 1102 epoch = 1; 1103 u64sz = sizeof(uint64_t); 1104 err = je_mallctl("epoch", (void *)&epoch, &u64sz, (void *)&epoch, 1105 sizeof(uint64_t)); 1106 if (err != 0) { 1107 if (err == EAGAIN) { 1108 malloc_write("<jemalloc>: Memory allocation failure in " 1109 "mallctl(\"epoch\", ...)\n"); 1110 return; 1111 } 1112 malloc_write("<jemalloc>: Failure in mallctl(\"epoch\", " 1113 "...)\n"); 1114 abort(); 1115 } 1116 1117 if (opts != NULL) { 1118 unsigned i; 1119 1120 for (i = 0; opts[i] != '\0'; i++) { 1121 switch (opts[i]) { 1122 case 'J': 1123 json = true; 1124 break; 1125 case 'g': 1126 general = false; 1127 break; 1128 case 'm': 1129 merged = false; 1130 break; 1131 case 'a': 1132 unmerged = false; 1133 break; 1134 case 'b': 1135 bins = false; 1136 break; 1137 case 'l': 1138 large = false; 1139 break; 1140 case 'h': 1141 huge = false; 1142 break; 1143 default:; 1144 } 1145 } 1146 } 1147 1148 if (json) { 1149 malloc_cprintf(write_cb, cbopaque, 1150 "{\n" 1151 "\t\"jemalloc\": {\n"); 1152 } else { 1153 malloc_cprintf(write_cb, cbopaque, 1154 "___ Begin jemalloc statistics ___\n"); 1155 } 1156 1157 if (general) { 1158 bool more = (merged || unmerged); 1159 stats_general_print(write_cb, cbopaque, json, more); 1160 } 1161 if (config_stats) { 1162 stats_print_helper(write_cb, cbopaque, json, merged, unmerged, 1163 bins, large, huge); 1164 } 1165 if (json) { 1166 malloc_cprintf(write_cb, cbopaque, 1167 "\t}\n" 1168 "}\n"); 1169 } else { 1170 malloc_cprintf(write_cb, cbopaque, 1171 "--- End jemalloc statistics ---\n"); 1172 } 1173 } 1174