[net-next-2.6.git] / tools / perf / scripts / python / sched-migration.py

#!/usr/bin/python
#
# Cpu task migration overview toy
#
# Copyright (C) 2010 Frederic Weisbecker <fweisbec@gmail.com>
#
# perf trace event handlers have been generated by perf trace -g python
#
# This software is distributed under the terms of the GNU General
# Public License ("GPL") version 2 as published by the Free Software
# Foundation.


import os
import sys

from collections import defaultdict
from UserList import UserList

sys.path.append(os.environ['PERF_EXEC_PATH'] + \
	'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
sys.path.append('scripts/python/Perf-Trace-Util/lib/Perf/Trace')

from perf_trace_context import *
from Core import *
from SchedGui import *


threads = { 0 : "idle"}

def thread_name(pid):
	return "%s:%d" % (threads[pid], pid)

class EventHeaders:
	def __init__(self, common_cpu, common_secs, common_nsecs,
		     common_pid, common_comm):
		self.cpu = common_cpu
		self.secs = common_secs
		self.nsecs = common_nsecs
		self.pid = common_pid
		self.comm = common_comm

	def ts(self):
		return (self.secs * (10 ** 9)) + self.nsecs

	def ts_format(self):
		return "%d.%d" % (self.secs, int(self.nsecs / 1000))


def taskState(state):
	states = {
		0 : "R",
		1 : "S",
		2 : "D",
		64: "DEAD"
	}

	if state not in states:
		return "Unknown"

	return states[state]


class RunqueueEventUnknown:
	@staticmethod
	def color():
		return None

	def __repr__(self):
		return "unknown"

class RunqueueEventSleep:
	@staticmethod
	def color():
		return (0, 0, 0xff)

	def __init__(self, sleeper):
		self.sleeper = sleeper

	def __repr__(self):
		return "%s gone to sleep" % thread_name(self.sleeper)

class RunqueueEventWakeup:
	@staticmethod
	def color():
		return (0xff, 0xff, 0)

	def __init__(self, wakee):
		self.wakee = wakee

	def __repr__(self):
		return "%s woke up" % thread_name(self.wakee)

class RunqueueEventFork:
	@staticmethod
	def color():
		return (0, 0xff, 0)

	def __init__(self, child):
		self.child = child

	def __repr__(self):
		return "new forked task %s" % thread_name(self.child)

class RunqueueMigrateIn:
	@staticmethod
	def color():
		return (0, 0xf0, 0xff)

	def __init__(self, new):
		self.new = new

	def __repr__(self):
		return "task migrated in %s" % thread_name(self.new)

class RunqueueMigrateOut:
	@staticmethod
	def color():
		return (0xff, 0, 0xff)

	def __init__(self, old):
		self.old = old

	def __repr__(self):
		return "task migrated out %s" % thread_name(self.old)

class RunqueueSnapshot:
	def __init__(self, tasks = [0], event = RunqueueEventUnknown()):
		self.tasks = tuple(tasks)
		self.event = event

	def sched_switch(self, prev, prev_state, next):
		event = RunqueueEventUnknown()

		if taskState(prev_state) == "R" and next in self.tasks \
			and prev in self.tasks:
			return self

		if taskState(prev_state) != "R":
			event = RunqueueEventSleep(prev)

		next_tasks = list(self.tasks[:])
		if prev in self.tasks:
			if taskState(prev_state) != "R":
				next_tasks.remove(prev)
		elif taskState(prev_state) == "R":
			next_tasks.append(prev)

		if next not in next_tasks:
			next_tasks.append(next)

		return RunqueueSnapshot(next_tasks, event)

	def migrate_out(self, old):
		if old not in self.tasks:
			return self
		next_tasks = [task for task in self.tasks if task != old]

		return RunqueueSnapshot(next_tasks, RunqueueMigrateOut(old))

	def __migrate_in(self, new, event):
		if new in self.tasks:
			self.event = event
			return self
		next_tasks = self.tasks[:] + tuple([new])

		return RunqueueSnapshot(next_tasks, event)

	def migrate_in(self, new):
		return self.__migrate_in(new, RunqueueMigrateIn(new))

	def wake_up(self, new):
		return self.__migrate_in(new, RunqueueEventWakeup(new))

	def wake_up_new(self, new):
		return self.__migrate_in(new, RunqueueEventFork(new))

	def load(self):
		""" Provide the number of tasks on the runqueue.
		    Don't count idle"""
		return len(self.tasks) - 1

	def __repr__(self):
		ret = self.tasks.__repr__()
		ret += self.origin_tostring()

		return ret

class TimeSlice:
	def __init__(self, start, prev):
		self.start = start
		self.prev = prev
		self.end = start
		# cpus that triggered the event
		self.event_cpus = []
		if prev is not None:
			self.total_load = prev.total_load
			self.rqs = prev.rqs.copy()
		else:
			self.rqs = defaultdict(RunqueueSnapshot)
			self.total_load = 0

	def __update_total_load(self, old_rq, new_rq):
		diff = new_rq.load() - old_rq.load()
		self.total_load += diff

	def sched_switch(self, ts_list, prev, prev_state, next, cpu):
		old_rq = self.prev.rqs[cpu]
		new_rq = old_rq.sched_switch(prev, prev_state, next)

		if old_rq is new_rq:
			return

		self.rqs[cpu] = new_rq
		self.__update_total_load(old_rq, new_rq)
		ts_list.append(self)
		self.event_cpus = [cpu]

	def migrate(self, ts_list, new, old_cpu, new_cpu):
		if old_cpu == new_cpu:
			return
		old_rq = self.prev.rqs[old_cpu]
		out_rq = old_rq.migrate_out(new)
		self.rqs[old_cpu] = out_rq
		self.__update_total_load(old_rq, out_rq)

		new_rq = self.prev.rqs[new_cpu]
		in_rq = new_rq.migrate_in(new)
		self.rqs[new_cpu] = in_rq
		self.__update_total_load(new_rq, in_rq)

		ts_list.append(self)

		if old_rq is not out_rq:
			self.event_cpus.append(old_cpu)
		self.event_cpus.append(new_cpu)

	def wake_up(self, ts_list, pid, cpu, fork):
		old_rq = self.prev.rqs[cpu]
		if fork:
			new_rq = old_rq.wake_up_new(pid)
		else:
			new_rq = old_rq.wake_up(pid)

		if new_rq is old_rq:
			return
		self.rqs[cpu] = new_rq
		self.__update_total_load(old_rq, new_rq)
		ts_list.append(self)
		self.event_cpus = [cpu]

	def next(self, t):
		self.end = t
		return TimeSlice(t, self)

class TimeSliceList(UserList):
	def __init__(self, arg = []):
		self.data = arg

	def get_time_slice(self, ts):
		if len(self.data) == 0:
			slice = TimeSlice(ts, TimeSlice(-1, None))
		else:
			slice = self.data[-1].next(ts)
		return slice

	def find_time_slice(self, ts):
		start = 0
		end = len(self.data)
		found = -1
		searching = True
		while searching:
			if start == end or start == end - 1:
				searching = False

			i = (end + start) / 2
			if self.data[i].start <= ts and self.data[i].end >= ts:
				found = i
				end = i
				continue

			if self.data[i].end < ts:
				start = i

			elif self.data[i].start > ts:
				end = i

		return found

	def set_root_win(self, win):
		self.root_win = win

	def mouse_down(self, cpu, t):
		idx = self.find_time_slice(t)
		if idx == -1:
			return

		ts = self[idx]
		rq = ts.rqs[cpu]
		raw = "CPU: %d\n" % cpu
		raw += "Last event : %s\n" % rq.event.__repr__()
		raw += "Timestamp : %d.%06d\n" % (ts.start / (10 ** 9), (ts.start % (10 ** 9)) / 1000)
		raw += "Duration : %6d us\n" % ((ts.end - ts.start) / (10 ** 6))
		raw += "Load = %d\n" % rq.load()
		for t in rq.tasks:
			raw += "%s \n" % thread_name(t)

		self.root_win.update_summary(raw)

	def update_rectangle_cpu(self, slice, cpu):
		rq = slice.rqs[cpu]

		if slice.total_load != 0:
			load_rate = rq.load() / float(slice.total_load)
		else:
			load_rate = 0

		red_power = int(0xff - (0xff * load_rate))
		color = (0xff, red_power, red_power)

		top_color = None

		if cpu in slice.event_cpus:
			top_color = rq.event.color()

		self.root_win.paint_rectangle_zone(cpu, color, top_color, slice.start, slice.end)

	def fill_zone(self, start, end):
		i = self.find_time_slice(start)
		if i == -1:
			return

		for i in xrange(i, len(self.data)):
			timeslice = self.data[i]
			if timeslice.start > end:
				return

			for cpu in timeslice.rqs:
				self.update_rectangle_cpu(timeslice, cpu)

	def interval(self):
		if len(self.data) == 0:
			return (0, 0)

		return (self.data[0].start, self.data[-1].end)

	def nr_rectangles(self):
		last_ts = self.data[-1]
		max_cpu = 0
		for cpu in last_ts.rqs:
			if cpu > max_cpu:
				max_cpu = cpu
		return max_cpu


class SchedEventProxy:
	def __init__(self):
		self.current_tsk = defaultdict(lambda : -1)
		self.timeslices = TimeSliceList()

	def sched_switch(self, headers, prev_comm, prev_pid, prev_prio, prev_state,
			 next_comm, next_pid, next_prio):
		""" Ensure the task we sched out this cpu is really the one
		    we logged. Otherwise we may have missed traces """

		on_cpu_task = self.current_tsk[headers.cpu]

		if on_cpu_task != -1 and on_cpu_task != prev_pid:
			print "Sched switch event rejected ts: %s cpu: %d prev: %s(%d) next: %s(%d)" % \
				(headers.ts_format(), headers.cpu, prev_comm, prev_pid, next_comm, next_pid)

		threads[prev_pid] = prev_comm
		threads[next_pid] = next_comm
		self.current_tsk[headers.cpu] = next_pid

		ts = self.timeslices.get_time_slice(headers.ts())
		ts.sched_switch(self.timeslices, prev_pid, prev_state, next_pid, headers.cpu)

	def migrate(self, headers, pid, prio, orig_cpu, dest_cpu):
		ts = self.timeslices.get_time_slice(headers.ts())
		ts.migrate(self.timeslices, pid, orig_cpu, dest_cpu)

	def wake_up(self, headers, comm, pid, success, target_cpu, fork):
		if success == 0:
			return
		ts = self.timeslices.get_time_slice(headers.ts())
		ts.wake_up(self.timeslices, pid, target_cpu, fork)


def trace_begin():
	global parser
	parser = SchedEventProxy()

def trace_end():
	app = wx.App(False)
	timeslices = parser.timeslices
	frame = RootFrame(timeslices, "Migration")
	app.MainLoop()

def sched__sched_stat_runtime(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, runtime, vruntime):
	pass

def sched__sched_stat_iowait(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, delay):
	pass

def sched__sched_stat_sleep(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, delay):
	pass

def sched__sched_stat_wait(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, delay):
	pass

def sched__sched_process_fork(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	parent_comm, parent_pid, child_comm, child_pid):
	pass

def sched__sched_process_wait(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio):
	pass

def sched__sched_process_exit(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio):
	pass

def sched__sched_process_free(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio):
	pass

def sched__sched_migrate_task(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio, orig_cpu,
	dest_cpu):
	headers = EventHeaders(common_cpu, common_secs, common_nsecs,
				common_pid, common_comm)
	parser.migrate(headers, pid, prio, orig_cpu, dest_cpu)

def sched__sched_switch(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	prev_comm, prev_pid, prev_prio, prev_state,
	next_comm, next_pid, next_prio):

	headers = EventHeaders(common_cpu, common_secs, common_nsecs,
				common_pid, common_comm)
	parser.sched_switch(headers, prev_comm, prev_pid, prev_prio, prev_state,
			 next_comm, next_pid, next_prio)

def sched__sched_wakeup_new(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio, success,
	target_cpu):
	headers = EventHeaders(common_cpu, common_secs, common_nsecs,
				common_pid, common_comm)
	parser.wake_up(headers, comm, pid, success, target_cpu, 1)

def sched__sched_wakeup(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio, success,
	target_cpu):
	headers = EventHeaders(common_cpu, common_secs, common_nsecs,
				common_pid, common_comm)
	parser.wake_up(headers, comm, pid, success, target_cpu, 0)

def sched__sched_wait_task(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid, prio):
	pass

def sched__sched_kthread_stop_ret(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	ret):
	pass

def sched__sched_kthread_stop(event_name, context, common_cpu,
	common_secs, common_nsecs, common_pid, common_comm,
	comm, pid):
	pass

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