39 	def __repr__(self):  argument
47 	def __init__(self, sleeper):  argument
48 		self.sleeper = sleeper
50 	def __repr__(self):  argument
51 		return "%s gone to sleep" % thread_name(self.sleeper)
58 	def __init__(self, wakee):  argument
59 		self.wakee = wakee
61 	def __repr__(self):  argument
62 		return "%s woke up" % thread_name(self.wakee)
69 	def __init__(self, child):  argument
70 		self.child = child
72 	def __repr__(self):  argument
73 		return "new forked task %s" % thread_name(self.child)
80 	def __init__(self, new):  argument
81 		self.new = new
83 	def __repr__(self):  argument
84 		return "task migrated in %s" % thread_name(self.new)
91 	def __init__(self, old):  argument
92 		self.old = old
94 	def __repr__(self):  argument
95 		return "task migrated out %s" % thread_name(self.old)
98 	def __init__(self, tasks = [0], event = RunqueueEventUnknown()):  argument
99 		self.tasks = tuple(tasks)
100 		self.event = event
102 	def sched_switch(self, prev, prev_state, next):  argument
105 		if taskState(prev_state) == "R" and next in self.tasks \
106 			and prev in self.tasks:
107 			return self
112 		next_tasks = list(self.tasks[:])
113 		if prev in self.tasks:
124 	def migrate_out(self, old):  argument
125 		if old not in self.tasks:
126 			return self
127 		next_tasks = [task for task in self.tasks if task != old]
131 	def __migrate_in(self, new, event):  argument
132 		if new in self.tasks:
133 			self.event = event
134 			return self
135 		next_tasks = self.tasks[:] + tuple([new])
139 	def migrate_in(self, new):  argument
140 		return self.__migrate_in(new, RunqueueMigrateIn(new))
142 	def wake_up(self, new):  argument
143 		return self.__migrate_in(new, RunqueueEventWakeup(new))
145 	def wake_up_new(self, new):  argument
146 		return self.__migrate_in(new, RunqueueEventFork(new))
148 	def load(self):  argument
151 		return len(self.tasks) - 1
153 	def __repr__(self):  argument
154 		ret = self.tasks.__repr__()
155 		ret += self.origin_tostring()
160 	def __init__(self, start, prev):  argument
161 		self.start = start
162 		self.prev = prev
163 		self.end = start
165 		self.event_cpus = []
167 			self.total_load = prev.total_load
168 			self.rqs = prev.rqs.copy()
170 			self.rqs = defaultdict(RunqueueSnapshot)
171 			self.total_load = 0
173 	def __update_total_load(self, old_rq, new_rq):  argument
175 		self.total_load += diff
177 	def sched_switch(self, ts_list, prev, prev_state, next, cpu):  argument
178 		old_rq = self.prev.rqs[cpu]
184 		self.rqs[cpu] = new_rq
185 		self.__update_total_load(old_rq, new_rq)
186 		ts_list.append(self)
187 		self.event_cpus = [cpu]
189 	def migrate(self, ts_list, new, old_cpu, new_cpu):  argument
192 		old_rq = self.prev.rqs[old_cpu]
194 		self.rqs[old_cpu] = out_rq
195 		self.__update_total_load(old_rq, out_rq)
197 		new_rq = self.prev.rqs[new_cpu]
199 		self.rqs[new_cpu] = in_rq
200 		self.__update_total_load(new_rq, in_rq)
202 		ts_list.append(self)
205 			self.event_cpus.append(old_cpu)
206 		self.event_cpus.append(new_cpu)
208 	def wake_up(self, ts_list, pid, cpu, fork):  argument
209 		old_rq = self.prev.rqs[cpu]
217 		self.rqs[cpu] = new_rq
218 		self.__update_total_load(old_rq, new_rq)
219 		ts_list.append(self)
220 		self.event_cpus = [cpu]
222 	def next(self, t):  argument
223 		self.end = t
224 		return TimeSlice(t, self)
227 	def __init__(self, arg = []):  argument
228 		self.data = arg
230 	def get_time_slice(self, ts):  argument
231 		if len(self.data) == 0:
234 			slice = self.data[-1].next(ts)
237 	def find_time_slice(self, ts):  argument
239 		end = len(self.data)
247 			if self.data[i].start <= ts and self.data[i].end >= ts:
252 			if self.data[i].end < ts:
255 			elif self.data[i].start > ts:
260 	def set_root_win(self, win):  argument
261 		self.root_win = win
263 	def mouse_down(self, cpu, t):  argument
264 		idx = self.find_time_slice(t)
268 		ts = self[idx]
278 		self.root_win.update_summary(raw)
280 	def update_rectangle_cpu(self, slice, cpu):  argument
296 		self.root_win.paint_rectangle_zone(cpu, color, top_color, slice.start, slice.end)
298 	def fill_zone(self, start, end):  argument
299 		i = self.find_time_slice(start)
303 		for i in xrange(i, len(self.data)):
304 			timeslice = self.data[i]
309 				self.update_rectangle_cpu(timeslice, cpu)
311 	def interval(self):  argument
312 		if len(self.data) == 0:
315 		return (self.data[0].start, self.data[-1].end)
317 	def nr_rectangles(self):  argument
318 		last_ts = self.data[-1]
327 	def __init__(self):  argument
328 		self.current_tsk = defaultdict(lambda : -1)
329 		self.timeslices = TimeSliceList()
331 	def sched_switch(self, headers, prev_comm, prev_pid, prev_prio, prev_state,  argument
336 		on_cpu_task = self.current_tsk[headers.cpu]
344 		self.current_tsk[headers.cpu] = next_pid
346 		ts = self.timeslices.get_time_slice(headers.ts())
347 		ts.sched_switch(self.timeslices, prev_pid, prev_state, next_pid, headers.cpu)
349 	def migrate(self, headers, pid, prio, orig_cpu, dest_cpu):  argument
350 		ts = self.timeslices.get_time_slice(headers.ts())
351 		ts.migrate(self.timeslices, pid, orig_cpu, dest_cpu)
353 	def wake_up(self, headers, comm, pid, success, target_cpu, fork):  argument
356 		ts = self.timeslices.get_time_slice(headers.ts())
357 		ts.wake_up(self.timeslices, pid, target_cpu, fork)