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