Linux Perf
compaction-times.py
Go to the documentation of this file.
1 # report time spent in compaction
2 # Licensed under the terms of the GNU GPL License version 2
3 
4 # testing:
5 # 'echo 1 > /proc/sys/vm/compact_memory' to force compaction of all zones
6 
7 import os
8 import sys
9 import re
10 
11 import signal
12 signal.signal(signal.SIGPIPE, signal.SIG_DFL)
13 
14 usage = "usage: perf script report compaction-times.py -- [-h] [-u] [-p|-pv] [-t | [-m] [-fs] [-ms]] [pid|pid-range|comm-regex]\n"
15 
16 class popt:
17  DISP_DFL = 0
18  DISP_PROC = 1
19  DISP_PROC_VERBOSE=2
20 
21 class topt:
22  DISP_TIME = 0
23  DISP_MIG = 1
24  DISP_ISOLFREE = 2
25  DISP_ISOLMIG = 4
26  DISP_ALL = 7
27 
29  def __init__(self, re):
30  self.re = re
31 
32  def filter(self, pid, comm):
33  m = self.re.search(comm)
34  return m == None or m.group() == ""
35 
36 class pid_filter:
37  def __init__(self, low, high):
38  self.low = (0 if low == "" else int(low))
39  self.high = (0 if high == "" else int(high))
40 
41  def filter(self, pid, comm):
42  return not (pid >= self.low and (self.high == 0 or pid <= self.high))
43 
44 def set_type(t):
45  global opt_disp
46  opt_disp = (t if opt_disp == topt.DISP_ALL else opt_disp|t)
47 
48 def ns(sec, nsec):
49  return (sec * 1000000000) + nsec
50 
51 def time(ns):
52  return "%dns" % ns if opt_ns else "%dus" % (round(ns, -3) / 1000)
53 
54 class pair:
55  def __init__(self, aval, bval, alabel = None, blabel = None):
56  self.alabel = alabel
57  self.blabel = blabel
58  self.aval = aval
59  self.bval = bval
60 
61  def __add__(self, rhs):
62  self.aval += rhs.aval
63  self.bval += rhs.bval
64  return self
65 
66  def __str__(self):
67  return "%s=%d %s=%d" % (self.alabel, self.aval, self.blabel, self.bval)
68 
69 class cnode:
70  def __init__(self, ns):
71  self.ns = ns
72  self.migrated = pair(0, 0, "moved", "failed")
73  self.fscan = pair(0,0, "scanned", "isolated")
74  self.mscan = pair(0,0, "scanned", "isolated")
75 
76  def __add__(self, rhs):
77  self.ns += rhs.ns
78  self.migrated += rhs.migrated
79  self.fscan += rhs.fscan
80  self.mscan += rhs.mscan
81  return self
82 
83  def __str__(self):
84  prev = 0
85  s = "%s " % time(self.ns)
86  if (opt_disp & topt.DISP_MIG):
87  s += "migration: %s" % self.migrated
88  prev = 1
89  if (opt_disp & topt.DISP_ISOLFREE):
90  s += "%sfree_scanner: %s" % (" " if prev else "", self.fscan)
91  prev = 1
92  if (opt_disp & topt.DISP_ISOLMIG):
93  s += "%smigration_scanner: %s" % (" " if prev else "", self.mscan)
94  return s
95 
96  def complete(self, secs, nsecs):
97  self.ns = ns(secs, nsecs) - self.ns
98 
99  def increment(self, migrated, fscan, mscan):
100  if (migrated != None):
101  self.migrated += migrated
102  if (fscan != None):
103  self.fscan += fscan
104  if (mscan != None):
105  self.mscan += mscan
106 
107 
108 class chead:
109  heads = {}
110  val = cnode(0);
111  fobj = None
112 
113  @classmethod
114  def add_filter(cls, filter):
115  cls.fobj = filter
116 
117  @classmethod
118  def create_pending(cls, pid, comm, start_secs, start_nsecs):
119  filtered = 0
120  try:
121  head = cls.heads[pid]
122  filtered = head.is_filtered()
123  except KeyError:
124  if cls.fobj != None:
125  filtered = cls.fobj.filter(pid, comm)
126  head = cls.heads[pid] = chead(comm, pid, filtered)
127 
128  if not filtered:
129  head.mark_pending(start_secs, start_nsecs)
130 
131  @classmethod
132  def increment_pending(cls, pid, migrated, fscan, mscan):
133  head = cls.heads[pid]
134  if not head.is_filtered():
135  if head.is_pending():
136  head.do_increment(migrated, fscan, mscan)
137  else:
138  sys.stderr.write("missing start compaction event for pid %d\n" % pid)
139 
140  @classmethod
141  def complete_pending(cls, pid, secs, nsecs):
142  head = cls.heads[pid]
143  if not head.is_filtered():
144  if head.is_pending():
145  head.make_complete(secs, nsecs)
146  else:
147  sys.stderr.write("missing start compaction event for pid %d\n" % pid)
148 
149  @classmethod
150  def gen(cls):
151  if opt_proc != popt.DISP_DFL:
152  for i in cls.heads:
153  yield cls.heads[i]
154 
155  @classmethod
156  def str(cls):
157  return cls.val
158 
159  def __init__(self, comm, pid, filtered):
160  self.comm = comm
161  self.pid = pid
162  self.val = cnode(0)
163  self.pending = None
164  self.filtered = filtered
165  self.list = []
166 
167  def __add__(self, rhs):
168  self.ns += rhs.ns
169  self.val += rhs.val
170  return self
171 
172  def mark_pending(self, secs, nsecs):
173  self.pending = cnode(ns(secs, nsecs))
174 
175  def do_increment(self, migrated, fscan, mscan):
176  self.pending.increment(migrated, fscan, mscan)
177 
178  def make_complete(self, secs, nsecs):
179  self.pending.complete(secs, nsecs)
180  chead.val += self.pending
181 
182  if opt_proc != popt.DISP_DFL:
183  self.val += self.pending
184 
185  if opt_proc == popt.DISP_PROC_VERBOSE:
186  self.list.append(self.pending)
187  self.pending = None
188 
189  def enumerate(self):
190  if opt_proc == popt.DISP_PROC_VERBOSE and not self.is_filtered():
191  for i, pelem in enumerate(self.list):
192  sys.stdout.write("%d[%s].%d: %s\n" % (self.pid, self.comm, i+1, pelem))
193 
194  def is_pending(self):
195  return self.pending != None
196 
197  def is_filtered(self):
198  return self.filtered
199 
200  def display(self):
201  if not self.is_filtered():
202  sys.stdout.write("%d[%s]: %s\n" % (self.pid, self.comm, self.val))
203 
204 
205 def trace_end():
206  sys.stdout.write("total: %s\n" % chead.str())
207  for i in chead.gen():
208  i.display(),
209  i.enumerate()
210 
211 def compaction__mm_compaction_migratepages(event_name, context, common_cpu,
212  common_secs, common_nsecs, common_pid, common_comm,
213  common_callchain, nr_migrated, nr_failed):
214 
215  chead.increment_pending(common_pid,
216  pair(nr_migrated, nr_failed), None, None)
217 
218 def compaction__mm_compaction_isolate_freepages(event_name, context, common_cpu,
219  common_secs, common_nsecs, common_pid, common_comm,
220  common_callchain, start_pfn, end_pfn, nr_scanned, nr_taken):
221 
222  chead.increment_pending(common_pid,
223  None, pair(nr_scanned, nr_taken), None)
224 
225 def compaction__mm_compaction_isolate_migratepages(event_name, context, common_cpu,
226  common_secs, common_nsecs, common_pid, common_comm,
227  common_callchain, start_pfn, end_pfn, nr_scanned, nr_taken):
228 
229  chead.increment_pending(common_pid,
230  None, None, pair(nr_scanned, nr_taken))
231 
232 def compaction__mm_compaction_end(event_name, context, common_cpu,
233  common_secs, common_nsecs, common_pid, common_comm,
234  common_callchain, zone_start, migrate_start, free_start, zone_end,
235  sync, status):
236 
237  chead.complete_pending(common_pid, common_secs, common_nsecs)
238 
239 def compaction__mm_compaction_begin(event_name, context, common_cpu,
240  common_secs, common_nsecs, common_pid, common_comm,
241  common_callchain, zone_start, migrate_start, free_start, zone_end,
242  sync):
243 
244  chead.create_pending(common_pid, common_comm, common_secs, common_nsecs)
245 
246 def pr_help():
247  global usage
248 
249  sys.stdout.write(usage)
250  sys.stdout.write("\n")
251  sys.stdout.write("-h display this help\n")
252  sys.stdout.write("-p display by process\n")
253  sys.stdout.write("-pv display by process (verbose)\n")
254  sys.stdout.write("-t display stall times only\n")
255  sys.stdout.write("-m display stats for migration\n")
256  sys.stdout.write("-fs display stats for free scanner\n")
257  sys.stdout.write("-ms display stats for migration scanner\n")
258  sys.stdout.write("-u display results in microseconds (default nanoseconds)\n")
259 
260 
261 comm_re = None
262 pid_re = None
263 pid_regex = "^(\d*)-(\d*)$|^(\d*)$"
264 
265 opt_proc = popt.DISP_DFL
266 opt_disp = topt.DISP_ALL
267 
268 opt_ns = True
269 
270 argc = len(sys.argv) - 1
271 if argc >= 1:
272  pid_re = re.compile(pid_regex)
273 
274  for i, opt in enumerate(sys.argv[1:]):
275  if opt[0] == "-":
276  if opt == "-h":
277  pr_help()
278  exit(0);
279  elif opt == "-p":
280  opt_proc = popt.DISP_PROC
281  elif opt == "-pv":
282  opt_proc = popt.DISP_PROC_VERBOSE
283  elif opt == '-u':
284  opt_ns = False
285  elif opt == "-t":
286  set_type(topt.DISP_TIME)
287  elif opt == "-m":
288  set_type(topt.DISP_MIG)
289  elif opt == "-fs":
290  set_type(topt.DISP_ISOLFREE)
291  elif opt == "-ms":
292  set_type(topt.DISP_ISOLMIG)
293  else:
294  sys.exit(usage)
295 
296  elif i == argc - 1:
297  m = pid_re.search(opt)
298  if m != None and m.group() != "":
299  if m.group(3) != None:
300  f = pid_filter(m.group(3), m.group(3))
301  else:
302  f = pid_filter(m.group(1), m.group(2))
303  else:
304  try:
305  comm_re=re.compile(opt)
306  except:
307  sys.stderr.write("invalid regex '%s'" % opt)
308  sys.exit(usage)
309  f = comm_filter(comm_re)
310 
311  chead.add_filter(f)
def compaction__mm_compaction_begin(event_name, context, common_cpu, common_secs, common_nsecs, common_pid, common_comm, common_callchain, zone_start, migrate_start, free_start, zone_end, sync)
def __init__(self, low, high)
def complete_pending(cls, pid, secs, nsecs)
def compaction__mm_compaction_end(event_name, context, common_cpu, common_secs, common_nsecs, common_pid, common_comm, common_callchain, zone_start, migrate_start, free_start, zone_end, sync, status)
def increment_pending(cls, pid, migrated, fscan, mscan)
def compaction__mm_compaction_isolate_freepages(event_name, context, common_cpu, common_secs, common_nsecs, common_pid, common_comm, common_callchain, start_pfn, end_pfn, nr_scanned, nr_taken)
def ns(sec, nsec)
def filter(self, pid, comm)
def __init__(self, comm, pid, filtered)
def increment(self, migrated, fscan, mscan)
def do_increment(self, migrated, fscan, mscan)
def __add__(self, rhs)
def complete(self, secs, nsecs)
struct strfilter * filter
Definition: builtin-probe.c:60
def filter(self, pid, comm)
def __init__(self, aval, bval, alabel=None, blabel=None)
def create_pending(cls, pid, comm, start_secs, start_nsecs)
def mark_pending(self, secs, nsecs)
def make_complete(self, secs, nsecs)
def compaction__mm_compaction_isolate_migratepages(event_name, context, common_cpu, common_secs, common_nsecs, common_pid, common_comm, common_callchain, start_pfn, end_pfn, nr_scanned, nr_taken)
def compaction__mm_compaction_migratepages(event_name, context, common_cpu, common_secs, common_nsecs, common_pid, common_comm, common_callchain, nr_migrated, nr_failed)
def add_filter(cls, filter)