forked from lttng/lttng-analyses
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcputop.py
executable file
·169 lines (153 loc) · 6.64 KB
/
cputop.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#!/usr/bin/env python3
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
import argparse
import operator
import sys
try:
from babeltrace import TraceCollection
except ImportError:
# quick fix for debian-based distros
sys.path.append("/usr/local/lib/python%d.%d/site-packages" %
(sys.version_info.major, sys.version_info.minor))
from babeltrace import TraceCollection
from LTTngAnalyzes.common import NSEC_PER_SEC, ns_to_asctime
from LTTngAnalyzes.state import State
from LTTngAnalyzes.progressbar import progressbar_setup, progressbar_update, \
progressbar_finish
from ascii_graph import Pyasciigraph
class CPUTop():
def __init__(self, traces):
self.trace_start_ts = 0
self.trace_end_ts = 0
self.traces = traces
self.state = State()
def run(self, args):
"""Process the trace"""
self.current_sec = 0
self.start_ns = 0
self.end_ns = 0
progressbar_setup(self, args)
for event in self.traces.events:
progressbar_update(self, args)
if self.start_ns == 0:
self.start_ns = event.timestamp
if self.trace_start_ts == 0:
self.trace_start_ts = event.timestamp
self.end_ns = event.timestamp
self.check_refresh(args, event)
self.trace_end_ts = event.timestamp
if event.name == "sched_switch":
self.state.sched.switch(event)
elif event.name == "sched_migrate_task":
self.state.sched.migrate_task(event)
progressbar_finish(self, args)
if args.refresh == 0:
# stats for the whole trace
self.compute_stats()
self.output(args, self.trace_start_ts, self.trace_end_ts, final=1)
else:
# stats only for the last segment
self.compute_stats()
self.output(args, self.start_ns, self.trace_end_ts,
final=1)
def check_refresh(self, args, event):
"""Check if we need to output something"""
if args.refresh == 0:
return
event_sec = event.timestamp / NSEC_PER_SEC
if self.current_sec == 0:
self.current_sec = event_sec
elif self.current_sec != event_sec and \
(self.current_sec + args.refresh) <= event_sec:
self.compute_stats()
self.output(args, self.start_ns, event.timestamp)
self.reset_total(event.timestamp)
self.current_sec = event_sec
self.start_ns = event.timestamp
def compute_stats(self):
for cpu in self.state.cpus.keys():
current_cpu = self.state.cpus[cpu]
total_ns = self.end_ns - self.start_ns
if current_cpu.start_task_ns != 0:
current_cpu.cpu_ns += self.end_ns - current_cpu.start_task_ns
cpu_total_ns = current_cpu.cpu_ns
current_cpu.cpu_pc = (cpu_total_ns * 100)/total_ns
if current_cpu.current_tid >= 0:
self.state.tids[current_cpu.current_tid].cpu_ns += \
self.end_ns - current_cpu.start_task_ns
def output(self, args, begin_ns, end_ns, final=0):
count = 0
limit = args.top
total_ns = end_ns - begin_ns
graph = Pyasciigraph()
values = []
print('%s to %s' % (ns_to_asctime(begin_ns), ns_to_asctime(end_ns)))
for tid in sorted(self.state.tids.values(),
key=operator.attrgetter('cpu_ns'), reverse=True):
if len(args.proc_list) > 0 and tid.comm not in args.proc_list:
continue
pc = float("%0.02f" % ((tid.cpu_ns * 100) / total_ns))
if tid.migrate_count > 0:
migrations = ", %d migrations" % (tid.migrate_count)
else:
migrations = ""
values.append(("%s (%d)%s" % (tid.comm, tid.tid, migrations), pc))
count = count + 1
if limit > 0 and count >= limit:
break
for line in graph.graph("Per-TID CPU Usage", values, unit=" %"):
print(line)
values = []
total_cpu_pc = 0
for cpu in sorted(self.state.cpus.values(),
key=operator.attrgetter('cpu_ns'), reverse=True):
cpu_pc = float("%0.02f" % cpu.cpu_pc)
total_cpu_pc += cpu_pc
values.append(("CPU %d" % cpu.cpu_id, cpu_pc))
for line in graph.graph("Per-CPU Usage", values, unit=" %"):
print(line)
print("\nTotal CPU Usage: %0.02f%%\n" %
(total_cpu_pc / len(self.state.cpus.keys())))
def reset_total(self, start_ts):
for cpu in self.state.cpus.keys():
current_cpu = self.state.cpus[cpu]
current_cpu.cpu_ns = 0
if current_cpu.start_task_ns != 0:
current_cpu.start_task_ns = start_ts
if current_cpu.current_tid >= 0:
self.state.tids[current_cpu.current_tid].last_sched = start_ts
for tid in self.state.tids.keys():
self.state.tids[tid].cpu_ns = 0
self.state.tids[tid].migrate_count = 0
self.state.tids[tid].read = 0
self.state.tids[tid].write = 0
for syscall in self.state.tids[tid].syscalls.keys():
self.state.tids[tid].syscalls[syscall].count = 0
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='CPU usage analysis')
parser.add_argument('path', metavar="<path/to/trace>", help='Trace path')
parser.add_argument('-r', '--refresh', type=int,
help='Refresh period in seconds', default=0)
parser.add_argument('--top', type=int, default=10,
help='Limit to top X TIDs (default = 10)')
parser.add_argument('--no-progress', action="store_true",
help='Don\'t display the progress bar')
args = parser.parse_args()
args.proc_list = []
traces = TraceCollection()
handle = traces.add_traces_recursive(args.path, "ctf")
if handle is None:
sys.exit(1)
c = CPUTop(traces)
c.run(args)
for h in handle.values():
traces.remove_trace(h)