Alexey Ivanov | cc01a9c | 2019-01-16 09:50:46 -0800 | [diff] [blame] | 1 | #!/usr/bin/python |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 2 | # @lint-avoid-python-3-compatibility-imports |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 3 | # |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 4 | # hardirqs Summarize hard IRQ (interrupt) event time. |
| 5 | # For Linux, uses BCC, eBPF. |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 6 | # |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 7 | # USAGE: hardirqs [-h] [-T] [-N] [-C] [-d] [-c CPU] [interval] [outputs] |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 8 | # |
| 9 | # Thanks Amer Ather for help understanding irq behavior. |
| 10 | # |
| 11 | # Copyright (c) 2015 Brendan Gregg. |
| 12 | # Licensed under the Apache License, Version 2.0 (the "License") |
| 13 | # |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 14 | # 19-Oct-2015 Brendan Gregg Created this. |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 15 | # 22-May-2021 Hengqi Chen Migrated to kernel tracepoints. |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 16 | # 07-Mar-2022 Rocky Xing Added CPU filter support. |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 17 | |
| 18 | from __future__ import print_function |
| 19 | from bcc import BPF |
| 20 | from time import sleep, strftime |
| 21 | import argparse |
xingfeng2510 | 7b2c114 | 2022-03-24 10:51:26 +0800 | [diff] [blame] | 22 | import sys |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 23 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 24 | # arguments |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 25 | examples = """examples: |
| 26 | ./hardirqs # sum hard irq event time |
| 27 | ./hardirqs -d # show hard irq event time as histograms |
| 28 | ./hardirqs 1 10 # print 1 second summaries, 10 times |
| 29 | ./hardirqs -NT 1 # 1s summaries, nanoseconds, and timestamps |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 30 | ./hardirqs -c 1 # sum hard irq event time on CPU 1 only |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 31 | """ |
| 32 | parser = argparse.ArgumentParser( |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 33 | description="Summarize hard irq event time as histograms", |
| 34 | formatter_class=argparse.RawDescriptionHelpFormatter, |
| 35 | epilog=examples) |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 36 | parser.add_argument("-T", "--timestamp", action="store_true", |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 37 | help="include timestamp on output") |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 38 | parser.add_argument("-N", "--nanoseconds", action="store_true", |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 39 | help="output in nanoseconds") |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 40 | parser.add_argument("-C", "--count", action="store_true", |
| 41 | help="show event counts instead of timing") |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 42 | parser.add_argument("-d", "--dist", action="store_true", |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 43 | help="show distributions as histograms") |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 44 | parser.add_argument("-c", "--cpu", type=int, |
| 45 | help="trace this CPU only") |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 46 | parser.add_argument("interval", nargs="?", default=99999999, |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 47 | help="output interval, in seconds") |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 48 | parser.add_argument("outputs", nargs="?", default=99999999, |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 49 | help="number of outputs") |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 50 | parser.add_argument("--ebpf", action="store_true", |
| 51 | help=argparse.SUPPRESS) |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 52 | args = parser.parse_args() |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 53 | countdown = int(args.outputs) |
| 54 | if args.count and (args.dist or args.nanoseconds): |
| 55 | print("The --count option can't be used with time-based options") |
| 56 | exit() |
| 57 | if args.count: |
| 58 | factor = 1 |
| 59 | label = "count" |
| 60 | elif args.nanoseconds: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 61 | factor = 1 |
| 62 | label = "nsecs" |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 63 | else: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 64 | factor = 1000 |
| 65 | label = "usecs" |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 66 | debug = 0 |
| 67 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 68 | # define BPF program |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 69 | bpf_text = """ |
| 70 | #include <uapi/linux/ptrace.h> |
| 71 | #include <linux/irq.h> |
| 72 | #include <linux/irqdesc.h> |
| 73 | #include <linux/interrupt.h> |
| 74 | |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 75 | // Add cpu_id as part of key for irq entry event to handle the case which irq |
| 76 | // is triggered while idle thread(swapper/x, tid=0) for each cpu core. |
| 77 | // Please see more detail at pull request #2804, #3733. |
| 78 | typedef struct entry_key { |
| 79 | u32 tid; |
| 80 | u32 cpu_id; |
| 81 | } entry_key_t; |
| 82 | |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 83 | typedef struct irq_key { |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 84 | char name[32]; |
| 85 | u64 slot; |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 86 | } irq_key_t; |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 87 | |
| 88 | typedef struct irq_name { |
| 89 | char name[32]; |
| 90 | } irq_name_t; |
| 91 | |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 92 | BPF_HASH(start, entry_key_t); |
| 93 | BPF_HASH(irqnames, entry_key_t, irq_name_t); |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 94 | BPF_HISTOGRAM(dist, irq_key_t); |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 95 | """ |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 96 | |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 97 | bpf_text_count = """ |
| 98 | TRACEPOINT_PROBE(irq, irq_handler_entry) |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 99 | { |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 100 | struct entry_key key = {}; |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 101 | irq_name_t name = {}; |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 102 | u32 cpu = bpf_get_smp_processor_id(); |
| 103 | |
| 104 | FILTER_CPU |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 105 | |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 106 | key.tid = bpf_get_current_pid_tgid(); |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 107 | key.cpu_id = cpu; |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 108 | |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 109 | TP_DATA_LOC_READ_STR(&name.name, name, sizeof(name)); |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 110 | irqnames.update(&key, &name); |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | TRACEPOINT_PROBE(irq, irq_handler_exit) |
| 115 | { |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 116 | struct entry_key key = {}; |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 117 | u32 cpu = bpf_get_smp_processor_id(); |
| 118 | |
| 119 | FILTER_CPU |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 120 | |
| 121 | key.tid = bpf_get_current_pid_tgid(); |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 122 | key.cpu_id = cpu; |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 123 | |
| 124 | // check ret value of irq handler is not IRQ_NONE to make sure |
| 125 | // the current event belong to this irq handler |
| 126 | if (args->ret != IRQ_NONE) { |
| 127 | irq_name_t *namep; |
| 128 | |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 129 | namep = irqnames.lookup(&key); |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 130 | if (namep == 0) { |
| 131 | return 0; // missed irq name |
| 132 | } |
| 133 | char *name = (char *)namep->name; |
| 134 | irq_key_t key = {.slot = 0 /* ignore */}; |
| 135 | |
| 136 | bpf_probe_read_kernel(&key.name, sizeof(key.name), name); |
| 137 | dist.atomic_increment(key); |
| 138 | } |
| 139 | |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 140 | irqnames.delete(&key); |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 141 | return 0; |
| 142 | } |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 143 | """ |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 144 | |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 145 | bpf_text_time = """ |
| 146 | TRACEPOINT_PROBE(irq, irq_handler_entry) |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 147 | { |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 148 | u64 ts = bpf_ktime_get_ns(); |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 149 | irq_name_t name = {}; |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 150 | struct entry_key key = {}; |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 151 | u32 cpu = bpf_get_smp_processor_id(); |
| 152 | |
| 153 | FILTER_CPU |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 154 | |
| 155 | key.tid = bpf_get_current_pid_tgid(); |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 156 | key.cpu_id = cpu; |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 157 | |
Hengqi Chen | 2cffe36 | 2021-11-22 21:54:51 +0800 | [diff] [blame] | 158 | TP_DATA_LOC_READ_STR(&name.name, name, sizeof(name)); |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 159 | irqnames.update(&key, &name); |
| 160 | start.update(&key, &ts); |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 161 | return 0; |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 162 | } |
| 163 | |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 164 | TRACEPOINT_PROBE(irq, irq_handler_exit) |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 165 | { |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 166 | u64 *tsp, delta; |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 167 | irq_name_t *namep; |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 168 | struct entry_key key = {}; |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 169 | u32 cpu = bpf_get_smp_processor_id(); |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 170 | |
| 171 | key.tid = bpf_get_current_pid_tgid(); |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 172 | key.cpu_id = cpu; |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 173 | |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 174 | // check ret value of irq handler is not IRQ_NONE to make sure |
| 175 | // the current event belong to this irq handler |
| 176 | if (args->ret != IRQ_NONE) { |
| 177 | // fetch timestamp and calculate delta |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 178 | tsp = start.lookup(&key); |
| 179 | namep = irqnames.lookup(&key); |
Ism Hong | 814c264 | 2021-12-06 11:28:34 +0800 | [diff] [blame] | 180 | if (tsp == 0 || namep == 0) { |
| 181 | return 0; // missed start |
| 182 | } |
| 183 | |
| 184 | char *name = (char *)namep->name; |
| 185 | delta = bpf_ktime_get_ns() - *tsp; |
| 186 | |
| 187 | // store as sum or histogram |
| 188 | STORE |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 189 | } |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 190 | |
Ism Hong | 99bfe8a | 2021-12-08 10:17:20 +0800 | [diff] [blame] | 191 | start.delete(&key); |
| 192 | irqnames.delete(&key); |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 193 | return 0; |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 194 | } |
| 195 | """ |
| 196 | |
Hengqi Chen | e6aa65e | 2021-05-22 16:07:36 +0800 | [diff] [blame] | 197 | if args.count: |
| 198 | bpf_text += bpf_text_count |
| 199 | else: |
| 200 | bpf_text += bpf_text_time |
| 201 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 202 | # code substitutions |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 203 | if args.dist: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 204 | bpf_text = bpf_text.replace('STORE', |
Kirill Smelkov | f2d125e | 2017-09-25 11:23:03 +0300 | [diff] [blame] | 205 | 'irq_key_t key = {.slot = bpf_log2l(delta / %d)};' % factor + |
Sumanth Korikkar | 7f6066d | 2020-05-20 10:49:56 -0500 | [diff] [blame] | 206 | 'bpf_probe_read_kernel(&key.name, sizeof(key.name), name);' + |
zcy | 80242fb | 2021-07-02 00:12:32 +0800 | [diff] [blame] | 207 | 'dist.atomic_increment(key);') |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 208 | else: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 209 | bpf_text = bpf_text.replace('STORE', |
| 210 | 'irq_key_t key = {.slot = 0 /* ignore */};' + |
Sumanth Korikkar | 7f6066d | 2020-05-20 10:49:56 -0500 | [diff] [blame] | 211 | 'bpf_probe_read_kernel(&key.name, sizeof(key.name), name);' + |
zcy | 80242fb | 2021-07-02 00:12:32 +0800 | [diff] [blame] | 212 | 'dist.atomic_increment(key, delta);') |
xingfeng2510 | c5baa7b | 2022-03-07 17:35:49 +0800 | [diff] [blame] | 213 | if args.cpu is not None: |
| 214 | bpf_text = bpf_text.replace('FILTER_CPU', |
| 215 | 'if (cpu != %d) { return 0; }' % int(args.cpu)) |
| 216 | else: |
| 217 | bpf_text = bpf_text.replace('FILTER_CPU', '') |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 218 | if debug or args.ebpf: |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 219 | print(bpf_text) |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 220 | if args.ebpf: |
| 221 | exit() |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 222 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 223 | # load BPF program |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 224 | b = BPF(text=bpf_text) |
| 225 | |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 226 | if args.count: |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 227 | print("Tracing hard irq events... Hit Ctrl-C to end.") |
| 228 | else: |
Brendan Gregg | c32b845 | 2017-11-26 23:38:32 -0800 | [diff] [blame] | 229 | print("Tracing hard irq event time... Hit Ctrl-C to end.") |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 230 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 231 | # output |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 232 | exiting = 0 if args.interval else 1 |
| 233 | dist = b.get_table("dist") |
| 234 | while (1): |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 235 | try: |
| 236 | sleep(int(args.interval)) |
| 237 | except KeyboardInterrupt: |
| 238 | exiting = 1 |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 239 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 240 | print() |
| 241 | if args.timestamp: |
| 242 | print("%-8s\n" % strftime("%H:%M:%S"), end="") |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 243 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 244 | if args.dist: |
xingfeng2510 | 55dcd2e | 2022-03-13 18:13:57 +0800 | [diff] [blame] | 245 | dist.print_log2_hist(label, "hardirq", section_print_fn=bytes.decode) |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 246 | else: |
| 247 | print("%-26s %11s" % ("HARDIRQ", "TOTAL_" + label)) |
| 248 | for k, v in sorted(dist.items(), key=lambda dist: dist[1].value): |
jeromemarchand | b96ebcd | 2018-10-10 01:58:15 +0200 | [diff] [blame] | 249 | print("%-26s %11d" % (k.name.decode('utf-8', 'replace'), v.value / factor)) |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 250 | dist.clear() |
Brendan Gregg | 860b649 | 2015-10-20 15:52:23 -0700 | [diff] [blame] | 251 | |
xingfeng2510 | 7b2c114 | 2022-03-24 10:51:26 +0800 | [diff] [blame] | 252 | sys.stdout.flush() |
| 253 | |
Alexei Starovoitov | bdf0773 | 2016-01-14 10:09:20 -0800 | [diff] [blame] | 254 | countdown -= 1 |
| 255 | if exiting or countdown == 0: |
| 256 | exit() |