Commit | Line | Data |
---|---|---|
ea251d51 | 1 | #include <math.h> |
2c5d4b4a | 2 | #include <linux/compiler.h> |
ea251d51 NK |
3 | |
4 | #include "../util/hist.h" | |
5 | #include "../util/util.h" | |
6 | #include "../util/sort.h" | |
4fb71074 | 7 | #include "../util/evsel.h" |
ea251d51 NK |
8 | |
9 | /* hist period print (hpp) functions */ | |
ea251d51 | 10 | |
a0088adc NK |
11 | #define hpp__call_print_fn(hpp, fn, fmt, ...) \ |
12 | ({ \ | |
13 | int __ret = fn(hpp, fmt, ##__VA_ARGS__); \ | |
14 | advance_hpp(hpp, __ret); \ | |
15 | __ret; \ | |
16 | }) | |
17 | ||
4a62109f | 18 | int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he, |
fb821c9e NK |
19 | hpp_field_fn get_field, const char *fmt, |
20 | hpp_snprint_fn print_fn, bool fmt_percent) | |
ea251d51 | 21 | { |
fb821c9e | 22 | int ret; |
b5ff71c3 | 23 | struct hists *hists = he->hists; |
759ff497 | 24 | struct perf_evsel *evsel = hists_to_evsel(hists); |
a0088adc NK |
25 | char *buf = hpp->buf; |
26 | size_t size = hpp->size; | |
ea251d51 | 27 | |
0c5268bf JO |
28 | if (fmt_percent) { |
29 | double percent = 0.0; | |
f2148330 | 30 | u64 total = hists__total_period(hists); |
9ffad987 | 31 | |
f2148330 NK |
32 | if (total) |
33 | percent = 100.0 * get_field(he) / total; | |
0c5268bf | 34 | |
fb821c9e | 35 | ret = hpp__call_print_fn(hpp, print_fn, fmt, percent); |
0c5268bf | 36 | } else |
fb821c9e | 37 | ret = hpp__call_print_fn(hpp, print_fn, fmt, get_field(he)); |
5b9e2146 | 38 | |
759ff497 | 39 | if (perf_evsel__is_group_event(evsel)) { |
5b9e2146 | 40 | int prev_idx, idx_delta; |
5b9e2146 NK |
41 | struct hist_entry *pair; |
42 | int nr_members = evsel->nr_members; | |
43 | ||
5b9e2146 NK |
44 | prev_idx = perf_evsel__group_idx(evsel); |
45 | ||
46 | list_for_each_entry(pair, &he->pairs.head, pairs.node) { | |
47 | u64 period = get_field(pair); | |
f2148330 | 48 | u64 total = hists__total_period(pair->hists); |
5b9e2146 NK |
49 | |
50 | if (!total) | |
51 | continue; | |
52 | ||
53 | evsel = hists_to_evsel(pair->hists); | |
54 | idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1; | |
55 | ||
56 | while (idx_delta--) { | |
57 | /* | |
58 | * zero-fill group members in the middle which | |
59 | * have no sample | |
60 | */ | |
9b0d2fb8 | 61 | if (fmt_percent) { |
a0088adc NK |
62 | ret += hpp__call_print_fn(hpp, print_fn, |
63 | fmt, 0.0); | |
9b0d2fb8 | 64 | } else { |
a0088adc NK |
65 | ret += hpp__call_print_fn(hpp, print_fn, |
66 | fmt, 0ULL); | |
9b0d2fb8 | 67 | } |
5b9e2146 NK |
68 | } |
69 | ||
a0088adc NK |
70 | if (fmt_percent) { |
71 | ret += hpp__call_print_fn(hpp, print_fn, fmt, | |
72 | 100.0 * period / total); | |
73 | } else { | |
74 | ret += hpp__call_print_fn(hpp, print_fn, fmt, | |
75 | period); | |
76 | } | |
5b9e2146 NK |
77 | |
78 | prev_idx = perf_evsel__group_idx(evsel); | |
79 | } | |
80 | ||
81 | idx_delta = nr_members - prev_idx - 1; | |
82 | ||
83 | while (idx_delta--) { | |
84 | /* | |
85 | * zero-fill group members at last which have no sample | |
86 | */ | |
9b0d2fb8 | 87 | if (fmt_percent) { |
a0088adc NK |
88 | ret += hpp__call_print_fn(hpp, print_fn, |
89 | fmt, 0.0); | |
9b0d2fb8 | 90 | } else { |
a0088adc NK |
91 | ret += hpp__call_print_fn(hpp, print_fn, |
92 | fmt, 0ULL); | |
9b0d2fb8 | 93 | } |
5b9e2146 NK |
94 | } |
95 | } | |
a0088adc NK |
96 | |
97 | /* | |
98 | * Restore original buf and size as it's where caller expects | |
99 | * the result will be saved. | |
100 | */ | |
101 | hpp->buf = buf; | |
102 | hpp->size = size; | |
103 | ||
4fb71074 | 104 | return ret; |
ea251d51 NK |
105 | } |
106 | ||
f156d84e NK |
107 | static int field_cmp(u64 field_a, u64 field_b) |
108 | { | |
109 | if (field_a > field_b) | |
110 | return 1; | |
111 | if (field_a < field_b) | |
112 | return -1; | |
113 | return 0; | |
114 | } | |
115 | ||
116 | static int __hpp__sort(struct hist_entry *a, struct hist_entry *b, | |
117 | hpp_field_fn get_field) | |
118 | { | |
119 | s64 ret; | |
120 | int i, nr_members; | |
121 | struct perf_evsel *evsel; | |
122 | struct hist_entry *pair; | |
123 | u64 *fields_a, *fields_b; | |
124 | ||
125 | ret = field_cmp(get_field(a), get_field(b)); | |
126 | if (ret || !symbol_conf.event_group) | |
127 | return ret; | |
128 | ||
129 | evsel = hists_to_evsel(a->hists); | |
130 | if (!perf_evsel__is_group_event(evsel)) | |
131 | return ret; | |
132 | ||
133 | nr_members = evsel->nr_members; | |
134 | fields_a = calloc(sizeof(*fields_a), nr_members); | |
135 | fields_b = calloc(sizeof(*fields_b), nr_members); | |
136 | ||
137 | if (!fields_a || !fields_b) | |
138 | goto out; | |
139 | ||
140 | list_for_each_entry(pair, &a->pairs.head, pairs.node) { | |
141 | evsel = hists_to_evsel(pair->hists); | |
142 | fields_a[perf_evsel__group_idx(evsel)] = get_field(pair); | |
143 | } | |
144 | ||
145 | list_for_each_entry(pair, &b->pairs.head, pairs.node) { | |
146 | evsel = hists_to_evsel(pair->hists); | |
147 | fields_b[perf_evsel__group_idx(evsel)] = get_field(pair); | |
148 | } | |
149 | ||
150 | for (i = 1; i < nr_members; i++) { | |
151 | ret = field_cmp(fields_a[i], fields_b[i]); | |
152 | if (ret) | |
153 | break; | |
154 | } | |
155 | ||
156 | out: | |
157 | free(fields_a); | |
158 | free(fields_b); | |
159 | ||
160 | return ret; | |
161 | } | |
162 | ||
4fb71074 | 163 | #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ |
2c5d4b4a | 164 | static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ |
94a0793d NK |
165 | struct perf_hpp *hpp, \ |
166 | struct perf_evsel *evsel) \ | |
4fb71074 NK |
167 | { \ |
168 | int len = _min_width; \ | |
169 | \ | |
94a0793d | 170 | if (symbol_conf.event_group) \ |
5b9e2146 | 171 | len = max(len, evsel->nr_members * _unit_width); \ |
94a0793d | 172 | \ |
4fb71074 | 173 | return scnprintf(hpp->buf, hpp->size, "%*s", len, _str); \ |
ea251d51 NK |
174 | } |
175 | ||
4fb71074 | 176 | #define __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ |
2c5d4b4a | 177 | static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ |
94a0793d NK |
178 | struct perf_hpp *hpp __maybe_unused, \ |
179 | struct perf_evsel *evsel) \ | |
4fb71074 NK |
180 | { \ |
181 | int len = _min_width; \ | |
182 | \ | |
94a0793d | 183 | if (symbol_conf.event_group) \ |
5b9e2146 | 184 | len = max(len, evsel->nr_members * _unit_width); \ |
94a0793d | 185 | \ |
4fb71074 | 186 | return len; \ |
ea251d51 NK |
187 | } |
188 | ||
a0088adc NK |
189 | static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) |
190 | { | |
191 | va_list args; | |
192 | ssize_t ssize = hpp->size; | |
193 | double percent; | |
194 | int ret; | |
195 | ||
196 | va_start(args, fmt); | |
197 | percent = va_arg(args, double); | |
198 | ret = value_color_snprintf(hpp->buf, hpp->size, fmt, percent); | |
199 | va_end(args); | |
200 | ||
201 | return (ret >= ssize) ? (ssize - 1) : ret; | |
202 | } | |
203 | ||
204 | static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) | |
205 | { | |
206 | va_list args; | |
207 | ssize_t ssize = hpp->size; | |
208 | int ret; | |
209 | ||
210 | va_start(args, fmt); | |
211 | ret = vsnprintf(hpp->buf, hpp->size, fmt, args); | |
212 | va_end(args); | |
213 | ||
214 | return (ret >= ssize) ? (ssize - 1) : ret; | |
215 | } | |
216 | ||
4fb71074 NK |
217 | #define __HPP_COLOR_PERCENT_FN(_type, _field) \ |
218 | static u64 he_get_##_field(struct hist_entry *he) \ | |
219 | { \ | |
220 | return he->stat._field; \ | |
221 | } \ | |
222 | \ | |
2c5d4b4a JO |
223 | static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ |
224 | struct perf_hpp *hpp, struct hist_entry *he) \ | |
4fb71074 | 225 | { \ |
fb821c9e | 226 | return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%", \ |
a0088adc | 227 | hpp_color_scnprintf, true); \ |
ea251d51 NK |
228 | } |
229 | ||
4fb71074 | 230 | #define __HPP_ENTRY_PERCENT_FN(_type, _field) \ |
2c5d4b4a JO |
231 | static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ |
232 | struct perf_hpp *hpp, struct hist_entry *he) \ | |
4fb71074 NK |
233 | { \ |
234 | const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \ | |
fb821c9e | 235 | return __hpp__fmt(hpp, he, he_get_##_field, fmt, \ |
a0088adc | 236 | hpp_entry_scnprintf, true); \ |
ea251d51 NK |
237 | } |
238 | ||
bc18b7f2 NK |
239 | #define __HPP_SORT_FN(_type, _field) \ |
240 | static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ | |
241 | { \ | |
f156d84e | 242 | return __hpp__sort(a, b, he_get_##_field); \ |
bc18b7f2 NK |
243 | } |
244 | ||
4fb71074 NK |
245 | #define __HPP_ENTRY_RAW_FN(_type, _field) \ |
246 | static u64 he_get_raw_##_field(struct hist_entry *he) \ | |
247 | { \ | |
248 | return he->stat._field; \ | |
249 | } \ | |
250 | \ | |
2c5d4b4a JO |
251 | static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ |
252 | struct perf_hpp *hpp, struct hist_entry *he) \ | |
4fb71074 NK |
253 | { \ |
254 | const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64; \ | |
fb821c9e | 255 | return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, \ |
a0088adc | 256 | hpp_entry_scnprintf, false); \ |
ea251d51 NK |
257 | } |
258 | ||
bc18b7f2 NK |
259 | #define __HPP_SORT_RAW_FN(_type, _field) \ |
260 | static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ | |
261 | { \ | |
f156d84e | 262 | return __hpp__sort(a, b, he_get_raw_##_field); \ |
bc18b7f2 NK |
263 | } |
264 | ||
265 | ||
4fb71074 NK |
266 | #define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width) \ |
267 | __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ | |
268 | __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ | |
269 | __HPP_COLOR_PERCENT_FN(_type, _field) \ | |
bc18b7f2 NK |
270 | __HPP_ENTRY_PERCENT_FN(_type, _field) \ |
271 | __HPP_SORT_FN(_type, _field) | |
ea251d51 | 272 | |
4fb71074 NK |
273 | #define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width) \ |
274 | __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ | |
275 | __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ | |
bc18b7f2 NK |
276 | __HPP_ENTRY_RAW_FN(_type, _field) \ |
277 | __HPP_SORT_RAW_FN(_type, _field) | |
ea251d51 | 278 | |
b5ff71c3 | 279 | |
4fb71074 NK |
280 | HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8) |
281 | HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8) | |
282 | HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8) | |
283 | HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8) | |
284 | HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8) | |
ea251d51 | 285 | |
4fb71074 NK |
286 | HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12) |
287 | HPP_RAW_FNS(period, "Period", period, 12, 12) | |
9ffad987 | 288 | |
bc18b7f2 NK |
289 | static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused, |
290 | struct hist_entry *b __maybe_unused) | |
291 | { | |
292 | return 0; | |
293 | } | |
294 | ||
1240005e JO |
295 | #define HPP__COLOR_PRINT_FNS(_name) \ |
296 | { \ | |
297 | .header = hpp__header_ ## _name, \ | |
298 | .width = hpp__width_ ## _name, \ | |
299 | .color = hpp__color_ ## _name, \ | |
bc18b7f2 NK |
300 | .entry = hpp__entry_ ## _name, \ |
301 | .cmp = hpp__nop_cmp, \ | |
302 | .collapse = hpp__nop_cmp, \ | |
303 | .sort = hpp__sort_ ## _name, \ | |
1240005e | 304 | } |
ea251d51 | 305 | |
1240005e JO |
306 | #define HPP__PRINT_FNS(_name) \ |
307 | { \ | |
308 | .header = hpp__header_ ## _name, \ | |
309 | .width = hpp__width_ ## _name, \ | |
bc18b7f2 NK |
310 | .entry = hpp__entry_ ## _name, \ |
311 | .cmp = hpp__nop_cmp, \ | |
312 | .collapse = hpp__nop_cmp, \ | |
313 | .sort = hpp__sort_ ## _name, \ | |
1240005e | 314 | } |
ea251d51 NK |
315 | |
316 | struct perf_hpp_fmt perf_hpp__format[] = { | |
1240005e JO |
317 | HPP__COLOR_PRINT_FNS(overhead), |
318 | HPP__COLOR_PRINT_FNS(overhead_sys), | |
319 | HPP__COLOR_PRINT_FNS(overhead_us), | |
320 | HPP__COLOR_PRINT_FNS(overhead_guest_sys), | |
321 | HPP__COLOR_PRINT_FNS(overhead_guest_us), | |
322 | HPP__PRINT_FNS(samples), | |
345dc0b4 | 323 | HPP__PRINT_FNS(period) |
ea251d51 NK |
324 | }; |
325 | ||
1240005e | 326 | LIST_HEAD(perf_hpp__list); |
8b536999 | 327 | LIST_HEAD(perf_hpp__sort_list); |
1240005e | 328 | |
4fb71074 | 329 | |
ea251d51 NK |
330 | #undef HPP__COLOR_PRINT_FNS |
331 | #undef HPP__PRINT_FNS | |
332 | ||
4fb71074 NK |
333 | #undef HPP_PERCENT_FNS |
334 | #undef HPP_RAW_FNS | |
335 | ||
336 | #undef __HPP_HEADER_FN | |
337 | #undef __HPP_WIDTH_FN | |
338 | #undef __HPP_COLOR_PERCENT_FN | |
339 | #undef __HPP_ENTRY_PERCENT_FN | |
340 | #undef __HPP_ENTRY_RAW_FN | |
341 | ||
342 | ||
1d77822e | 343 | void perf_hpp__init(void) |
ea251d51 | 344 | { |
26d8b338 NK |
345 | struct list_head *list; |
346 | int i; | |
347 | ||
348 | for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { | |
a2ce067e NK |
349 | struct perf_hpp_fmt *fmt = &perf_hpp__format[i]; |
350 | ||
351 | INIT_LIST_HEAD(&fmt->list); | |
352 | ||
353 | /* sort_list may be linked by setup_sorting() */ | |
354 | if (fmt->sort_list.next == NULL) | |
355 | INIT_LIST_HEAD(&fmt->sort_list); | |
26d8b338 NK |
356 | } |
357 | ||
a7d945bc NK |
358 | /* |
359 | * If user specified field order, no need to setup default fields. | |
360 | */ | |
361 | if (field_order) | |
362 | return; | |
363 | ||
2b8bfa6b JO |
364 | perf_hpp__column_enable(PERF_HPP__OVERHEAD); |
365 | ||
ea251d51 | 366 | if (symbol_conf.show_cpu_utilization) { |
1240005e JO |
367 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS); |
368 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_US); | |
ea251d51 NK |
369 | |
370 | if (perf_guest) { | |
1240005e JO |
371 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS); |
372 | perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US); | |
ea251d51 NK |
373 | } |
374 | } | |
375 | ||
376 | if (symbol_conf.show_nr_samples) | |
1240005e | 377 | perf_hpp__column_enable(PERF_HPP__SAMPLES); |
ea251d51 NK |
378 | |
379 | if (symbol_conf.show_total_period) | |
1240005e | 380 | perf_hpp__column_enable(PERF_HPP__PERIOD); |
26d8b338 NK |
381 | |
382 | /* prepend overhead field for backward compatiblity. */ | |
383 | list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list; | |
384 | if (list_empty(list)) | |
385 | list_add(list, &perf_hpp__sort_list); | |
1d77822e | 386 | } |
ea251d51 | 387 | |
1240005e JO |
388 | void perf_hpp__column_register(struct perf_hpp_fmt *format) |
389 | { | |
390 | list_add_tail(&format->list, &perf_hpp__list); | |
391 | } | |
392 | ||
8b536999 NK |
393 | void perf_hpp__register_sort_field(struct perf_hpp_fmt *format) |
394 | { | |
395 | list_add_tail(&format->sort_list, &perf_hpp__sort_list); | |
396 | } | |
397 | ||
1240005e | 398 | void perf_hpp__column_enable(unsigned col) |
1d77822e JO |
399 | { |
400 | BUG_ON(col >= PERF_HPP__MAX_INDEX); | |
1240005e | 401 | perf_hpp__column_register(&perf_hpp__format[col]); |
ea251d51 NK |
402 | } |
403 | ||
26d8b338 NK |
404 | void perf_hpp__setup_output_field(void) |
405 | { | |
406 | struct perf_hpp_fmt *fmt; | |
407 | ||
408 | /* append sort keys to output field */ | |
409 | perf_hpp__for_each_sort_list(fmt) { | |
a7d945bc NK |
410 | if (!list_empty(&fmt->list)) |
411 | continue; | |
412 | ||
413 | /* | |
414 | * sort entry fields are dynamically created, | |
415 | * so they can share a same sort key even though | |
416 | * the list is empty. | |
417 | */ | |
418 | if (perf_hpp__is_sort_entry(fmt)) { | |
419 | struct perf_hpp_fmt *pos; | |
420 | ||
421 | perf_hpp__for_each_format(pos) { | |
422 | if (perf_hpp__same_sort_entry(pos, fmt)) | |
423 | goto next; | |
424 | } | |
425 | } | |
426 | ||
427 | perf_hpp__column_register(fmt); | |
428 | next: | |
429 | continue; | |
430 | } | |
431 | } | |
432 | ||
433 | void perf_hpp__append_sort_keys(void) | |
434 | { | |
435 | struct perf_hpp_fmt *fmt; | |
436 | ||
437 | /* append output fields to sort keys */ | |
438 | perf_hpp__for_each_format(fmt) { | |
439 | if (!list_empty(&fmt->sort_list)) | |
440 | continue; | |
441 | ||
442 | /* | |
443 | * sort entry fields are dynamically created, | |
444 | * so they can share a same sort key even though | |
445 | * the list is empty. | |
446 | */ | |
447 | if (perf_hpp__is_sort_entry(fmt)) { | |
448 | struct perf_hpp_fmt *pos; | |
449 | ||
450 | perf_hpp__for_each_sort_list(pos) { | |
451 | if (perf_hpp__same_sort_entry(pos, fmt)) | |
452 | goto next; | |
453 | } | |
454 | } | |
455 | ||
456 | perf_hpp__register_sort_field(fmt); | |
457 | next: | |
458 | continue; | |
26d8b338 NK |
459 | } |
460 | } | |
461 | ||
ea251d51 NK |
462 | int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size, |
463 | struct hists *hists) | |
464 | { | |
465 | const char *sep = symbol_conf.field_sep; | |
466 | struct sort_entry *se; | |
467 | int ret = 0; | |
468 | ||
469 | list_for_each_entry(se, &hist_entry__sort_list, list) { | |
470 | if (se->elide) | |
471 | continue; | |
472 | ||
473 | ret += scnprintf(s + ret, size - ret, "%s", sep ?: " "); | |
474 | ret += se->se_snprintf(he, s + ret, size - ret, | |
475 | hists__col_len(hists, se->se_width_idx)); | |
476 | } | |
477 | ||
478 | return ret; | |
479 | } | |
7e62ef44 NK |
480 | |
481 | /* | |
482 | * See hists__fprintf to match the column widths | |
483 | */ | |
484 | unsigned int hists__sort_list_width(struct hists *hists) | |
485 | { | |
1240005e | 486 | struct perf_hpp_fmt *fmt; |
7e62ef44 | 487 | struct sort_entry *se; |
1240005e | 488 | int i = 0, ret = 0; |
94a0793d | 489 | struct perf_hpp dummy_hpp; |
7e62ef44 | 490 | |
1240005e | 491 | perf_hpp__for_each_format(fmt) { |
7e62ef44 NK |
492 | if (i) |
493 | ret += 2; | |
494 | ||
94a0793d | 495 | ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists)); |
7e62ef44 NK |
496 | } |
497 | ||
498 | list_for_each_entry(se, &hist_entry__sort_list, list) | |
499 | if (!se->elide) | |
500 | ret += 2 + hists__col_len(hists, se->se_width_idx); | |
501 | ||
502 | if (verbose) /* Addr + origin */ | |
503 | ret += 3 + BITS_PER_LONG / 4; | |
504 | ||
505 | return ret; | |
506 | } |