1 | #define JEMALLOC_STATS_C_ |
2 | #include "jemalloc/internal/jemalloc_preamble.h" |
3 | #include "jemalloc/internal/jemalloc_internal_includes.h" |
4 | |
5 | #include "jemalloc/internal/assert.h" |
6 | #include "jemalloc/internal/ctl.h" |
7 | #include "jemalloc/internal/emitter.h" |
8 | #include "jemalloc/internal/mutex.h" |
9 | #include "jemalloc/internal/mutex_prof.h" |
10 | |
11 | const char *global_mutex_names[mutex_prof_num_global_mutexes] = { |
12 | #define OP(mtx) #mtx, |
13 | MUTEX_PROF_GLOBAL_MUTEXES |
14 | #undef OP |
15 | }; |
16 | |
17 | const char *arena_mutex_names[mutex_prof_num_arena_mutexes] = { |
18 | #define OP(mtx) #mtx, |
19 | MUTEX_PROF_ARENA_MUTEXES |
20 | #undef OP |
21 | }; |
22 | |
23 | #define CTL_GET(n, v, t) do { \ |
24 | size_t sz = sizeof(t); \ |
25 | xmallctl(n, (void *)v, &sz, NULL, 0); \ |
26 | } while (0) |
27 | |
28 | #define CTL_M2_GET(n, i, v, t) do { \ |
29 | size_t mib[CTL_MAX_DEPTH]; \ |
30 | size_t miblen = sizeof(mib) / sizeof(size_t); \ |
31 | size_t sz = sizeof(t); \ |
32 | xmallctlnametomib(n, mib, &miblen); \ |
33 | mib[2] = (i); \ |
34 | xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0); \ |
35 | } while (0) |
36 | |
37 | #define CTL_M2_M4_GET(n, i, j, v, t) do { \ |
38 | size_t mib[CTL_MAX_DEPTH]; \ |
39 | size_t miblen = sizeof(mib) / sizeof(size_t); \ |
40 | size_t sz = sizeof(t); \ |
41 | xmallctlnametomib(n, mib, &miblen); \ |
42 | mib[2] = (i); \ |
43 | mib[4] = (j); \ |
44 | xmallctlbymib(mib, miblen, (void *)v, &sz, NULL, 0); \ |
45 | } while (0) |
46 | |
47 | /******************************************************************************/ |
48 | /* Data. */ |
49 | |
50 | bool opt_stats_print = false; |
51 | char opt_stats_print_opts[stats_print_tot_num_options+1] = "" ; |
52 | |
53 | /******************************************************************************/ |
54 | |
55 | static uint64_t |
56 | rate_per_second(uint64_t value, uint64_t uptime_ns) { |
57 | uint64_t billion = 1000000000; |
58 | if (uptime_ns == 0 || value == 0) { |
59 | return 0; |
60 | } |
61 | if (uptime_ns < billion) { |
62 | return value; |
63 | } else { |
64 | uint64_t uptime_s = uptime_ns / billion; |
65 | return value / uptime_s; |
66 | } |
67 | } |
68 | |
69 | /* Calculate x.yyy and output a string (takes a fixed sized char array). */ |
70 | static bool |
71 | get_rate_str(uint64_t dividend, uint64_t divisor, char str[6]) { |
72 | if (divisor == 0 || dividend > divisor) { |
73 | /* The rate is not supposed to be greater than 1. */ |
74 | return true; |
75 | } |
76 | if (dividend > 0) { |
77 | assert(UINT64_MAX / dividend >= 1000); |
78 | } |
79 | |
80 | unsigned n = (unsigned)((dividend * 1000) / divisor); |
81 | if (n < 10) { |
82 | malloc_snprintf(str, 6, "0.00%u" , n); |
83 | } else if (n < 100) { |
84 | malloc_snprintf(str, 6, "0.0%u" , n); |
85 | } else if (n < 1000) { |
86 | malloc_snprintf(str, 6, "0.%u" , n); |
87 | } else { |
88 | malloc_snprintf(str, 6, "1" ); |
89 | } |
90 | |
91 | return false; |
92 | } |
93 | |
94 | #define MUTEX_CTL_STR_MAX_LENGTH 128 |
95 | static void |
96 | gen_mutex_ctl_str(char *str, size_t buf_len, const char *prefix, |
97 | const char *mutex, const char *counter) { |
98 | malloc_snprintf(str, buf_len, "stats.%s.%s.%s" , prefix, mutex, counter); |
99 | } |
100 | |
101 | static void |
102 | mutex_stats_init_cols(emitter_row_t *row, const char *table_name, |
103 | emitter_col_t *name, |
104 | emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters], |
105 | emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) { |
106 | mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0; |
107 | mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0; |
108 | |
109 | emitter_col_t *col; |
110 | |
111 | if (name != NULL) { |
112 | emitter_col_init(name, row); |
113 | name->justify = emitter_justify_left; |
114 | name->width = 21; |
115 | name->type = emitter_type_title; |
116 | name->str_val = table_name; |
117 | } |
118 | |
119 | #define WIDTH_uint32_t 12 |
120 | #define WIDTH_uint64_t 16 |
121 | #define OP(counter, counter_type, human, derived, base_counter) \ |
122 | col = &col_##counter_type[k_##counter_type]; \ |
123 | ++k_##counter_type; \ |
124 | emitter_col_init(col, row); \ |
125 | col->justify = emitter_justify_right; \ |
126 | col->width = derived ? 8 : WIDTH_##counter_type; \ |
127 | col->type = emitter_type_title; \ |
128 | col->str_val = human; |
129 | MUTEX_PROF_COUNTERS |
130 | #undef OP |
131 | #undef WIDTH_uint32_t |
132 | #undef WIDTH_uint64_t |
133 | col_uint64_t[mutex_counter_total_wait_time_ps].width = 10; |
134 | } |
135 | |
136 | static void |
137 | mutex_stats_read_global(const char *name, emitter_col_t *col_name, |
138 | emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters], |
139 | emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters], |
140 | uint64_t uptime) { |
141 | char cmd[MUTEX_CTL_STR_MAX_LENGTH]; |
142 | |
143 | col_name->str_val = name; |
144 | |
145 | emitter_col_t *dst; |
146 | #define EMITTER_TYPE_uint32_t emitter_type_uint32 |
147 | #define EMITTER_TYPE_uint64_t emitter_type_uint64 |
148 | #define OP(counter, counter_type, human, derived, base_counter) \ |
149 | dst = &col_##counter_type[mutex_counter_##counter]; \ |
150 | dst->type = EMITTER_TYPE_##counter_type; \ |
151 | if (!derived) { \ |
152 | gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH, \ |
153 | "mutexes", name, #counter); \ |
154 | CTL_GET(cmd, (counter_type *)&dst->bool_val, counter_type); \ |
155 | } else { \ |
156 | emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter]; \ |
157 | dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \ |
158 | } |
159 | MUTEX_PROF_COUNTERS |
160 | #undef OP |
161 | #undef EMITTER_TYPE_uint32_t |
162 | #undef EMITTER_TYPE_uint64_t |
163 | } |
164 | |
165 | static void |
166 | mutex_stats_read_arena(unsigned arena_ind, mutex_prof_arena_ind_t mutex_ind, |
167 | const char *name, emitter_col_t *col_name, |
168 | emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters], |
169 | emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters], |
170 | uint64_t uptime) { |
171 | char cmd[MUTEX_CTL_STR_MAX_LENGTH]; |
172 | |
173 | col_name->str_val = name; |
174 | |
175 | emitter_col_t *dst; |
176 | #define EMITTER_TYPE_uint32_t emitter_type_uint32 |
177 | #define EMITTER_TYPE_uint64_t emitter_type_uint64 |
178 | #define OP(counter, counter_type, human, derived, base_counter) \ |
179 | dst = &col_##counter_type[mutex_counter_##counter]; \ |
180 | dst->type = EMITTER_TYPE_##counter_type; \ |
181 | if (!derived) { \ |
182 | gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH, \ |
183 | "arenas.0.mutexes", arena_mutex_names[mutex_ind], #counter);\ |
184 | CTL_M2_GET(cmd, arena_ind, (counter_type *)&dst->bool_val, counter_type); \ |
185 | } else { \ |
186 | emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter]; \ |
187 | dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \ |
188 | } |
189 | MUTEX_PROF_COUNTERS |
190 | #undef OP |
191 | #undef EMITTER_TYPE_uint32_t |
192 | #undef EMITTER_TYPE_uint64_t |
193 | } |
194 | |
195 | static void |
196 | mutex_stats_read_arena_bin(unsigned arena_ind, unsigned bin_ind, |
197 | emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters], |
198 | emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters], |
199 | uint64_t uptime) { |
200 | char cmd[MUTEX_CTL_STR_MAX_LENGTH]; |
201 | emitter_col_t *dst; |
202 | |
203 | #define EMITTER_TYPE_uint32_t emitter_type_uint32 |
204 | #define EMITTER_TYPE_uint64_t emitter_type_uint64 |
205 | #define OP(counter, counter_type, human, derived, base_counter) \ |
206 | dst = &col_##counter_type[mutex_counter_##counter]; \ |
207 | dst->type = EMITTER_TYPE_##counter_type; \ |
208 | if (!derived) { \ |
209 | gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH, \ |
210 | "arenas.0.bins.0","mutex", #counter); \ |
211 | CTL_M2_M4_GET(cmd, arena_ind, bin_ind, \ |
212 | (counter_type *)&dst->bool_val, counter_type); \ |
213 | } else { \ |
214 | emitter_col_t *base = &col_##counter_type[mutex_counter_##base_counter]; \ |
215 | dst->counter_type##_val = rate_per_second(base->counter_type##_val, uptime); \ |
216 | } |
217 | MUTEX_PROF_COUNTERS |
218 | #undef OP |
219 | #undef EMITTER_TYPE_uint32_t |
220 | #undef EMITTER_TYPE_uint64_t |
221 | } |
222 | |
223 | /* "row" can be NULL to avoid emitting in table mode. */ |
224 | static void |
225 | mutex_stats_emit(emitter_t *emitter, emitter_row_t *row, |
226 | emitter_col_t col_uint64_t[mutex_prof_num_uint64_t_counters], |
227 | emitter_col_t col_uint32_t[mutex_prof_num_uint32_t_counters]) { |
228 | if (row != NULL) { |
229 | emitter_table_row(emitter, row); |
230 | } |
231 | |
232 | mutex_prof_uint64_t_counter_ind_t k_uint64_t = 0; |
233 | mutex_prof_uint32_t_counter_ind_t k_uint32_t = 0; |
234 | |
235 | emitter_col_t *col; |
236 | |
237 | #define EMITTER_TYPE_uint32_t emitter_type_uint32 |
238 | #define EMITTER_TYPE_uint64_t emitter_type_uint64 |
239 | #define OP(counter, type, human, derived, base_counter) \ |
240 | if (!derived) { \ |
241 | col = &col_##type[k_##type]; \ |
242 | ++k_##type; \ |
243 | emitter_json_kv(emitter, #counter, EMITTER_TYPE_##type, \ |
244 | (const void *)&col->bool_val); \ |
245 | } |
246 | MUTEX_PROF_COUNTERS; |
247 | #undef OP |
248 | #undef EMITTER_TYPE_uint32_t |
249 | #undef EMITTER_TYPE_uint64_t |
250 | } |
251 | |
252 | #define COL(row_name, column_name, left_or_right, col_width, etype) \ |
253 | emitter_col_t col_##column_name; \ |
254 | emitter_col_init(&col_##column_name, &row_name); \ |
255 | col_##column_name.justify = emitter_justify_##left_or_right; \ |
256 | col_##column_name.width = col_width; \ |
257 | col_##column_name.type = emitter_type_##etype; |
258 | |
259 | #define COL_HDR(row_name, column_name, human, left_or_right, col_width, etype) \ |
260 | COL(row_name, column_name, left_or_right, col_width, etype) \ |
261 | emitter_col_t header_##column_name; \ |
262 | emitter_col_init(&header_##column_name, &header_##row_name); \ |
263 | header_##column_name.justify = emitter_justify_##left_or_right; \ |
264 | header_##column_name.width = col_width; \ |
265 | header_##column_name.type = emitter_type_title; \ |
266 | header_##column_name.str_val = human ? human : #column_name; |
267 | |
268 | |
269 | static void |
270 | stats_arena_bins_print(emitter_t *emitter, bool mutex, unsigned i, uint64_t uptime) { |
271 | size_t page; |
272 | bool in_gap, in_gap_prev; |
273 | unsigned nbins, j; |
274 | |
275 | CTL_GET("arenas.page" , &page, size_t); |
276 | |
277 | CTL_GET("arenas.nbins" , &nbins, unsigned); |
278 | |
279 | emitter_row_t ; |
280 | emitter_row_init(&header_row); |
281 | |
282 | emitter_row_t row; |
283 | emitter_row_init(&row); |
284 | |
285 | COL_HDR(row, size, NULL, right, 20, size) |
286 | COL_HDR(row, ind, NULL, right, 4, unsigned) |
287 | COL_HDR(row, allocated, NULL, right, 13, uint64) |
288 | COL_HDR(row, nmalloc, NULL, right, 13, uint64) |
289 | COL_HDR(row, nmalloc_ps, "(#/sec)" , right, 8, uint64) |
290 | COL_HDR(row, ndalloc, NULL, right, 13, uint64) |
291 | COL_HDR(row, ndalloc_ps, "(#/sec)" , right, 8, uint64) |
292 | COL_HDR(row, nrequests, NULL, right, 13, uint64) |
293 | COL_HDR(row, nrequests_ps, "(#/sec)" , right, 10, uint64) |
294 | COL_HDR(row, nshards, NULL, right, 9, unsigned) |
295 | COL_HDR(row, curregs, NULL, right, 13, size) |
296 | COL_HDR(row, curslabs, NULL, right, 13, size) |
297 | COL_HDR(row, nonfull_slabs, NULL, right, 15, size) |
298 | COL_HDR(row, regs, NULL, right, 5, unsigned) |
299 | COL_HDR(row, pgs, NULL, right, 4, size) |
300 | /* To buffer a right- and left-justified column. */ |
301 | COL_HDR(row, justify_spacer, NULL, right, 1, title) |
302 | COL_HDR(row, util, NULL, right, 6, title) |
303 | COL_HDR(row, nfills, NULL, right, 13, uint64) |
304 | COL_HDR(row, nfills_ps, "(#/sec)" , right, 8, uint64) |
305 | COL_HDR(row, nflushes, NULL, right, 13, uint64) |
306 | COL_HDR(row, nflushes_ps, "(#/sec)" , right, 8, uint64) |
307 | COL_HDR(row, nslabs, NULL, right, 13, uint64) |
308 | COL_HDR(row, nreslabs, NULL, right, 13, uint64) |
309 | COL_HDR(row, nreslabs_ps, "(#/sec)" , right, 8, uint64) |
310 | |
311 | /* Don't want to actually print the name. */ |
312 | header_justify_spacer.str_val = " " ; |
313 | col_justify_spacer.str_val = " " ; |
314 | |
315 | emitter_col_t col_mutex64[mutex_prof_num_uint64_t_counters]; |
316 | emitter_col_t col_mutex32[mutex_prof_num_uint32_t_counters]; |
317 | |
318 | emitter_col_t [mutex_prof_num_uint64_t_counters]; |
319 | emitter_col_t [mutex_prof_num_uint32_t_counters]; |
320 | |
321 | if (mutex) { |
322 | mutex_stats_init_cols(&row, NULL, NULL, col_mutex64, |
323 | col_mutex32); |
324 | mutex_stats_init_cols(&header_row, NULL, NULL, header_mutex64, |
325 | header_mutex32); |
326 | } |
327 | |
328 | /* |
329 | * We print a "bins:" header as part of the table row; we need to adjust |
330 | * the header size column to compensate. |
331 | */ |
332 | header_size.width -=5; |
333 | emitter_table_printf(emitter, "bins:" ); |
334 | emitter_table_row(emitter, &header_row); |
335 | emitter_json_array_kv_begin(emitter, "bins" ); |
336 | |
337 | for (j = 0, in_gap = false; j < nbins; j++) { |
338 | uint64_t nslabs; |
339 | size_t reg_size, slab_size, curregs; |
340 | size_t curslabs; |
341 | size_t nonfull_slabs; |
342 | uint32_t nregs, nshards; |
343 | uint64_t nmalloc, ndalloc, nrequests, nfills, nflushes; |
344 | uint64_t nreslabs; |
345 | |
346 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nslabs" , i, j, &nslabs, |
347 | uint64_t); |
348 | in_gap_prev = in_gap; |
349 | in_gap = (nslabs == 0); |
350 | |
351 | if (in_gap_prev && !in_gap) { |
352 | emitter_table_printf(emitter, |
353 | " ---\n" ); |
354 | } |
355 | |
356 | CTL_M2_GET("arenas.bin.0.size" , j, ®_size, size_t); |
357 | CTL_M2_GET("arenas.bin.0.nregs" , j, &nregs, uint32_t); |
358 | CTL_M2_GET("arenas.bin.0.slab_size" , j, &slab_size, size_t); |
359 | CTL_M2_GET("arenas.bin.0.nshards" , j, &nshards, uint32_t); |
360 | |
361 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nmalloc" , i, j, &nmalloc, |
362 | uint64_t); |
363 | CTL_M2_M4_GET("stats.arenas.0.bins.0.ndalloc" , i, j, &ndalloc, |
364 | uint64_t); |
365 | CTL_M2_M4_GET("stats.arenas.0.bins.0.curregs" , i, j, &curregs, |
366 | size_t); |
367 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nrequests" , i, j, |
368 | &nrequests, uint64_t); |
369 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nfills" , i, j, &nfills, |
370 | uint64_t); |
371 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nflushes" , i, j, &nflushes, |
372 | uint64_t); |
373 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nreslabs" , i, j, &nreslabs, |
374 | uint64_t); |
375 | CTL_M2_M4_GET("stats.arenas.0.bins.0.curslabs" , i, j, &curslabs, |
376 | size_t); |
377 | CTL_M2_M4_GET("stats.arenas.0.bins.0.nonfull_slabs" , i, j, &nonfull_slabs, |
378 | size_t); |
379 | |
380 | if (mutex) { |
381 | mutex_stats_read_arena_bin(i, j, col_mutex64, |
382 | col_mutex32, uptime); |
383 | } |
384 | |
385 | emitter_json_object_begin(emitter); |
386 | emitter_json_kv(emitter, "nmalloc" , emitter_type_uint64, |
387 | &nmalloc); |
388 | emitter_json_kv(emitter, "ndalloc" , emitter_type_uint64, |
389 | &ndalloc); |
390 | emitter_json_kv(emitter, "curregs" , emitter_type_size, |
391 | &curregs); |
392 | emitter_json_kv(emitter, "nrequests" , emitter_type_uint64, |
393 | &nrequests); |
394 | emitter_json_kv(emitter, "nfills" , emitter_type_uint64, |
395 | &nfills); |
396 | emitter_json_kv(emitter, "nflushes" , emitter_type_uint64, |
397 | &nflushes); |
398 | emitter_json_kv(emitter, "nreslabs" , emitter_type_uint64, |
399 | &nreslabs); |
400 | emitter_json_kv(emitter, "curslabs" , emitter_type_size, |
401 | &curslabs); |
402 | emitter_json_kv(emitter, "nonfull_slabs" , emitter_type_size, |
403 | &nonfull_slabs); |
404 | if (mutex) { |
405 | emitter_json_object_kv_begin(emitter, "mutex" ); |
406 | mutex_stats_emit(emitter, NULL, col_mutex64, |
407 | col_mutex32); |
408 | emitter_json_object_end(emitter); |
409 | } |
410 | emitter_json_object_end(emitter); |
411 | |
412 | size_t availregs = nregs * curslabs; |
413 | char util[6]; |
414 | if (get_rate_str((uint64_t)curregs, (uint64_t)availregs, util)) |
415 | { |
416 | if (availregs == 0) { |
417 | malloc_snprintf(util, sizeof(util), "1" ); |
418 | } else if (curregs > availregs) { |
419 | /* |
420 | * Race detected: the counters were read in |
421 | * separate mallctl calls and concurrent |
422 | * operations happened in between. In this case |
423 | * no meaningful utilization can be computed. |
424 | */ |
425 | malloc_snprintf(util, sizeof(util), " race" ); |
426 | } else { |
427 | not_reached(); |
428 | } |
429 | } |
430 | |
431 | col_size.size_val = reg_size; |
432 | col_ind.unsigned_val = j; |
433 | col_allocated.size_val = curregs * reg_size; |
434 | col_nmalloc.uint64_val = nmalloc; |
435 | col_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime); |
436 | col_ndalloc.uint64_val = ndalloc; |
437 | col_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime); |
438 | col_nrequests.uint64_val = nrequests; |
439 | col_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime); |
440 | col_nshards.unsigned_val = nshards; |
441 | col_curregs.size_val = curregs; |
442 | col_curslabs.size_val = curslabs; |
443 | col_nonfull_slabs.size_val = nonfull_slabs; |
444 | col_regs.unsigned_val = nregs; |
445 | col_pgs.size_val = slab_size / page; |
446 | col_util.str_val = util; |
447 | col_nfills.uint64_val = nfills; |
448 | col_nfills_ps.uint64_val = rate_per_second(nfills, uptime); |
449 | col_nflushes.uint64_val = nflushes; |
450 | col_nflushes_ps.uint64_val = rate_per_second(nflushes, uptime); |
451 | col_nslabs.uint64_val = nslabs; |
452 | col_nreslabs.uint64_val = nreslabs; |
453 | col_nreslabs_ps.uint64_val = rate_per_second(nreslabs, uptime); |
454 | |
455 | /* |
456 | * Note that mutex columns were initialized above, if mutex == |
457 | * true. |
458 | */ |
459 | |
460 | emitter_table_row(emitter, &row); |
461 | } |
462 | emitter_json_array_end(emitter); /* Close "bins". */ |
463 | |
464 | if (in_gap) { |
465 | emitter_table_printf(emitter, " ---\n" ); |
466 | } |
467 | } |
468 | |
469 | static void |
470 | stats_arena_lextents_print(emitter_t *emitter, unsigned i, uint64_t uptime) { |
471 | unsigned nbins, nlextents, j; |
472 | bool in_gap, in_gap_prev; |
473 | |
474 | CTL_GET("arenas.nbins" , &nbins, unsigned); |
475 | CTL_GET("arenas.nlextents" , &nlextents, unsigned); |
476 | |
477 | emitter_row_t ; |
478 | emitter_row_init(&header_row); |
479 | emitter_row_t row; |
480 | emitter_row_init(&row); |
481 | |
482 | COL_HDR(row, size, NULL, right, 20, size) |
483 | COL_HDR(row, ind, NULL, right, 4, unsigned) |
484 | COL_HDR(row, allocated, NULL, right, 13, size) |
485 | COL_HDR(row, nmalloc, NULL, right, 13, uint64) |
486 | COL_HDR(row, nmalloc_ps, "(#/sec)" , right, 8, uint64) |
487 | COL_HDR(row, ndalloc, NULL, right, 13, uint64) |
488 | COL_HDR(row, ndalloc_ps, "(#/sec)" , right, 8, uint64) |
489 | COL_HDR(row, nrequests, NULL, right, 13, uint64) |
490 | COL_HDR(row, nrequests_ps, "(#/sec)" , right, 8, uint64) |
491 | COL_HDR(row, curlextents, NULL, right, 13, size) |
492 | |
493 | /* As with bins, we label the large extents table. */ |
494 | header_size.width -= 6; |
495 | emitter_table_printf(emitter, "large:" ); |
496 | emitter_table_row(emitter, &header_row); |
497 | emitter_json_array_kv_begin(emitter, "lextents" ); |
498 | |
499 | for (j = 0, in_gap = false; j < nlextents; j++) { |
500 | uint64_t nmalloc, ndalloc, nrequests; |
501 | size_t lextent_size, curlextents; |
502 | |
503 | CTL_M2_M4_GET("stats.arenas.0.lextents.0.nmalloc" , i, j, |
504 | &nmalloc, uint64_t); |
505 | CTL_M2_M4_GET("stats.arenas.0.lextents.0.ndalloc" , i, j, |
506 | &ndalloc, uint64_t); |
507 | CTL_M2_M4_GET("stats.arenas.0.lextents.0.nrequests" , i, j, |
508 | &nrequests, uint64_t); |
509 | in_gap_prev = in_gap; |
510 | in_gap = (nrequests == 0); |
511 | |
512 | if (in_gap_prev && !in_gap) { |
513 | emitter_table_printf(emitter, |
514 | " ---\n" ); |
515 | } |
516 | |
517 | CTL_M2_GET("arenas.lextent.0.size" , j, &lextent_size, size_t); |
518 | CTL_M2_M4_GET("stats.arenas.0.lextents.0.curlextents" , i, j, |
519 | &curlextents, size_t); |
520 | |
521 | emitter_json_object_begin(emitter); |
522 | emitter_json_kv(emitter, "curlextents" , emitter_type_size, |
523 | &curlextents); |
524 | emitter_json_object_end(emitter); |
525 | |
526 | col_size.size_val = lextent_size; |
527 | col_ind.unsigned_val = nbins + j; |
528 | col_allocated.size_val = curlextents * lextent_size; |
529 | col_nmalloc.uint64_val = nmalloc; |
530 | col_nmalloc_ps.uint64_val = rate_per_second(nmalloc, uptime); |
531 | col_ndalloc.uint64_val = ndalloc; |
532 | col_ndalloc_ps.uint64_val = rate_per_second(ndalloc, uptime); |
533 | col_nrequests.uint64_val = nrequests; |
534 | col_nrequests_ps.uint64_val = rate_per_second(nrequests, uptime); |
535 | col_curlextents.size_val = curlextents; |
536 | |
537 | if (!in_gap) { |
538 | emitter_table_row(emitter, &row); |
539 | } |
540 | } |
541 | emitter_json_array_end(emitter); /* Close "lextents". */ |
542 | if (in_gap) { |
543 | emitter_table_printf(emitter, " ---\n" ); |
544 | } |
545 | } |
546 | |
547 | static void |
548 | stats_arena_extents_print(emitter_t *emitter, unsigned i) { |
549 | unsigned j; |
550 | bool in_gap, in_gap_prev; |
551 | emitter_row_t ; |
552 | emitter_row_init(&header_row); |
553 | emitter_row_t row; |
554 | emitter_row_init(&row); |
555 | |
556 | COL_HDR(row, size, NULL, right, 20, size) |
557 | COL_HDR(row, ind, NULL, right, 4, unsigned) |
558 | COL_HDR(row, ndirty, NULL, right, 13, size) |
559 | COL_HDR(row, dirty, NULL, right, 13, size) |
560 | COL_HDR(row, nmuzzy, NULL, right, 13, size) |
561 | COL_HDR(row, muzzy, NULL, right, 13, size) |
562 | COL_HDR(row, nretained, NULL, right, 13, size) |
563 | COL_HDR(row, retained, NULL, right, 13, size) |
564 | COL_HDR(row, ntotal, NULL, right, 13, size) |
565 | COL_HDR(row, total, NULL, right, 13, size) |
566 | |
567 | /* Label this section. */ |
568 | header_size.width -= 8; |
569 | emitter_table_printf(emitter, "extents:" ); |
570 | emitter_table_row(emitter, &header_row); |
571 | emitter_json_array_kv_begin(emitter, "extents" ); |
572 | |
573 | in_gap = false; |
574 | for (j = 0; j < SC_NPSIZES; j++) { |
575 | size_t ndirty, nmuzzy, nretained, total, dirty_bytes, |
576 | muzzy_bytes, retained_bytes, total_bytes; |
577 | CTL_M2_M4_GET("stats.arenas.0.extents.0.ndirty" , i, j, |
578 | &ndirty, size_t); |
579 | CTL_M2_M4_GET("stats.arenas.0.extents.0.nmuzzy" , i, j, |
580 | &nmuzzy, size_t); |
581 | CTL_M2_M4_GET("stats.arenas.0.extents.0.nretained" , i, j, |
582 | &nretained, size_t); |
583 | CTL_M2_M4_GET("stats.arenas.0.extents.0.dirty_bytes" , i, j, |
584 | &dirty_bytes, size_t); |
585 | CTL_M2_M4_GET("stats.arenas.0.extents.0.muzzy_bytes" , i, j, |
586 | &muzzy_bytes, size_t); |
587 | CTL_M2_M4_GET("stats.arenas.0.extents.0.retained_bytes" , i, j, |
588 | &retained_bytes, size_t); |
589 | total = ndirty + nmuzzy + nretained; |
590 | total_bytes = dirty_bytes + muzzy_bytes + retained_bytes; |
591 | |
592 | in_gap_prev = in_gap; |
593 | in_gap = (total == 0); |
594 | |
595 | if (in_gap_prev && !in_gap) { |
596 | emitter_table_printf(emitter, |
597 | " ---\n" ); |
598 | } |
599 | |
600 | emitter_json_object_begin(emitter); |
601 | emitter_json_kv(emitter, "ndirty" , emitter_type_size, &ndirty); |
602 | emitter_json_kv(emitter, "nmuzzy" , emitter_type_size, &nmuzzy); |
603 | emitter_json_kv(emitter, "nretained" , emitter_type_size, |
604 | &nretained); |
605 | |
606 | emitter_json_kv(emitter, "dirty_bytes" , emitter_type_size, |
607 | &dirty_bytes); |
608 | emitter_json_kv(emitter, "muzzy_bytes" , emitter_type_size, |
609 | &muzzy_bytes); |
610 | emitter_json_kv(emitter, "retained_bytes" , emitter_type_size, |
611 | &retained_bytes); |
612 | emitter_json_object_end(emitter); |
613 | |
614 | col_size.size_val = sz_pind2sz(j); |
615 | col_ind.size_val = j; |
616 | col_ndirty.size_val = ndirty; |
617 | col_dirty.size_val = dirty_bytes; |
618 | col_nmuzzy.size_val = nmuzzy; |
619 | col_muzzy.size_val = muzzy_bytes; |
620 | col_nretained.size_val = nretained; |
621 | col_retained.size_val = retained_bytes; |
622 | col_ntotal.size_val = total; |
623 | col_total.size_val = total_bytes; |
624 | |
625 | if (!in_gap) { |
626 | emitter_table_row(emitter, &row); |
627 | } |
628 | } |
629 | emitter_json_array_end(emitter); /* Close "extents". */ |
630 | if (in_gap) { |
631 | emitter_table_printf(emitter, " ---\n" ); |
632 | } |
633 | } |
634 | |
635 | static void |
636 | stats_arena_mutexes_print(emitter_t *emitter, unsigned arena_ind, uint64_t uptime) { |
637 | emitter_row_t row; |
638 | emitter_col_t col_name; |
639 | emitter_col_t col64[mutex_prof_num_uint64_t_counters]; |
640 | emitter_col_t col32[mutex_prof_num_uint32_t_counters]; |
641 | |
642 | emitter_row_init(&row); |
643 | mutex_stats_init_cols(&row, "" , &col_name, col64, col32); |
644 | |
645 | emitter_json_object_kv_begin(emitter, "mutexes" ); |
646 | emitter_table_row(emitter, &row); |
647 | |
648 | for (mutex_prof_arena_ind_t i = 0; i < mutex_prof_num_arena_mutexes; |
649 | i++) { |
650 | const char *name = arena_mutex_names[i]; |
651 | emitter_json_object_kv_begin(emitter, name); |
652 | mutex_stats_read_arena(arena_ind, i, name, &col_name, col64, |
653 | col32, uptime); |
654 | mutex_stats_emit(emitter, &row, col64, col32); |
655 | emitter_json_object_end(emitter); /* Close the mutex dict. */ |
656 | } |
657 | emitter_json_object_end(emitter); /* End "mutexes". */ |
658 | } |
659 | |
660 | static void |
661 | stats_arena_print(emitter_t *emitter, unsigned i, bool bins, bool large, |
662 | bool mutex, bool extents) { |
663 | unsigned nthreads; |
664 | const char *dss; |
665 | ssize_t dirty_decay_ms, muzzy_decay_ms; |
666 | size_t page, pactive, pdirty, pmuzzy, mapped, retained; |
667 | size_t base, internal, resident, metadata_thp, extent_avail; |
668 | uint64_t dirty_npurge, dirty_nmadvise, dirty_purged; |
669 | uint64_t muzzy_npurge, muzzy_nmadvise, muzzy_purged; |
670 | size_t small_allocated; |
671 | uint64_t small_nmalloc, small_ndalloc, small_nrequests, small_nfills, |
672 | small_nflushes; |
673 | size_t large_allocated; |
674 | uint64_t large_nmalloc, large_ndalloc, large_nrequests, large_nfills, |
675 | large_nflushes; |
676 | size_t tcache_bytes, abandoned_vm; |
677 | uint64_t uptime; |
678 | |
679 | CTL_GET("arenas.page" , &page, size_t); |
680 | |
681 | CTL_M2_GET("stats.arenas.0.nthreads" , i, &nthreads, unsigned); |
682 | emitter_kv(emitter, "nthreads" , "assigned threads" , |
683 | emitter_type_unsigned, &nthreads); |
684 | |
685 | CTL_M2_GET("stats.arenas.0.uptime" , i, &uptime, uint64_t); |
686 | emitter_kv(emitter, "uptime_ns" , "uptime" , emitter_type_uint64, |
687 | &uptime); |
688 | |
689 | CTL_M2_GET("stats.arenas.0.dss" , i, &dss, const char *); |
690 | emitter_kv(emitter, "dss" , "dss allocation precedence" , |
691 | emitter_type_string, &dss); |
692 | |
693 | CTL_M2_GET("stats.arenas.0.dirty_decay_ms" , i, &dirty_decay_ms, |
694 | ssize_t); |
695 | CTL_M2_GET("stats.arenas.0.muzzy_decay_ms" , i, &muzzy_decay_ms, |
696 | ssize_t); |
697 | CTL_M2_GET("stats.arenas.0.pactive" , i, &pactive, size_t); |
698 | CTL_M2_GET("stats.arenas.0.pdirty" , i, &pdirty, size_t); |
699 | CTL_M2_GET("stats.arenas.0.pmuzzy" , i, &pmuzzy, size_t); |
700 | CTL_M2_GET("stats.arenas.0.dirty_npurge" , i, &dirty_npurge, uint64_t); |
701 | CTL_M2_GET("stats.arenas.0.dirty_nmadvise" , i, &dirty_nmadvise, |
702 | uint64_t); |
703 | CTL_M2_GET("stats.arenas.0.dirty_purged" , i, &dirty_purged, uint64_t); |
704 | CTL_M2_GET("stats.arenas.0.muzzy_npurge" , i, &muzzy_npurge, uint64_t); |
705 | CTL_M2_GET("stats.arenas.0.muzzy_nmadvise" , i, &muzzy_nmadvise, |
706 | uint64_t); |
707 | CTL_M2_GET("stats.arenas.0.muzzy_purged" , i, &muzzy_purged, uint64_t); |
708 | |
709 | emitter_row_t decay_row; |
710 | emitter_row_init(&decay_row); |
711 | |
712 | /* JSON-style emission. */ |
713 | emitter_json_kv(emitter, "dirty_decay_ms" , emitter_type_ssize, |
714 | &dirty_decay_ms); |
715 | emitter_json_kv(emitter, "muzzy_decay_ms" , emitter_type_ssize, |
716 | &muzzy_decay_ms); |
717 | |
718 | emitter_json_kv(emitter, "pactive" , emitter_type_size, &pactive); |
719 | emitter_json_kv(emitter, "pdirty" , emitter_type_size, &pdirty); |
720 | emitter_json_kv(emitter, "pmuzzy" , emitter_type_size, &pmuzzy); |
721 | |
722 | emitter_json_kv(emitter, "dirty_npurge" , emitter_type_uint64, |
723 | &dirty_npurge); |
724 | emitter_json_kv(emitter, "dirty_nmadvise" , emitter_type_uint64, |
725 | &dirty_nmadvise); |
726 | emitter_json_kv(emitter, "dirty_purged" , emitter_type_uint64, |
727 | &dirty_purged); |
728 | |
729 | emitter_json_kv(emitter, "muzzy_npurge" , emitter_type_uint64, |
730 | &muzzy_npurge); |
731 | emitter_json_kv(emitter, "muzzy_nmadvise" , emitter_type_uint64, |
732 | &muzzy_nmadvise); |
733 | emitter_json_kv(emitter, "muzzy_purged" , emitter_type_uint64, |
734 | &muzzy_purged); |
735 | |
736 | /* Table-style emission. */ |
737 | COL(decay_row, decay_type, right, 9, title); |
738 | col_decay_type.str_val = "decaying:" ; |
739 | |
740 | COL(decay_row, decay_time, right, 6, title); |
741 | col_decay_time.str_val = "time" ; |
742 | |
743 | COL(decay_row, decay_npages, right, 13, title); |
744 | col_decay_npages.str_val = "npages" ; |
745 | |
746 | COL(decay_row, decay_sweeps, right, 13, title); |
747 | col_decay_sweeps.str_val = "sweeps" ; |
748 | |
749 | COL(decay_row, decay_madvises, right, 13, title); |
750 | col_decay_madvises.str_val = "madvises" ; |
751 | |
752 | COL(decay_row, decay_purged, right, 13, title); |
753 | col_decay_purged.str_val = "purged" ; |
754 | |
755 | /* Title row. */ |
756 | emitter_table_row(emitter, &decay_row); |
757 | |
758 | /* Dirty row. */ |
759 | col_decay_type.str_val = "dirty:" ; |
760 | |
761 | if (dirty_decay_ms >= 0) { |
762 | col_decay_time.type = emitter_type_ssize; |
763 | col_decay_time.ssize_val = dirty_decay_ms; |
764 | } else { |
765 | col_decay_time.type = emitter_type_title; |
766 | col_decay_time.str_val = "N/A" ; |
767 | } |
768 | |
769 | col_decay_npages.type = emitter_type_size; |
770 | col_decay_npages.size_val = pdirty; |
771 | |
772 | col_decay_sweeps.type = emitter_type_uint64; |
773 | col_decay_sweeps.uint64_val = dirty_npurge; |
774 | |
775 | col_decay_madvises.type = emitter_type_uint64; |
776 | col_decay_madvises.uint64_val = dirty_nmadvise; |
777 | |
778 | col_decay_purged.type = emitter_type_uint64; |
779 | col_decay_purged.uint64_val = dirty_purged; |
780 | |
781 | emitter_table_row(emitter, &decay_row); |
782 | |
783 | /* Muzzy row. */ |
784 | col_decay_type.str_val = "muzzy:" ; |
785 | |
786 | if (muzzy_decay_ms >= 0) { |
787 | col_decay_time.type = emitter_type_ssize; |
788 | col_decay_time.ssize_val = muzzy_decay_ms; |
789 | } else { |
790 | col_decay_time.type = emitter_type_title; |
791 | col_decay_time.str_val = "N/A" ; |
792 | } |
793 | |
794 | col_decay_npages.type = emitter_type_size; |
795 | col_decay_npages.size_val = pmuzzy; |
796 | |
797 | col_decay_sweeps.type = emitter_type_uint64; |
798 | col_decay_sweeps.uint64_val = muzzy_npurge; |
799 | |
800 | col_decay_madvises.type = emitter_type_uint64; |
801 | col_decay_madvises.uint64_val = muzzy_nmadvise; |
802 | |
803 | col_decay_purged.type = emitter_type_uint64; |
804 | col_decay_purged.uint64_val = muzzy_purged; |
805 | |
806 | emitter_table_row(emitter, &decay_row); |
807 | |
808 | /* Small / large / total allocation counts. */ |
809 | emitter_row_t alloc_count_row; |
810 | emitter_row_init(&alloc_count_row); |
811 | |
812 | COL(alloc_count_row, count_title, left, 21, title); |
813 | col_count_title.str_val = "" ; |
814 | |
815 | COL(alloc_count_row, count_allocated, right, 16, title); |
816 | col_count_allocated.str_val = "allocated" ; |
817 | |
818 | COL(alloc_count_row, count_nmalloc, right, 16, title); |
819 | col_count_nmalloc.str_val = "nmalloc" ; |
820 | COL(alloc_count_row, count_nmalloc_ps, right, 8, title); |
821 | col_count_nmalloc_ps.str_val = "(#/sec)" ; |
822 | |
823 | COL(alloc_count_row, count_ndalloc, right, 16, title); |
824 | col_count_ndalloc.str_val = "ndalloc" ; |
825 | COL(alloc_count_row, count_ndalloc_ps, right, 8, title); |
826 | col_count_ndalloc_ps.str_val = "(#/sec)" ; |
827 | |
828 | COL(alloc_count_row, count_nrequests, right, 16, title); |
829 | col_count_nrequests.str_val = "nrequests" ; |
830 | COL(alloc_count_row, count_nrequests_ps, right, 10, title); |
831 | col_count_nrequests_ps.str_val = "(#/sec)" ; |
832 | |
833 | COL(alloc_count_row, count_nfills, right, 16, title); |
834 | col_count_nfills.str_val = "nfill" ; |
835 | COL(alloc_count_row, count_nfills_ps, right, 10, title); |
836 | col_count_nfills_ps.str_val = "(#/sec)" ; |
837 | |
838 | COL(alloc_count_row, count_nflushes, right, 16, title); |
839 | col_count_nflushes.str_val = "nflush" ; |
840 | COL(alloc_count_row, count_nflushes_ps, right, 10, title); |
841 | col_count_nflushes_ps.str_val = "(#/sec)" ; |
842 | |
843 | emitter_table_row(emitter, &alloc_count_row); |
844 | |
845 | col_count_nmalloc_ps.type = emitter_type_uint64; |
846 | col_count_ndalloc_ps.type = emitter_type_uint64; |
847 | col_count_nrequests_ps.type = emitter_type_uint64; |
848 | col_count_nfills_ps.type = emitter_type_uint64; |
849 | col_count_nflushes_ps.type = emitter_type_uint64; |
850 | |
851 | #define GET_AND_EMIT_ALLOC_STAT(small_or_large, name, valtype) \ |
852 | CTL_M2_GET("stats.arenas.0." #small_or_large "." #name, i, \ |
853 | &small_or_large##_##name, valtype##_t); \ |
854 | emitter_json_kv(emitter, #name, emitter_type_##valtype, \ |
855 | &small_or_large##_##name); \ |
856 | col_count_##name.type = emitter_type_##valtype; \ |
857 | col_count_##name.valtype##_val = small_or_large##_##name; |
858 | |
859 | emitter_json_object_kv_begin(emitter, "small" ); |
860 | col_count_title.str_val = "small:" ; |
861 | |
862 | GET_AND_EMIT_ALLOC_STAT(small, allocated, size) |
863 | GET_AND_EMIT_ALLOC_STAT(small, nmalloc, uint64) |
864 | col_count_nmalloc_ps.uint64_val = |
865 | rate_per_second(col_count_nmalloc.uint64_val, uptime); |
866 | GET_AND_EMIT_ALLOC_STAT(small, ndalloc, uint64) |
867 | col_count_ndalloc_ps.uint64_val = |
868 | rate_per_second(col_count_ndalloc.uint64_val, uptime); |
869 | GET_AND_EMIT_ALLOC_STAT(small, nrequests, uint64) |
870 | col_count_nrequests_ps.uint64_val = |
871 | rate_per_second(col_count_nrequests.uint64_val, uptime); |
872 | GET_AND_EMIT_ALLOC_STAT(small, nfills, uint64) |
873 | col_count_nfills_ps.uint64_val = |
874 | rate_per_second(col_count_nfills.uint64_val, uptime); |
875 | GET_AND_EMIT_ALLOC_STAT(small, nflushes, uint64) |
876 | col_count_nflushes_ps.uint64_val = |
877 | rate_per_second(col_count_nflushes.uint64_val, uptime); |
878 | |
879 | emitter_table_row(emitter, &alloc_count_row); |
880 | emitter_json_object_end(emitter); /* Close "small". */ |
881 | |
882 | emitter_json_object_kv_begin(emitter, "large" ); |
883 | col_count_title.str_val = "large:" ; |
884 | |
885 | GET_AND_EMIT_ALLOC_STAT(large, allocated, size) |
886 | GET_AND_EMIT_ALLOC_STAT(large, nmalloc, uint64) |
887 | col_count_nmalloc_ps.uint64_val = |
888 | rate_per_second(col_count_nmalloc.uint64_val, uptime); |
889 | GET_AND_EMIT_ALLOC_STAT(large, ndalloc, uint64) |
890 | col_count_ndalloc_ps.uint64_val = |
891 | rate_per_second(col_count_ndalloc.uint64_val, uptime); |
892 | GET_AND_EMIT_ALLOC_STAT(large, nrequests, uint64) |
893 | col_count_nrequests_ps.uint64_val = |
894 | rate_per_second(col_count_nrequests.uint64_val, uptime); |
895 | GET_AND_EMIT_ALLOC_STAT(large, nfills, uint64) |
896 | col_count_nfills_ps.uint64_val = |
897 | rate_per_second(col_count_nfills.uint64_val, uptime); |
898 | GET_AND_EMIT_ALLOC_STAT(large, nflushes, uint64) |
899 | col_count_nflushes_ps.uint64_val = |
900 | rate_per_second(col_count_nflushes.uint64_val, uptime); |
901 | |
902 | emitter_table_row(emitter, &alloc_count_row); |
903 | emitter_json_object_end(emitter); /* Close "large". */ |
904 | |
905 | #undef GET_AND_EMIT_ALLOC_STAT |
906 | |
907 | /* Aggregated small + large stats are emitter only in table mode. */ |
908 | col_count_title.str_val = "total:" ; |
909 | col_count_allocated.size_val = small_allocated + large_allocated; |
910 | col_count_nmalloc.uint64_val = small_nmalloc + large_nmalloc; |
911 | col_count_ndalloc.uint64_val = small_ndalloc + large_ndalloc; |
912 | col_count_nrequests.uint64_val = small_nrequests + large_nrequests; |
913 | col_count_nfills.uint64_val = small_nfills + large_nfills; |
914 | col_count_nflushes.uint64_val = small_nflushes + large_nflushes; |
915 | col_count_nmalloc_ps.uint64_val = |
916 | rate_per_second(col_count_nmalloc.uint64_val, uptime); |
917 | col_count_ndalloc_ps.uint64_val = |
918 | rate_per_second(col_count_ndalloc.uint64_val, uptime); |
919 | col_count_nrequests_ps.uint64_val = |
920 | rate_per_second(col_count_nrequests.uint64_val, uptime); |
921 | col_count_nfills_ps.uint64_val = |
922 | rate_per_second(col_count_nfills.uint64_val, uptime); |
923 | col_count_nflushes_ps.uint64_val = |
924 | rate_per_second(col_count_nflushes.uint64_val, uptime); |
925 | emitter_table_row(emitter, &alloc_count_row); |
926 | |
927 | emitter_row_t mem_count_row; |
928 | emitter_row_init(&mem_count_row); |
929 | |
930 | emitter_col_t mem_count_title; |
931 | emitter_col_init(&mem_count_title, &mem_count_row); |
932 | mem_count_title.justify = emitter_justify_left; |
933 | mem_count_title.width = 21; |
934 | mem_count_title.type = emitter_type_title; |
935 | mem_count_title.str_val = "" ; |
936 | |
937 | emitter_col_t mem_count_val; |
938 | emitter_col_init(&mem_count_val, &mem_count_row); |
939 | mem_count_val.justify = emitter_justify_right; |
940 | mem_count_val.width = 16; |
941 | mem_count_val.type = emitter_type_title; |
942 | mem_count_val.str_val = "" ; |
943 | |
944 | emitter_table_row(emitter, &mem_count_row); |
945 | mem_count_val.type = emitter_type_size; |
946 | |
947 | /* Active count in bytes is emitted only in table mode. */ |
948 | mem_count_title.str_val = "active:" ; |
949 | mem_count_val.size_val = pactive * page; |
950 | emitter_table_row(emitter, &mem_count_row); |
951 | |
952 | #define GET_AND_EMIT_MEM_STAT(stat) \ |
953 | CTL_M2_GET("stats.arenas.0."#stat, i, &stat, size_t); \ |
954 | emitter_json_kv(emitter, #stat, emitter_type_size, &stat); \ |
955 | mem_count_title.str_val = #stat":"; \ |
956 | mem_count_val.size_val = stat; \ |
957 | emitter_table_row(emitter, &mem_count_row); |
958 | |
959 | GET_AND_EMIT_MEM_STAT(mapped) |
960 | GET_AND_EMIT_MEM_STAT(retained) |
961 | GET_AND_EMIT_MEM_STAT(base) |
962 | GET_AND_EMIT_MEM_STAT(internal) |
963 | GET_AND_EMIT_MEM_STAT(metadata_thp) |
964 | GET_AND_EMIT_MEM_STAT(tcache_bytes) |
965 | GET_AND_EMIT_MEM_STAT(resident) |
966 | GET_AND_EMIT_MEM_STAT(abandoned_vm) |
967 | GET_AND_EMIT_MEM_STAT(extent_avail) |
968 | #undef GET_AND_EMIT_MEM_STAT |
969 | |
970 | if (mutex) { |
971 | stats_arena_mutexes_print(emitter, i, uptime); |
972 | } |
973 | if (bins) { |
974 | stats_arena_bins_print(emitter, mutex, i, uptime); |
975 | } |
976 | if (large) { |
977 | stats_arena_lextents_print(emitter, i, uptime); |
978 | } |
979 | if (extents) { |
980 | stats_arena_extents_print(emitter, i); |
981 | } |
982 | } |
983 | |
984 | static void |
985 | stats_general_print(emitter_t *emitter) { |
986 | const char *cpv; |
987 | bool bv, bv2; |
988 | unsigned uv; |
989 | uint32_t u32v; |
990 | uint64_t u64v; |
991 | ssize_t ssv, ssv2; |
992 | size_t sv, bsz, usz, ssz, sssz, cpsz; |
993 | |
994 | bsz = sizeof(bool); |
995 | usz = sizeof(unsigned); |
996 | ssz = sizeof(size_t); |
997 | sssz = sizeof(ssize_t); |
998 | cpsz = sizeof(const char *); |
999 | |
1000 | CTL_GET("version" , &cpv, const char *); |
1001 | emitter_kv(emitter, "version" , "Version" , emitter_type_string, &cpv); |
1002 | |
1003 | /* config. */ |
1004 | emitter_dict_begin(emitter, "config" , "Build-time option settings" ); |
1005 | #define CONFIG_WRITE_BOOL(name) \ |
1006 | do { \ |
1007 | CTL_GET("config."#name, &bv, bool); \ |
1008 | emitter_kv(emitter, #name, "config."#name, \ |
1009 | emitter_type_bool, &bv); \ |
1010 | } while (0) |
1011 | |
1012 | CONFIG_WRITE_BOOL(cache_oblivious); |
1013 | CONFIG_WRITE_BOOL(debug); |
1014 | CONFIG_WRITE_BOOL(fill); |
1015 | CONFIG_WRITE_BOOL(lazy_lock); |
1016 | emitter_kv(emitter, "malloc_conf" , "config.malloc_conf" , |
1017 | emitter_type_string, &config_malloc_conf); |
1018 | |
1019 | CONFIG_WRITE_BOOL(opt_safety_checks); |
1020 | CONFIG_WRITE_BOOL(prof); |
1021 | CONFIG_WRITE_BOOL(prof_libgcc); |
1022 | CONFIG_WRITE_BOOL(prof_libunwind); |
1023 | CONFIG_WRITE_BOOL(stats); |
1024 | CONFIG_WRITE_BOOL(utrace); |
1025 | CONFIG_WRITE_BOOL(xmalloc); |
1026 | #undef CONFIG_WRITE_BOOL |
1027 | emitter_dict_end(emitter); /* Close "config" dict. */ |
1028 | |
1029 | /* opt. */ |
1030 | #define OPT_WRITE(name, var, size, emitter_type) \ |
1031 | if (je_mallctl("opt."name, (void *)&var, &size, NULL, 0) == \ |
1032 | 0) { \ |
1033 | emitter_kv(emitter, name, "opt."name, emitter_type, \ |
1034 | &var); \ |
1035 | } |
1036 | |
1037 | #define OPT_WRITE_MUTABLE(name, var1, var2, size, emitter_type, \ |
1038 | altname) \ |
1039 | if (je_mallctl("opt."name, (void *)&var1, &size, NULL, 0) == \ |
1040 | 0 && je_mallctl(altname, (void *)&var2, &size, NULL, 0) \ |
1041 | == 0) { \ |
1042 | emitter_kv_note(emitter, name, "opt."name, \ |
1043 | emitter_type, &var1, altname, emitter_type, \ |
1044 | &var2); \ |
1045 | } |
1046 | |
1047 | #define OPT_WRITE_BOOL(name) OPT_WRITE(name, bv, bsz, emitter_type_bool) |
1048 | #define OPT_WRITE_BOOL_MUTABLE(name, altname) \ |
1049 | OPT_WRITE_MUTABLE(name, bv, bv2, bsz, emitter_type_bool, altname) |
1050 | |
1051 | #define OPT_WRITE_UNSIGNED(name) \ |
1052 | OPT_WRITE(name, uv, usz, emitter_type_unsigned) |
1053 | |
1054 | #define OPT_WRITE_SIZE_T(name) \ |
1055 | OPT_WRITE(name, sv, ssz, emitter_type_size) |
1056 | #define OPT_WRITE_SSIZE_T(name) \ |
1057 | OPT_WRITE(name, ssv, sssz, emitter_type_ssize) |
1058 | #define OPT_WRITE_SSIZE_T_MUTABLE(name, altname) \ |
1059 | OPT_WRITE_MUTABLE(name, ssv, ssv2, sssz, emitter_type_ssize, \ |
1060 | altname) |
1061 | |
1062 | #define OPT_WRITE_CHAR_P(name) \ |
1063 | OPT_WRITE(name, cpv, cpsz, emitter_type_string) |
1064 | |
1065 | emitter_dict_begin(emitter, "opt" , "Run-time option settings" ); |
1066 | |
1067 | OPT_WRITE_BOOL("abort" ) |
1068 | OPT_WRITE_BOOL("abort_conf" ) |
1069 | OPT_WRITE_BOOL("confirm_conf" ) |
1070 | OPT_WRITE_BOOL("retain" ) |
1071 | OPT_WRITE_CHAR_P("dss" ) |
1072 | OPT_WRITE_UNSIGNED("narenas" ) |
1073 | OPT_WRITE_CHAR_P("percpu_arena" ) |
1074 | OPT_WRITE_SIZE_T("oversize_threshold" ) |
1075 | OPT_WRITE_CHAR_P("metadata_thp" ) |
1076 | OPT_WRITE_BOOL_MUTABLE("background_thread" , "background_thread" ) |
1077 | OPT_WRITE_SSIZE_T_MUTABLE("dirty_decay_ms" , "arenas.dirty_decay_ms" ) |
1078 | OPT_WRITE_SSIZE_T_MUTABLE("muzzy_decay_ms" , "arenas.muzzy_decay_ms" ) |
1079 | OPT_WRITE_SIZE_T("lg_extent_max_active_fit" ) |
1080 | OPT_WRITE_CHAR_P("junk" ) |
1081 | OPT_WRITE_BOOL("zero" ) |
1082 | OPT_WRITE_BOOL("utrace" ) |
1083 | OPT_WRITE_BOOL("xmalloc" ) |
1084 | OPT_WRITE_BOOL("tcache" ) |
1085 | OPT_WRITE_SSIZE_T("lg_tcache_max" ) |
1086 | OPT_WRITE_CHAR_P("thp" ) |
1087 | OPT_WRITE_BOOL("prof" ) |
1088 | OPT_WRITE_CHAR_P("prof_prefix" ) |
1089 | OPT_WRITE_BOOL_MUTABLE("prof_active" , "prof.active" ) |
1090 | OPT_WRITE_BOOL_MUTABLE("prof_thread_active_init" , |
1091 | "prof.thread_active_init" ) |
1092 | OPT_WRITE_SSIZE_T_MUTABLE("lg_prof_sample" , "prof.lg_sample" ) |
1093 | OPT_WRITE_BOOL("prof_accum" ) |
1094 | OPT_WRITE_SSIZE_T("lg_prof_interval" ) |
1095 | OPT_WRITE_BOOL("prof_gdump" ) |
1096 | OPT_WRITE_BOOL("prof_final" ) |
1097 | OPT_WRITE_BOOL("prof_leak" ) |
1098 | OPT_WRITE_BOOL("stats_print" ) |
1099 | OPT_WRITE_CHAR_P("stats_print_opts" ) |
1100 | |
1101 | emitter_dict_end(emitter); |
1102 | |
1103 | #undef OPT_WRITE |
1104 | #undef OPT_WRITE_MUTABLE |
1105 | #undef OPT_WRITE_BOOL |
1106 | #undef OPT_WRITE_BOOL_MUTABLE |
1107 | #undef OPT_WRITE_UNSIGNED |
1108 | #undef OPT_WRITE_SSIZE_T |
1109 | #undef OPT_WRITE_SSIZE_T_MUTABLE |
1110 | #undef OPT_WRITE_CHAR_P |
1111 | |
1112 | /* prof. */ |
1113 | if (config_prof) { |
1114 | emitter_dict_begin(emitter, "prof" , "Profiling settings" ); |
1115 | |
1116 | CTL_GET("prof.thread_active_init" , &bv, bool); |
1117 | emitter_kv(emitter, "thread_active_init" , |
1118 | "prof.thread_active_init" , emitter_type_bool, &bv); |
1119 | |
1120 | CTL_GET("prof.active" , &bv, bool); |
1121 | emitter_kv(emitter, "active" , "prof.active" , emitter_type_bool, |
1122 | &bv); |
1123 | |
1124 | CTL_GET("prof.gdump" , &bv, bool); |
1125 | emitter_kv(emitter, "gdump" , "prof.gdump" , emitter_type_bool, |
1126 | &bv); |
1127 | |
1128 | CTL_GET("prof.interval" , &u64v, uint64_t); |
1129 | emitter_kv(emitter, "interval" , "prof.interval" , |
1130 | emitter_type_uint64, &u64v); |
1131 | |
1132 | CTL_GET("prof.lg_sample" , &ssv, ssize_t); |
1133 | emitter_kv(emitter, "lg_sample" , "prof.lg_sample" , |
1134 | emitter_type_ssize, &ssv); |
1135 | |
1136 | emitter_dict_end(emitter); /* Close "prof". */ |
1137 | } |
1138 | |
1139 | /* arenas. */ |
1140 | /* |
1141 | * The json output sticks arena info into an "arenas" dict; the table |
1142 | * output puts them at the top-level. |
1143 | */ |
1144 | emitter_json_object_kv_begin(emitter, "arenas" ); |
1145 | |
1146 | CTL_GET("arenas.narenas" , &uv, unsigned); |
1147 | emitter_kv(emitter, "narenas" , "Arenas" , emitter_type_unsigned, &uv); |
1148 | |
1149 | /* |
1150 | * Decay settings are emitted only in json mode; in table mode, they're |
1151 | * emitted as notes with the opt output, above. |
1152 | */ |
1153 | CTL_GET("arenas.dirty_decay_ms" , &ssv, ssize_t); |
1154 | emitter_json_kv(emitter, "dirty_decay_ms" , emitter_type_ssize, &ssv); |
1155 | |
1156 | CTL_GET("arenas.muzzy_decay_ms" , &ssv, ssize_t); |
1157 | emitter_json_kv(emitter, "muzzy_decay_ms" , emitter_type_ssize, &ssv); |
1158 | |
1159 | CTL_GET("arenas.quantum" , &sv, size_t); |
1160 | emitter_kv(emitter, "quantum" , "Quantum size" , emitter_type_size, &sv); |
1161 | |
1162 | CTL_GET("arenas.page" , &sv, size_t); |
1163 | emitter_kv(emitter, "page" , "Page size" , emitter_type_size, &sv); |
1164 | |
1165 | if (je_mallctl("arenas.tcache_max" , (void *)&sv, &ssz, NULL, 0) == 0) { |
1166 | emitter_kv(emitter, "tcache_max" , |
1167 | "Maximum thread-cached size class" , emitter_type_size, &sv); |
1168 | } |
1169 | |
1170 | unsigned nbins; |
1171 | CTL_GET("arenas.nbins" , &nbins, unsigned); |
1172 | emitter_kv(emitter, "nbins" , "Number of bin size classes" , |
1173 | emitter_type_unsigned, &nbins); |
1174 | |
1175 | unsigned nhbins; |
1176 | CTL_GET("arenas.nhbins" , &nhbins, unsigned); |
1177 | emitter_kv(emitter, "nhbins" , "Number of thread-cache bin size classes" , |
1178 | emitter_type_unsigned, &nhbins); |
1179 | |
1180 | /* |
1181 | * We do enough mallctls in a loop that we actually want to omit them |
1182 | * (not just omit the printing). |
1183 | */ |
1184 | if (emitter->output == emitter_output_json) { |
1185 | emitter_json_array_kv_begin(emitter, "bin" ); |
1186 | for (unsigned i = 0; i < nbins; i++) { |
1187 | emitter_json_object_begin(emitter); |
1188 | |
1189 | CTL_M2_GET("arenas.bin.0.size" , i, &sv, size_t); |
1190 | emitter_json_kv(emitter, "size" , emitter_type_size, |
1191 | &sv); |
1192 | |
1193 | CTL_M2_GET("arenas.bin.0.nregs" , i, &u32v, uint32_t); |
1194 | emitter_json_kv(emitter, "nregs" , emitter_type_uint32, |
1195 | &u32v); |
1196 | |
1197 | CTL_M2_GET("arenas.bin.0.slab_size" , i, &sv, size_t); |
1198 | emitter_json_kv(emitter, "slab_size" , emitter_type_size, |
1199 | &sv); |
1200 | |
1201 | CTL_M2_GET("arenas.bin.0.nshards" , i, &u32v, uint32_t); |
1202 | emitter_json_kv(emitter, "nshards" , emitter_type_uint32, |
1203 | &u32v); |
1204 | |
1205 | emitter_json_object_end(emitter); |
1206 | } |
1207 | emitter_json_array_end(emitter); /* Close "bin". */ |
1208 | } |
1209 | |
1210 | unsigned nlextents; |
1211 | CTL_GET("arenas.nlextents" , &nlextents, unsigned); |
1212 | emitter_kv(emitter, "nlextents" , "Number of large size classes" , |
1213 | emitter_type_unsigned, &nlextents); |
1214 | |
1215 | if (emitter->output == emitter_output_json) { |
1216 | emitter_json_array_kv_begin(emitter, "lextent" ); |
1217 | for (unsigned i = 0; i < nlextents; i++) { |
1218 | emitter_json_object_begin(emitter); |
1219 | |
1220 | CTL_M2_GET("arenas.lextent.0.size" , i, &sv, size_t); |
1221 | emitter_json_kv(emitter, "size" , emitter_type_size, |
1222 | &sv); |
1223 | |
1224 | emitter_json_object_end(emitter); |
1225 | } |
1226 | emitter_json_array_end(emitter); /* Close "lextent". */ |
1227 | } |
1228 | |
1229 | emitter_json_object_end(emitter); /* Close "arenas" */ |
1230 | } |
1231 | |
1232 | static void |
1233 | stats_print_helper(emitter_t *emitter, bool merged, bool destroyed, |
1234 | bool unmerged, bool bins, bool large, bool mutex, bool extents) { |
1235 | /* |
1236 | * These should be deleted. We keep them around for a while, to aid in |
1237 | * the transition to the emitter code. |
1238 | */ |
1239 | size_t allocated, active, metadata, metadata_thp, resident, mapped, |
1240 | retained; |
1241 | size_t num_background_threads; |
1242 | uint64_t background_thread_num_runs, background_thread_run_interval; |
1243 | |
1244 | CTL_GET("stats.allocated" , &allocated, size_t); |
1245 | CTL_GET("stats.active" , &active, size_t); |
1246 | CTL_GET("stats.metadata" , &metadata, size_t); |
1247 | CTL_GET("stats.metadata_thp" , &metadata_thp, size_t); |
1248 | CTL_GET("stats.resident" , &resident, size_t); |
1249 | CTL_GET("stats.mapped" , &mapped, size_t); |
1250 | CTL_GET("stats.retained" , &retained, size_t); |
1251 | |
1252 | if (have_background_thread) { |
1253 | CTL_GET("stats.background_thread.num_threads" , |
1254 | &num_background_threads, size_t); |
1255 | CTL_GET("stats.background_thread.num_runs" , |
1256 | &background_thread_num_runs, uint64_t); |
1257 | CTL_GET("stats.background_thread.run_interval" , |
1258 | &background_thread_run_interval, uint64_t); |
1259 | } else { |
1260 | num_background_threads = 0; |
1261 | background_thread_num_runs = 0; |
1262 | background_thread_run_interval = 0; |
1263 | } |
1264 | |
1265 | /* Generic global stats. */ |
1266 | emitter_json_object_kv_begin(emitter, "stats" ); |
1267 | emitter_json_kv(emitter, "allocated" , emitter_type_size, &allocated); |
1268 | emitter_json_kv(emitter, "active" , emitter_type_size, &active); |
1269 | emitter_json_kv(emitter, "metadata" , emitter_type_size, &metadata); |
1270 | emitter_json_kv(emitter, "metadata_thp" , emitter_type_size, |
1271 | &metadata_thp); |
1272 | emitter_json_kv(emitter, "resident" , emitter_type_size, &resident); |
1273 | emitter_json_kv(emitter, "mapped" , emitter_type_size, &mapped); |
1274 | emitter_json_kv(emitter, "retained" , emitter_type_size, &retained); |
1275 | |
1276 | emitter_table_printf(emitter, "Allocated: %zu, active: %zu, " |
1277 | "metadata: %zu (n_thp %zu), resident: %zu, mapped: %zu, " |
1278 | "retained: %zu\n" , allocated, active, metadata, metadata_thp, |
1279 | resident, mapped, retained); |
1280 | |
1281 | /* Background thread stats. */ |
1282 | emitter_json_object_kv_begin(emitter, "background_thread" ); |
1283 | emitter_json_kv(emitter, "num_threads" , emitter_type_size, |
1284 | &num_background_threads); |
1285 | emitter_json_kv(emitter, "num_runs" , emitter_type_uint64, |
1286 | &background_thread_num_runs); |
1287 | emitter_json_kv(emitter, "run_interval" , emitter_type_uint64, |
1288 | &background_thread_run_interval); |
1289 | emitter_json_object_end(emitter); /* Close "background_thread". */ |
1290 | |
1291 | emitter_table_printf(emitter, "Background threads: %zu, " |
1292 | "num_runs: %" FMTu64", run_interval: %" FMTu64" ns\n" , |
1293 | num_background_threads, background_thread_num_runs, |
1294 | background_thread_run_interval); |
1295 | |
1296 | if (mutex) { |
1297 | emitter_row_t row; |
1298 | emitter_col_t name; |
1299 | emitter_col_t col64[mutex_prof_num_uint64_t_counters]; |
1300 | emitter_col_t col32[mutex_prof_num_uint32_t_counters]; |
1301 | uint64_t uptime; |
1302 | |
1303 | emitter_row_init(&row); |
1304 | mutex_stats_init_cols(&row, "" , &name, col64, col32); |
1305 | |
1306 | emitter_table_row(emitter, &row); |
1307 | emitter_json_object_kv_begin(emitter, "mutexes" ); |
1308 | |
1309 | CTL_M2_GET("stats.arenas.0.uptime" , 0, &uptime, uint64_t); |
1310 | |
1311 | for (int i = 0; i < mutex_prof_num_global_mutexes; i++) { |
1312 | mutex_stats_read_global(global_mutex_names[i], &name, |
1313 | col64, col32, uptime); |
1314 | emitter_json_object_kv_begin(emitter, global_mutex_names[i]); |
1315 | mutex_stats_emit(emitter, &row, col64, col32); |
1316 | emitter_json_object_end(emitter); |
1317 | } |
1318 | |
1319 | emitter_json_object_end(emitter); /* Close "mutexes". */ |
1320 | } |
1321 | |
1322 | emitter_json_object_end(emitter); /* Close "stats". */ |
1323 | |
1324 | if (merged || destroyed || unmerged) { |
1325 | unsigned narenas; |
1326 | |
1327 | emitter_json_object_kv_begin(emitter, "stats.arenas" ); |
1328 | |
1329 | CTL_GET("arenas.narenas" , &narenas, unsigned); |
1330 | size_t mib[3]; |
1331 | size_t miblen = sizeof(mib) / sizeof(size_t); |
1332 | size_t sz; |
1333 | VARIABLE_ARRAY(bool, initialized, narenas); |
1334 | bool destroyed_initialized; |
1335 | unsigned i, j, ninitialized; |
1336 | |
1337 | xmallctlnametomib("arena.0.initialized" , mib, &miblen); |
1338 | for (i = ninitialized = 0; i < narenas; i++) { |
1339 | mib[1] = i; |
1340 | sz = sizeof(bool); |
1341 | xmallctlbymib(mib, miblen, &initialized[i], &sz, |
1342 | NULL, 0); |
1343 | if (initialized[i]) { |
1344 | ninitialized++; |
1345 | } |
1346 | } |
1347 | mib[1] = MALLCTL_ARENAS_DESTROYED; |
1348 | sz = sizeof(bool); |
1349 | xmallctlbymib(mib, miblen, &destroyed_initialized, &sz, |
1350 | NULL, 0); |
1351 | |
1352 | /* Merged stats. */ |
1353 | if (merged && (ninitialized > 1 || !unmerged)) { |
1354 | /* Print merged arena stats. */ |
1355 | emitter_table_printf(emitter, "Merged arenas stats:\n" ); |
1356 | emitter_json_object_kv_begin(emitter, "merged" ); |
1357 | stats_arena_print(emitter, MALLCTL_ARENAS_ALL, bins, |
1358 | large, mutex, extents); |
1359 | emitter_json_object_end(emitter); /* Close "merged". */ |
1360 | } |
1361 | |
1362 | /* Destroyed stats. */ |
1363 | if (destroyed_initialized && destroyed) { |
1364 | /* Print destroyed arena stats. */ |
1365 | emitter_table_printf(emitter, |
1366 | "Destroyed arenas stats:\n" ); |
1367 | emitter_json_object_kv_begin(emitter, "destroyed" ); |
1368 | stats_arena_print(emitter, MALLCTL_ARENAS_DESTROYED, |
1369 | bins, large, mutex, extents); |
1370 | emitter_json_object_end(emitter); /* Close "destroyed". */ |
1371 | } |
1372 | |
1373 | /* Unmerged stats. */ |
1374 | if (unmerged) { |
1375 | for (i = j = 0; i < narenas; i++) { |
1376 | if (initialized[i]) { |
1377 | char arena_ind_str[20]; |
1378 | malloc_snprintf(arena_ind_str, |
1379 | sizeof(arena_ind_str), "%u" , i); |
1380 | emitter_json_object_kv_begin(emitter, |
1381 | arena_ind_str); |
1382 | emitter_table_printf(emitter, |
1383 | "arenas[%s]:\n" , arena_ind_str); |
1384 | stats_arena_print(emitter, i, bins, |
1385 | large, mutex, extents); |
1386 | /* Close "<arena-ind>". */ |
1387 | emitter_json_object_end(emitter); |
1388 | } |
1389 | } |
1390 | } |
1391 | emitter_json_object_end(emitter); /* Close "stats.arenas". */ |
1392 | } |
1393 | } |
1394 | |
1395 | void |
1396 | stats_print(void (*write_cb)(void *, const char *), void *cbopaque, |
1397 | const char *opts) { |
1398 | int err; |
1399 | uint64_t epoch; |
1400 | size_t u64sz; |
1401 | #define OPTION(o, v, d, s) bool v = d; |
1402 | STATS_PRINT_OPTIONS |
1403 | #undef OPTION |
1404 | |
1405 | /* |
1406 | * Refresh stats, in case mallctl() was called by the application. |
1407 | * |
1408 | * Check for OOM here, since refreshing the ctl cache can trigger |
1409 | * allocation. In practice, none of the subsequent mallctl()-related |
1410 | * calls in this function will cause OOM if this one succeeds. |
1411 | * */ |
1412 | epoch = 1; |
1413 | u64sz = sizeof(uint64_t); |
1414 | err = je_mallctl("epoch" , (void *)&epoch, &u64sz, (void *)&epoch, |
1415 | sizeof(uint64_t)); |
1416 | if (err != 0) { |
1417 | if (err == EAGAIN) { |
1418 | malloc_write("<jemalloc>: Memory allocation failure in " |
1419 | "mallctl(\"epoch\", ...)\n" ); |
1420 | return; |
1421 | } |
1422 | malloc_write("<jemalloc>: Failure in mallctl(\"epoch\", " |
1423 | "...)\n" ); |
1424 | abort(); |
1425 | } |
1426 | |
1427 | if (opts != NULL) { |
1428 | for (unsigned i = 0; opts[i] != '\0'; i++) { |
1429 | switch (opts[i]) { |
1430 | #define OPTION(o, v, d, s) case o: v = s; break; |
1431 | STATS_PRINT_OPTIONS |
1432 | #undef OPTION |
1433 | default:; |
1434 | } |
1435 | } |
1436 | } |
1437 | |
1438 | emitter_t emitter; |
1439 | emitter_init(&emitter, |
1440 | json ? emitter_output_json : emitter_output_table, write_cb, |
1441 | cbopaque); |
1442 | emitter_begin(&emitter); |
1443 | emitter_table_printf(&emitter, "___ Begin jemalloc statistics ___\n" ); |
1444 | emitter_json_object_kv_begin(&emitter, "jemalloc" ); |
1445 | |
1446 | if (general) { |
1447 | stats_general_print(&emitter); |
1448 | } |
1449 | if (config_stats) { |
1450 | stats_print_helper(&emitter, merged, destroyed, unmerged, |
1451 | bins, large, mutex, extents); |
1452 | } |
1453 | |
1454 | emitter_json_object_end(&emitter); /* Closes the "jemalloc" dict. */ |
1455 | emitter_table_printf(&emitter, "--- End jemalloc statistics ---\n" ); |
1456 | emitter_end(&emitter); |
1457 | } |
1458 | |