dcee3bd312
python and tkinter. Schedgraph takes input from files produces by ktrdump -ct when KTR_SCHED is compiled into the kernel. The output represents the states of each thread with colored line segments as well as colored points for non-state scheduler events. Each line segment and point is clickable to obtain extra detail.
1210 lines
32 KiB
Python
1210 lines
32 KiB
Python
#!/usr/local/bin/python
|
|
|
|
# Copyright (c) 2002-2003, Jeffrey Roberson <jeff@freebsd.org>
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice unmodified, this list of conditions, and the following
|
|
# disclaimer.
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
# $FreeBSD$
|
|
|
|
import sys
|
|
import re
|
|
from Tkinter import *
|
|
|
|
# 1) Add a per-thread summary display
|
|
# 2) Add bounding box style zoom.
|
|
# 3) Click to center.
|
|
# 4) Implement some sorting mechanism.
|
|
|
|
ticksps = None
|
|
status = None
|
|
configtypes = []
|
|
|
|
def ticks2sec(ticks):
|
|
ns = ticksps / 1000000000
|
|
ticks /= ns
|
|
if (ticks < 1000):
|
|
return (str(ticks) + "ns")
|
|
ticks /= 1000
|
|
if (ticks < 1000):
|
|
return (str(ticks) + "us")
|
|
ticks /= 1000
|
|
if (ticks < 1000):
|
|
return (str(ticks) + "ms")
|
|
ticks /= 1000
|
|
return (str(ticks) + "s")
|
|
|
|
class Scaler(Frame):
|
|
def __init__(self, master, target):
|
|
Frame.__init__(self, master)
|
|
self.scale = Scale(self, command=self.scaleset,
|
|
from_=1000, to_=1000000, orient=HORIZONTAL, resolution=1000)
|
|
self.label = Label(self, text="Ticks per pixel")
|
|
self.label.pack(side=LEFT)
|
|
self.scale.pack(fill="both", expand=1)
|
|
self.target = target
|
|
self.scale.set(target.scaleget())
|
|
self.initialized = 1
|
|
|
|
def scaleset(self, value):
|
|
self.target.scaleset(int(value))
|
|
|
|
def set(self, value):
|
|
self.scale.set(value)
|
|
|
|
class Status(Frame):
|
|
def __init__(self, master):
|
|
Frame.__init__(self, master)
|
|
self.label = Label(self, bd=1, relief=SUNKEN, anchor=W)
|
|
self.label.pack(fill="both", expand=1)
|
|
self.clear()
|
|
|
|
def set(self, str):
|
|
self.label.config(text=str)
|
|
|
|
def clear(self):
|
|
self.label.config(text="")
|
|
|
|
def startup(self, str):
|
|
self.set(str)
|
|
root.update()
|
|
|
|
class EventConf(Frame):
|
|
def __init__(self, master, name, color, enabled):
|
|
Frame.__init__(self, master)
|
|
self.name = name
|
|
self.color = StringVar()
|
|
self.color_default = color
|
|
self.color_current = color
|
|
self.color.set(color)
|
|
self.enabled = IntVar()
|
|
self.enabled_default = enabled
|
|
self.enabled_current = enabled
|
|
self.enabled.set(enabled)
|
|
self.draw()
|
|
|
|
def draw(self):
|
|
self.label = Label(self, text=self.name, anchor=W)
|
|
self.sample = Canvas(self, width=24, height=24,
|
|
bg='grey')
|
|
self.rect = self.sample.create_rectangle(0, 0, 24, 24,
|
|
fill=self.color.get())
|
|
self.list = OptionMenu(self, self.color,
|
|
"dark red", "red", "pink",
|
|
"dark orange", "orange",
|
|
"yellow", "light yellow",
|
|
"dark green", "green", "light green",
|
|
"dark blue", "blue", "light blue",
|
|
"dark violet", "violet", "purple",
|
|
"dark grey", "light grey",
|
|
"white", "black",
|
|
command=self.setcolor)
|
|
self.checkbox = Checkbutton(self, text="enabled",
|
|
variable=self.enabled)
|
|
self.label.grid(row=0, column=0, sticky=E+W)
|
|
self.sample.grid(row=0, column=1)
|
|
self.list.grid(row=0, column=2, sticky=E+W)
|
|
self.checkbox.grid(row=0, column=3)
|
|
self.columnconfigure(0, weight=1)
|
|
self.columnconfigure(2, minsize=110)
|
|
|
|
def setcolor(self, color):
|
|
self.color.set(color)
|
|
self.sample.itemconfigure(self.rect, fill=color)
|
|
|
|
def apply(self):
|
|
cchange = 0
|
|
echange = 0
|
|
if (self.color_current != self.color.get()):
|
|
cchange = 1
|
|
if (self.enabled_current != self.enabled.get()):
|
|
echange = 1
|
|
self.color_current = self.color.get()
|
|
self.enabled_current = self.enabled.get()
|
|
if (echange != 0):
|
|
if (self.enabled_current):
|
|
graph.setcolor(self.name, self.color_current)
|
|
else:
|
|
graph.hide(self.name)
|
|
return
|
|
if (cchange != 0):
|
|
graph.setcolor(self.name, self.color_current)
|
|
|
|
def revert(self):
|
|
self.setcolor(self.color_current)
|
|
self.enabled.set(self.enabled_current)
|
|
|
|
def default(self):
|
|
self.setcolor(self.color_default)
|
|
self.enabled.set(self.enabled_default)
|
|
|
|
class EventConfigure(Toplevel):
|
|
def __init__(self):
|
|
Toplevel.__init__(self)
|
|
self.resizable(0, 0)
|
|
self.title("Event Configuration")
|
|
self.items = LabelFrame(self, text="Event Type")
|
|
self.buttons = Frame(self)
|
|
self.drawbuttons()
|
|
self.items.grid(row=0, column=0, sticky=E+W)
|
|
self.columnconfigure(0, weight=1)
|
|
self.buttons.grid(row=1, column=0, sticky=E+W)
|
|
self.types = []
|
|
self.irow = 0
|
|
for type in configtypes:
|
|
self.additem(type.name, type.color, type.enabled)
|
|
|
|
def additem(self, name, color, enabled=1):
|
|
item = EventConf(self.items, name, color, enabled)
|
|
self.types.append(item)
|
|
item.grid(row=self.irow, column=0, sticky=E+W)
|
|
self.irow += 1
|
|
|
|
def drawbuttons(self):
|
|
self.apply = Button(self.buttons, text="Apply",
|
|
command=self.apress)
|
|
self.revert = Button(self.buttons, text="Revert",
|
|
command=self.rpress)
|
|
self.default = Button(self.buttons, text="Default",
|
|
command=self.dpress)
|
|
self.apply.grid(row=0, column=0, sticky=E+W)
|
|
self.revert.grid(row=0, column=1, sticky=E+W)
|
|
self.default.grid(row=0, column=2, sticky=E+W)
|
|
self.buttons.columnconfigure(0, weight=1)
|
|
self.buttons.columnconfigure(1, weight=1)
|
|
self.buttons.columnconfigure(2, weight=1)
|
|
|
|
def apress(self):
|
|
for item in self.types:
|
|
item.apply()
|
|
|
|
def rpress(self):
|
|
for item in self.types:
|
|
item.revert()
|
|
|
|
def dpress(self):
|
|
for item in self.types:
|
|
item.default()
|
|
|
|
class EventView(Toplevel):
|
|
def __init__(self, event, canvas):
|
|
Toplevel.__init__(self)
|
|
self.resizable(0, 0)
|
|
self.title("Event")
|
|
self.event = event
|
|
self.frame = Frame(self)
|
|
self.frame.grid(row=0, column=0, sticky=N+S+E+W)
|
|
self.buttons = Frame(self)
|
|
self.buttons.grid(row=1, column=0, sticky=E+W)
|
|
self.canvas = canvas
|
|
self.drawlabels()
|
|
self.drawbuttons()
|
|
event.displayref(canvas)
|
|
self.bind("<Destroy>", self.destroycb)
|
|
|
|
def destroycb(self, event):
|
|
self.unbind("<Destroy>")
|
|
if (self.event != None):
|
|
self.event.displayunref(self.canvas)
|
|
self.event = None
|
|
self.destroy()
|
|
|
|
def clearlabels(self):
|
|
for label in self.frame.grid_slaves():
|
|
label.grid_remove()
|
|
|
|
def drawlabels(self):
|
|
ypos = 0
|
|
labels = self.event.labels()
|
|
while (len(labels) < 7):
|
|
labels.append(("", "", 0))
|
|
for label in labels:
|
|
name, value, linked = label
|
|
l = Label(self.frame, text=name, bd=1, width=15,
|
|
relief=SUNKEN, anchor=W)
|
|
if (linked):
|
|
fgcolor = "blue"
|
|
else:
|
|
fgcolor = "black"
|
|
r = Label(self.frame, text=value, bd=1,
|
|
relief=SUNKEN, anchor=W, fg=fgcolor)
|
|
l.grid(row=ypos, column=0, sticky=E+W)
|
|
r.grid(row=ypos, column=1, sticky=E+W)
|
|
if (linked):
|
|
r.bind("<Button-1>", self.linkpress)
|
|
ypos += 1
|
|
self.frame.columnconfigure(1, minsize=80)
|
|
|
|
def drawbuttons(self):
|
|
self.back = Button(self.buttons, text="<", command=self.bpress)
|
|
self.forw = Button(self.buttons, text=">", command=self.fpress)
|
|
self.new = Button(self.buttons, text="new", command=self.npress)
|
|
self.back.grid(row=0, column=0, sticky=E+W)
|
|
self.forw.grid(row=0, column=1, sticky=E+W)
|
|
self.new.grid(row=0, column=2, sticky=E+W)
|
|
self.buttons.columnconfigure(2, weight=1)
|
|
|
|
def newevent(self, event):
|
|
self.event.displayunref(self.canvas)
|
|
self.clearlabels()
|
|
self.event = event
|
|
self.event.displayref(self.canvas)
|
|
self.drawlabels()
|
|
|
|
def npress(self):
|
|
EventView(self.event, self.canvas)
|
|
|
|
def bpress(self):
|
|
prev = self.event.prev()
|
|
if (prev == None):
|
|
return
|
|
while (prev.real == 0):
|
|
prev = prev.prev()
|
|
if (prev == None):
|
|
return
|
|
self.newevent(prev)
|
|
|
|
def fpress(self):
|
|
next = self.event.next()
|
|
if (next == None):
|
|
return
|
|
while (next.real == 0):
|
|
next = next.next()
|
|
if (next == None):
|
|
return
|
|
self.newevent(next)
|
|
|
|
def linkpress(self, wevent):
|
|
event = self.event.getlinked()
|
|
if (event != None):
|
|
self.newevent(event)
|
|
|
|
class Event:
|
|
name = "none"
|
|
color = "grey"
|
|
def __init__(self, source, cpu, timestamp, last=0):
|
|
self.source = source
|
|
self.cpu = cpu
|
|
self.timestamp = int(timestamp)
|
|
self.entries = []
|
|
self.real = 1
|
|
self.idx = None
|
|
self.state = 0
|
|
self.item = None
|
|
self.dispcnt = 0
|
|
self.linked = None
|
|
if (last):
|
|
source.lastevent(self)
|
|
else:
|
|
source.event(self)
|
|
|
|
def status(self):
|
|
statstr = self.name + " " + self.source.name
|
|
statstr += " on: cpu" + str(self.cpu)
|
|
statstr += " at: " + str(self.timestamp)
|
|
statstr += self.stattxt()
|
|
status.set(statstr)
|
|
|
|
def stattxt(self):
|
|
return ""
|
|
|
|
def textadd(self, tuple):
|
|
pass
|
|
self.entries.append(tuple)
|
|
|
|
def labels(self):
|
|
return [("Source:", self.source.name, 0),
|
|
("Event:", self.name, 0),
|
|
("CPU:", self.cpu, 0),
|
|
("Timestamp:", self.timestamp, 0)] + self.entries
|
|
def mouseenter(self, canvas, item):
|
|
self.displayref(canvas)
|
|
self.status()
|
|
|
|
def mouseexit(self, canvas, item):
|
|
self.displayunref(canvas)
|
|
status.clear()
|
|
|
|
def mousepress(self, canvas, item):
|
|
EventView(self, canvas)
|
|
|
|
def next(self):
|
|
return self.source.eventat(self.idx + 1)
|
|
|
|
def prev(self):
|
|
return self.source.eventat(self.idx - 1)
|
|
|
|
def displayref(self, canvas):
|
|
if (self.dispcnt == 0):
|
|
canvas.itemconfigure(self.item, width=2)
|
|
self.dispcnt += 1
|
|
|
|
def displayunref(self, canvas):
|
|
self.dispcnt -= 1
|
|
if (self.dispcnt == 0):
|
|
canvas.itemconfigure(self.item, width=0)
|
|
canvas.tag_raise("point", "state")
|
|
|
|
def getlinked(self):
|
|
return self.linked.findevent(self.timestamp)
|
|
|
|
class PointEvent(Event):
|
|
def __init__(self, thread, cpu, timestamp, last=0):
|
|
Event.__init__(self, thread, cpu, timestamp, last)
|
|
|
|
def draw(self, canvas, xpos, ypos):
|
|
l = canvas.create_oval(xpos - 6, ypos + 1, xpos + 6, ypos - 11,
|
|
fill=self.color, tags=("all", "point", "event")
|
|
+ (self.name,), width=0)
|
|
canvas.events[l] = self
|
|
self.item = l
|
|
if (self.enabled == 0):
|
|
canvas.itemconfigure(l, state="hidden")
|
|
|
|
return (xpos)
|
|
|
|
class StateEvent(Event):
|
|
def __init__(self, thread, cpu, timestamp, last=0):
|
|
Event.__init__(self, thread, cpu, timestamp, last)
|
|
self.duration = 0
|
|
self.skipnext = 0
|
|
self.skipself = 0
|
|
self.state = 1
|
|
|
|
def draw(self, canvas, xpos, ypos):
|
|
next = self.nextstate()
|
|
if (self.skipself == 1 or next == None):
|
|
return (xpos)
|
|
if (self.skipnext):
|
|
skipped = next
|
|
next.skipself = 1
|
|
next.real = 0
|
|
next = next.nextstate()
|
|
if (next == None):
|
|
next = skipped
|
|
self.duration = next.timestamp - self.timestamp
|
|
delta = self.duration / canvas.ratio
|
|
l = canvas.create_rectangle(xpos, ypos,
|
|
xpos + delta, ypos - 10, fill=self.color, width=0,
|
|
tags=("all", "state", "event") + (self.name,))
|
|
canvas.events[l] = self
|
|
self.item = l
|
|
if (self.enabled == 0):
|
|
canvas.itemconfigure(l, state="hidden")
|
|
|
|
return (xpos + delta)
|
|
|
|
def stattxt(self):
|
|
return " duration: " + ticks2sec(self.duration)
|
|
|
|
def nextstate(self):
|
|
next = self.next()
|
|
while (next != None and next.state == 0):
|
|
next = next.next()
|
|
return (next)
|
|
|
|
def labels(self):
|
|
return [("Source:", self.source.name, 0),
|
|
("Event:", self.name, 0),
|
|
("Timestamp:", self.timestamp, 0),
|
|
("CPU:", self.cpu, 0),
|
|
("Duration:", ticks2sec(self.duration), 0)] \
|
|
+ self.entries
|
|
|
|
class Count(Event):
|
|
name = "Count"
|
|
color = "red"
|
|
enabled = 1
|
|
def __init__(self, source, cpu, timestamp, count):
|
|
self.count = int(count)
|
|
Event.__init__(self, source, cpu, timestamp)
|
|
self.duration = 0
|
|
self.textadd(("count:", self.count, 0))
|
|
|
|
def draw(self, canvas, xpos, ypos):
|
|
next = self.next()
|
|
self.duration = next.timestamp - self.timestamp
|
|
delta = self.duration / canvas.ratio
|
|
yhight = self.source.yscale() * self.count
|
|
l = canvas.create_rectangle(xpos, ypos - yhight,
|
|
xpos + delta, ypos, fill=self.color, width=0,
|
|
tags=("all", "count", "event") + (self.name,))
|
|
canvas.events[l] = self
|
|
self.item = l
|
|
if (self.enabled == 0):
|
|
canvas.itemconfigure(l, state="hidden")
|
|
return (xpos + delta)
|
|
|
|
def stattxt(self):
|
|
return " count: " + str(self.count)
|
|
|
|
configtypes.append(Count)
|
|
|
|
class Running(StateEvent):
|
|
name = "running"
|
|
color = "green"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Running)
|
|
|
|
class Idle(StateEvent):
|
|
name = "idle"
|
|
color = "grey"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Idle)
|
|
|
|
class Yielding(StateEvent):
|
|
name = "yielding"
|
|
color = "yellow"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Yielding)
|
|
|
|
class Swapped(StateEvent):
|
|
name = "swapped"
|
|
color = "violet"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Swapped)
|
|
|
|
class Suspended(StateEvent):
|
|
name = "suspended"
|
|
color = "purple"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Suspended)
|
|
|
|
class Iwait(StateEvent):
|
|
name = "iwait"
|
|
color = "grey"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Iwait)
|
|
|
|
class Preempted(StateEvent):
|
|
name = "preempted"
|
|
color = "red"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio, bythread):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.skipnext = 1
|
|
self.prio = prio
|
|
self.linked = bythread
|
|
self.textadd(("prio:", self.prio, 0))
|
|
self.textadd(("by thread:", self.linked.name, 1))
|
|
|
|
configtypes.append(Preempted)
|
|
|
|
class Sleep(StateEvent):
|
|
name = "sleep"
|
|
color = "blue"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio, wmesg):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.wmesg = wmesg
|
|
self.textadd(("prio:", self.prio, 0))
|
|
self.textadd(("wmesg:", self.wmesg, 0))
|
|
|
|
def stattxt(self):
|
|
statstr = StateEvent.stattxt(self)
|
|
statstr += " sleeping on: " + self.wmesg
|
|
return (statstr)
|
|
|
|
configtypes.append(Sleep)
|
|
|
|
class Blocked(StateEvent):
|
|
name = "blocked"
|
|
color = "dark red"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio, lock):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.lock = lock
|
|
self.textadd(("prio:", self.prio, 0))
|
|
self.textadd(("lock:", self.lock, 0))
|
|
|
|
def stattxt(self):
|
|
statstr = StateEvent.stattxt(self)
|
|
statstr += " blocked on: " + self.lock
|
|
return (statstr)
|
|
|
|
configtypes.append(Blocked)
|
|
|
|
class KsegrpRunq(StateEvent):
|
|
name = "KsegrpRunq"
|
|
color = "orange"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio, bythread):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.linked = bythread
|
|
self.textadd(("prio:", self.prio, 0))
|
|
self.textadd(("by thread:", self.linked.name, 1))
|
|
|
|
configtypes.append(KsegrpRunq)
|
|
|
|
class Runq(StateEvent):
|
|
name = "Runq"
|
|
color = "yellow"
|
|
enabled = 1
|
|
def __init__(self, thread, cpu, timestamp, prio, bythread):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.linked = bythread
|
|
self.textadd(("prio:", self.prio, 0))
|
|
self.textadd(("by thread:", self.linked.name, 1))
|
|
|
|
configtypes.append(Runq)
|
|
|
|
class Sched_exit(StateEvent):
|
|
name = "exit"
|
|
color = "grey"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, prio):
|
|
StateEvent.__init__(self, thread, cpu, timestamp)
|
|
self.name = "sched_exit"
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Sched_exit)
|
|
|
|
class Padevent(StateEvent):
|
|
def __init__(self, thread, cpu, timestamp, last=0):
|
|
StateEvent.__init__(self, thread, cpu, timestamp, last)
|
|
self.name = "pad"
|
|
self.real = 0
|
|
|
|
def draw(self, canvas, xpos, ypos):
|
|
next = self.next()
|
|
if (next == None):
|
|
return (xpos)
|
|
self.duration = next.timestamp - self.timestamp
|
|
delta = self.duration / canvas.ratio
|
|
return (xpos + delta)
|
|
|
|
class Tick(PointEvent):
|
|
name = "tick"
|
|
color = "black"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, prio, stathz):
|
|
PointEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.textadd(("prio:", self.prio, 0))
|
|
|
|
configtypes.append(Tick)
|
|
|
|
class Prio(PointEvent):
|
|
name = "prio"
|
|
color = "black"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, prio, newprio, bythread):
|
|
PointEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.newprio = newprio
|
|
self.linked = bythread
|
|
self.textadd(("new prio:", self.newprio, 0))
|
|
self.textadd(("prio:", self.prio, 0))
|
|
if (self.linked != self.source):
|
|
self.textadd(("by thread:", self.linked.name, 1))
|
|
else:
|
|
self.textadd(("by thread:", self.linked.name, 0))
|
|
|
|
configtypes.append(Prio)
|
|
|
|
class Lend(PointEvent):
|
|
name = "lend"
|
|
color = "black"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, prio, tothread):
|
|
PointEvent.__init__(self, thread, cpu, timestamp)
|
|
self.prio = prio
|
|
self.linked = tothread
|
|
self.textadd(("prio:", self.prio, 0))
|
|
self.textadd(("to thread:", self.linked.name, 1))
|
|
|
|
configtypes.append(Lend)
|
|
|
|
class Wokeup(PointEvent):
|
|
name = "wokeup"
|
|
color = "black"
|
|
enabled = 0
|
|
def __init__(self, thread, cpu, timestamp, ranthread):
|
|
PointEvent.__init__(self, thread, cpu, timestamp)
|
|
self.linked = ranthread
|
|
self.textadd(("ran thread:", self.linked.name, 1))
|
|
|
|
configtypes.append(Wokeup)
|
|
|
|
class EventSource:
|
|
def __init__(self, name):
|
|
self.name = name
|
|
self.events = []
|
|
self.cpu = 0
|
|
self.cpux = 0
|
|
|
|
def fixup(self):
|
|
pass
|
|
|
|
def event(self, event):
|
|
self.events.insert(0, event)
|
|
|
|
def remove(self, event):
|
|
self.events.remove(event)
|
|
|
|
def lastevent(self, event):
|
|
self.events.append(event)
|
|
|
|
def draw(self, canvas, ypos):
|
|
xpos = 10
|
|
self.cpux = 10
|
|
self.cpu = self.events[1].cpu
|
|
for i in range(0, len(self.events)):
|
|
self.events[i].idx = i
|
|
for event in self.events:
|
|
if (event.cpu != self.cpu and event.cpu != -1):
|
|
self.drawcpu(canvas, xpos, ypos)
|
|
self.cpux = xpos
|
|
self.cpu = event.cpu
|
|
xpos = event.draw(canvas, xpos, ypos)
|
|
self.drawcpu(canvas, xpos, ypos)
|
|
|
|
def drawname(self, canvas, ypos):
|
|
ypos = ypos - (self.ysize() / 2)
|
|
canvas.create_text(10, ypos, anchor="w", text=self.name)
|
|
|
|
def drawcpu(self, canvas, xpos, ypos):
|
|
cpu = int(self.cpu)
|
|
if (cpu == 0):
|
|
color = 'light grey'
|
|
elif (cpu == 1):
|
|
color = 'dark grey'
|
|
elif (cpu == 2):
|
|
color = 'light blue'
|
|
elif (cpu == 3):
|
|
color == 'light green'
|
|
else:
|
|
color == "white"
|
|
l = canvas.create_rectangle(self.cpux,
|
|
ypos - self.ysize() - canvas.bdheight,
|
|
xpos, ypos + canvas.bdheight, fill=color, width=0,
|
|
tags=("all", "cpuinfo"))
|
|
|
|
def ysize(self):
|
|
return (None)
|
|
|
|
def eventat(self, i):
|
|
if (i >= len(self.events)):
|
|
return (None)
|
|
event = self.events[i]
|
|
return (event)
|
|
|
|
def findevent(self, timestamp):
|
|
for event in self.events:
|
|
if (event.timestamp >= timestamp and event.real):
|
|
return (event)
|
|
return (None)
|
|
|
|
class Thread(EventSource):
|
|
names = {}
|
|
def __init__(self, td, pcomm):
|
|
EventSource.__init__(self, pcomm)
|
|
self.str = td
|
|
try:
|
|
cnt = Thread.names[pcomm]
|
|
except:
|
|
Thread.names[pcomm] = 0
|
|
return
|
|
Thread.names[pcomm] = cnt + 1
|
|
|
|
def fixup(self):
|
|
cnt = Thread.names[self.name]
|
|
if (cnt == 0):
|
|
return
|
|
cnt -= 1
|
|
Thread.names[self.name] = cnt
|
|
self.name += " td" + str(cnt)
|
|
|
|
def ysize(self):
|
|
return (10)
|
|
|
|
class Counter(EventSource):
|
|
max = 0
|
|
def __init__(self, name):
|
|
EventSource.__init__(self, name)
|
|
|
|
def event(self, event):
|
|
EventSource.event(self, event)
|
|
try:
|
|
count = event.count
|
|
except:
|
|
return
|
|
count = int(count)
|
|
if (count > Counter.max):
|
|
Counter.max = count
|
|
|
|
def ysize(self):
|
|
return (80)
|
|
|
|
def yscale(self):
|
|
return (self.ysize() / Counter.max)
|
|
|
|
|
|
class KTRFile:
|
|
def __init__(self, file):
|
|
self.timestamp_first = None
|
|
self.timestamp_last = None
|
|
self.lineno = -1
|
|
self.threads = []
|
|
self.sources = []
|
|
self.ticks = {}
|
|
self.load = {}
|
|
|
|
self.parse(file)
|
|
self.fixup()
|
|
global ticksps
|
|
ticksps = self.ticksps()
|
|
|
|
def parse(self, file):
|
|
try:
|
|
ifp = open(file)
|
|
except:
|
|
print "Can't open", file
|
|
sys.exit(1)
|
|
|
|
ktrhdr = "\s+\d+\s+(\d+)\s+(\d+)\s+"
|
|
tdname = "(\S+)\(([^)]*)\)"
|
|
|
|
ktrstr = "mi_switch: " + tdname
|
|
ktrstr += " prio (\d+) inhibit (\d+) wmesg (\S+) lock (\S+)"
|
|
switchout_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "mi_switch: " + tdname + " prio (\d+) idle"
|
|
idled_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "mi_switch: " + tdname + " prio (\d+) preempted by "
|
|
ktrstr += tdname
|
|
preempted_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "mi_switch: running " + tdname + " prio (\d+)"
|
|
switchin_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "sched_add: " + tdname + " prio (\d+) by " + tdname
|
|
sched_add_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "setrunqueue: " + tdname + " prio (\d+) by " + tdname
|
|
setrunqueue_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "sched_rem: " + tdname + " prio (\d+) by " + tdname
|
|
sched_rem_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "sched_exit_thread: " + tdname + " prio (\d+)"
|
|
sched_exit_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "statclock: " + tdname + " prio (\d+)"
|
|
ktrstr += " stathz (\d+)"
|
|
sched_clock_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
ktrstr = "sched_prio: " + tdname + " prio (\d+)"
|
|
ktrstr += " newprio (\d+) by " + tdname
|
|
sched_prio_re = re.compile(ktrhdr + ktrstr)
|
|
|
|
cpuload_re = re.compile(ktrhdr + "load: (\d)")
|
|
loadglobal_re = re.compile(ktrhdr + "global load: (\d)")
|
|
|
|
parsers = [[cpuload_re, self.cpuload],
|
|
[loadglobal_re, self.loadglobal],
|
|
[switchin_re, self.switchin],
|
|
[switchout_re, self.switchout],
|
|
[sched_add_re, self.sched_add],
|
|
[setrunqueue_re, self.sched_rem],
|
|
[sched_prio_re, self.sched_prio],
|
|
[preempted_re, self.preempted],
|
|
[sched_rem_re, self.sched_rem],
|
|
[sched_exit_re, self.sched_exit],
|
|
[sched_clock_re, self.sched_clock],
|
|
[idled_re, self.idled]]
|
|
|
|
for line in ifp.readlines():
|
|
self.lineno += 1
|
|
if ((self.lineno % 1024) == 0):
|
|
status.startup("Parsing line " +
|
|
str(self.lineno))
|
|
for p in parsers:
|
|
m = p[0].match(line)
|
|
if (m != None):
|
|
p[1](*m.groups())
|
|
break
|
|
# if (m == None):
|
|
# print line,
|
|
|
|
def checkstamp(self, timestamp):
|
|
timestamp = int(timestamp)
|
|
if (self.timestamp_first == None):
|
|
self.timestamp_first = timestamp
|
|
if (timestamp > self.timestamp_first):
|
|
print "Bad timestamp on line ", self.lineno
|
|
return (0)
|
|
self.timestamp_last = timestamp
|
|
return (1)
|
|
|
|
def timespan(self):
|
|
return (self.timestamp_first - self.timestamp_last);
|
|
|
|
def ticksps(self):
|
|
return (self.timespan() / self.ticks[0]) * int(self.stathz)
|
|
|
|
def switchout(self, cpu, timestamp, td, pcomm, prio, inhibit, wmesg, lock):
|
|
TDI_SUSPENDED = 0x0001
|
|
TDI_SLEEPING = 0x0002
|
|
TDI_SWAPPED = 0x0004
|
|
TDI_LOCK = 0x0008
|
|
TDI_IWAIT = 0x0010
|
|
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
inhibit = int(inhibit)
|
|
thread = self.findtd(td, pcomm)
|
|
if (inhibit & TDI_SWAPPED):
|
|
Swapped(thread, cpu, timestamp, prio)
|
|
elif (inhibit & TDI_SLEEPING):
|
|
Sleep(thread, cpu, timestamp, prio, wmesg)
|
|
elif (inhibit & TDI_LOCK):
|
|
Blocked(thread, cpu, timestamp, prio, lock)
|
|
elif (inhibit & TDI_IWAIT):
|
|
Iwait(thread, cpu, timestamp, prio)
|
|
elif (inhibit & TDI_SUSPENDED):
|
|
Suspended(thread, cpu, timestamp, prio)
|
|
elif (inhibit == 0):
|
|
Yielding(thread, cpu, timestamp, prio)
|
|
else:
|
|
print "Unknown event", inhibit
|
|
sys.exit(1)
|
|
|
|
def idled(self, cpu, timestamp, td, pcomm, prio):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
Idle(thread, cpu, timestamp, prio)
|
|
|
|
def preempted(self, cpu, timestamp, td, pcomm, prio, bytd, bypcomm):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
Preempted(thread, cpu, timestamp, prio,
|
|
self.findtd(bytd, bypcomm))
|
|
|
|
def switchin(self, cpu, timestamp, td, pcomm, prio):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
Running(thread, cpu, timestamp, prio)
|
|
|
|
def sched_add(self, cpu, timestamp, td, pcomm, prio, bytd, bypcomm):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
bythread = self.findtd(bytd, bypcomm)
|
|
Runq(thread, cpu, timestamp, prio, bythread)
|
|
Wokeup(bythread, cpu, timestamp, thread)
|
|
|
|
def sched_rem(self, cpu, timestamp, td, pcomm, prio, bytd, bypcomm):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
KsegrpRunq(thread, cpu, timestamp, prio,
|
|
self.findtd(bytd, bypcomm))
|
|
|
|
def sched_exit(self, cpu, timestamp, td, pcomm, prio):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
Sched_exit(thread, cpu, timestamp, prio)
|
|
|
|
def sched_clock(self, cpu, timestamp, td, pcomm, prio, stathz):
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
self.stathz = stathz
|
|
cpu = int(cpu)
|
|
try:
|
|
ticks = self.ticks[cpu]
|
|
except:
|
|
self.ticks[cpu] = 0
|
|
self.ticks[cpu] += 1
|
|
thread = self.findtd(td, pcomm)
|
|
Tick(thread, cpu, timestamp, prio, stathz)
|
|
|
|
def sched_prio(self, cpu, timestamp, td, pcomm, prio, newprio, bytd, bypcomm):
|
|
if (prio == newprio):
|
|
return
|
|
if (self.checkstamp(timestamp) == 0):
|
|
return
|
|
thread = self.findtd(td, pcomm)
|
|
bythread = self.findtd(bytd, bypcomm)
|
|
Prio(thread, cpu, timestamp, prio, newprio, bythread)
|
|
Lend(bythread, cpu, timestamp, newprio, thread)
|
|
|
|
def cpuload(self, cpu, timestamp, count):
|
|
cpu = int(cpu)
|
|
try:
|
|
load = self.load[cpu]
|
|
except:
|
|
load = Counter("cpu" + str(cpu) + " load")
|
|
self.load[cpu] = load
|
|
self.sources.insert(0, load)
|
|
Count(load, cpu, timestamp, count)
|
|
|
|
def loadglobal(self, cpu, timestamp, count):
|
|
cpu = 0
|
|
try:
|
|
load = self.load[cpu]
|
|
except:
|
|
load = Counter("CPU load")
|
|
self.load[cpu] = load
|
|
self.sources.insert(0, load)
|
|
Count(load, cpu, timestamp, count)
|
|
|
|
def findtd(self, td, pcomm):
|
|
for thread in self.threads:
|
|
if (thread.str == td and thread.name == pcomm):
|
|
return thread
|
|
thread = Thread(td, pcomm)
|
|
self.threads.append(thread)
|
|
self.sources.append(thread)
|
|
return (thread)
|
|
|
|
def fixup(self):
|
|
for source in self.sources:
|
|
Padevent(source, -1, self.timestamp_last)
|
|
Padevent(source, -1, self.timestamp_first, last=1)
|
|
source.fixup()
|
|
|
|
class SchedDisplay(Canvas):
|
|
def __init__(self, master):
|
|
self.ratio = 1
|
|
self.ktrfile = None
|
|
self.sources = None
|
|
self.bdheight = 10
|
|
self.events = {}
|
|
|
|
Canvas.__init__(self, master, width=800, height=500, bg='grey',
|
|
scrollregion=(0, 0, 800, 500))
|
|
|
|
def setfile(self, ktrfile):
|
|
self.ktrfile = ktrfile
|
|
self.sources = ktrfile.sources
|
|
|
|
def draw(self):
|
|
ypos = 0
|
|
xsize = self.xsize()
|
|
for source in self.sources:
|
|
status.startup("Drawing " + source.name)
|
|
self.create_line(0, ypos, xsize, ypos,
|
|
width=1, fill="black", tags=("all",))
|
|
ypos += self.bdheight
|
|
ypos += source.ysize()
|
|
source.draw(self, ypos)
|
|
ypos += self.bdheight
|
|
try:
|
|
self.tag_raise("point", "state")
|
|
self.tag_lower("cpuinfo", "all")
|
|
except:
|
|
pass
|
|
self.create_line(0, ypos, xsize, ypos,
|
|
width=1, fill="black", tags=("all",))
|
|
self.tag_bind("event", "<Enter>", self.mouseenter)
|
|
self.tag_bind("event", "<Leave>", self.mouseexit)
|
|
self.tag_bind("event", "<Button-1>", self.mousepress)
|
|
|
|
def mouseenter(self, event):
|
|
item, = self.find_withtag(CURRENT)
|
|
event = self.events[item]
|
|
event.mouseenter(self, item)
|
|
|
|
def mouseexit(self, event):
|
|
item, = self.find_withtag(CURRENT)
|
|
event = self.events[item]
|
|
event.mouseexit(self, item)
|
|
|
|
def mousepress(self, event):
|
|
item, = self.find_withtag(CURRENT)
|
|
event = self.events[item]
|
|
event.mousepress(self, item)
|
|
|
|
def drawnames(self, canvas):
|
|
status.startup("Drawing names")
|
|
ypos = 0
|
|
canvas.configure(scrollregion=(0, 0,
|
|
canvas["width"], self.ysize()))
|
|
for source in self.sources:
|
|
canvas.create_line(0, ypos, canvas["width"], ypos,
|
|
width=1, fill="black", tags=("all",))
|
|
ypos += self.bdheight
|
|
ypos += source.ysize()
|
|
source.drawname(canvas, ypos)
|
|
ypos += self.bdheight
|
|
canvas.create_line(0, ypos, canvas["width"], ypos,
|
|
width=1, fill="black", tags=("all",))
|
|
|
|
def xsize(self):
|
|
return ((self.ktrfile.timespan() / self.ratio) + 20)
|
|
|
|
def ysize(self):
|
|
ysize = 0
|
|
for source in self.sources:
|
|
ysize += source.ysize() + (self.bdheight * 2)
|
|
return (ysize)
|
|
|
|
def scaleset(self, ratio):
|
|
if (self.ktrfile == None):
|
|
return
|
|
oldratio = self.ratio
|
|
xstart, ystart = self.xview()
|
|
length = (float(self["width"]) / self.xsize())
|
|
middle = xstart + (length / 2)
|
|
|
|
self.ratio = ratio
|
|
self.configure(scrollregion=(0, 0, self.xsize(), self.ysize()))
|
|
self.scale("all", 0, 0, float(oldratio) / ratio, 1)
|
|
|
|
length = (float(self["width"]) / self.xsize())
|
|
xstart = middle - (length / 2)
|
|
self.xview_moveto(xstart)
|
|
|
|
def scaleget(self):
|
|
return self.ratio
|
|
|
|
def setcolor(self, tag, color):
|
|
self.itemconfigure(tag, state="normal", fill=color)
|
|
|
|
def hide(self, tag):
|
|
self.itemconfigure(tag, state="hidden")
|
|
|
|
class GraphMenu(Frame):
|
|
def __init__(self, master):
|
|
Frame.__init__(self, master, bd=2, relief=RAISED)
|
|
self.view = Menubutton(self, text="Configure")
|
|
self.viewmenu = Menu(self.view, tearoff=0)
|
|
self.viewmenu.add_command(label="Events",
|
|
command=self.econf)
|
|
self.view["menu"] = self.viewmenu
|
|
self.view.pack(side=LEFT)
|
|
|
|
def econf(self):
|
|
EventConfigure()
|
|
|
|
|
|
class SchedGraph(Frame):
|
|
def __init__(self, master):
|
|
Frame.__init__(self, master)
|
|
self.menu = None
|
|
self.names = None
|
|
self.display = None
|
|
self.scale = None
|
|
self.status = None
|
|
self.pack(expand=1, fill="both")
|
|
self.buildwidgets()
|
|
self.layout()
|
|
self.draw(sys.argv[1])
|
|
|
|
def buildwidgets(self):
|
|
global status
|
|
self.menu = GraphMenu(self)
|
|
self.display = SchedDisplay(self)
|
|
self.names = Canvas(self,
|
|
width=100, height=self.display["height"],
|
|
bg='grey', scrollregion=(0, 0, 50, 100))
|
|
self.scale = Scaler(self, self.display)
|
|
status = self.status = Status(self)
|
|
self.scrollY = Scrollbar(self, orient="vertical",
|
|
command=self.display_yview)
|
|
self.display.scrollX = Scrollbar(self, orient="horizontal",
|
|
command=self.display.xview)
|
|
self.display["xscrollcommand"] = self.display.scrollX.set
|
|
self.display["yscrollcommand"] = self.scrollY.set
|
|
self.names["yscrollcommand"] = self.scrollY.set
|
|
|
|
def layout(self):
|
|
self.columnconfigure(1, weight=1)
|
|
self.rowconfigure(1, weight=1)
|
|
self.menu.grid(row=0, column=0, columnspan=3, sticky=E+W)
|
|
self.names.grid(row=1, column=0, sticky=N+S)
|
|
self.display.grid(row=1, column=1, sticky=W+E+N+S)
|
|
self.scrollY.grid(row=1, column=2, sticky=N+S)
|
|
self.display.scrollX.grid(row=2, column=0, columnspan=2,
|
|
sticky=E+W)
|
|
self.scale.grid(row=3, column=0, columnspan=3, sticky=E+W)
|
|
self.status.grid(row=4, column=0, columnspan=3, sticky=E+W)
|
|
|
|
def draw(self, file):
|
|
self.master.update()
|
|
ktrfile = KTRFile(file)
|
|
self.display.setfile(ktrfile)
|
|
self.display.drawnames(self.names)
|
|
self.display.draw()
|
|
self.scale.set(250000)
|
|
self.display.xview_moveto(0)
|
|
|
|
def display_yview(self, *args):
|
|
self.names.yview(*args)
|
|
self.display.yview(*args)
|
|
|
|
def setcolor(self, tag, color):
|
|
self.display.setcolor(tag, color)
|
|
|
|
def hide(self, tag):
|
|
self.display.hide(tag)
|
|
|
|
if (len(sys.argv) != 2):
|
|
print "usage:", sys.argv[0], "<ktr file>"
|
|
sys.exit(1)
|
|
|
|
root = Tk()
|
|
root.title("Scheduler Graph")
|
|
graph = SchedGraph(root)
|
|
root.mainloop()
|