tools/perf/scripts/python/sched-migration.py

   1 # Cpu task migration overview toy
   2 #
   3 # Copyright (C) 2010 Frederic Weisbecker <fweisbec@gmail.com>
   4 #
   5 # perf script event handlers have been generated by perf script -g python
   6 #
   7 # This software is distributed under the terms of the GNU General
   8 # Public License ("GPL") version 2 as published by the Free Software
   9 # Foundation.
  10 from __future__ import print_function
  11
  12 import os
  13 import sys
  14
  15 from collections import defaultdict
  16 try:
  17         from UserList import UserList
  18 except ImportError:
  19         # Python 3: UserList moved to the collections package
  20         from collections import UserList
  21
  22 sys.path.append(os.environ['PERF_EXEC_PATH'] + \
  23         '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
  24 sys.path.append('scripts/python/Perf-Trace-Util/lib/Perf/Trace')
  25
  26 from perf_trace_context import *
  27 from Core import *
  28 from SchedGui import *
  29
  30
  31 threads = { 0 : "idle"}
  32
  33 def thread_name(pid):
  34         return "%s:%d" % (threads[pid], pid)
  35
  36 class RunqueueEventUnknown:
  37         @staticmethod
  38         def color():
  39                 return None
  40
  41         def __repr__(self):
  42                 return "unknown"
  43
  44 class RunqueueEventSleep:
  45         @staticmethod
  46         def color():
  47                 return (0, 0, 0xff)
  48
  49         def __init__(self, sleeper):
  50                 self.sleeper = sleeper
  51
  52         def __repr__(self):
  53                 return "%s gone to sleep" % thread_name(self.sleeper)
  54
  55 class RunqueueEventWakeup:
  56         @staticmethod
  57         def color():
  58                 return (0xff, 0xff, 0)
  59
  60         def __init__(self, wakee):
  61                 self.wakee = wakee
  62
  63         def __repr__(self):
  64                 return "%s woke up" % thread_name(self.wakee)
  65
  66 class RunqueueEventFork:
  67         @staticmethod
  68         def color():
  69                 return (0, 0xff, 0)
  70
  71         def __init__(self, child):
  72                 self.child = child
  73
  74         def __repr__(self):
  75                 return "new forked task %s" % thread_name(self.child)
  76
  77 class RunqueueMigrateIn:
  78         @staticmethod
  79         def color():
  80                 return (0, 0xf0, 0xff)
  81
  82         def __init__(self, new):
  83                 self.new = new
  84
  85         def __repr__(self):
  86                 return "task migrated in %s" % thread_name(self.new)
  87
  88 class RunqueueMigrateOut:
  89         @staticmethod
  90         def color():
  91                 return (0xff, 0, 0xff)
  92
  93         def __init__(self, old):
  94                 self.old = old
  95
  96         def __repr__(self):
  97                 return "task migrated out %s" % thread_name(self.old)
  98
  99 class RunqueueSnapshot:
 100         def __init__(self, tasks = [0], event = RunqueueEventUnknown()):
 101                 self.tasks = tuple(tasks)
 102                 self.event = event
 103
 104         def sched_switch(self, prev, prev_state, next):
 105                 event = RunqueueEventUnknown()
 106
 107                 if taskState(prev_state) == "R" and next in self.tasks \
 108                         and prev in self.tasks:
 109                         return self
 110
 111                 if taskState(prev_state) != "R":
 112                         event = RunqueueEventSleep(prev)
 113
 114                 next_tasks = list(self.tasks[:])
 115                 if prev in self.tasks:
 116                         if taskState(prev_state) != "R":
 117                                 next_tasks.remove(prev)
 118                 elif taskState(prev_state) == "R":
 119                         next_tasks.append(prev)
 120
 121                 if next not in next_tasks:
 122                         next_tasks.append(next)
 123
 124                 return RunqueueSnapshot(next_tasks, event)
 125
 126         def migrate_out(self, old):
 127                 if old not in self.tasks:
 128                         return self
 129                 next_tasks = [task for task in self.tasks if task != old]
 130
 131                 return RunqueueSnapshot(next_tasks, RunqueueMigrateOut(old))
 132
 133         def __migrate_in(self, new, event):
 134                 if new in self.tasks:
 135                         self.event = event
 136                         return self
 137                 next_tasks = self.tasks[:] + tuple([new])
 138
 139                 return RunqueueSnapshot(next_tasks, event)
 140
 141         def migrate_in(self, new):
 142                 return self.__migrate_in(new, RunqueueMigrateIn(new))
 143
 144         def wake_up(self, new):
 145                 return self.__migrate_in(new, RunqueueEventWakeup(new))
 146
 147         def wake_up_new(self, new):
 148                 return self.__migrate_in(new, RunqueueEventFork(new))
 149
 150         def load(self):
 151                 """ Provide the number of tasks on the runqueue.
 152                     Don't count idle"""
 153                 return len(self.tasks) - 1
 154
 155         def __repr__(self):
 156                 ret = self.tasks.__repr__()
 157                 ret += self.origin_tostring()
 158
 159                 return ret
 160
 161 class TimeSlice:
 162         def __init__(self, start, prev):
 163                 self.start = start
 164                 self.prev = prev
 165                 self.end = start
 166                 # cpus that triggered the event
 167                 self.event_cpus = []
 168                 if prev is not None:
 169                         self.total_load = prev.total_load
 170                         self.rqs = prev.rqs.copy()
 171                 else:
 172                         self.rqs = defaultdict(RunqueueSnapshot)
 173                         self.total_load = 0
 174
 175         def __update_total_load(self, old_rq, new_rq):
 176                 diff = new_rq.load() - old_rq.load()
 177                 self.total_load += diff
 178
 179         def sched_switch(self, ts_list, prev, prev_state, next, cpu):
 180                 old_rq = self.prev.rqs[cpu]
 181                 new_rq = old_rq.sched_switch(prev, prev_state, next)
 182
 183                 if old_rq is new_rq:
 184                         return
 185
 186                 self.rqs[cpu] = new_rq
 187                 self.__update_total_load(old_rq, new_rq)
 188                 ts_list.append(self)
 189                 self.event_cpus = [cpu]
 190
 191         def migrate(self, ts_list, new, old_cpu, new_cpu):
 192                 if old_cpu == new_cpu:
 193                         return
 194                 old_rq = self.prev.rqs[old_cpu]
 195                 out_rq = old_rq.migrate_out(new)
 196                 self.rqs[old_cpu] = out_rq
 197                 self.__update_total_load(old_rq, out_rq)
 198
 199                 new_rq = self.prev.rqs[new_cpu]
 200                 in_rq = new_rq.migrate_in(new)
 201                 self.rqs[new_cpu] = in_rq
 202                 self.__update_total_load(new_rq, in_rq)
 203
 204                 ts_list.append(self)
 205
 206                 if old_rq is not out_rq:
 207                         self.event_cpus.append(old_cpu)
 208                 self.event_cpus.append(new_cpu)
 209
 210         def wake_up(self, ts_list, pid, cpu, fork):
 211                 old_rq = self.prev.rqs[cpu]
 212                 if fork:
 213                         new_rq = old_rq.wake_up_new(pid)
 214                 else:
 215                         new_rq = old_rq.wake_up(pid)
 216
 217                 if new_rq is old_rq:
 218                         return
 219                 self.rqs[cpu] = new_rq
 220                 self.__update_total_load(old_rq, new_rq)
 221                 ts_list.append(self)
 222                 self.event_cpus = [cpu]
 223
 224         def next(self, t):
 225                 self.end = t
 226                 return TimeSlice(t, self)
 227
 228 class TimeSliceList(UserList):
 229         def __init__(self, arg = []):
 230                 self.data = arg
 231
 232         def get_time_slice(self, ts):
 233                 if len(self.data) == 0:
 234                         slice = TimeSlice(ts, TimeSlice(-1, None))
 235                 else:
 236                         slice = self.data[-1].next(ts)
 237                 return slice
 238
 239         def find_time_slice(self, ts):
 240                 start = 0
 241                 end = len(self.data)
 242                 found = -1
 243                 searching = True
 244                 while searching:
 245                         if start == end or start == end - 1:
 246                                 searching = False
 247
 248                         i = (end + start) / 2
 249                         if self.data[i].start <= ts and self.data[i].end >= ts:
 250                                 found = i
 251                                 end = i
 252                                 continue
 253
 254                         if self.data[i].end < ts:
 255                                 start = i
 256
 257                         elif self.data[i].start > ts:
 258                                 end = i
 259
 260                 return found
 261
 262         def set_root_win(self, win):
 263                 self.root_win = win
 264
 265         def mouse_down(self, cpu, t):
 266                 idx = self.find_time_slice(t)
 267                 if idx == -1:
 268                         return
 269
 270                 ts = self[idx]
 271                 rq = ts.rqs[cpu]
 272                 raw = "CPU: %d\n" % cpu
 273                 raw += "Last event : %s\n" % rq.event.__repr__()
 274                 raw += "Timestamp : %d.%06d\n" % (ts.start / (10 ** 9), (ts.start % (10 ** 9)) / 1000)
 275                 raw += "Duration : %6d us\n" % ((ts.end - ts.start) / (10 ** 6))
 276                 raw += "Load = %d\n" % rq.load()
 277                 for t in rq.tasks:
 278                         raw += "%s \n" % thread_name(t)
 279
 280                 self.root_win.update_summary(raw)
 281
 282         def update_rectangle_cpu(self, slice, cpu):
 283                 rq = slice.rqs[cpu]
 284
 285                 if slice.total_load != 0:
 286                         load_rate = rq.load() / float(slice.total_load)
 287                 else:
 288                         load_rate = 0
 289
 290                 red_power = int(0xff - (0xff * load_rate))
 291                 color = (0xff, red_power, red_power)
 292
 293                 top_color = None
 294
 295                 if cpu in slice.event_cpus:
 296                         top_color = rq.event.color()
 297
 298                 self.root_win.paint_rectangle_zone(cpu, color, top_color, slice.start, slice.end)
 299
 300         def fill_zone(self, start, end):
 301                 i = self.find_time_slice(start)
 302                 if i == -1:
 303                         return
 304
 305                 for i in range(i, len(self.data)):
 306                         timeslice = self.data[i]
 307                         if timeslice.start > end:
 308                                 return
 309
 310                         for cpu in timeslice.rqs:
 311                                 self.update_rectangle_cpu(timeslice, cpu)
 312
 313         def interval(self):
 314                 if len(self.data) == 0:
 315                         return (0, 0)
 316
 317                 return (self.data[0].start, self.data[-1].end)
 318
 319         def nr_rectangles(self):
 320                 last_ts = self.data[-1]
 321                 max_cpu = 0
 322                 for cpu in last_ts.rqs:
 323                         if cpu > max_cpu:
 324                                 max_cpu = cpu
 325                 return max_cpu
 326
 327
 328 class SchedEventProxy:
 329         def __init__(self):
 330                 self.current_tsk = defaultdict(lambda : -1)
 331                 self.timeslices = TimeSliceList()
 332
 333         def sched_switch(self, headers, prev_comm, prev_pid, prev_prio, prev_state,
 334                          next_comm, next_pid, next_prio):
 335                 """ Ensure the task we sched out this cpu is really the one
 336                     we logged. Otherwise we may have missed traces """
 337
 338                 on_cpu_task = self.current_tsk[headers.cpu]
 339
 340                 if on_cpu_task != -1 and on_cpu_task != prev_pid:
 341                         print("Sched switch event rejected ts: %s cpu: %d prev: %s(%d) next: %s(%d)" % \
 342                                 headers.ts_format(), headers.cpu, prev_comm, prev_pid, next_comm, next_pid)
 343
 344                 threads[prev_pid] = prev_comm
 345                 threads[next_pid] = next_comm
 346                 self.current_tsk[headers.cpu] = next_pid
 347
 348                 ts = self.timeslices.get_time_slice(headers.ts())
 349                 ts.sched_switch(self.timeslices, prev_pid, prev_state, next_pid, headers.cpu)
 350
 351         def migrate(self, headers, pid, prio, orig_cpu, dest_cpu):
 352                 ts = self.timeslices.get_time_slice(headers.ts())
 353                 ts.migrate(self.timeslices, pid, orig_cpu, dest_cpu)
 354
 355         def wake_up(self, headers, comm, pid, success, target_cpu, fork):
 356                 if success == 0:
 357                         return
 358                 ts = self.timeslices.get_time_slice(headers.ts())
 359                 ts.wake_up(self.timeslices, pid, target_cpu, fork)
 360
 361
 362 def trace_begin():
 363         global parser
 364         parser = SchedEventProxy()
 365
 366 def trace_end():
 367         app = wx.App(False)
 368         timeslices = parser.timeslices
 369         frame = RootFrame(timeslices, "Migration")
 370         app.MainLoop()
 371
 372 def sched__sched_stat_runtime(event_name, context, common_cpu,
 373         common_secs, common_nsecs, common_pid, common_comm,
 374         common_callchain, comm, pid, runtime, vruntime):
 375         pass
 376
 377 def sched__sched_stat_iowait(event_name, context, common_cpu,
 378         common_secs, common_nsecs, common_pid, common_comm,
 379         common_callchain, comm, pid, delay):
 380         pass
 381
 382 def sched__sched_stat_sleep(event_name, context, common_cpu,
 383         common_secs, common_nsecs, common_pid, common_comm,
 384         common_callchain, comm, pid, delay):
 385         pass
 386
 387 def sched__sched_stat_wait(event_name, context, common_cpu,
 388         common_secs, common_nsecs, common_pid, common_comm,
 389         common_callchain, comm, pid, delay):
 390         pass
 391
 392 def sched__sched_process_fork(event_name, context, common_cpu,
 393         common_secs, common_nsecs, common_pid, common_comm,
 394         common_callchain, parent_comm, parent_pid, child_comm, child_pid):
 395         pass
 396
 397 def sched__sched_process_wait(event_name, context, common_cpu,
 398         common_secs, common_nsecs, common_pid, common_comm,
 399         common_callchain, comm, pid, prio):
 400         pass
 401
 402 def sched__sched_process_exit(event_name, context, common_cpu,
 403         common_secs, common_nsecs, common_pid, common_comm,
 404         common_callchain, comm, pid, prio):
 405         pass
 406
 407 def sched__sched_process_free(event_name, context, common_cpu,
 408         common_secs, common_nsecs, common_pid, common_comm,
 409         common_callchain, comm, pid, prio):
 410         pass
 411
 412 def sched__sched_migrate_task(event_name, context, common_cpu,
 413         common_secs, common_nsecs, common_pid, common_comm,
 414         common_callchain, comm, pid, prio, orig_cpu,
 415         dest_cpu):
 416         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
 417                                 common_pid, common_comm, common_callchain)
 418         parser.migrate(headers, pid, prio, orig_cpu, dest_cpu)
 419
 420 def sched__sched_switch(event_name, context, common_cpu,
 421         common_secs, common_nsecs, common_pid, common_comm, common_callchain,
 422         prev_comm, prev_pid, prev_prio, prev_state,
 423         next_comm, next_pid, next_prio):
 424
 425         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
 426                                 common_pid, common_comm, common_callchain)
 427         parser.sched_switch(headers, prev_comm, prev_pid, prev_prio, prev_state,
 428                          next_comm, next_pid, next_prio)
 429
 430 def sched__sched_wakeup_new(event_name, context, common_cpu,
 431         common_secs, common_nsecs, common_pid, common_comm,
 432         common_callchain, comm, pid, prio, success,
 433         target_cpu):
 434         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
 435                                 common_pid, common_comm, common_callchain)
 436         parser.wake_up(headers, comm, pid, success, target_cpu, 1)
 437
 438 def sched__sched_wakeup(event_name, context, common_cpu,
 439         common_secs, common_nsecs, common_pid, common_comm,
 440         common_callchain, comm, pid, prio, success,
 441         target_cpu):
 442         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
 443                                 common_pid, common_comm, common_callchain)
 444         parser.wake_up(headers, comm, pid, success, target_cpu, 0)
 445
 446 def sched__sched_wait_task(event_name, context, common_cpu,
 447         common_secs, common_nsecs, common_pid, common_comm,
 448         common_callchain, comm, pid, prio):
 449         pass
 450
 451 def sched__sched_kthread_stop_ret(event_name, context, common_cpu,
 452         common_secs, common_nsecs, common_pid, common_comm,
 453         common_callchain, ret):
 454         pass
 455
 456 def sched__sched_kthread_stop(event_name, context, common_cpu,
 457         common_secs, common_nsecs, common_pid, common_comm,
 458         common_callchain, comm, pid):
 459         pass
 460
 461 def trace_unhandled(event_name, context, event_fields_dict):
 462         pass