3663 lines
114 KiB
Python
3663 lines
114 KiB
Python
#!/usr/bin/env python3
|
||
|
||
"""
|
||
performance-log-viewer.py -- PIKA performance log viewer
|
||
Copyright (C) 2018 Ell
|
||
|
||
This program is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
|
||
Usage: performance-log-viewer.py < infile
|
||
"""
|
||
|
||
import builtins, sys, os, math, statistics, bisect, functools, enum, re, \
|
||
subprocess
|
||
|
||
from collections import namedtuple
|
||
from xml.etree import ElementTree
|
||
|
||
import gi
|
||
gi.require_version ("Gdk", "3.0")
|
||
gi.require_version ("Gtk", "3.0")
|
||
from gi.repository import GLib, GObject, Gio, Gdk, Gtk, Pango
|
||
|
||
def compose (head = None, *tail):
|
||
return (
|
||
lambda *args, **kwargs: head (compose (*tail) (*args, **kwargs))
|
||
) if tail else head or (lambda x: x)
|
||
|
||
def div (x, y):
|
||
return x / y if y else \
|
||
+math.inf if x > 0 else \
|
||
-math.inf if x < 0 else \
|
||
None
|
||
|
||
def format_float (x):
|
||
return "%g" % (round (100 * x) / 100)
|
||
|
||
def format_percentage (x, digits = 0):
|
||
return "%%.%df%%%%" % digits % (100 * x)
|
||
|
||
def format_size (size):
|
||
return GLib.format_size_full (size, GLib.FormatSizeFlags.IEC_UNITS)
|
||
|
||
def format_duration (t):
|
||
return "%02d:%02d:%02d.%02d" % (int (t / 3600),
|
||
int (t / 60) % 60,
|
||
int (t % 60),
|
||
round (100 * t) % 100)
|
||
|
||
def format_color (color):
|
||
return "#%02x%02x%02x" % tuple (
|
||
map (lambda x: min (max (round (255 * x), 0), 255), color)
|
||
)
|
||
|
||
def is_bright_color (color):
|
||
return max (tuple (color)[0:3]) > 0.5
|
||
|
||
def blend_colors (color1, color2, amount):
|
||
color1 = tuple (color1)
|
||
color2 = tuple (color2)
|
||
|
||
a1 = color1[-1]
|
||
a2 = color2[-1]
|
||
|
||
a = (1 - amount) * a1 + amount * a2
|
||
|
||
return tuple (a and ((1 - amount) * a1 * c1 + amount * a2 * c2) / a
|
||
for c1, c2 in zip (color1[:-1], color2[:-1])) + (a,)
|
||
|
||
def rounded_rectangle (cr, x, y, width, height, radius):
|
||
radius = min (radius, width / 2, height / 2)
|
||
|
||
cr.arc (x + radius, y + radius, radius, -math.pi, -math.pi / 2)
|
||
cr.rel_line_to (width - 2 * radius, 0)
|
||
|
||
cr.arc (x + width - radius, y + radius, radius, -math.pi / 2, 0)
|
||
cr.rel_line_to (0, height - 2 * radius)
|
||
|
||
cr.arc (x + width - radius, y + height - radius, radius, 0, math.pi / 2)
|
||
cr.rel_line_to (-(width - 2 * radius), 0)
|
||
|
||
cr.arc (x + radius, y + height - radius, radius, math.pi / 2, math.pi)
|
||
cr.rel_line_to (0, -(height - 2 * radius))
|
||
|
||
cr.close_path ()
|
||
|
||
def get_basename (path):
|
||
match = re.fullmatch (".*[\\\\/](.+?)[\\\\/]?", path)
|
||
|
||
return match[1] if match else path
|
||
|
||
search_path = list (filter (
|
||
bool,
|
||
os.environ.get ("PERFORMANCE_LOG_VIEWER_PATH", ".").split (":")
|
||
))
|
||
|
||
editor_command = os.environ.get ("PERFORMANCE_LOG_VIEWER_EDITOR",
|
||
"xdg-open {file}")
|
||
editor_command += " &"
|
||
|
||
def find_file (filename):
|
||
def lookup (filename):
|
||
filename = re.sub ("[\\\\/]", GLib.DIR_SEPARATOR_S, filename)
|
||
|
||
if GLib.path_is_absolute (filename):
|
||
file = Gio.File.new_for_path (filename)
|
||
|
||
if file.query_exists ():
|
||
return file
|
||
|
||
for path in search_path:
|
||
rest = filename
|
||
|
||
while rest:
|
||
file = Gio.File.new_for_path (GLib.build_filenamev ((path, rest)))
|
||
|
||
if file.query_exists ():
|
||
return file
|
||
|
||
sep = rest.find (GLib.DIR_SEPARATOR_S)
|
||
|
||
rest = rest[sep + 1:] if sep >= 0 else ""
|
||
|
||
return None
|
||
|
||
if filename not in find_file.cache:
|
||
find_file.cache[filename] = lookup (filename)
|
||
|
||
return find_file.cache[filename]
|
||
|
||
find_file.cache = {}
|
||
|
||
def run_editor (file, line):
|
||
subprocess.call (editor_command.format (file = "\"%s\"" % file.get_path (),
|
||
line = line),
|
||
shell = True)
|
||
|
||
VariableType = namedtuple ("VariableType",
|
||
("parse", "format", "format_numeric"))
|
||
|
||
var_types = {
|
||
"boolean": VariableType (
|
||
parse = int,
|
||
format = compose (str, bool),
|
||
format_numeric = format_float
|
||
),
|
||
|
||
"integer": VariableType (
|
||
parse = int,
|
||
format = format_float,
|
||
format_numeric = None
|
||
),
|
||
|
||
"size": VariableType (
|
||
parse = int,
|
||
format = format_size,
|
||
format_numeric = None
|
||
),
|
||
|
||
"size-ratio": VariableType (
|
||
parse = lambda x: div (*map (int, x.split ("/"))),
|
||
format = format_percentage,
|
||
format_numeric = None
|
||
),
|
||
|
||
"int-ratio": VariableType (
|
||
parse = lambda x: div (*map (int, x.split (":"))),
|
||
format = lambda x: "%g:%g" % (
|
||
(0, 0) if math.isnan (x) else
|
||
(1, 0) if x == math.inf else
|
||
(-1, 0) if x == -math.inf else
|
||
(0, 1) if x == 0 else
|
||
(round (100 * x) / 100, 1) if abs (x) > 1 else
|
||
(1, round (100 / x) / 100)
|
||
),
|
||
format_numeric = None
|
||
),
|
||
|
||
"percentage": VariableType (
|
||
parse = float,
|
||
format = format_percentage,
|
||
format_numeric = None
|
||
),
|
||
|
||
"duration": VariableType (
|
||
parse = float,
|
||
format = format_duration,
|
||
format_numeric = None
|
||
),
|
||
|
||
"rate-of-change": VariableType (
|
||
parse = float,
|
||
format = lambda x: "%s/s" % format_size (x),
|
||
format_numeric = None
|
||
)
|
||
}
|
||
var_types = {
|
||
type: VariableType (
|
||
parse = parse,
|
||
format = lambda x, f = format: \
|
||
f (x) if x is not None else "N/A",
|
||
format_numeric = lambda x, f = format_numeric or format:
|
||
f (x) if x is not None else "N/A"
|
||
)
|
||
for type, (parse, format, format_numeric) in var_types.items ()
|
||
}
|
||
|
||
# Read performance log from STDIN
|
||
log = ElementTree.fromstring (sys.stdin.buffer.read ())
|
||
|
||
Variable = namedtuple ("Variable", ("type", "desc", "color"))
|
||
Value = namedtuple ("Value", ("value", "raw"))
|
||
|
||
var_colors = [
|
||
(0.8, 0.4, 0.4),
|
||
(0.8, 0.6, 0.4),
|
||
(0.4, 0.8, 0.4),
|
||
(0.8, 0.8, 0.4),
|
||
(0.4, 0.4, 0.8),
|
||
(0.4, 0.8, 0.8),
|
||
(0.8, 0.4, 0.8),
|
||
(0.8, 0.8, 0.8)
|
||
]
|
||
|
||
var_defs = {}
|
||
|
||
for var in log.find ("var-defs"):
|
||
color = var_colors[len (var_defs) % len (var_colors)]
|
||
|
||
var_defs[var.get ("name")] = Variable (var.get ("type"),
|
||
var.get ("desc"),
|
||
color)
|
||
|
||
AddressInfo = namedtuple ("AddressInfo", ("id",
|
||
"name",
|
||
"object",
|
||
"symbol",
|
||
"offset",
|
||
"source",
|
||
"line"))
|
||
|
||
address_map = {}
|
||
|
||
if log.find ("address-map"):
|
||
for address in log.find ("address-map").iterfind ("address"):
|
||
value = int (address.get ("value"), 0)
|
||
|
||
object = address.find ("object").text
|
||
symbol = address.find ("symbol").text
|
||
base = address.find ("base").text
|
||
source = address.find ("source").text
|
||
line = address.find ("line").text
|
||
|
||
address_map[value] = AddressInfo (
|
||
id = int (base, 0) if base else value,
|
||
name = symbol or base or hex (value),
|
||
object = object,
|
||
symbol = symbol,
|
||
offset = value - int (base, 0) if base else None,
|
||
source = source,
|
||
line = int (line) if line else None
|
||
)
|
||
|
||
class ThreadState (enum.Enum):
|
||
SUSPENDED = enum.auto ()
|
||
RUNNING = enum.auto ()
|
||
|
||
def __str__ (self):
|
||
return {
|
||
ThreadState.SUSPENDED: "S",
|
||
ThreadState.RUNNING: "R"
|
||
}[self]
|
||
|
||
Thread = namedtuple ("Thread", ("id", "name", "state", "frames"))
|
||
Frame = namedtuple ("Frame", ("id", "address", "info"))
|
||
|
||
Sample = namedtuple ("Sample", ("t", "vars", "markers", "backtrace"))
|
||
Marker = namedtuple ("Marker", ("id", "t", "description"))
|
||
|
||
samples = []
|
||
markers = []
|
||
last_marker = 0
|
||
|
||
for element in log.find ("samples"):
|
||
if element.tag == "sample":
|
||
sample = Sample (
|
||
t = int (element.get ("t")),
|
||
vars = {},
|
||
markers = markers[last_marker:],
|
||
backtrace = []
|
||
)
|
||
|
||
for var in element.find ("vars"):
|
||
sample.vars[var.tag] = Value (
|
||
value = var_types[var_defs[var.tag].type].parse (var.text) \
|
||
if var.text else None,
|
||
raw = var.text.strip () if var.text else None
|
||
)
|
||
|
||
if element.find ("backtrace"):
|
||
for thread in element.find ("backtrace").iterfind ("thread"):
|
||
id = thread.get ("id")
|
||
name = thread.get ("name")
|
||
running = thread.get ("running")
|
||
|
||
t = Thread (
|
||
id = int (id),
|
||
name = name,
|
||
state = ThreadState.RUNNING if running and int (running) \
|
||
else ThreadState.SUSPENDED,
|
||
frames = []
|
||
)
|
||
|
||
for frame in thread.iterfind ("frame"):
|
||
address = int (frame.get ("address"), 0)
|
||
|
||
info = address_map.get (address, None)
|
||
|
||
if not info:
|
||
info = AddressInfo (
|
||
id = address,
|
||
name = hex (address),
|
||
object = None,
|
||
symbol = None,
|
||
offset = None,
|
||
source = None,
|
||
line = None
|
||
)
|
||
|
||
t.frames.append (Frame (
|
||
id = len (t.frames),
|
||
address = address,
|
||
info = info
|
||
))
|
||
|
||
sample.backtrace.append (t)
|
||
|
||
samples.append (sample)
|
||
|
||
last_marker = len (markers)
|
||
elif element.tag == "marker":
|
||
marker = Marker (
|
||
id = int (element.get ("id")),
|
||
t = int (element.get ("t")),
|
||
description = element.text.strip () if element.text else None
|
||
)
|
||
|
||
markers.append (marker)
|
||
|
||
if samples:
|
||
samples[-1].markers.extend (markers[last_marker:])
|
||
|
||
DELTA_SAME = __builtins__.object ()
|
||
|
||
def delta_encode (dest, src):
|
||
if type (dest) == type (src):
|
||
if dest == src:
|
||
return DELTA_SAME
|
||
elif type (dest) == tuple:
|
||
return tuple (delta_encode (d, s) for d, s in zip (dest, src)) + \
|
||
dest[len (src):]
|
||
|
||
return dest
|
||
|
||
def delta_decode (dest, src):
|
||
if dest == DELTA_SAME:
|
||
return src
|
||
elif type (dest) == type (src):
|
||
if type (dest) == tuple:
|
||
return tuple (delta_decode (d, s) for d, s in zip (dest, src)) + \
|
||
dest[len (src):]
|
||
|
||
return dest
|
||
|
||
class History (GObject.GObject):
|
||
Source = namedtuple ("HistorySource", ("get", "set"))
|
||
|
||
def __init__ (self):
|
||
GObject.GObject.__init__ (self)
|
||
|
||
self.sources = []
|
||
|
||
self.state = None
|
||
|
||
self.undo_stack = []
|
||
self.redo_stack = []
|
||
|
||
self.blocked = 0
|
||
self.n_groups = 0
|
||
self.pending_record = False
|
||
|
||
@GObject.Property (type = bool, default = False)
|
||
def can_undo (self):
|
||
return bool (self.undo_stack)
|
||
|
||
@GObject.Property (type = bool, default = False)
|
||
def can_redo (self):
|
||
return bool (self.redo_stack)
|
||
|
||
def add_source (self, get, set):
|
||
self.sources.append (self.Source (get, set))
|
||
|
||
def block (self):
|
||
self.blocked += 1
|
||
|
||
def unblock (self):
|
||
self.blocked -= 1
|
||
|
||
def is_blocked (self):
|
||
return self.blocked > 0
|
||
|
||
def start_group (self):
|
||
self.n_groups += 1
|
||
|
||
def end_group (self):
|
||
self.n_groups -= 1
|
||
|
||
if self.n_groups == 0 and self.pending_record:
|
||
self.record ()
|
||
|
||
def record (self):
|
||
if self.is_blocked ():
|
||
return
|
||
|
||
if self.n_groups == 0:
|
||
state = tuple (source.get () for source in self.sources)
|
||
|
||
if self.state is None:
|
||
self.state = state
|
||
else:
|
||
self.pending_record = False
|
||
|
||
delta = delta_encode (self.state, state)
|
||
|
||
if delta == DELTA_SAME:
|
||
return
|
||
|
||
self.undo_stack.append (delta_encode (self.state, state))
|
||
self.redo_stack = []
|
||
|
||
self.state = state
|
||
|
||
self.notify ("can-undo")
|
||
self.notify ("can-redo")
|
||
else:
|
||
self.pending_record = True
|
||
|
||
def update (self):
|
||
if self.is_blocked ():
|
||
return
|
||
|
||
if self.n_groups == 0:
|
||
state = tuple (source.get () for source in self.sources)
|
||
|
||
for stack in self.undo_stack, self.redo_stack:
|
||
if stack:
|
||
stack[-1] = delta_encode (delta_decode (stack[-1],
|
||
self.state),
|
||
state)
|
||
|
||
self.state = state
|
||
else:
|
||
self.pending_record = True
|
||
|
||
def move (self, src, dest):
|
||
self.block ()
|
||
|
||
state = src.pop ()
|
||
|
||
for source, substate, prev_substate in \
|
||
zip (self.sources, self.state, state):
|
||
if prev_substate != DELTA_SAME:
|
||
source.set (delta_decode (prev_substate, substate))
|
||
|
||
state = delta_decode (state, self.state)
|
||
|
||
dest.append (delta_encode (self.state, state))
|
||
|
||
self.state = state
|
||
|
||
self.notify ("can-undo")
|
||
self.notify ("can-redo")
|
||
|
||
self.unblock ()
|
||
|
||
def undo (self):
|
||
self.move (self.undo_stack, self.redo_stack)
|
||
|
||
def redo (self):
|
||
self.move (self.redo_stack, self.undo_stack)
|
||
|
||
history = History ()
|
||
|
||
class SelectionOp (enum.Enum):
|
||
REPLACE = enum.auto ()
|
||
ADD = enum.auto ()
|
||
SUBTRACT = enum.auto ()
|
||
INTERSECT = enum.auto ()
|
||
XOR = enum.auto ()
|
||
|
||
class Selection (GObject.GObject):
|
||
__gsignals__ = {
|
||
"changed": (GObject.SignalFlags.RUN_FIRST, None, ()),
|
||
"change-complete": (GObject.SignalFlags.RUN_FIRST, None, ()),
|
||
"highlight-changed": (GObject.SignalFlags.RUN_FIRST, None, ())
|
||
}
|
||
|
||
def __init__ (self, iter = ()):
|
||
GObject.GObject.__init__ (self)
|
||
|
||
self.selection = set (iter)
|
||
self.highlight = None
|
||
self.cursor = None
|
||
self.cursor_dir = 0
|
||
|
||
self.pending_change_completion = False
|
||
|
||
def __eq__ (self, other):
|
||
return type (self) == type (other) and \
|
||
self.selection == other.selection and \
|
||
self.cursor == other.cursor and \
|
||
self.cursor_dir == other.cursor_dir
|
||
|
||
def __str__ (self):
|
||
n_sel = len (self.selection)
|
||
|
||
if n_sel == 0 or n_sel == len (samples):
|
||
return "All Samples"
|
||
elif n_sel == 1:
|
||
i, = self.selection
|
||
|
||
return "Sample %d" % i
|
||
else:
|
||
sel = list (self.selection)
|
||
|
||
sel.sort ()
|
||
|
||
if all (sel[i] + 1 == sel[i + 1] for i in range (n_sel - 1)):
|
||
return "Samples %d–%d" % (sel[0], sel[-1])
|
||
else:
|
||
return "%d Samples" % n_sel
|
||
|
||
def copy (self):
|
||
selection = Selection ()
|
||
|
||
selection.highlight = self.highlight
|
||
selection.cursor = self.cursor
|
||
selection.cursor_dir = self.cursor_dir
|
||
selection.selection = self.selection.copy ()
|
||
|
||
return selection
|
||
|
||
def get_effective_selection (self):
|
||
if self.selection:
|
||
return self.selection
|
||
else:
|
||
return set (range (len (samples)))
|
||
|
||
def select (self, selection, op = SelectionOp.REPLACE):
|
||
if op == SelectionOp.REPLACE:
|
||
self.selection = selection.copy ()
|
||
elif op == SelectionOp.ADD:
|
||
self.selection |= selection
|
||
elif op == SelectionOp.SUBTRACT:
|
||
self.selection -= selection
|
||
elif op == SelectionOp.INTERSECT:
|
||
self.selection &= selection
|
||
elif op == SelectionOp.XOR:
|
||
self.selection.symmetric_difference_update (selection)
|
||
|
||
if len (self.selection) == 1:
|
||
(self.cursor,) = self.selection
|
||
else:
|
||
self.cursor = None
|
||
|
||
self.cursor_dir = 0
|
||
|
||
self.pending_change_completion = True
|
||
|
||
self.emit ("changed")
|
||
|
||
def select_range (self, first, last, op = SelectionOp.REPLACE):
|
||
if first > last:
|
||
temp = first
|
||
first = last
|
||
last = temp
|
||
|
||
first = max (first, 0)
|
||
last = min (last, len (samples) - 1)
|
||
|
||
if first <= last:
|
||
self.select (set (range (first, last + 1)), op)
|
||
else:
|
||
self.select (set (), op)
|
||
|
||
def clear (self):
|
||
self.select (set ())
|
||
|
||
def invert (self):
|
||
self.select_range (0, len (samples), SelectionOp.XOR)
|
||
|
||
def change_complete (self):
|
||
if self.pending_change_completion:
|
||
self.pending_change_completion = False
|
||
|
||
history.start_group ()
|
||
|
||
history.record ()
|
||
|
||
self.emit ("change-complete")
|
||
|
||
history.end_group ()
|
||
|
||
def set_highlight (self, highlight):
|
||
self.highlight = highlight
|
||
|
||
self.emit ("highlight-changed")
|
||
|
||
def source_get (self):
|
||
return self.copy ()
|
||
|
||
def source_set (self, selection):
|
||
self.cursor = selection.cursor
|
||
self.cursor_dir = selection.cursor_dir
|
||
self.selection = selection.selection.copy ()
|
||
|
||
self.emit ("changed")
|
||
self.emit ("change-complete")
|
||
|
||
def add_history_source (self):
|
||
history.add_source (self.source_get, self.source_set)
|
||
|
||
selection = Selection ()
|
||
selection.add_history_source ()
|
||
|
||
class FindSamplesPopover (Gtk.Popover):
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Popover.__init__ (self, *args, **kwargs)
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL,
|
||
border_width = 20,
|
||
spacing = 8)
|
||
self.add (vbox)
|
||
vbox.show ()
|
||
|
||
entry = Gtk.Entry (width_chars = 40,
|
||
placeholder_text = "Python expression")
|
||
self.entry = entry
|
||
vbox.pack_start (entry, False, False, 0)
|
||
entry.show ()
|
||
|
||
entry.connect ("activate", self.find_samples)
|
||
|
||
entry.get_buffer ().connect (
|
||
"notify::text",
|
||
lambda *args: self.entry.get_style_context ().remove_class ("error")
|
||
)
|
||
|
||
frame = Gtk.Frame (label = "Selection",
|
||
shadow_type = Gtk.ShadowType.NONE)
|
||
vbox.pack_start (frame, False, False, 8)
|
||
frame.get_label_widget ().get_style_context ().add_class ("dim-label")
|
||
frame.show ()
|
||
|
||
vbox2 = Gtk.Box (orientation = Gtk.Orientation.VERTICAL,
|
||
border_width = 8,
|
||
spacing = 8)
|
||
frame.add (vbox2)
|
||
vbox2.show ()
|
||
|
||
self.radios = []
|
||
|
||
radio = Gtk.RadioButton.new_with_mnemonic (None, "_Replace")
|
||
self.radios.append ((radio, SelectionOp.REPLACE))
|
||
vbox2.pack_start (radio, False, False, 0)
|
||
radio.show ()
|
||
|
||
radio = Gtk.RadioButton.new_with_mnemonic_from_widget (radio, "_Add")
|
||
self.radios.append ((radio, SelectionOp.ADD))
|
||
vbox2.pack_start (radio, False, False, 0)
|
||
radio.show ()
|
||
|
||
radio = Gtk.RadioButton.new_with_mnemonic_from_widget (radio, "_Subtract")
|
||
self.radios.append ((radio, SelectionOp.SUBTRACT))
|
||
vbox2.pack_start (radio, False, False, 0)
|
||
radio.show ()
|
||
|
||
radio = Gtk.RadioButton.new_with_mnemonic_from_widget (radio, "_Intersect")
|
||
self.radios.append ((radio, SelectionOp.INTERSECT))
|
||
vbox2.pack_start (radio, False, False, 0)
|
||
radio.show ()
|
||
|
||
button = Gtk.Button.new_with_mnemonic ("_Find")
|
||
vbox.pack_start (button, False, False, 0)
|
||
button.set_halign (Gtk.Align.CENTER)
|
||
button.show ()
|
||
|
||
button.connect ("clicked", self.find_samples)
|
||
|
||
def do_hide (self):
|
||
self.entry.set_text ("")
|
||
self.entry.get_style_context ().remove_class ("error")
|
||
|
||
Gtk.Popover.do_hide (self)
|
||
|
||
def find_samples (self, *args):
|
||
def var_name (var):
|
||
return var.replace ("-", "_")
|
||
|
||
try:
|
||
f = eval ("lambda thread, function, %s: %s" % (
|
||
", ".join (map (var_name, var_defs)),
|
||
self.entry.get_text ()))
|
||
except:
|
||
self.entry.get_style_context ().add_class ("error")
|
||
|
||
return
|
||
|
||
sel = set ()
|
||
|
||
for i in range (len (samples)):
|
||
try:
|
||
def match_thread (thread, id, state = None):
|
||
return (id is None or \
|
||
(type (id) == int and \
|
||
id == thread.id) or \
|
||
(type (id) == str and \
|
||
thread.name and \
|
||
re.fullmatch (id, thread.name))) and \
|
||
(state is None or \
|
||
re.fullmatch (state, str (thread.state)))
|
||
|
||
def thread (id, state = None):
|
||
return any (match_thread (thread, id, state)
|
||
for thread in samples[i].backtrace or [])
|
||
|
||
def function (name, id = None, state = None):
|
||
for thread in samples[i].backtrace or []:
|
||
if match_thread (thread, id, state):
|
||
for frame in thread.frames:
|
||
if re.fullmatch (name, frame.info.name):
|
||
return True
|
||
|
||
return False
|
||
|
||
if f (thread, function, **{
|
||
var_name (var): value.value
|
||
for var, value in samples[i].vars.items ()
|
||
}):
|
||
sel.add (i)
|
||
except:
|
||
pass
|
||
|
||
op = [op for radio, op in self.radios if radio.get_active ()][0]
|
||
|
||
selection.select (sel, op)
|
||
|
||
selection.change_complete ()
|
||
|
||
self.hide ()
|
||
|
||
class CellRendererColorToggle (Gtk.CellRendererToggle):
|
||
padding = 3
|
||
|
||
color = GObject.Property (type = Gdk.RGBA, default = Gdk.RGBA (0, 0, 0))
|
||
|
||
def do_render (self, cr, widget, background_area, cell_area, flags):
|
||
state = widget.get_state_flags ()
|
||
style = widget.get_style_context ()
|
||
fg_color = style.get_color (state)
|
||
active = self.get_property ("active")
|
||
size = max (min (cell_area.width, cell_area.height) -
|
||
2 * self.padding,
|
||
0)
|
||
|
||
(r, g, b, a) = self.color
|
||
|
||
if is_bright_color (fg_color):
|
||
bg = (0.75 * r, 0.75 * g, 0.75 * b)
|
||
fg = (r, g, b)
|
||
else:
|
||
bg = (r, g, b)
|
||
fg = (0.75 * r, 0.75 * g, 0.75 * b)
|
||
|
||
x = cell_area.x + (cell_area.width - size) // 2
|
||
y = cell_area.y + (cell_area.height - size) // 2
|
||
|
||
if active:
|
||
cr.rectangle (x, y, size, size)
|
||
|
||
cr.set_source_rgba (*bg)
|
||
cr.fill ()
|
||
else:
|
||
style.save ()
|
||
|
||
style.set_state (Gtk.StateFlags (state & ~Gtk.StateFlags.SELECTED))
|
||
Gtk.render_background (style, cr, x, y, size, size)
|
||
|
||
style.restore ()
|
||
|
||
cr.rectangle (x, y, size, size)
|
||
|
||
cr.set_source_rgb (*fg)
|
||
cr.set_line_width (2)
|
||
cr.stroke ()
|
||
|
||
class VariableSet (Gtk.TreeView):
|
||
class Store (Gtk.ListStore):
|
||
NAME = 0
|
||
DESC = 1
|
||
COLOR = 2
|
||
ACTIVE = 3
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self, str, str, Gdk.RGBA, bool)
|
||
|
||
for var, var_def in var_defs.items ():
|
||
i = self.append ((var,
|
||
var_def.desc,
|
||
Gdk.RGBA (*var_def.color),
|
||
False))
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.TreeView.__init__ (self, *args, headers_visible = False, **kwargs)
|
||
|
||
store = self.Store ()
|
||
self.store = store
|
||
self.set_model (store)
|
||
self.set_tooltip_column (store.DESC)
|
||
|
||
col = Gtk.TreeViewColumn ()
|
||
self.append_column (col)
|
||
|
||
cell = CellRendererColorToggle ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "active", store.ACTIVE)
|
||
col.add_attribute (cell, "color", store.COLOR)
|
||
|
||
cell.connect ("toggled", self.var_toggled)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, True)
|
||
col.add_attribute (cell, "text", store.NAME)
|
||
|
||
def var_toggled (self, cell, path):
|
||
self.store[path][self.store.ACTIVE] = not cell.get_property ("active")
|
||
|
||
class SampleGraph (Gtk.DrawingArea):
|
||
def __init__ (self, model = None, *args, **kwargs):
|
||
Gtk.DrawingArea.__init__ (self, *args, can_focus = True, **kwargs)
|
||
|
||
self.style_widget = Gtk.Entry ()
|
||
|
||
self.model = model
|
||
|
||
if model:
|
||
model.connect ("row-changed", lambda *args: self.update ())
|
||
|
||
self.update ()
|
||
|
||
self.selection = None
|
||
self.sel = None
|
||
|
||
selection.connect ("changed", self.selection_changed)
|
||
selection.connect ("highlight-changed",
|
||
lambda selection: self.queue_draw ())
|
||
|
||
self.add_events (Gdk.EventMask.BUTTON_PRESS_MASK |
|
||
Gdk.EventMask.BUTTON_RELEASE_MASK |
|
||
Gdk.EventMask.KEY_PRESS_MASK |
|
||
Gdk.EventMask.KEY_RELEASE_MASK)
|
||
|
||
self.selection_changed (selection)
|
||
|
||
def sample_to_x (self, i):
|
||
if not samples:
|
||
return None
|
||
|
||
width = self.get_allocated_width ()
|
||
n_samples = max (len (samples), 2)
|
||
|
||
return 1 + (width - 3) * i / (n_samples - 1)
|
||
|
||
def sample_to_range (self, i):
|
||
if not samples:
|
||
return None
|
||
|
||
width = self.get_allocated_width ()
|
||
n_samples = max (len (samples), 2)
|
||
|
||
return (1 + math.floor ((width - 3) * (i - 0.5) / (n_samples - 1)),
|
||
1 + math.ceil ((width - 3) * (i + 0.5) / (n_samples - 1)))
|
||
|
||
def x_to_sample (self, x):
|
||
if not samples:
|
||
return None
|
||
|
||
width = max (self.get_allocated_width (), 4)
|
||
n_samples = len (samples)
|
||
|
||
return round ((n_samples - 1) * (x - 1) / (width - 3))
|
||
|
||
def update (self):
|
||
if not samples or not self.model:
|
||
return
|
||
|
||
self.max_value = 1
|
||
|
||
for row in self.model:
|
||
var_name = row[self.model.NAME]
|
||
var_active = row[self.model.ACTIVE]
|
||
|
||
if var_active:
|
||
values = (sample.vars[var_name].value for sample in samples)
|
||
values = filter (lambda x: x is not None, values)
|
||
values = filter (math.isfinite, values)
|
||
|
||
try:
|
||
self.max_value = max (self.max_value, max (values))
|
||
except:
|
||
pass
|
||
|
||
self.queue_draw ()
|
||
|
||
def selection_changed (self, selection):
|
||
if selection.selection:
|
||
self.sel = list (selection.selection)
|
||
self.sel.sort ()
|
||
else:
|
||
self.sel = None
|
||
|
||
self.queue_draw ()
|
||
|
||
def do_get_preferred_width (self):
|
||
return (300, 300)
|
||
|
||
def do_get_preferred_height (self):
|
||
if self.model:
|
||
return (32, 256)
|
||
else:
|
||
return (16, 16)
|
||
|
||
def update_selection (self):
|
||
sel = self.selection.copy ()
|
||
|
||
i0 = self.selection_i0
|
||
i1 = self.selection_i1
|
||
|
||
if self.selection_range:
|
||
swap = i0 > i1
|
||
|
||
if swap:
|
||
temp = i0
|
||
i0 = i1
|
||
i1 = temp
|
||
|
||
n_samples = len (samples)
|
||
|
||
while i0 > 0 and not samples[i0 - 1].markers: i0 -= 1
|
||
while i1 < n_samples - 1 and not samples[i1 + 1].markers: i1 += 1
|
||
|
||
if swap:
|
||
temp = i0
|
||
i0 = i1
|
||
i1 = temp
|
||
|
||
sel.select_range (i0, i1, self.selection_op)
|
||
|
||
selection.select (sel.selection)
|
||
|
||
selection.cursor = i1
|
||
selection.cursor_dir = i1 - i0
|
||
|
||
def do_button_press_event (self, event):
|
||
state = event.state & Gdk.ModifierType.MODIFIER_MASK
|
||
|
||
self.grab_focus ()
|
||
|
||
if event.button == 1:
|
||
i = self.x_to_sample (event.x)
|
||
|
||
if i is None:
|
||
return False
|
||
|
||
self.selection = selection.copy ()
|
||
self.selection_i0 = i
|
||
self.selection_i1 = i
|
||
self.selection_op = SelectionOp.REPLACE
|
||
self.selection_range = event.type != Gdk.EventType.BUTTON_PRESS
|
||
|
||
if state == Gdk.ModifierType.SHIFT_MASK:
|
||
self.selection_op = SelectionOp.ADD
|
||
elif state == Gdk.ModifierType.CONTROL_MASK:
|
||
self.selection_op = SelectionOp.SUBTRACT
|
||
elif state == (Gdk.ModifierType.SHIFT_MASK |
|
||
Gdk.ModifierType.CONTROL_MASK):
|
||
self.selection_op = SelectionOp.INTERSECT
|
||
|
||
self.update_selection ()
|
||
|
||
self.grab_add ()
|
||
elif event.button == 3:
|
||
if state == 0:
|
||
selection.clear ()
|
||
elif state == Gdk.ModifierType.CONTROL_MASK:
|
||
selection.invert ()
|
||
|
||
self.grab_add ()
|
||
|
||
return True
|
||
|
||
def do_button_release_event (self, event):
|
||
if event.button == 1 or event.button == 3:
|
||
self.selection = None
|
||
|
||
selection.change_complete ()
|
||
|
||
self.grab_remove ()
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
def do_motion_notify_event (self, event):
|
||
i = self.x_to_sample (event.x)
|
||
|
||
selection.set_highlight (i)
|
||
|
||
if self.selection and i is not None:
|
||
self.selection_i1 = i
|
||
|
||
self.update_selection ()
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
def do_leave_notify_event (self, event):
|
||
selection.set_highlight (None)
|
||
|
||
return False
|
||
|
||
def do_key_press_event (self, event):
|
||
if event.keyval == Gdk.KEY_Left or \
|
||
event.keyval == Gdk.KEY_Right or \
|
||
event.keyval == Gdk.KEY_Home or \
|
||
event.keyval == Gdk.KEY_KP_Home or \
|
||
event.keyval == Gdk.KEY_End or \
|
||
event.keyval == Gdk.KEY_KP_End:
|
||
n_samples = len (samples)
|
||
|
||
state = event.state & Gdk.ModifierType.MODIFIER_MASK
|
||
|
||
op = SelectionOp.REPLACE
|
||
|
||
if state == Gdk.ModifierType.SHIFT_MASK:
|
||
op = SelectionOp.XOR
|
||
|
||
cursor = selection.cursor
|
||
cursor_dir = selection.cursor_dir
|
||
|
||
if event.keyval == Gdk.KEY_Left or \
|
||
event.keyval == Gdk.KEY_Home or \
|
||
event.keyval == Gdk.KEY_KP_Home:
|
||
if selection.cursor is not None:
|
||
if cursor_dir <= 0 or op == SelectionOp.REPLACE:
|
||
cursor -= 1
|
||
else:
|
||
cursor = n_samples - 1
|
||
|
||
cursor_dir = -1
|
||
elif event.keyval == Gdk.KEY_Right or \
|
||
event.keyval == Gdk.KEY_End or \
|
||
event.keyval == Gdk.KEY_KP_End:
|
||
if cursor is not None:
|
||
if cursor_dir >= 0 or op == SelectionOp.REPLACE:
|
||
cursor += 1
|
||
else:
|
||
cursor = 0
|
||
|
||
cursor_dir = +1
|
||
|
||
if cursor < 0 or cursor >= n_samples:
|
||
cursor = min (max (cursor, 0), n_samples - 1)
|
||
|
||
selection.cursor = cursor
|
||
selection.cursor_dir = cursor_dir
|
||
|
||
if op != SelectionOp.REPLACE:
|
||
return True
|
||
|
||
i0 = cursor
|
||
|
||
if event.keyval == Gdk.KEY_Home or \
|
||
event.keyval == Gdk.KEY_KP_Home:
|
||
cursor = 0
|
||
elif event.keyval == Gdk.KEY_End or \
|
||
event.keyval == Gdk.KEY_KP_End:
|
||
cursor = n_samples - 1
|
||
|
||
if op == SelectionOp.REPLACE:
|
||
i0 = cursor
|
||
|
||
selection.select_range (i0, cursor, op)
|
||
|
||
if len (selection.selection) > 1:
|
||
selection.cursor = cursor
|
||
selection.cursor_dir = cursor_dir
|
||
|
||
return True
|
||
elif event.keyval == Gdk.KEY_Escape:
|
||
selection.select (set ())
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
def do_key_release_event (self, event):
|
||
selection.change_complete ()
|
||
|
||
return False
|
||
|
||
def do_draw (self, cr):
|
||
state = self.get_state_flags ()
|
||
style = (self.style_widget if self.model else
|
||
self).get_style_context ()
|
||
(width, height) = (self.get_allocated_width (),
|
||
self.get_allocated_height ())
|
||
|
||
fg_color = tuple (style.get_color (state))
|
||
grid_color = (*fg_color[:3], 0.25 * fg_color[3])
|
||
highlight_color = grid_color
|
||
selection_color = (*fg_color[:3], 0.15 * fg_color[3])
|
||
|
||
Gtk.render_background (style, cr, 0, 0, width, height)
|
||
|
||
if self.model:
|
||
max_value = self.max_value
|
||
vscale = (height - 4) / max_value
|
||
|
||
cr.save ()
|
||
|
||
cr.translate (0, height - 2)
|
||
cr.scale (1, -1)
|
||
|
||
first_sample = True
|
||
has_infinite = False
|
||
|
||
for row in self.model:
|
||
var_name = row[self.model.NAME]
|
||
var_active = row[self.model.ACTIVE]
|
||
|
||
if var_active:
|
||
is_boolean = var_defs[var_name].type == "boolean"
|
||
is_continuous = not is_boolean
|
||
|
||
for i in range (len (samples)):
|
||
value = samples[i].vars[var_name].value
|
||
|
||
if value is not None:
|
||
first_sample = False
|
||
|
||
if math.isinf (value):
|
||
first_sample = True
|
||
has_infinite = True
|
||
|
||
value = max_value
|
||
elif is_boolean:
|
||
value *= max_value
|
||
|
||
y = value * vscale
|
||
|
||
if is_continuous:
|
||
x = self.sample_to_x (i)
|
||
|
||
if first_sample:
|
||
cr.move_to (x, y)
|
||
else:
|
||
cr.line_to (x, y)
|
||
else:
|
||
(x0, x1) = self.sample_to_range (i)
|
||
|
||
if first_sample:
|
||
cr.move_to (x0, y)
|
||
else:
|
||
cr.line_to (x0, y)
|
||
|
||
cr.line_to (x1, y)
|
||
else:
|
||
first_sample = True
|
||
|
||
(r, g, b) = var_defs[var_name].color
|
||
|
||
cr.set_source_rgb (r, g, b)
|
||
cr.set_line_width (2)
|
||
cr.stroke ()
|
||
|
||
if has_infinite:
|
||
cr.save ()
|
||
|
||
for i in range (len (samples)):
|
||
value = samples[i].vars[var_name].value
|
||
|
||
if value is not None and math.isinf (value):
|
||
first_sample = False
|
||
|
||
y = max_value * vscale
|
||
|
||
if is_continuous:
|
||
x = self.sample_to_x (i)
|
||
|
||
if first_sample:
|
||
cr.move_to (x, y)
|
||
else:
|
||
cr.line_to (x, y)
|
||
else:
|
||
(x0, x1) = self.sample_to_range (i)
|
||
|
||
if first_sample:
|
||
cr.move_to (x0, y)
|
||
else:
|
||
cr.line_to (x0, y)
|
||
|
||
cr.line_to (x1, y)
|
||
else:
|
||
first_sample = True
|
||
|
||
cr.set_dash ([6, 6], 0)
|
||
cr.stroke ()
|
||
|
||
cr.restore ()
|
||
|
||
cr.restore ()
|
||
|
||
cr.set_line_width (1)
|
||
|
||
cr.set_source_rgba (*grid_color)
|
||
|
||
n_hgrid_lines = 4
|
||
n_vgrid_lines = 1
|
||
|
||
for i in range (n_hgrid_lines + 1):
|
||
cr.move_to (0, round (i * (height - 1) / n_hgrid_lines) + 0.5)
|
||
cr.rel_line_to (width, 0)
|
||
|
||
cr.stroke ()
|
||
|
||
for i in range (n_vgrid_lines + 1):
|
||
cr.move_to (round (i * (width - 1) / n_vgrid_lines) + 0.5, 0)
|
||
cr.rel_line_to (0, height)
|
||
|
||
cr.stroke ()
|
||
else:
|
||
for i in range (len (samples)):
|
||
if samples[i].markers:
|
||
(x0, x1) = self.sample_to_range (i)
|
||
|
||
cr.rectangle (x0, 0, x1 - x0, height)
|
||
|
||
cr.set_source_rgba (*fg_color)
|
||
cr.fill ()
|
||
|
||
if selection.highlight is not None:
|
||
(x0, x1) = self.sample_to_range (selection.highlight)
|
||
|
||
cr.rectangle (x0, 0, x1 - x0, height)
|
||
|
||
(r, g, b, a) = style.get_color (state)
|
||
|
||
cr.set_source_rgba (*highlight_color)
|
||
cr.fill ()
|
||
|
||
if self.sel:
|
||
def draw_selection ():
|
||
x0 = self.sample_to_range (i0)[0]
|
||
x1 = self.sample_to_range (i1)[1]
|
||
|
||
cr.rectangle (x0, 0, x1 - x0, height)
|
||
|
||
(r, g, b, a) = style.get_color (state)
|
||
|
||
cr.set_source_rgba (*selection_color)
|
||
cr.fill ()
|
||
|
||
i0 = None
|
||
|
||
for i in self.sel:
|
||
if i0 is None:
|
||
i0 = i
|
||
i1 = i
|
||
elif i == i1 + 1:
|
||
i1 = i
|
||
else:
|
||
draw_selection ()
|
||
|
||
i0 = i
|
||
i1 = i
|
||
|
||
if i0 is not None:
|
||
draw_selection ()
|
||
|
||
class SampleGraphList (Gtk.Box):
|
||
Item = namedtuple (
|
||
"SampleGraphListGraph", ("widget",
|
||
"model",
|
||
"remove_button",
|
||
"move_up_button",
|
||
"move_down_button")
|
||
)
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Box.__init__ (self,
|
||
*args,
|
||
orientation = Gtk.Orientation.VERTICAL,
|
||
**kwargs)
|
||
|
||
self.items = []
|
||
|
||
self.vset_size_group = Gtk.SizeGroup (
|
||
mode = Gtk.SizeGroupMode.HORIZONTAL
|
||
)
|
||
|
||
hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
|
||
self.pack_start (hbox, False, False, 0)
|
||
hbox.show ()
|
||
|
||
empty = Gtk.DrawingArea ()
|
||
hbox.pack_start (empty, False, True, 0)
|
||
self.vset_size_group.add_widget (empty)
|
||
empty.show ()
|
||
|
||
graph = SampleGraph (has_tooltip = True)
|
||
hbox.pack_start (graph, True, True, 0)
|
||
graph.show ()
|
||
|
||
graph.connect ("query-tooltip", self.graph_query_tooltip)
|
||
|
||
separator = Gtk.Separator (orientation = Gtk.Orientation.HORIZONTAL)
|
||
self.pack_start (separator, False, False, 0)
|
||
separator.show ()
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
|
||
self.items_vbox = vbox
|
||
self.pack_start (vbox, False, False, 0)
|
||
vbox.show ()
|
||
|
||
self.add_item (0)
|
||
|
||
def update_items (self):
|
||
for widget in self.items_vbox.get_children ():
|
||
self.items_vbox.remove (widget)
|
||
|
||
i = 0
|
||
|
||
for item in self.items:
|
||
if i > 0:
|
||
separator = Gtk.Separator (
|
||
orientation = Gtk.Orientation.HORIZONTAL
|
||
)
|
||
self.items_vbox.pack_start (separator, False, False, 0)
|
||
separator.show ()
|
||
|
||
self.items_vbox.pack_start (item.widget, False, False, 0)
|
||
|
||
item.remove_button.set_sensitive (len (self.items) > 1)
|
||
item.move_up_button.set_sensitive (i > 0)
|
||
item.move_down_button.set_sensitive (i < len (self.items) - 1)
|
||
|
||
i += 1
|
||
|
||
def add_item (self, i):
|
||
hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
|
||
hbox.show ()
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
|
||
hbox.pack_start (vbox, False, True, 0)
|
||
self.vset_size_group.add_widget (vbox)
|
||
vbox.show ()
|
||
|
||
scroll = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.NEVER,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
|
||
)
|
||
vbox.pack_start (scroll, True, True, 0)
|
||
scroll.show ()
|
||
|
||
vset = VariableSet ()
|
||
scroll.add (vset)
|
||
vset.show ()
|
||
|
||
buttons = Gtk.ButtonBox (orientation = Gtk.Orientation.HORIZONTAL)
|
||
vbox.pack_start (buttons, False, False, 0)
|
||
buttons.set_layout (Gtk.ButtonBoxStyle.EXPAND)
|
||
buttons.show ()
|
||
|
||
button = Gtk.Button.new_from_icon_name ("list-add-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
add_button = button
|
||
buttons.add (button)
|
||
button.show ()
|
||
|
||
button = Gtk.Button.new_from_icon_name ("list-remove-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
remove_button = button
|
||
buttons.add (button)
|
||
button.show ()
|
||
|
||
button = Gtk.Button.new_from_icon_name ("go-up-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
move_up_button = button
|
||
buttons.add (button)
|
||
button.show ()
|
||
|
||
button = Gtk.Button.new_from_icon_name ("go-down-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
move_down_button = button
|
||
buttons.add (button)
|
||
button.show ()
|
||
|
||
graph = SampleGraph (vset.get_model (), has_tooltip = True)
|
||
hbox.pack_start (graph, True, True, 0)
|
||
graph.show ()
|
||
|
||
graph.connect ("query-tooltip", self.graph_query_tooltip)
|
||
|
||
item = self.Item (
|
||
widget = hbox,
|
||
model = vset.get_model (),
|
||
remove_button = remove_button,
|
||
move_up_button = move_up_button,
|
||
move_down_button = move_down_button
|
||
)
|
||
self.items.insert (i, item)
|
||
|
||
add_button.connect ("clicked",
|
||
lambda *args: self.add_item (
|
||
self.items.index (item) + 1
|
||
))
|
||
remove_button.connect ("clicked",
|
||
lambda *args: self.remove_item (
|
||
self.items.index (item)
|
||
))
|
||
move_up_button.connect ("clicked",
|
||
lambda *args: self.move_item (
|
||
self.items.index (item),
|
||
-1
|
||
))
|
||
move_down_button.connect ("clicked",
|
||
lambda *args: self.move_item (
|
||
self.items.index (item),
|
||
+1
|
||
))
|
||
|
||
self.update_items ()
|
||
|
||
def remove_item (self, i):
|
||
del self.items[i]
|
||
|
||
self.update_items ()
|
||
|
||
def move_item (self, i, offset):
|
||
item = self.items[i]
|
||
del self.items[i]
|
||
self.items.insert (i + offset, item)
|
||
|
||
self.update_items ()
|
||
|
||
def graph_query_tooltip (self, graph, x, y, keyboard_mode, tooltip):
|
||
if keyboard_mode:
|
||
return False
|
||
|
||
i = graph.x_to_sample (x)
|
||
|
||
if i is None or i < 0 or i >= len (samples):
|
||
return False
|
||
|
||
grid = Gtk.Grid (column_spacing = 4)
|
||
tooltip.set_custom (grid)
|
||
grid.show ()
|
||
|
||
row = 0
|
||
|
||
label = Gtk.Label ()
|
||
grid.attach (label, 0, row, 2, 1)
|
||
label.set_markup ("<b>Sample %d</b>" % i)
|
||
label.show ()
|
||
|
||
row += 1
|
||
|
||
label = Gtk.Label ()
|
||
grid.attach (label, 0, row, 2, 1)
|
||
label.set_markup ("<sub>%s</sub>" %
|
||
format_duration (samples[i].t / 1000000))
|
||
label.get_style_context ().add_class ("dim-label")
|
||
label.show ()
|
||
|
||
row += 1
|
||
|
||
for item in self.items:
|
||
model = item.model
|
||
|
||
vars = tuple (var[model.NAME] for var in model if var[model.ACTIVE])
|
||
|
||
if not vars:
|
||
continue
|
||
|
||
separator = Gtk.Separator (orientation = Gtk.Orientation.HORIZONTAL)
|
||
grid.attach (separator, 0, row, 2, 1)
|
||
separator.show ()
|
||
|
||
row += 1
|
||
|
||
for var in vars:
|
||
color = format_color (var_defs[var].color)
|
||
|
||
label = Gtk.Label (halign = Gtk.Align.START)
|
||
grid.attach (label, 0, row, 1, 1)
|
||
label.set_markup (
|
||
"<span color=\"%s\"><b>%s</b></span>" % (color, var)
|
||
)
|
||
label.show ()
|
||
|
||
value = samples[i].vars[var].value
|
||
text = var_types[var_defs[var].type].format (value) \
|
||
if value is not None else "N/A"
|
||
|
||
label = Gtk.Label (label = text, halign = Gtk.Align.END)
|
||
grid.attach (label, 1, row, 1, 1)
|
||
label.show ()
|
||
|
||
row += 1
|
||
|
||
markers = samples[i].markers
|
||
|
||
if markers:
|
||
separator = Gtk.Separator (orientation = Gtk.Orientation.HORIZONTAL)
|
||
grid.attach (separator, 0, row, 2, 1)
|
||
separator.show ()
|
||
|
||
row += 1
|
||
|
||
for marker in markers:
|
||
label = Gtk.Label (halign = Gtk.Align.START)
|
||
grid.attach (label, 0, row, 1, 1)
|
||
label.set_markup ("<b>Marker %d</b>" % (marker.id))
|
||
label.show ()
|
||
|
||
if marker.description:
|
||
label = Gtk.Label (marker.description,
|
||
halign = Gtk.Align.END)
|
||
grid.attach (label, 1, row, 1, 1)
|
||
label.show ()
|
||
|
||
row += 1
|
||
|
||
return True
|
||
|
||
class InformationViewer (Gtk.ScrolledWindow):
|
||
class Store (Gtk.ListStore):
|
||
NAME = 0
|
||
VALUE = 1
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self, str, str)
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.ScrolledWindow.__init__ (
|
||
self,
|
||
*args,
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
**kwargs
|
||
)
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL,
|
||
border_width = 32,
|
||
margin_left = 64,
|
||
margin_right = 64,
|
||
spacing = 32)
|
||
self.add (vbox)
|
||
vbox.show ()
|
||
|
||
def add_element (element):
|
||
name = {
|
||
"params": "Log Parameters",
|
||
"pika-version": "PIKA Version",
|
||
"env": "Environment",
|
||
"gegl-config": "GEGL Config"
|
||
}.get (element.tag, element.tag)
|
||
text = element.text.strip ()
|
||
n_items = len (element)
|
||
|
||
if not text and n_items == 0:
|
||
return
|
||
|
||
vbox2 = Gtk.Box (orientation = Gtk.Orientation.VERTICAL,
|
||
spacing = 16)
|
||
vbox.pack_start (vbox2, False, False, 0)
|
||
vbox2.show ()
|
||
|
||
label = Gtk.Label (xalign = 0)
|
||
vbox2.pack_start (label, False, False, 0)
|
||
label.set_markup ("<b>%s</b>" % name)
|
||
label.show ()
|
||
|
||
frame = Gtk.Frame (shadow_type = Gtk.ShadowType.IN)
|
||
vbox2.pack_start (frame, False, False, 0)
|
||
frame.show ()
|
||
|
||
if text:
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
height_request = 400
|
||
)
|
||
frame.add (scrolled)
|
||
scrolled.show ()
|
||
|
||
text = Gtk.TextView (editable = False,
|
||
monospace = True,
|
||
wrap_mode = Gtk.WrapMode.WORD,
|
||
left_margin = 16,
|
||
right_margin = 16,
|
||
top_margin = 16,
|
||
bottom_margin = 16)
|
||
scrolled.add (text)
|
||
text.get_buffer ().set_text (element.text.strip (), -1)
|
||
text.show ()
|
||
else:
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.NEVER
|
||
)
|
||
frame.add (scrolled)
|
||
scrolled.show ()
|
||
|
||
store = self.Store ()
|
||
|
||
for item in element:
|
||
store.append ((item.tag, item.text.strip ()))
|
||
|
||
tree = Gtk.TreeView (model = store)
|
||
scrolled.add (tree)
|
||
tree.show ()
|
||
|
||
col = Gtk.TreeViewColumn (title = "Name")
|
||
tree.append_column (col)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.NAME)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Value")
|
||
tree.append_column (col)
|
||
col.set_alignment (0.5)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.VALUE)
|
||
|
||
params = log.find ("params")
|
||
|
||
if params:
|
||
add_element (params)
|
||
|
||
info = log.find ("info")
|
||
|
||
if info:
|
||
for element in info:
|
||
add_element (element)
|
||
|
||
class MarkersViewer (Gtk.ScrolledWindow):
|
||
class Store (Gtk.ListStore):
|
||
ID = 0
|
||
TIME = 1
|
||
DESC = 2
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self, int, GObject.TYPE_INT64, str)
|
||
|
||
for marker in markers:
|
||
self.append ((marker.id, marker.t, marker.description))
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Box.__init__ (self,
|
||
*args,
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
**kwargs)
|
||
|
||
self.needs_update = True
|
||
|
||
store = self.Store ()
|
||
self.store = store
|
||
|
||
tree = Gtk.TreeView (model = store)
|
||
self.tree = tree
|
||
self.add (tree)
|
||
tree.show ()
|
||
|
||
tree.get_selection ().set_mode (Gtk.SelectionMode.MULTIPLE)
|
||
|
||
self.tree_selection_changed_handler = tree.get_selection ().connect (
|
||
"changed", self.tree_selection_changed
|
||
)
|
||
|
||
col = Gtk.TreeViewColumn (title = "#")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.ID)
|
||
|
||
def format_time_col (tree_col, cell, model, iter, col):
|
||
time = model[iter][col]
|
||
|
||
cell.set_property ("text", format_duration (time / 1000000))
|
||
|
||
col = Gtk.TreeViewColumn (title = "Time")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
col.set_alignment (0.5)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.set_cell_data_func (cell, format_time_col, store.TIME)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Description")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
col.set_alignment (0.5)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.DESC)
|
||
|
||
col = Gtk.TreeViewColumn ()
|
||
tree.append_column (col)
|
||
|
||
selection.connect ("change-complete", self.selection_change_complete)
|
||
|
||
def update (self):
|
||
markers = set ()
|
||
|
||
if not self.needs_update:
|
||
return
|
||
|
||
self.needs_update = False
|
||
|
||
for i in selection.selection:
|
||
markers.update (marker.id for marker in samples[i].markers)
|
||
|
||
tree_sel = self.tree.get_selection ()
|
||
|
||
GObject.signal_handler_block (tree_sel,
|
||
self.tree_selection_changed_handler)
|
||
|
||
tree_sel.unselect_all ()
|
||
|
||
for row in self.store:
|
||
if row[self.store.ID] in markers:
|
||
tree_sel.select_iter (row.iter)
|
||
|
||
GObject.signal_handler_unblock (tree_sel,
|
||
self.tree_selection_changed_handler)
|
||
|
||
def do_map (self):
|
||
self.update ()
|
||
|
||
Gtk.ScrolledWindow.do_map (self)
|
||
|
||
def selection_change_complete (self, selection):
|
||
self.needs_update = True
|
||
|
||
if self.get_mapped ():
|
||
self.update ()
|
||
|
||
def tree_selection_changed (self, tree_sel):
|
||
sel = set ()
|
||
|
||
for row in self.store:
|
||
if tree_sel.iter_is_selected (row.iter):
|
||
id = row[self.store.ID]
|
||
|
||
for i in range (len (samples)):
|
||
if any (marker.id == id for marker in samples[i].markers):
|
||
sel.add (i)
|
||
|
||
selection.select (sel)
|
||
|
||
selection.change_complete ()
|
||
|
||
class VariablesViewer (Gtk.ScrolledWindow):
|
||
class Store (Gtk.ListStore):
|
||
NAME = 0
|
||
DESC = 1
|
||
COLOR = 2
|
||
VALUE = 3
|
||
RAW = 4
|
||
MIN = 5
|
||
MAX = 6
|
||
MEDIAN = 7
|
||
MEAN = 8
|
||
STDEV = 9
|
||
LAST_COLUMN = 10
|
||
|
||
def __init__ (self):
|
||
n_stats = self.LAST_COLUMN - self.COLOR
|
||
|
||
Gtk.ListStore.__init__ (self,
|
||
*((str, str, Gdk.RGBA) + n_stats * (str,)))
|
||
|
||
for var, var_def in var_defs.items ():
|
||
self.append (((var,
|
||
var_def.desc,
|
||
Gdk.RGBA (*var_def.color)) +
|
||
n_stats * ("",)))
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Box.__init__ (self,
|
||
*args,
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
**kwargs)
|
||
|
||
self.needs_update = True
|
||
|
||
store = self.Store ()
|
||
self.store = store
|
||
|
||
tree = Gtk.TreeView (model = store)
|
||
self.add (tree)
|
||
tree.set_tooltip_column (store.DESC)
|
||
tree.show ()
|
||
|
||
self.single_sample_cols = []
|
||
self.multi_sample_cols = []
|
||
|
||
col = Gtk.TreeViewColumn (title = "Variable")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = CellRendererColorToggle (active = True)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "color", store.COLOR)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.NAME)
|
||
|
||
def add_value_column (title, column, single_sample):
|
||
col = Gtk.TreeViewColumn (title = title)
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
col.set_alignment (0.5)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", column)
|
||
|
||
if single_sample:
|
||
self.single_sample_cols.append (col)
|
||
else:
|
||
self.multi_sample_cols.append (col)
|
||
|
||
add_value_column ("Value", store.VALUE, True)
|
||
add_value_column ("Raw", store.RAW, True)
|
||
add_value_column ("Min", store.MIN, False)
|
||
add_value_column ("Max", store.MAX, False)
|
||
add_value_column ("Median", store.MEDIAN, False)
|
||
add_value_column ("Mean", store.MEAN, False)
|
||
add_value_column ("Std. Dev.", store.STDEV, False)
|
||
|
||
col = Gtk.TreeViewColumn ()
|
||
tree.append_column (col)
|
||
|
||
selection.connect ("change-complete", self.selection_change_complete)
|
||
|
||
def update (self):
|
||
if not self.needs_update:
|
||
return
|
||
|
||
self.needs_update = False
|
||
|
||
sel = selection.get_effective_selection ()
|
||
n_sel = len (sel)
|
||
|
||
if n_sel == 1:
|
||
i, = sel
|
||
|
||
for row in self.store:
|
||
var_name = row[self.store.NAME]
|
||
|
||
var = samples[i].vars[var_name]
|
||
var_type = var_types[var_defs[var_name].type]
|
||
|
||
row[self.store.VALUE] = var_type.format (var.value)
|
||
row[self.store.RAW] = var.raw if var.raw is not None \
|
||
else "N/A"
|
||
else:
|
||
for row in self.store:
|
||
var_name = row[self.store.NAME]
|
||
|
||
var_type = var_types[var_defs[var_name].type]
|
||
|
||
vals = (samples[i].vars[var_name].value for i in sel)
|
||
vals = tuple (val for val in vals if val is not None)
|
||
|
||
if vals:
|
||
min_val = min (vals)
|
||
max_val = max (vals)
|
||
median = statistics.median (vals)
|
||
mean = statistics.mean (vals)
|
||
stdev = statistics.pstdev (vals, mean)
|
||
|
||
row[self.store.MIN] = var_type.format (min_val)
|
||
row[self.store.MAX] = var_type.format (max_val)
|
||
row[self.store.MEDIAN] = var_type.format (median)
|
||
row[self.store.MEAN] = var_type.format_numeric (mean)
|
||
row[self.store.STDEV] = var_type.format_numeric (stdev)
|
||
else:
|
||
row[self.store.MIN] = \
|
||
row[self.store.MAX] = \
|
||
row[self.store.MEDIAN] = \
|
||
row[self.store.MEAN] = \
|
||
row[self.store.STDEV] = var_type.format (None)
|
||
|
||
for col in self.single_sample_cols: col.set_visible (n_sel == 1)
|
||
for col in self.multi_sample_cols: col.set_visible (n_sel > 1)
|
||
|
||
def do_map (self):
|
||
self.update ()
|
||
|
||
Gtk.ScrolledWindow.do_map (self)
|
||
|
||
def selection_change_complete (self, selection):
|
||
self.needs_update = True
|
||
|
||
if self.get_mapped ():
|
||
self.update ()
|
||
|
||
class BacktraceViewer (Gtk.Box):
|
||
class ThreadStore (Gtk.ListStore):
|
||
INDEX = 0
|
||
ID = 1
|
||
NAME = 2
|
||
STATE = 3
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self, int, int, str, str)
|
||
|
||
class FrameStore (Gtk.ListStore):
|
||
ID = 0
|
||
ADDRESS = 1
|
||
OBJECT = 2
|
||
FUNCTION = 3
|
||
OFFSET = 4
|
||
SOURCE = 5
|
||
LINE = 6
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self, int, str, str, str, str, str, str)
|
||
|
||
class CellRendererViewSource (Gtk.CellRendererPixbuf):
|
||
file = GObject.Property (type = Gio.File, default = None)
|
||
line = GObject.Property (type = int, default = 0)
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.CellRendererPixbuf.__init__ (
|
||
self,
|
||
*args,
|
||
icon_name = "text-x-generic-symbolic",
|
||
mode = Gtk.CellRendererMode.ACTIVATABLE,
|
||
**kwargs)
|
||
|
||
self.connect ("notify::file",
|
||
lambda *args:
|
||
self.set_property ("visible", bool (self.file)))
|
||
|
||
def do_activate (self, event, widget, path, *args):
|
||
if self.file:
|
||
run_editor (self.file, self.line)
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Box.__init__ (self,
|
||
*args,
|
||
orientation = Gtk.Orientation.HORIZONTAL,
|
||
**kwargs)
|
||
|
||
self.needs_update = True
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
|
||
self.pack_start (vbox, False, False, 0)
|
||
vbox.show ()
|
||
|
||
header = Gtk.HeaderBar (title = "Threads", has_subtitle = False)
|
||
vbox.pack_start (header, False, False, 0)
|
||
header.show ()
|
||
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.NEVER,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
|
||
)
|
||
vbox.pack_start (scrolled, True, True, 0)
|
||
scrolled.show ()
|
||
|
||
store = self.ThreadStore ()
|
||
self.thread_store = store
|
||
store.set_sort_column_id (store.ID, Gtk.SortType.ASCENDING)
|
||
|
||
tree = Gtk.TreeView (model = store)
|
||
self.thread_tree = tree
|
||
scrolled.add (tree)
|
||
tree.set_search_column (store.NAME)
|
||
tree.show ()
|
||
|
||
tree.connect ("row-activated", self.threads_row_activated)
|
||
|
||
tree.get_selection ().connect ("changed",
|
||
self.threads_selection_changed)
|
||
|
||
col = Gtk.TreeViewColumn (title = "ID")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.ThreadStore.ID)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Name")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.ThreadStore.NAME)
|
||
|
||
col = Gtk.TreeViewColumn (title = "State")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.ThreadStore.STATE)
|
||
|
||
separator = Gtk.Separator (orientation = Gtk.Orientation.VERTICAL)
|
||
self.pack_start (separator, False, False, 0)
|
||
separator.show ()
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
|
||
self.pack_start (vbox, True, True, 0)
|
||
vbox.show ()
|
||
|
||
header = Gtk.HeaderBar (title = "Stack", has_subtitle = False)
|
||
vbox.pack_start (header, False, False, 0)
|
||
header.show ()
|
||
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
|
||
)
|
||
vbox.pack_start (scrolled, True, True, 0)
|
||
scrolled.show ()
|
||
|
||
store = self.FrameStore ()
|
||
self.frame_store = store
|
||
|
||
tree = Gtk.TreeView (model = store, has_tooltip = True)
|
||
scrolled.add (tree)
|
||
tree.set_search_column (store.FUNCTION)
|
||
tree.show ()
|
||
|
||
tree.connect ("row-activated", self.frames_row_activated)
|
||
tree.connect ("query-tooltip", self.frames_query_tooltip)
|
||
|
||
def format_filename_col (tree_col, cell, model, iter, col):
|
||
object = model[iter][col]
|
||
|
||
cell.set_property ("text", get_basename (object) if object else "")
|
||
|
||
self.tooltip_columns = {}
|
||
|
||
col = Gtk.TreeViewColumn (title = "#")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.FrameStore.ID)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Address")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.FrameStore.ADDRESS)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Object")
|
||
self.tooltip_columns[col] = store.OBJECT
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.set_cell_data_func (cell, format_filename_col, store.OBJECT)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Function")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.FrameStore.FUNCTION)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Offset")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.FrameStore.OFFSET)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Source")
|
||
self.tooltip_columns[col] = store.SOURCE
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.set_cell_data_func (cell, format_filename_col, store.SOURCE)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Line")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", self.FrameStore.LINE)
|
||
|
||
def format_view_source_col (tree_col, cell, model, iter, cols):
|
||
filename = model[iter][cols[0]] or None
|
||
line = model[iter][cols[1]] or "0"
|
||
|
||
cell.set_property ("file", filename and find_file (filename))
|
||
cell.set_property ("line", int (line))
|
||
|
||
def format_view_source_tooltip (row):
|
||
filename = row[store.SOURCE]
|
||
|
||
if filename:
|
||
file = find_file (filename)
|
||
|
||
if file:
|
||
return file.get_path ()
|
||
|
||
return None
|
||
|
||
col = Gtk.TreeViewColumn ()
|
||
self.tooltip_columns[col] = format_view_source_tooltip
|
||
tree.append_column (col)
|
||
|
||
cell = self.CellRendererViewSource (xalign = 0)
|
||
col.pack_start (cell, False)
|
||
col.set_cell_data_func (cell, format_view_source_col, (store.SOURCE,
|
||
store.LINE))
|
||
|
||
selection.connect ("change-complete", self.selection_change_complete)
|
||
|
||
@GObject.Property (type = bool, default = False)
|
||
def available (self):
|
||
sel = selection.get_effective_selection ()
|
||
|
||
if len (sel) == 1:
|
||
i, = sel
|
||
|
||
return bool (samples[i].backtrace)
|
||
|
||
return False
|
||
|
||
def update (self):
|
||
if not self.needs_update or not self.available:
|
||
return
|
||
|
||
self.needs_update = False
|
||
|
||
tid = None
|
||
|
||
sel_rows = self.thread_tree.get_selection ().get_selected_rows ()[1]
|
||
|
||
if sel_rows:
|
||
tid = self.thread_store[sel_rows[0]][self.ThreadStore.ID]
|
||
|
||
i, = selection.get_effective_selection ()
|
||
|
||
self.thread_store.clear ()
|
||
|
||
for t in range (len (samples[i].backtrace)):
|
||
thread = samples[i].backtrace[t]
|
||
|
||
iter = self.thread_store.append (
|
||
(t, thread.id, thread.name, str (thread.state))
|
||
)
|
||
|
||
if thread.id == tid:
|
||
self.thread_tree.get_selection ().select_iter (iter)
|
||
|
||
def do_map (self):
|
||
self.update ()
|
||
|
||
Gtk.Box.do_map (self)
|
||
|
||
def selection_change_complete (self, selection):
|
||
self.needs_update = True
|
||
|
||
if self.get_mapped ():
|
||
self.update ()
|
||
|
||
self.notify ("available")
|
||
|
||
def threads_row_activated (self, tree, path, col):
|
||
iter = self.thread_store.get_iter (path)
|
||
|
||
tid = self.thread_store[iter][self.ThreadStore.ID]
|
||
|
||
sel = set ()
|
||
|
||
for i in range (len (samples)):
|
||
threads = filter (lambda thread:
|
||
thread.id == tid and
|
||
thread.state == ThreadState.RUNNING,
|
||
samples[i].backtrace or [])
|
||
|
||
if list (threads):
|
||
sel.add (i)
|
||
|
||
selection.select (sel)
|
||
|
||
selection.change_complete ()
|
||
|
||
def threads_selection_changed (self, tree_sel):
|
||
self.frame_store.clear ()
|
||
|
||
(store, rows) = tree_sel.get_selected_rows ()
|
||
|
||
if not rows:
|
||
return
|
||
|
||
i, = selection.get_effective_selection ()
|
||
|
||
try:
|
||
frames = samples[i].backtrace[store[rows[0]][store.INDEX]].frames
|
||
|
||
for frame in frames:
|
||
info = frame.info
|
||
|
||
self.frame_store.append ((
|
||
frame.id, hex (frame.address), info.object, info.symbol,
|
||
hex (info.offset) if info.offset is not None else None,
|
||
info.source, str (info.line) if info.line else None
|
||
))
|
||
except:
|
||
pass
|
||
|
||
def frames_row_activated (self, tree, path, col):
|
||
iter = self.frame_store.get_iter (path)
|
||
|
||
address = int (self.frame_store[iter][self.FrameStore.ADDRESS], 0)
|
||
info = address_map.get (address, None)
|
||
|
||
if not info:
|
||
return
|
||
|
||
id = info.id
|
||
|
||
if not id:
|
||
return
|
||
|
||
sel = set ()
|
||
|
||
def has_frame (sample, id):
|
||
for thread in sample.backtrace or []:
|
||
for frame in thread.frames:
|
||
if frame.info.id == id:
|
||
return True
|
||
|
||
return False
|
||
|
||
for i in range (len (samples)):
|
||
if has_frame (samples[i], id):
|
||
sel.add (i)
|
||
|
||
selection.select (sel)
|
||
|
||
selection.change_complete ()
|
||
|
||
def frames_query_tooltip (self, tree, x, y, keyboard_mode, tooltip):
|
||
hit, x, y, model, path, iter = tree.get_tooltip_context (x, y,
|
||
keyboard_mode)
|
||
|
||
if hit:
|
||
column = None
|
||
|
||
if keyboard_mode:
|
||
cursor_path, cursor_col = tree.get_cursor ()
|
||
|
||
if path.compare (cursor_path) == 0:
|
||
column = self.tooltip_columns[cursor_col]
|
||
else:
|
||
for col in self.tooltip_columns:
|
||
area = tree.get_cell_area (path, col)
|
||
|
||
if x >= area.x and x < area.x + area.width and \
|
||
y >= area.y and y < area.y + area.height:
|
||
column = self.tooltip_columns[col]
|
||
|
||
break
|
||
|
||
if column is not None:
|
||
value = None
|
||
|
||
if type (column) == int:
|
||
value = model[iter][column]
|
||
else:
|
||
value = column (model[iter])
|
||
|
||
if value:
|
||
tooltip.set_text (str (value))
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
class CellRendererPercentage (Gtk.CellRendererText):
|
||
padding = 0
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.CellRendererText.__init__ (self, *args, xalign = 1, **kwargs)
|
||
|
||
self.value = 0
|
||
|
||
@GObject.Property (type = float)
|
||
def value (self):
|
||
return self.value_property
|
||
|
||
@value.setter
|
||
def value (self, value):
|
||
self.value_property = value
|
||
|
||
self.set_property ("text", format_percentage (value, 2))
|
||
|
||
def do_render (self, cr, widget, background_area, cell_area, flags):
|
||
full_width = cell_area.width - 2 * self.padding
|
||
full_height = cell_area.height - 2 * self.padding
|
||
|
||
if full_width <= 0 or full_height <= 0:
|
||
return
|
||
|
||
state = widget.get_state_flags()
|
||
style = widget.get_style_context ()
|
||
fg_color = style.get_color (state)
|
||
|
||
rounded_rectangle (cr,
|
||
cell_area.x + self.padding,
|
||
cell_area.y + self.padding,
|
||
full_width,
|
||
full_height,
|
||
1)
|
||
|
||
cr.clip ()
|
||
|
||
cr.set_source_rgba (*blend_colors ((0, 0, 0, 0), fg_color, 0.2))
|
||
cr.paint ()
|
||
|
||
Gtk.CellRendererText.do_render (self,
|
||
cr, widget,
|
||
background_area, cell_area,
|
||
flags)
|
||
|
||
value = min (max (self.value, 0), 1)
|
||
width = round (full_width * value)
|
||
height = full_height
|
||
|
||
if width > 0 and height > 0:
|
||
state = Gtk.StateFlags (state |
|
||
Gtk.StateFlags.SELECTED)
|
||
flags = Gtk.CellRendererState (flags |
|
||
Gtk.CellRendererState.SELECTED)
|
||
|
||
style.save ()
|
||
style.set_state (state)
|
||
|
||
x = round ((full_width - width) * self.get_property ("xalign"))
|
||
|
||
cr.rectangle (cell_area.x + self.padding + x,
|
||
cell_area.y + self.padding,
|
||
width,
|
||
height)
|
||
|
||
cr.clip ()
|
||
|
||
Gtk.render_background (style, cr,
|
||
cell_area.x, cell_area.y,
|
||
cell_area.width, cell_area.height)
|
||
|
||
cr.set_source_rgba (0, 0, 0, 0.25)
|
||
cr.paint ()
|
||
|
||
Gtk.CellRendererText.do_render (self,
|
||
cr, widget,
|
||
background_area, cell_area,
|
||
flags)
|
||
|
||
style.restore ()
|
||
|
||
class ProfileViewer (Gtk.ScrolledWindow):
|
||
class ThreadFilter (Gtk.TreeView):
|
||
class Store (Gtk.ListStore):
|
||
VISIBLE = 0
|
||
ID = 1
|
||
NAME = 2
|
||
STATE = {list (ThreadState)[i]: 3 + i
|
||
for i in range (len (ThreadState))}
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self,
|
||
bool, int, str,
|
||
*(len (self.STATE) * (bool,)))
|
||
|
||
threads = list ({thread.id
|
||
for sample in samples
|
||
for thread in sample.backtrace or ()})
|
||
threads.sort ()
|
||
|
||
states = [state == ThreadState.RUNNING for state in self.STATE]
|
||
|
||
for id in threads:
|
||
self.append ((False, id, None, *states))
|
||
|
||
def get_filter (self):
|
||
return {row[self.ID]: {state
|
||
for state, column in self.STATE.items ()
|
||
if row[column]}
|
||
for row in self}
|
||
|
||
def set_filter (self, filter):
|
||
for row in self:
|
||
states = filter[row[self.ID]]
|
||
|
||
for state, column in self.STATE.items ():
|
||
row[column] = state in states
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.TreeView.__init__ (self, *args, **kwargs)
|
||
|
||
self.needs_update = True
|
||
|
||
store = self.Store ()
|
||
self.store = store
|
||
|
||
filter = Gtk.TreeModelFilter (child_model = store)
|
||
filter.set_visible_column (store.VISIBLE)
|
||
self.set_model (filter)
|
||
self.set_search_column (store.NAME)
|
||
|
||
col = Gtk.TreeViewColumn (title = "ID")
|
||
self.append_column (col)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.ID)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Name")
|
||
self.append_column (col)
|
||
|
||
cell = Gtk.CellRendererText ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.NAME)
|
||
|
||
for state in store.STATE:
|
||
col = Gtk.TreeViewColumn (title = str (state))
|
||
col.column = store.STATE[state]
|
||
self.append_column (col)
|
||
col.set_alignment (0.5)
|
||
col.set_clickable (True)
|
||
|
||
def col_clicked (col):
|
||
active = not all (row[col.column] for row in filter)
|
||
|
||
for row in filter:
|
||
row[col.column] = active
|
||
|
||
col.connect ("clicked", col_clicked)
|
||
|
||
cell = Gtk.CellRendererToggle ()
|
||
cell.column = store.STATE[state]
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "active", store.STATE[state])
|
||
|
||
def cell_toggled (cell, path):
|
||
filter[path][cell.column] = not cell.get_property ("active")
|
||
|
||
cell.connect ("toggled", cell_toggled)
|
||
|
||
selection.connect ("change-complete",
|
||
self.selection_change_complete)
|
||
|
||
def update (self):
|
||
if not self.needs_update:
|
||
return
|
||
|
||
self.needs_update = False
|
||
|
||
sel = selection.get_effective_selection ()
|
||
|
||
threads = {thread.id: thread.name
|
||
for i in sel
|
||
for thread in samples[i].backtrace or ()}
|
||
|
||
for row in self.store:
|
||
id = row[self.store.ID]
|
||
|
||
if id in threads:
|
||
row[self.store.VISIBLE] = True
|
||
row[self.store.NAME] = threads[id]
|
||
else:
|
||
row[self.store.VISIBLE] = False
|
||
row[self.store.NAME] = None
|
||
|
||
def do_map (self):
|
||
self.update ()
|
||
|
||
Gtk.TreeView.do_map (self)
|
||
|
||
def selection_change_complete (self, selection):
|
||
self.needs_update = True
|
||
|
||
if self.get_mapped ():
|
||
self.update ()
|
||
|
||
class ThreadPopover (Gtk.Popover):
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Popover.__init__ (self, *args, border_width = 4, **kwargs)
|
||
|
||
frame = Gtk.Frame (shadow_type = Gtk.ShadowType.IN)
|
||
self.add (frame)
|
||
frame.show ()
|
||
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.NEVER,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
propagate_natural_height = True,
|
||
max_content_height = 400
|
||
)
|
||
frame.add (scrolled)
|
||
scrolled.show ()
|
||
|
||
thread_filter = ProfileViewer.ThreadFilter ()
|
||
self.thread_filter = thread_filter
|
||
scrolled.add (thread_filter)
|
||
thread_filter.show ()
|
||
|
||
class Profile (Gtk.Box):
|
||
ProfileFrame = namedtuple ("ProfileFrame", ("sample", "stack", "i"))
|
||
|
||
class Direction (enum.Enum):
|
||
CALLEES = enum.auto ()
|
||
CALLERS = enum.auto ()
|
||
|
||
class Store (Gtk.ListStore):
|
||
ID = 0
|
||
FUNCTION = 1
|
||
EXCLUSIVE = 2
|
||
INCLUSIVE = 3
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self,
|
||
GObject.TYPE_UINT64, str, float, float)
|
||
|
||
__gsignals__ = {
|
||
"needs-update": (GObject.SignalFlags.RUN_FIRST,
|
||
None, (bool,)),
|
||
"subprofile-added": (GObject.SignalFlags.RUN_FIRST,
|
||
None, (Gtk.Widget,)),
|
||
"subprofile-removed": (GObject.SignalFlags.RUN_FIRST,
|
||
None, (Gtk.Widget,)),
|
||
"path-changed": (GObject.SignalFlags.RUN_FIRST,
|
||
None, ())
|
||
}
|
||
|
||
def __init__ (self,
|
||
root = None,
|
||
id = None,
|
||
title = None,
|
||
frames = None,
|
||
direction = Direction.CALLEES,
|
||
sort = (Store.INCLUSIVE, Gtk.SortType.DESCENDING),
|
||
*args,
|
||
**kwargs):
|
||
Gtk.Box.__init__ (self,
|
||
*args,
|
||
orientation = Gtk.Orientation.HORIZONTAL,
|
||
**kwargs)
|
||
|
||
self.root = root or self
|
||
self.id = id
|
||
self.frames = frames
|
||
self.direction = direction
|
||
|
||
self.subprofile = None
|
||
|
||
vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
|
||
self.pack_start (vbox, False, False, 0)
|
||
vbox.show ()
|
||
|
||
header = Gtk.HeaderBar (title = title or "All Functions")
|
||
self.header = header
|
||
vbox.pack_start (header, False, False, 0)
|
||
header.show ()
|
||
|
||
if not id:
|
||
popover = ProfileViewer.ThreadPopover ()
|
||
|
||
thread_filter_store = popover.thread_filter.store
|
||
|
||
self.thread_filter_store = thread_filter_store
|
||
self.thread_filter = thread_filter_store.get_filter ()
|
||
|
||
history.add_source (self.thread_filter_source_get,
|
||
self.thread_filter_source_set)
|
||
|
||
button = Gtk.MenuButton (popover = popover)
|
||
header.pack_end (button)
|
||
button.show ()
|
||
|
||
button.connect ("toggled", self.thread_filter_button_toggled)
|
||
|
||
hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL,
|
||
spacing = 4)
|
||
button.add (hbox)
|
||
hbox.show ()
|
||
|
||
label = Gtk.Label (label = "Threads")
|
||
hbox.pack_start (label, False, False, 0)
|
||
label.show ()
|
||
|
||
image = Gtk.Image.new_from_icon_name ("pan-down-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
hbox.pack_start (image, False, False, 0)
|
||
image.show ()
|
||
|
||
history.add_source (self.direction_source_get,
|
||
self.direction_source_set)
|
||
|
||
button = Gtk.Button (tooltip_text = "Call-graph direction")
|
||
header.pack_end (button)
|
||
button.show ()
|
||
|
||
button.connect ("clicked", self.direction_button_clicked)
|
||
|
||
image = Gtk.Image ()
|
||
self.direction_image = image
|
||
button.add (image)
|
||
image.show ()
|
||
else:
|
||
button = Gtk.Button.new_from_icon_name (
|
||
"edit-select-symbolic",
|
||
Gtk.IconSize.BUTTON
|
||
)
|
||
header.pack_end (button)
|
||
button.set_tooltip_text (
|
||
str (Selection (frame.sample for frame in frames))
|
||
)
|
||
button.show ()
|
||
|
||
button.connect ("clicked", self.select_samples_clicked)
|
||
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.NEVER,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
|
||
)
|
||
vbox.pack_start (scrolled, True, True, 0)
|
||
scrolled.show ()
|
||
|
||
store = self.Store ()
|
||
self.store = store
|
||
store.set_sort_column_id (*sort)
|
||
|
||
tree = Gtk.TreeView (model = store)
|
||
self.tree = tree
|
||
scrolled.add (tree)
|
||
tree.set_search_column (store.FUNCTION)
|
||
tree.show ()
|
||
|
||
tree.get_selection ().connect ("changed",
|
||
self.tree_selection_changed)
|
||
|
||
tree.connect ("row-activated", self.tree_row_activated)
|
||
tree.connect ("key-press-event", self.tree_key_press_event)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Function")
|
||
tree.append_column (col)
|
||
col.set_resizable (True)
|
||
col.set_sort_column_id (store.FUNCTION)
|
||
|
||
cell = Gtk.CellRendererText (ellipsize = Pango.EllipsizeMode.END)
|
||
col.pack_start (cell, True)
|
||
col.add_attribute (cell, "text", store.FUNCTION)
|
||
cell.set_property ("width-chars", 40)
|
||
|
||
col = Gtk.TreeViewColumn (title = "Self")
|
||
tree.append_column (col)
|
||
col.set_alignment (0.5)
|
||
col.set_sort_column_id (store.EXCLUSIVE)
|
||
|
||
cell = CellRendererPercentage ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "value", store.EXCLUSIVE)
|
||
|
||
col = Gtk.TreeViewColumn (title = "All")
|
||
tree.append_column (col)
|
||
col.set_alignment (0.5)
|
||
col.set_sort_column_id (store.INCLUSIVE)
|
||
|
||
cell = CellRendererPercentage ()
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "value", store.INCLUSIVE)
|
||
|
||
if id:
|
||
self.update ()
|
||
|
||
def update (self):
|
||
self.remove_subprofile ()
|
||
|
||
if not self.id:
|
||
self.update_frames ()
|
||
|
||
self.update_store ()
|
||
|
||
self.update_ui ()
|
||
|
||
def update_frames (self):
|
||
self.frames = []
|
||
|
||
for i in selection.get_effective_selection ():
|
||
for thread in samples[i].backtrace or []:
|
||
if thread.state in self.thread_filter[thread.id]:
|
||
thread_frames = thread.frames
|
||
|
||
if self.direction == self.Direction.CALLERS:
|
||
thread_frames = reversed (thread_frames)
|
||
|
||
stack = []
|
||
prev_id = 0
|
||
|
||
for frame in thread_frames:
|
||
id = frame.info.id
|
||
|
||
if id == prev_id:
|
||
continue
|
||
|
||
self.frames.append (self.ProfileFrame (
|
||
sample = i,
|
||
stack = stack,
|
||
i = len (stack)
|
||
))
|
||
|
||
stack.append (frame)
|
||
|
||
prev_id = id
|
||
|
||
def update_store (self):
|
||
stacks = {}
|
||
symbols = {}
|
||
|
||
sort = self.store.get_sort_column_id ()
|
||
|
||
self.store = self.Store ()
|
||
|
||
for frame in self.frames:
|
||
info = frame.stack[frame.i].info
|
||
symbol_id = info.id
|
||
stack_id = builtins.id (frame.stack)
|
||
|
||
symbol = symbols.get (symbol_id, None)
|
||
|
||
if not symbol:
|
||
symbol = [info, 0, 0]
|
||
symbols[symbol_id] = symbol
|
||
|
||
stack = stacks.get (stack_id, None)
|
||
|
||
if not stack:
|
||
stack = set ()
|
||
stacks[stack_id] = stack
|
||
|
||
if frame.i == 0:
|
||
symbol[1] += 1
|
||
|
||
if symbol_id not in stack:
|
||
stack.add (symbol_id)
|
||
|
||
symbol[2] += 1
|
||
|
||
n_stacks = len (stacks)
|
||
|
||
for symbol in symbols.values ():
|
||
id = symbol[0].id
|
||
name = symbol[0].name if id != self.id else "[Self]"
|
||
|
||
self.store.append ((id,
|
||
name,
|
||
symbol[1] / n_stacks,
|
||
symbol[2] / n_stacks))
|
||
|
||
self.store.set_sort_column_id (*sort)
|
||
|
||
self.tree.set_model (self.store)
|
||
self.tree.set_search_column (self.store.FUNCTION)
|
||
|
||
def update_ui (self):
|
||
if not self.id:
|
||
if self.direction == self.Direction.CALLEES:
|
||
icon_name = "format-indent-more-symbolic"
|
||
else:
|
||
icon_name = "format-indent-less-symbolic"
|
||
|
||
self.direction_image.set_from_icon_name (icon_name,
|
||
Gtk.IconSize.BUTTON)
|
||
else:
|
||
if self.direction == self.Direction.CALLEES:
|
||
subtitle = "Callees"
|
||
else:
|
||
subtitle = "Callers"
|
||
|
||
self.header.set_subtitle (subtitle)
|
||
|
||
def select (self, id):
|
||
if id is not None:
|
||
for row in self.store:
|
||
if row[self.store.ID] == id:
|
||
iter = row.iter
|
||
path = self.store.get_path (iter)
|
||
|
||
self.tree.get_selection ().select_iter (iter)
|
||
|
||
self.tree.scroll_to_cell (path, None, True, 0.5, 0)
|
||
|
||
break
|
||
else:
|
||
self.tree.get_selection ().unselect_all ()
|
||
|
||
def add_subprofile (self, subprofile):
|
||
self.remove_subprofile ()
|
||
|
||
box = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
|
||
self.subprofile_box = box
|
||
self.pack_start (box, True, True, 0)
|
||
box.show ()
|
||
|
||
separator = Gtk.Separator (orientation = Gtk.Orientation.VERTICAL)
|
||
box.pack_start (separator, False, False, 0)
|
||
separator.show ()
|
||
|
||
self.subprofile = subprofile
|
||
box.pack_start (subprofile, True, True, 0)
|
||
subprofile.show ()
|
||
|
||
subprofile.connect ("subprofile-added",
|
||
lambda profile, subprofile:
|
||
self.emit ("subprofile-added",
|
||
subprofile))
|
||
subprofile.connect ("subprofile-removed",
|
||
lambda profile, subprofile:
|
||
self.emit ("subprofile-removed",
|
||
subprofile))
|
||
subprofile.connect ("path-changed",
|
||
lambda profile: self.emit ("path-changed"))
|
||
|
||
self.emit ("subprofile-added", subprofile)
|
||
|
||
def remove_subprofile (self):
|
||
if self.subprofile:
|
||
subprofile = self.subprofile
|
||
|
||
self.remove (self.subprofile_box)
|
||
|
||
self.subprofile = None
|
||
self.subprofile_box = None
|
||
|
||
self.emit ("subprofile-removed", subprofile)
|
||
|
||
def get_path (self):
|
||
tree_sel = self.tree.get_selection ()
|
||
|
||
sel_rows = tree_sel.get_selected_rows ()[1]
|
||
|
||
if not sel_rows:
|
||
return ()
|
||
|
||
id = self.store[sel_rows[0]][self.store.ID]
|
||
|
||
if self.subprofile:
|
||
return (id,) + self.subprofile.get_path ()
|
||
else:
|
||
return (id,)
|
||
|
||
def set_path (self, path):
|
||
self.select (path[0] if path else None)
|
||
|
||
if self.subprofile:
|
||
self.subprofile.set_path (path[1:])
|
||
|
||
def thread_filter_source_get (self):
|
||
return self.thread_filter_store.get_filter ()
|
||
|
||
def thread_filter_source_set (self, thread_filter):
|
||
self.thread_filter = thread_filter
|
||
|
||
self.thread_filter_store.set_filter (thread_filter)
|
||
|
||
self.emit ("needs-update", False)
|
||
|
||
def thread_filter_button_toggled (self, button):
|
||
if not button.get_active ():
|
||
thread_filter = self.thread_filter_store.get_filter ()
|
||
|
||
if thread_filter != self.thread_filter:
|
||
self.thread_filter = thread_filter
|
||
|
||
history.start_group ()
|
||
|
||
history.record ()
|
||
|
||
self.emit ("needs-update", True)
|
||
|
||
history.end_group ()
|
||
|
||
def direction_source_get (self):
|
||
return self.direction
|
||
|
||
def direction_source_set (self, direction):
|
||
self.direction = direction
|
||
|
||
self.emit ("needs-update", False)
|
||
|
||
def direction_button_clicked (self, button):
|
||
if self.direction == self.Direction.CALLEES:
|
||
self.direction = self.Direction.CALLERS
|
||
else:
|
||
self.direction = self.Direction.CALLEES
|
||
|
||
history.start_group ()
|
||
|
||
history.record ()
|
||
|
||
self.emit ("needs-update", True)
|
||
|
||
history.end_group ()
|
||
|
||
def select_samples_clicked (self, button):
|
||
selection.select ({frame.sample for frame in self.frames})
|
||
|
||
selection.change_complete ()
|
||
|
||
def tree_selection_changed (self, tree_sel):
|
||
self.remove_subprofile ()
|
||
|
||
sel_rows = tree_sel.get_selected_rows ()[1]
|
||
|
||
if not sel_rows:
|
||
self.emit ("path-changed")
|
||
|
||
return
|
||
|
||
id = self.store[sel_rows[0]][self.store.ID]
|
||
title = self.store[sel_rows[0]][self.store.FUNCTION]
|
||
|
||
frames = []
|
||
|
||
for frame in self.frames:
|
||
if frame.stack[frame.i].info.id == id:
|
||
frames.append (frame)
|
||
|
||
if frame.i > 0 and id != self.id:
|
||
frames.append (self.ProfileFrame (sample = frame.sample,
|
||
stack = frame.stack,
|
||
i = frame.i - 1))
|
||
|
||
if id != self.id:
|
||
self.add_subprofile (ProfileViewer.Profile (
|
||
self.root,
|
||
id,
|
||
title,
|
||
frames,
|
||
self.direction,
|
||
self.store.get_sort_column_id ()
|
||
))
|
||
else:
|
||
filenames = {frame.stack[frame.i].info.source
|
||
for frame in frames}
|
||
filenames = list (filter (bool, filenames))
|
||
|
||
if len (filenames) == 1:
|
||
file = find_file (filenames[0])
|
||
|
||
if file:
|
||
self.add_subprofile (ProfileViewer.SourceProfile (
|
||
file,
|
||
frames[0].stack[frames[0].i].info.name,
|
||
frames
|
||
))
|
||
|
||
self.emit ("path-changed")
|
||
|
||
def tree_row_activated (self, tree, path, col):
|
||
if self.root != self:
|
||
self.root.select (self.store[path][self.store.ID])
|
||
|
||
def tree_key_press_event (self, tree, event):
|
||
if event.keyval == Gdk.KEY_Escape:
|
||
self.select (None)
|
||
|
||
if self.root is not self:
|
||
self.get_parent ().get_ancestor (
|
||
ProfileViewer.Profile
|
||
).tree.grab_focus ()
|
||
|
||
return True
|
||
|
||
return False
|
||
|
||
class SourceProfile (Gtk.Box):
|
||
class Store (Gtk.ListStore):
|
||
LINE = 0
|
||
HAS_FRAMES = 1
|
||
EXCLUSIVE = 2
|
||
INCLUSIVE = 3
|
||
TEXT = 4
|
||
|
||
def __init__ (self):
|
||
Gtk.ListStore.__init__ (self, int, bool, float, float, str)
|
||
|
||
__gsignals__ = {
|
||
"subprofile-added": (GObject.SignalFlags.RUN_FIRST,
|
||
None, (Gtk.Widget,)),
|
||
"subprofile-removed": (GObject.SignalFlags.RUN_FIRST,
|
||
None, (Gtk.Widget,)),
|
||
"path-changed": (GObject.SignalFlags.RUN_FIRST,
|
||
None, ())
|
||
}
|
||
|
||
def __init__ (self,
|
||
file,
|
||
function,
|
||
frames,
|
||
*args,
|
||
**kwargs):
|
||
Gtk.Box.__init__ (self,
|
||
*args,
|
||
orientation = Gtk.Orientation.VERTICAL,
|
||
**kwargs)
|
||
|
||
self.file = file
|
||
self.frames = frames
|
||
|
||
header = Gtk.HeaderBar (title = file.get_basename (),
|
||
subtitle = function)
|
||
self.header = header
|
||
self.pack_start (header, False, False, 0)
|
||
header.show ()
|
||
|
||
box = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
|
||
header.pack_start (box)
|
||
box.get_style_context ().add_class ("linked")
|
||
box.get_style_context ().add_class ("raised")
|
||
box.show ()
|
||
|
||
button = Gtk.Button.new_from_icon_name ("go-up-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
self.prev_button = button
|
||
box.pack_start (button, False, True, 0)
|
||
button.show ()
|
||
|
||
button.connect ("clicked", lambda *args: self.move (-1))
|
||
|
||
button = Gtk.Button.new_from_icon_name ("go-down-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
self.next_button = button
|
||
box.pack_end (button, False, True, 0)
|
||
button.show ()
|
||
|
||
button.connect ("clicked", lambda *args: self.move (+1))
|
||
|
||
button = Gtk.Button.new_from_icon_name ("edit-select-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
self.select_samples_button = button
|
||
header.pack_end (button)
|
||
button.show ()
|
||
|
||
button.connect ("clicked", self.select_samples_clicked)
|
||
|
||
button = Gtk.Button.new_from_icon_name ("text-x-generic-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
header.pack_end (button)
|
||
button.set_tooltip_text (file.get_path ())
|
||
button.show ()
|
||
|
||
button.connect ("clicked", self.view_source_clicked)
|
||
|
||
scrolled = Gtk.ScrolledWindow (
|
||
hscrollbar_policy = Gtk.PolicyType.NEVER,
|
||
vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
|
||
)
|
||
self.pack_start (scrolled, True, True, 0)
|
||
scrolled.show ()
|
||
|
||
store = self.Store ()
|
||
self.store = store
|
||
|
||
tree = Gtk.TreeView (model = store)
|
||
self.tree = tree
|
||
scrolled.add (tree)
|
||
tree.set_search_column (store.LINE)
|
||
tree.show ()
|
||
|
||
tree.get_selection ().connect ("changed",
|
||
self.tree_selection_changed)
|
||
|
||
scale = 0.85
|
||
|
||
col = Gtk.TreeViewColumn (title = "Self")
|
||
tree.append_column (col)
|
||
col.set_alignment (0.5)
|
||
col.set_sort_column_id (store.EXCLUSIVE)
|
||
|
||
cell = CellRendererPercentage (scale = scale)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "visible", store.HAS_FRAMES)
|
||
col.add_attribute (cell, "value", store.EXCLUSIVE)
|
||
|
||
col = Gtk.TreeViewColumn (title = "All")
|
||
tree.append_column (col)
|
||
col.set_alignment (0.5)
|
||
col.set_sort_column_id (store.INCLUSIVE)
|
||
|
||
cell = CellRendererPercentage (scale = scale)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "visible", store.HAS_FRAMES)
|
||
col.add_attribute (cell, "value", store.INCLUSIVE)
|
||
|
||
col = Gtk.TreeViewColumn ()
|
||
tree.append_column (col)
|
||
|
||
cell = Gtk.CellRendererText (xalign = 1,
|
||
xpad = 8,
|
||
family = "Monospace",
|
||
weight = Pango.Weight.BOLD,
|
||
scale = scale)
|
||
col.pack_start (cell, False)
|
||
col.add_attribute (cell, "text", store.LINE)
|
||
|
||
cell = Gtk.CellRendererText (family = "Monospace",
|
||
scale = scale)
|
||
col.pack_start (cell, True)
|
||
col.add_attribute (cell, "text", store.TEXT)
|
||
|
||
self.update ()
|
||
|
||
def get_samples (self):
|
||
sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
|
||
|
||
if sel_rows:
|
||
line = self.store[sel_rows[0]][self.store.LINE]
|
||
|
||
sel = {frame.sample for frame in self.frames
|
||
if frame.stack[frame.i].info.line == line}
|
||
|
||
return sel
|
||
else:
|
||
return {}
|
||
|
||
def update (self):
|
||
self.update_store ()
|
||
self.update_ui ()
|
||
|
||
def update_store (self):
|
||
stacks = {}
|
||
lines = {}
|
||
|
||
for frame in self.frames:
|
||
info = frame.stack[frame.i].info
|
||
line_id = info.line
|
||
stack_id = builtins.id (frame.stack)
|
||
|
||
line = lines.get (line_id, None)
|
||
|
||
if not line:
|
||
line = [0, 0]
|
||
lines[line_id] = line
|
||
|
||
stack = stacks.get (stack_id, None)
|
||
|
||
if not stack:
|
||
stack = set ()
|
||
stacks[stack_id] = stack
|
||
|
||
if frame.i == 0:
|
||
line[0] += 1
|
||
|
||
if line_id not in stack:
|
||
stack.add (line_id)
|
||
|
||
line[1] += 1
|
||
|
||
self.lines = list (lines.keys ())
|
||
self.lines.sort ()
|
||
|
||
n_stacks = len (stacks)
|
||
|
||
self.store.clear ()
|
||
|
||
i = 1
|
||
|
||
for text in open (self.file.get_path (), "r"):
|
||
text = text.rstrip ("\n")
|
||
|
||
line = lines.get (i, None)
|
||
|
||
if line:
|
||
self.store.append ((i,
|
||
True,
|
||
line[0] / n_stacks,
|
||
line[1] / n_stacks,
|
||
text))
|
||
else:
|
||
self.store.append ((i,
|
||
False,
|
||
0,
|
||
0,
|
||
text))
|
||
|
||
i += 1
|
||
|
||
self.select (max (lines.items (), key = lambda line: line[1][1])[0])
|
||
|
||
def update_ui (self):
|
||
sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
|
||
|
||
if sel_rows:
|
||
line = self.store[sel_rows[0]][self.store.LINE]
|
||
|
||
i = bisect.bisect_left (self.lines, line)
|
||
|
||
self.prev_button.set_sensitive (i > 0)
|
||
|
||
if i < len (self.lines) and self.lines[i] == line:
|
||
i += 1
|
||
|
||
self.next_button.set_sensitive (i < len (self.lines))
|
||
else:
|
||
self.prev_button.set_sensitive (False)
|
||
self.next_button.set_sensitive (False)
|
||
|
||
samples = self.get_samples ()
|
||
|
||
if samples:
|
||
self.select_samples_button.set_sensitive (True)
|
||
self.select_samples_button.set_tooltip_text (
|
||
str (Selection (samples))
|
||
)
|
||
else:
|
||
self.select_samples_button.set_sensitive (False)
|
||
self.select_samples_button.set_tooltip_text (None)
|
||
|
||
def select (self, line):
|
||
if line is not None:
|
||
for row in self.store:
|
||
if row[self.store.LINE] == line:
|
||
iter = row.iter
|
||
path = self.store.get_path (iter)
|
||
|
||
self.tree.get_selection ().select_iter (iter)
|
||
|
||
self.tree.scroll_to_cell (path, None, True, 0.5, 0)
|
||
|
||
break
|
||
else:
|
||
self.tree.get_selection ().unselect_all ()
|
||
|
||
|
||
def move (self, dir):
|
||
if dir == 0:
|
||
return
|
||
|
||
sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
|
||
|
||
if sel_rows:
|
||
line = self.store[sel_rows[0]][self.store.LINE]
|
||
|
||
i = bisect.bisect_left (self.lines, line)
|
||
|
||
if dir < 0:
|
||
i -= 1
|
||
elif i < len (self.lines) and self.lines[i] == line:
|
||
i += 1
|
||
|
||
if i >= 0 and i < len (self.lines):
|
||
self.select (self.lines[i])
|
||
else:
|
||
self.select (None)
|
||
|
||
def select_samples_clicked (self, button):
|
||
selection.select (self.get_samples ())
|
||
|
||
selection.change_complete ()
|
||
|
||
def view_source_clicked (self, button):
|
||
line = 0
|
||
|
||
sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
|
||
|
||
if sel_rows:
|
||
line = self.store[sel_rows[0]][self.store.LINE]
|
||
|
||
run_editor (self.file, line)
|
||
|
||
def get_path (self):
|
||
tree_sel = self.tree.get_selection ()
|
||
|
||
sel_rows = tree_sel.get_selected_rows ()[1]
|
||
|
||
if not sel_rows:
|
||
return ()
|
||
|
||
line = self.store[sel_rows[0]][self.store.LINE]
|
||
|
||
return (line,)
|
||
|
||
def set_path (self, path):
|
||
self.select (path[0] if path else None)
|
||
|
||
def tree_selection_changed (self, tree_sel):
|
||
self.update_ui ()
|
||
|
||
self.emit ("path-changed")
|
||
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.ScrolledWindow.__init__ (
|
||
self,
|
||
*args,
|
||
hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
|
||
vscrollbar_policy = Gtk.PolicyType.NEVER,
|
||
**kwargs
|
||
)
|
||
|
||
self.adjustment_changed_handler = None
|
||
self.needs_update = True
|
||
self.path = ()
|
||
|
||
profile = self.Profile ()
|
||
self.root_profile = profile
|
||
self.add (profile)
|
||
profile.show ()
|
||
|
||
selection.connect ("change-complete", self.selection_change_complete)
|
||
|
||
profile.connect ("needs-update", self.profile_needs_update)
|
||
profile.connect ("subprofile-added", self.profile_subprofile_added)
|
||
profile.connect ("subprofile-removed", self.profile_subprofile_removed)
|
||
profile.connect ("path-changed", self.profile_path_changed)
|
||
|
||
history.add_source (self.source_get, self.source_set)
|
||
|
||
@GObject.Property (type = bool, default = False)
|
||
def available (self):
|
||
sel = selection.get_effective_selection ()
|
||
|
||
if len (sel) > 1:
|
||
return any (samples[i].backtrace for i in sel)
|
||
|
||
return False
|
||
|
||
def update (self):
|
||
if not self.available:
|
||
return
|
||
|
||
history.block ()
|
||
|
||
if self.needs_update:
|
||
self.root_profile.update ()
|
||
|
||
self.needs_update = False
|
||
|
||
self.root_profile.set_path (self.path)
|
||
|
||
history.unblock ()
|
||
|
||
def queue_update (self, now = False):
|
||
self.needs_update = True
|
||
|
||
if now or self.get_mapped ():
|
||
self.update ()
|
||
|
||
def do_map (self):
|
||
self.update ()
|
||
|
||
Gtk.ScrolledWindow.do_map (self)
|
||
|
||
def selection_change_complete (self, selection):
|
||
self.queue_update ()
|
||
|
||
self.notify ("available")
|
||
|
||
def profile_needs_update (self, profile, now):
|
||
self.queue_update (now)
|
||
|
||
def profile_subprofile_added (self, profile, subprofile):
|
||
if not history.is_blocked ():
|
||
self.path = profile.get_path ()
|
||
|
||
history.record ()
|
||
|
||
if not self.adjustment_changed_handler:
|
||
adjustment = self.get_hadjustment ()
|
||
|
||
def adjustment_changed (adjustment):
|
||
GObject.signal_handler_disconnect (
|
||
adjustment,
|
||
self.adjustment_changed_handler
|
||
)
|
||
self.adjustment_changed_handler = None
|
||
|
||
adjustment.set_value (adjustment.get_upper ())
|
||
|
||
self.adjustment_changed_handler = adjustment.connect (
|
||
"changed",
|
||
adjustment_changed
|
||
)
|
||
|
||
def profile_subprofile_removed (self, profile, subprofile):
|
||
if not history.is_blocked ():
|
||
self.path = profile.get_path ()
|
||
|
||
history.record ()
|
||
|
||
|
||
def profile_path_changed (self, profile):
|
||
if not history.is_blocked ():
|
||
self.path = profile.get_path ()
|
||
|
||
history.update ()
|
||
|
||
def source_get (self):
|
||
return self.path
|
||
|
||
def source_set (self, path):
|
||
self.path = path
|
||
|
||
if self.get_mapped ():
|
||
self.root_profile.set_path (path)
|
||
|
||
class LogViewer (Gtk.Window):
|
||
def __init__ (self, *args, **kwargs):
|
||
Gtk.Window.__init__ (
|
||
self,
|
||
*args,
|
||
default_width = 1024,
|
||
default_height = 768,
|
||
window_position = Gtk.WindowPosition.CENTER,
|
||
**kwargs)
|
||
|
||
header = Gtk.HeaderBar (
|
||
title = "PIKA Performance Log Viewer",
|
||
show_close_button = True
|
||
)
|
||
self.header = header
|
||
self.set_titlebar (header)
|
||
header.show ()
|
||
|
||
box = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
|
||
header.pack_start (box)
|
||
box.get_style_context ().add_class ("linked")
|
||
box.get_style_context ().add_class ("raised")
|
||
box.show ()
|
||
|
||
button = Gtk.Button.new_from_icon_name ("go-previous-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
box.pack_start (button, False, True, 0)
|
||
button.show ()
|
||
|
||
history.bind_property ("can-undo",
|
||
button, "sensitive",
|
||
GObject.BindingFlags.SYNC_CREATE)
|
||
|
||
button.connect ("clicked", lambda *args: history.undo ())
|
||
|
||
button = Gtk.Button.new_from_icon_name ("go-next-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
box.pack_end (button, False, True, 0)
|
||
button.show ()
|
||
|
||
history.bind_property ("can-redo",
|
||
button, "sensitive",
|
||
GObject.BindingFlags.SYNC_CREATE)
|
||
|
||
button.connect ("clicked", lambda *args: history.redo ())
|
||
|
||
button = Gtk.MenuButton ()
|
||
header.pack_end (button)
|
||
button.set_tooltip_text ("Find samples")
|
||
button.show ()
|
||
|
||
image = Gtk.Image.new_from_icon_name ("edit-find-symbolic",
|
||
Gtk.IconSize.BUTTON)
|
||
button.add (image)
|
||
image.show ()
|
||
|
||
popover = FindSamplesPopover (relative_to = button)
|
||
self.find_popover = popover
|
||
button.set_popover (popover)
|
||
|
||
def selection_action (action):
|
||
def f (*args):
|
||
action (selection)
|
||
selection.change_complete ()
|
||
|
||
return f
|
||
|
||
button = Gtk.Button.new_from_icon_name (
|
||
"object-flip-horizontal-symbolic",
|
||
Gtk.IconSize.BUTTON
|
||
)
|
||
header.pack_end (button)
|
||
button.set_tooltip_text ("Invert selection")
|
||
button.show ()
|
||
|
||
button.connect ("clicked", selection_action (Selection.invert))
|
||
|
||
button = Gtk.Button.new_from_icon_name (
|
||
"edit-clear-symbolic",
|
||
Gtk.IconSize.BUTTON
|
||
)
|
||
self.clear_selection_button = button
|
||
header.pack_end (button)
|
||
button.set_tooltip_text ("Clear selection")
|
||
button.show ()
|
||
|
||
button.connect ("clicked", selection_action (Selection.clear))
|
||
|
||
paned = Gtk.Paned (orientation = Gtk.Orientation.VERTICAL)
|
||
self.paned = paned
|
||
self.add (paned)
|
||
paned.set_position (144)
|
||
paned.show ()
|
||
|
||
graphs = SampleGraphList ()
|
||
paned.add1 (graphs)
|
||
paned.child_set (graphs, shrink = False)
|
||
graphs.show ()
|
||
|
||
hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
|
||
paned.add2 (hbox)
|
||
hbox.show ()
|
||
|
||
sidebar = Gtk.StackSidebar ()
|
||
hbox.pack_start (sidebar, False, False, 0)
|
||
sidebar.show ()
|
||
|
||
stack = Gtk.Stack (transition_type = Gtk.StackTransitionType.CROSSFADE)
|
||
self.stack = stack
|
||
hbox.pack_start (stack, True, True, 0)
|
||
stack.show ()
|
||
|
||
sidebar.set_stack (stack)
|
||
|
||
info_viewer = InformationViewer ()
|
||
stack.add_titled (info_viewer, "information", "Information")
|
||
info_viewer.show ()
|
||
|
||
if markers:
|
||
markers_viewer = MarkersViewer ()
|
||
stack.add_titled (markers_viewer, "markers", "Markers")
|
||
markers_viewer.show ()
|
||
|
||
vars_viewer = VariablesViewer ()
|
||
stack.add_titled (vars_viewer, "variables", "Variables")
|
||
vars_viewer.show ()
|
||
|
||
box = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
|
||
self.cflow_box = box
|
||
stack.add_named (box, "cflow")
|
||
|
||
backtrace_viewer = BacktraceViewer ()
|
||
self.backtrace_viewer = backtrace_viewer
|
||
box.pack_start (backtrace_viewer, True, True, 0)
|
||
|
||
backtrace_viewer.bind_property ("available",
|
||
backtrace_viewer, "visible",
|
||
GObject.BindingFlags.SYNC_CREATE)
|
||
|
||
backtrace_viewer.connect ("notify::available",
|
||
self.cflow_notify_available)
|
||
|
||
profile_viewer = ProfileViewer ()
|
||
self.profile_viewer = profile_viewer
|
||
box.pack_start (profile_viewer, True, True, 0)
|
||
|
||
profile_viewer.bind_property ("available",
|
||
profile_viewer, "visible",
|
||
GObject.BindingFlags.SYNC_CREATE)
|
||
|
||
profile_viewer.connect ("notify::available",
|
||
self.cflow_notify_available)
|
||
|
||
self.cflow_notify_available (self)
|
||
|
||
selection.connect ("change-complete", self.selection_change_complete)
|
||
|
||
self.selection_change_complete (selection)
|
||
|
||
def selection_change_complete (self, selection):
|
||
self.header.set_subtitle (str (selection))
|
||
self.clear_selection_button.set_sensitive (selection.selection)
|
||
|
||
def cflow_notify_available (self, *args):
|
||
if self.backtrace_viewer.available:
|
||
self.stack.child_set (self.cflow_box, title = "Backtrace")
|
||
self.cflow_box.show ()
|
||
elif self.profile_viewer.available:
|
||
self.stack.child_set (self.cflow_box, title = "Profile")
|
||
self.cflow_box.show ()
|
||
else:
|
||
self.cflow_box.hide ()
|
||
|
||
Gtk.Settings.get_default ().set_property ("gtk-application-prefer-dark-theme",
|
||
True)
|
||
|
||
window = LogViewer ()
|
||
window.show ()
|
||
|
||
window.connect ("destroy", Gtk.main_quit)
|
||
|
||
history.record ()
|
||
|
||
Gtk.main ()
|
