From: Ian Rogers <irogers@google.com>
To: irogers@google.com, acme@kernel.org, alice.mei.rogers@gmail.com,
namhyung@kernel.org
Cc: adrian.hunter@intel.com, dapeng1.mi@linux.intel.com,
james.clark@linaro.org, leo.yan@linux.dev,
linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org,
mingo@redhat.com, peterz@infradead.org, tmricht@linux.ibm.com
Subject: [PATCH v3 44/49] perf python: Move and clean up exported-sql-viewer.py
Date: Wed, 23 Sep 2026 11:12:07 -0700 [thread overview]
Message-ID: <20260923181213.3032038-45-irogers@google.com> (raw)
In-Reply-To: <20260923181213.3032038-1-irogers@google.com>
Move exported-sql-viewer.py from tools/perf/scripts/python/ to
tools/perf/python/ as it is a standalone PySide/PyQt GUI application
for viewing SQLite and PostgreSQL databases exported by perf script.
Improvements and cleanups compared to the legacy script:
- Add support for PySide6 (falling back to PySide2 and PySide) loaded
dynamically via importlib, and provide stub base classes (_QtBase,
_QtWidget) so static analysis (mypy and pylint) and --help-only
execution succeed when Qt bindings are not installed.
- Fix a Python 3 NameError crash in HBoxLayout where expanded_mark and
not_expanded_mark called Python 2's removed unicode() builtin instead
of chr(0x25BC) and chr(0x25B6).
- Replace instance-level method monkey-patching
(self.mousePressEvent = self.MousePressEvent) on SwitchGraphView with
proper class methods gated by self.rb_enabled so Qt virtual method
dispatch works cleanly across PySide2 and PySide6.
- Remove Python 2 constructs (cPickle, xrange), wildcard imports, bare
'except:' clauses, and variable names shadowing Python builtins.
Assisted-by: Antigravity:gemini-3.1-pro
Signed-off-by: Ian Rogers <irogers@google.com>
---
tools/perf/python/exported-sql-viewer.py | 5103 +++++++++++++++++
.../scripts/python/exported-sql-viewer.py | 5030 ----------------
2 files changed, 5103 insertions(+), 5030 deletions(-)
create mode 100755 tools/perf/python/exported-sql-viewer.py
delete mode 100755 tools/perf/scripts/python/exported-sql-viewer.py
diff --git a/tools/perf/python/exported-sql-viewer.py b/tools/perf/python/exported-sql-viewer.py
new file mode 100755
index 000000000000..f31aa45d9a54
--- /dev/null
+++ b/tools/perf/python/exported-sql-viewer.py
@@ -0,0 +1,5103 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: GPL-2.0
+"""exported-sql-viewer.py: view data from sql database."""
+# Copyright (c) 2014-2018, Intel Corporation.
+
+# To use this script you will need to have exported data using either the
+# export-to-sqlite.py or the export-to-postgresql.py script. Refer to those
+# scripts for details.
+#
+# Following on from the example in the export scripts, a
+# call-graph can be displayed for the pt_example database like this:
+#
+# python exported-sql-viewer.py pt_example
+#
+# Note that for PostgreSQL, this script supports connecting to remote databases
+# by setting hostname, port, username, password, and dbname e.g.
+#
+# python exported-sql-viewer.py \
+# "hostname=myhost username=myuser password=mypassword dbname=pt_example"
+#
+# The result is a GUI window with a tree representing a context-sensitive
+# call-graph. Expanding a couple of levels of the tree and adjusting column
+# widths to suit will display something like:
+#
+# Call Graph: pt_example
+# Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
+# v- ls
+# v- 2638:2638
+# v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
+# |- unknown unknown 1 13198 0.1 1 0.0
+# >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
+# >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
+# v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
+# >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
+# >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
+# >- __libc_csu_init ls 1 10354 0.1 10 0.0
+# |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
+# v- main ls 1 8182043 99.6 180254 99.9
+#
+# Points to note:
+# The top level is a command name (comm)
+# The next level is a thread (pid:tid)
+# Subsequent levels are functions
+# 'Count' is the number of calls
+# 'Time' is the elapsed time until the function returns
+# Percentages are relative to the level above
+# 'Branch Count' is the total number of branches for that function and all
+# functions that it calls
+
+# There is also a "All branches" report, which displays branches and
+# possibly disassembly. However, presently, the only supported disassembler is
+# Intel XED, and additionally the object code must be present in perf build ID
+# cache. To use Intel XED, libxed.so must be present. To build and install
+# libxed.so:
+# git clone https://github.com/intelxed/mbuild.git mbuild
+# git clone https://github.com/intelxed/xed
+# cd xed
+# ./mfile.py --share
+# sudo ./mfile.py --prefix=/usr/local install
+# sudo ldconfig
+#
+# Example report:
+#
+# Time CPU Command PID TID Branch Type In Tx Branch
+# 8107675239590 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
+# 7fab593ea260 48 89 e7 mov %rsp, %rdi
+# 8107675239899 2 ls 22011 22011 hardware interrupt No 7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
+# 8107675241900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
+# 7fab593ea260 48 89 e7 mov %rsp, %rdi
+# 7fab593ea263 e8 c8 06 00 00 callq 0x7fab593ea930
+# 8107675241900 2 ls 22011 22011 call No 7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so)
+# 7fab593ea930 55 pushq %rbp
+# 7fab593ea931 48 89 e5 mov %rsp, %rbp
+# 7fab593ea934 41 57 pushq %r15
+# 7fab593ea936 41 56 pushq %r14
+# 7fab593ea938 41 55 pushq %r13
+# 7fab593ea93a 41 54 pushq %r12
+# 7fab593ea93c 53 pushq %rbx
+# 7fab593ea93d 48 89 fb mov %rdi, %rbx
+# 7fab593ea940 48 83 ec 68 sub $0x68, %rsp
+# 7fab593ea944 0f 31 rdtsc
+# 7fab593ea946 48 c1 e2 20 shl $0x20, %rdx
+# 7fab593ea94a 89 c0 mov %eax, %eax
+# 7fab593ea94c 48 09 c2 or %rax, %rdx
+# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
+# 8107675242232 2 ls 22011 22011 hardware interrupt No 7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
+# 8107675242900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so)
+# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
+# 7fab593ea956 48 89 15 3b 13 22 00 movq %rdx, 0x22133b(%rip)
+# 8107675243232 2 ls 22011 22011 hardware interrupt No 7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
+
+from __future__ import print_function
+
+import sys
+# Only change warnings if the python -W option was not used
+if not sys.warnoptions:
+ import warnings
+ # PySide2 causes deprecation warnings, ignore them.
+ warnings.filterwarnings("ignore", category=DeprecationWarning)
+import argparse
+import weakref
+import threading
+import pickle
+glb_nsz = 16
+import re
+import os
+import random
+import copy
+import math
+from libxed import LibXED
+
+import importlib
+from typing import Any
+
+class _QtBase:
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ pass
+ def __call__(self, *args: Any, **kwargs: Any) -> Any:
+ return self
+ def __getattr__(self, name: str) -> Any:
+ return _QtBase()
+ def mousePressEvent(self, event: Any) -> None:
+ pass
+ def mouseMoveEvent(self, event: Any) -> None:
+ pass
+ def mouseReleaseEvent(self, event: Any) -> None:
+ pass
+ def resizeEvent(self, event: Any) -> None:
+ pass
+ def changeEvent(self, event: Any) -> None:
+ pass
+
+class _QtWidget(_QtBase):
+ pass
+
+class _QtMdiSubWindow(_QtWidget):
+ pass
+
+QAbstractItemModel: Any = _QtBase
+QAbstractItemView: Any = _QtBase
+QAbstractTableModel: Any = _QtBase
+QAction: Any = _QtBase
+QApplication: Any = _QtBase
+QCheckBox: Any = _QtBase
+QColor: Any = _QtBase
+QComboBox: Any = _QtBase
+QDialog: Any = _QtWidget
+QEvent: Any = _QtBase
+QFont: Any = _QtBase
+QFontMetrics: Any = _QtBase
+QGraphicsItem: Any = _QtBase
+QGraphicsLineItem: Any = _QtBase
+QGraphicsScene: Any = _QtBase
+QGraphicsSimpleTextItem: Any = _QtBase
+QGraphicsView: Any = _QtBase
+QGridLayout: Any = _QtBase
+QHBoxLayout: Any = _QtBase
+QKeySequence: Any = _QtBase
+QLabel: Any = _QtBase
+QLineEdit: Any = _QtBase
+QMainWindow: Any = _QtWidget
+QMdiArea: Any = _QtBase
+QMdiSubWindow: Any = _QtMdiSubWindow
+QMenu: Any = _QtBase
+QMessageBox: Any = _QtBase
+QModelIndex: Any = _QtBase
+QObject: Any = _QtBase
+QPalette: Any = _QtBase
+QPoint: Any = _QtBase
+QPointF: Any = _QtBase
+QProgressBar: Any = _QtBase
+QPushButton: Any = _QtBase
+QRect: Any = _QtBase
+QRectF: Any = _QtBase
+QRubberBand: Any = _QtBase
+QSize: Any = _QtBase
+QSizePolicy: Any = _QtBase
+QSortFilterProxyModel: Any = _QtBase
+QSpinBox: Any = _QtBase
+QSplitter: Any = _QtWidget
+QSqlDatabase: Any = _QtBase
+QSqlQuery: Any = _QtBase
+QStyle: Any = _QtBase
+Qt: Any = _QtBase
+QTableView: Any = _QtWidget
+QTextBrowser: Any = _QtWidget
+QThread: Any = _QtBase
+QToolButton: Any = _QtBase
+QTreeView: Any = _QtWidget
+QVBoxLayout: Any = _QtBase
+qVersion: Any = _QtBase
+QWidget: Any = _QtWidget
+Signal: Any = _QtBase
+
+pyside_version_1 = False
+for _pkg in ("PySide6", "PySide2"):
+ try:
+ for _mod_name in ("QtCore", "QtGui", "QtSql", "QtWidgets"):
+ _mod = importlib.import_module(f"{_pkg}.{_mod_name}")
+ for _sym in dir(_mod):
+ if not _sym.startswith("_"):
+ globals()[_sym] = getattr(_mod, _sym)
+ break
+ except ImportError:
+ pass
+
+
+from decimal import Decimal, ROUND_HALF_UP
+from ctypes import create_string_buffer, addressof, sizeof, \
+ c_void_p, c_bool, c_char, c_longlong
+from multiprocessing import Process, Array, Value, Event
+
+
+def printerr(*args, **keyword_args):
+ print(*args, file=sys.stderr, **keyword_args)
+
+# Data formatting helpers
+
+def tohex(ip):
+ if ip < 0:
+ ip += 1 << 64
+ return "%x" % ip
+
+def offstr(offset):
+ if offset:
+ return "+0x%x" % offset
+ return ""
+
+def dsoname(name):
+ if name == "[kernel.kallsyms]":
+ return "[kernel]"
+ return name
+
+def findnth(s, sub, n, offs=0):
+ pos = s.find(sub)
+ if pos < 0:
+ return pos
+ if n <= 1:
+ return offs + pos
+ return findnth(s[pos + 1:], sub, n - 1, offs + pos + 1)
+
+# Percent to one decimal place
+
+def PercentToOneDP(n, d):
+ if not d:
+ return "0.0"
+ x = (n * Decimal(100)) / d
+ return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP))
+
+# Helper for queries that must not fail
+
+def QueryExec(query, stmt):
+ ret = query.exec_(stmt)
+ if not ret:
+ raise RuntimeError("Query failed: " + query.lastError().text())
+
+# Background thread
+
+class Thread(QThread):
+
+ done = Signal(object)
+
+ def __init__(self, task, param=None, parent=None):
+ super(Thread, self).__init__(parent)
+ self.task = task
+ self.param = param
+
+ def run(self):
+ while True:
+ if self.param is None:
+ done, result = self.task()
+ else:
+ done, result = self.task(self.param)
+ self.done.emit(result)
+ if done:
+ break
+
+# Tree data model
+
+class TreeModel(QAbstractItemModel):
+
+ def __init__(self, glb, params, parent=None):
+ super(TreeModel, self).__init__(parent)
+ self.glb = glb
+ self.params = params
+ self.root = self.GetRoot()
+ self.last_row_read = 0
+
+ def Item(self, parent):
+ if parent.isValid():
+ return parent.internalPointer()
+ else:
+ return self.root
+
+ def rowCount(self, parent):
+ result = self.Item(parent).childCount()
+ if result < 0:
+ result = 0
+ self.dataChanged.emit(parent, parent)
+ return result
+
+ def hasChildren(self, parent):
+ return self.Item(parent).hasChildren()
+
+ def headerData(self, section, orientation, role):
+ if role == Qt.TextAlignmentRole:
+ return self.columnAlignment(section)
+ if role != Qt.DisplayRole:
+ return None
+ if orientation != Qt.Horizontal:
+ return None
+ return self.columnHeader(section)
+
+ def parent(self, child):
+ child_item = child.internalPointer()
+ if child_item is self.root:
+ return QModelIndex()
+ parent_item = child_item.getParentItem()
+ return self.createIndex(parent_item.getRow(), 0, parent_item)
+
+ def index(self, row, column, parent):
+ child_item = self.Item(parent).getChildItem(row)
+ return self.createIndex(row, column, child_item)
+
+ def DisplayData(self, item, index):
+ return item.getData(index.column())
+
+ def FetchIfNeeded(self, row):
+ if row > self.last_row_read:
+ self.last_row_read = row
+ if row + 10 >= self.root.child_count:
+ self.fetcher.Fetch(glb_chunk_sz)
+
+ def columnAlignment(self, _column):
+ return Qt.AlignLeft
+
+ def columnFont(self, _column):
+ return None
+
+ def data(self, index, role):
+ if role == Qt.TextAlignmentRole:
+ return self.columnAlignment(index.column())
+ if role == Qt.FontRole:
+ return self.columnFont(index.column())
+ if role != Qt.DisplayRole:
+ return None
+ item = index.internalPointer()
+ return self.DisplayData(item, index)
+
+# Table data model
+
+class TableModel(QAbstractTableModel):
+
+ def __init__(self, parent=None):
+ super(TableModel, self).__init__(parent)
+ self.child_count = 0
+ self.child_items = []
+ self.last_row_read = 0
+
+ def Item(self, parent):
+ if parent.isValid():
+ return parent.internalPointer()
+ else:
+ return self
+
+ def rowCount(self, _parent):
+ return self.child_count
+
+ def headerData(self, section, orientation, role):
+ if role == Qt.TextAlignmentRole:
+ return self.columnAlignment(section)
+ if role != Qt.DisplayRole:
+ return None
+ if orientation != Qt.Horizontal:
+ return None
+ return self.columnHeader(section)
+
+ def index(self, row, column, _parent):
+ return self.createIndex(row, column, self.child_items[row])
+
+ def DisplayData(self, item, index):
+ return item.getData(index.column())
+
+ def FetchIfNeeded(self, row):
+ if row > self.last_row_read:
+ self.last_row_read = row
+ if row + 10 >= self.child_count:
+ self.fetcher.Fetch(glb_chunk_sz)
+
+ def columnAlignment(self, _column):
+ return Qt.AlignLeft
+
+ def columnFont(self, _column):
+ return None
+
+ def data(self, index, role):
+ if role == Qt.TextAlignmentRole:
+ return self.columnAlignment(index.column())
+ if role == Qt.FontRole:
+ return self.columnFont(index.column())
+ if role != Qt.DisplayRole:
+ return None
+ item = index.internalPointer()
+ return self.DisplayData(item, index)
+
+# Model cache
+
+model_cache: Any = weakref.WeakValueDictionary()
+model_cache_lock = threading.Lock()
+
+def LookupCreateModel(model_name, create_fn):
+ model_cache_lock.acquire()
+ try:
+ model = model_cache[model_name]
+ except KeyError:
+ model = None
+ if model is None:
+ model = create_fn()
+ model_cache[model_name] = model
+ model_cache_lock.release()
+ return model
+
+def LookupModel(model_name):
+ model_cache_lock.acquire()
+ try:
+ model = model_cache[model_name]
+ except KeyError:
+ model = None
+ model_cache_lock.release()
+ return model
+
+# Find bar
+
+class FindBar():
+
+ def __init__(self, parent, finder, is_reg_expr=False):
+ self.finder = finder
+ self.context = []
+ self.last_value = None
+ self.last_pattern = None
+
+ label = QLabel("Find:")
+ label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+ self.textbox = QComboBox()
+ self.textbox.setEditable(True)
+ self.textbox.currentIndexChanged.connect(self.ValueChanged)
+
+ self.progress = QProgressBar()
+ self.progress.setRange(0, 0)
+ self.progress.hide()
+
+ if is_reg_expr:
+ self.pattern = QCheckBox("Regular Expression")
+ else:
+ self.pattern = QCheckBox("Pattern")
+ self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+ self.next_button = QToolButton()
+ self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
+ self.next_button.released.connect(lambda: self.NextPrev(1))
+
+ self.prev_button = QToolButton()
+ self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
+ self.prev_button.released.connect(lambda: self.NextPrev(-1))
+
+ self.close_button = QToolButton()
+ self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
+ self.close_button.released.connect(self.Deactivate)
+
+ self.hbox = QHBoxLayout()
+ self.hbox.setContentsMargins(0, 0, 0, 0)
+
+ self.hbox.addWidget(label)
+ self.hbox.addWidget(self.textbox)
+ self.hbox.addWidget(self.progress)
+ self.hbox.addWidget(self.pattern)
+ self.hbox.addWidget(self.next_button)
+ self.hbox.addWidget(self.prev_button)
+ self.hbox.addWidget(self.close_button)
+
+ self.bar = QWidget()
+ self.bar.setLayout(self.hbox)
+ self.bar.hide()
+
+ def Widget(self):
+ return self.bar
+
+ def Activate(self):
+ self.bar.show()
+ self.textbox.lineEdit().selectAll()
+ self.textbox.setFocus()
+
+ def Deactivate(self):
+ self.bar.hide()
+
+ def Busy(self):
+ self.textbox.setEnabled(False)
+ self.pattern.hide()
+ self.next_button.hide()
+ self.prev_button.hide()
+ self.progress.show()
+
+ def Idle(self):
+ self.textbox.setEnabled(True)
+ self.progress.hide()
+ self.pattern.show()
+ self.next_button.show()
+ self.prev_button.show()
+
+ def Find(self, direction):
+ value = self.textbox.currentText()
+ pattern = self.pattern.isChecked()
+ self.last_value = value
+ self.last_pattern = pattern
+ self.finder.Find(value, direction, pattern, self.context)
+
+ def ValueChanged(self):
+ _value = self.textbox.currentText()
+ pattern = self.pattern.isChecked()
+ index = self.textbox.currentIndex()
+ data = self.textbox.itemData(index)
+ # Store the pattern in the combo box to keep it with the text value
+ if data == None:
+ self.textbox.setItemData(index, pattern)
+ else:
+ self.pattern.setChecked(data)
+ self.Find(0)
+
+ def NextPrev(self, direction):
+ value = self.textbox.currentText()
+ pattern = self.pattern.isChecked()
+ if value != self.last_value:
+ index = self.textbox.findText(value)
+ # Allow for a button press before the value has been added to the combo box
+ if index < 0:
+ index = self.textbox.count()
+ self.textbox.addItem(value, pattern)
+ self.textbox.setCurrentIndex(index)
+ return
+ else:
+ self.textbox.setItemData(index, pattern)
+ elif pattern != self.last_pattern:
+ # Keep the pattern recorded in the combo box up to date
+ index = self.textbox.currentIndex()
+ self.textbox.setItemData(index, pattern)
+ self.Find(direction)
+
+ def NotFound(self):
+ QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
+
+# Context-sensitive call graph data model item base
+
+class CallGraphLevelItemBase(object):
+ def Select(self) -> None:
+ pass
+ def data(self, _column: int, _role: int) -> Any:
+ return None
+
+ def __init__(self, glb, params, row, parent_item):
+ self.glb = glb
+ self.params = params
+ self.row = row
+ self.parent_item = parent_item
+ self.query_done = False
+ self.child_count = 0
+ self.child_items = []
+ if parent_item:
+ self.level = parent_item.level + 1
+ else:
+ self.level = 0
+
+ def getChildItem(self, row):
+ return self.child_items[row]
+
+ def getParentItem(self):
+ return self.parent_item
+
+ def getRow(self):
+ return self.row
+
+ def childCount(self):
+ if not self.query_done:
+ self.Select()
+ if not self.child_count:
+ return -1
+ return self.child_count
+
+ def hasChildren(self):
+ if not self.query_done:
+ return True
+ return self.child_count > 0
+
+ def getData(self, column):
+ return self.data[column]
+
+# Context-sensitive call graph data model level 2+ item base
+
+class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase):
+
+ def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item):
+ super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
+ self.comm_id = comm_id
+ self.thread_id = thread_id
+ self.call_path_id = call_path_id
+ self.insn_cnt = insn_cnt
+ self.cyc_cnt = cyc_cnt
+ self.branch_count = branch_count
+ self.time = time
+
+ def Select(self):
+ self.query_done = True
+ query = QSqlQuery(self.glb.db)
+ if self.params.have_ipc:
+ ipc_str = ", SUM(insn_count), SUM(cyc_count)"
+ else:
+ ipc_str = ""
+ QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time)" + ipc_str + ", SUM(branch_count)"
+ " FROM calls"
+ " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+ " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+ " INNER JOIN dsos ON symbols.dso_id = dsos.id"
+ " WHERE parent_call_path_id = " + str(self.call_path_id) +
+ " AND comm_id = " + str(self.comm_id) +
+ " AND thread_id = " + str(self.thread_id) +
+ " GROUP BY call_path_id, name, short_name"
+ " ORDER BY call_path_id")
+ while query.next():
+ if self.params.have_ipc:
+ insn_cnt = int(query.value(5))
+ cyc_cnt = int(query.value(6))
+ branch_count = int(query.value(7))
+ else:
+ insn_cnt = 0
+ cyc_cnt = 0
+ branch_count = int(query.value(5))
+ child_item = CallGraphLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
+ self.child_items.append(child_item)
+ self.child_count += 1
+
+# Context-sensitive call graph data model level three item
+
+class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase):
+
+ def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, insn_cnt, cyc_cnt, branch_count, parent_item):
+ super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item)
+ dso = dsoname(dso)
+ if self.params.have_ipc:
+ insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
+ cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
+ br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
+ ipc = CalcIPC(cyc_cnt, insn_cnt)
+ self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
+ else:
+ self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
+ self.dbid = call_path_id
+
+# Context-sensitive call graph data model level two item
+
+class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase):
+
+ def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
+ super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, parent_item)
+ if self.params.have_ipc:
+ self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
+ else:
+ self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
+ self.dbid = thread_id
+
+ def Select(self):
+ super(CallGraphLevelTwoItem, self).Select()
+ for child_item in self.child_items:
+ self.time += child_item.time
+ self.insn_cnt += child_item.insn_cnt
+ self.cyc_cnt += child_item.cyc_cnt
+ self.branch_count += child_item.branch_count
+ for child_item in self.child_items:
+ child_item.data[4] = PercentToOneDP(child_item.time, self.time)
+ if self.params.have_ipc:
+ child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
+ child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
+ child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
+ else:
+ child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
+
+# Context-sensitive call graph data model level one item
+
+class CallGraphLevelOneItem(CallGraphLevelItemBase):
+
+ def __init__(self, glb, params, row, comm_id, comm, parent_item):
+ super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
+ if self.params.have_ipc:
+ self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
+ else:
+ self.data = [comm, "", "", "", "", "", ""]
+ self.dbid = comm_id
+
+ def Select(self):
+ self.query_done = True
+ query = QSqlQuery(self.glb.db)
+ QueryExec(query, "SELECT thread_id, pid, tid"
+ " FROM comm_threads"
+ " INNER JOIN threads ON thread_id = threads.id"
+ " WHERE comm_id = " + str(self.dbid))
+ while query.next():
+ child_item = CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
+ self.child_items.append(child_item)
+ self.child_count += 1
+
+# Context-sensitive call graph data model root item
+
+class CallGraphRootItem(CallGraphLevelItemBase):
+
+ def __init__(self, glb, params):
+ super(CallGraphRootItem, self).__init__(glb, params, 0, None)
+ self.dbid = 0
+ self.query_done = True
+ if_has_calls = ""
+ if IsSelectable(glb.db, "comms", columns = "has_calls"):
+ if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
+ query = QSqlQuery(glb.db)
+ QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
+ while query.next():
+ if not query.value(0):
+ continue
+ child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
+ self.child_items.append(child_item)
+ self.child_count += 1
+
+# Call graph model parameters
+
+class CallGraphModelParams():
+
+ def __init__(self, glb, _parent=None):
+ self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
+
+# Context-sensitive call graph data model base
+
+class CallGraphModelBase(TreeModel):
+
+ def __init__(self, glb, parent=None):
+ super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
+
+ def FindSelect(self, value, pattern, query):
+ if pattern:
+ # postgresql and sqlite pattern patching differences:
+ # postgresql LIKE is case sensitive but sqlite LIKE is not
+ # postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not
+ # postgresql supports ILIKE which is case insensitive
+ # sqlite supports GLOB (text only) which uses * and ? and is case sensitive
+ if not self.glb.dbref.is_sqlite3:
+ # Escape % and _
+ s = value.replace("%", "\\%")
+ s = s.replace("_", "\\_")
+ # Translate * and ? into SQL LIKE pattern characters % and _
+ if sys.version_info[0] == 3:
+ trans = str.maketrans("*?", "%_")
+ else:
+ trans = bytes.maketrans("*?", "%_")
+ match = " LIKE '" + str(s).translate(trans) + "'"
+ else:
+ match = " GLOB '" + str(value) + "'"
+ else:
+ match = " = '" + str(value) + "'"
+ self.DoFindSelect(query, match)
+
+ def Found(self, query, found):
+ if found:
+ return self.FindPath(query)
+ return []
+
+ def FindValue(self, value, pattern, query, last_value, last_pattern):
+ if last_value == value and pattern == last_pattern:
+ found = query.first()
+ else:
+ self.FindSelect(value, pattern, query)
+ found = query.next()
+ return self.Found(query, found)
+
+ def FindNext(self, query):
+ found = query.next()
+ if not found:
+ found = query.first()
+ return self.Found(query, found)
+
+ def FindPrev(self, query):
+ found = query.previous()
+ if not found:
+ found = query.last()
+ return self.Found(query, found)
+
+ def FindThread(self, c):
+ if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern:
+ ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
+ elif c.direction > 0:
+ ids = self.FindNext(c.query)
+ else:
+ ids = self.FindPrev(c.query)
+ return (True, ids)
+
+ def Find(self, value, direction, pattern, context, callback):
+ class Context():
+ def __init__(self, *x):
+ self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
+ def Update(self, *x):
+ self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern)
+ if len(context):
+ context[0].Update(value, direction, pattern)
+ else:
+ context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
+ # Use a thread so the UI is not blocked during the SELECT
+ thread = Thread(self.FindThread, context[0])
+ thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection)
+ thread.start()
+
+ def FindDone(self, _thread, callback, ids):
+ callback(ids)
+
+# Context-sensitive call graph data model
+
+class CallGraphModel(CallGraphModelBase):
+
+ def GetRoot(self):
+ return CallGraphRootItem(self.glb, self.params)
+
+ def columnCount(self, _parent=None):
+ if self.params.have_ipc:
+ return 12
+ else:
+ return 7
+
+ def columnHeader(self, column):
+ if self.params.have_ipc:
+ headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
+ else:
+ headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
+ return headers[column]
+
+ def columnAlignment(self, column):
+ if self.params.have_ipc:
+ alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
+ else:
+ alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
+ return alignment[column]
+
+ def DoFindSelect(self, query, match):
+ QueryExec(query, "SELECT call_path_id, comm_id, thread_id"
+ " FROM calls"
+ " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+ " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+ " WHERE calls.id <> 0"
+ " AND symbols.name" + match +
+ " GROUP BY comm_id, thread_id, call_path_id"
+ " ORDER BY comm_id, thread_id, call_path_id")
+
+ def FindPath(self, query):
+ # Turn the query result into a list of ids that the tree view can walk
+ # to open the tree at the right place.
+ ids = []
+ parent_id = query.value(0)
+ while parent_id:
+ ids.insert(0, parent_id)
+ q2 = QSqlQuery(self.glb.db)
+ QueryExec(q2, "SELECT parent_id"
+ " FROM call_paths"
+ " WHERE id = " + str(parent_id))
+ if not q2.next():
+ break
+ parent_id = q2.value(0)
+ # The call path root is not used
+ if ids[0] == 1:
+ del ids[0]
+ ids.insert(0, query.value(2))
+ ids.insert(0, query.value(1))
+ return ids
+
+# Call tree data model level 2+ item base
+
+class CallTreeLevelTwoPlusItemBase(CallGraphLevelItemBase):
+
+ def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
+ super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
+ self.comm_id = comm_id
+ self.thread_id = thread_id
+ self.calls_id = calls_id
+ self.call_time = call_time
+ self.time = time
+ self.insn_cnt = insn_cnt
+ self.cyc_cnt = cyc_cnt
+ self.branch_count = branch_count
+
+ def Select(self):
+ self.query_done = True
+ if self.calls_id == 0:
+ comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
+ else:
+ comm_thread = ""
+ if self.params.have_ipc:
+ ipc_str = ", insn_count, cyc_count"
+ else:
+ ipc_str = ""
+ query = QSqlQuery(self.glb.db)
+ QueryExec(query, "SELECT calls.id, name, short_name, call_time, return_time - call_time" + ipc_str + ", branch_count"
+ " FROM calls"
+ " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+ " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+ " INNER JOIN dsos ON symbols.dso_id = dsos.id"
+ " WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
+ " ORDER BY call_time, calls.id")
+ while query.next():
+ if self.params.have_ipc:
+ insn_cnt = int(query.value(5))
+ cyc_cnt = int(query.value(6))
+ branch_count = int(query.value(7))
+ else:
+ insn_cnt = 0
+ cyc_cnt = 0
+ branch_count = int(query.value(5))
+ child_item = CallTreeLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
+ self.child_items.append(child_item)
+ self.child_count += 1
+
+# Call tree data model level three item
+
+class CallTreeLevelThreeItem(CallTreeLevelTwoPlusItemBase):
+
+ def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
+ super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item)
+ dso = dsoname(dso)
+ if self.params.have_ipc:
+ insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
+ cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
+ br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
+ ipc = CalcIPC(cyc_cnt, insn_cnt)
+ self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
+ else:
+ self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
+ self.dbid = calls_id
+
+# Call tree data model level two item
+
+class CallTreeLevelTwoItem(CallTreeLevelTwoPlusItemBase):
+
+ def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
+ super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0, parent_item)
+ if self.params.have_ipc:
+ self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
+ else:
+ self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
+ self.dbid = thread_id
+
+ def Select(self):
+ super(CallTreeLevelTwoItem, self).Select()
+ for child_item in self.child_items:
+ self.time += child_item.time
+ self.insn_cnt += child_item.insn_cnt
+ self.cyc_cnt += child_item.cyc_cnt
+ self.branch_count += child_item.branch_count
+ for child_item in self.child_items:
+ child_item.data[4] = PercentToOneDP(child_item.time, self.time)
+ if self.params.have_ipc:
+ child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
+ child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
+ child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
+ else:
+ child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
+
+# Call tree data model level one item
+
+class CallTreeLevelOneItem(CallGraphLevelItemBase):
+
+ def __init__(self, glb, params, row, comm_id, comm, parent_item):
+ super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
+ if self.params.have_ipc:
+ self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
+ else:
+ self.data = [comm, "", "", "", "", "", ""]
+ self.dbid = comm_id
+
+ def Select(self):
+ self.query_done = True
+ query = QSqlQuery(self.glb.db)
+ QueryExec(query, "SELECT thread_id, pid, tid"
+ " FROM comm_threads"
+ " INNER JOIN threads ON thread_id = threads.id"
+ " WHERE comm_id = " + str(self.dbid))
+ while query.next():
+ child_item = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
+ self.child_items.append(child_item)
+ self.child_count += 1
+
+# Call tree data model root item
+
+class CallTreeRootItem(CallGraphLevelItemBase):
+
+ def __init__(self, glb, params):
+ super(CallTreeRootItem, self).__init__(glb, params, 0, None)
+ self.dbid = 0
+ self.query_done = True
+ if_has_calls = ""
+ if IsSelectable(glb.db, "comms", columns = "has_calls"):
+ if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
+ query = QSqlQuery(glb.db)
+ QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
+ while query.next():
+ if not query.value(0):
+ continue
+ child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
+ self.child_items.append(child_item)
+ self.child_count += 1
+
+# Call Tree data model
+
+class CallTreeModel(CallGraphModelBase):
+
+ def GetRoot(self):
+ return CallTreeRootItem(self.glb, self.params)
+
+ def columnCount(self, _parent=None):
+ if self.params.have_ipc:
+ return 12
+ else:
+ return 7
+
+ def columnHeader(self, column):
+ if self.params.have_ipc:
+ headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
+ else:
+ headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
+ return headers[column]
+
+ def columnAlignment(self, column):
+ if self.params.have_ipc:
+ alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
+ else:
+ alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
+ return alignment[column]
+
+ def DoFindSelect(self, query, match):
+ QueryExec(query, "SELECT calls.id, comm_id, thread_id"
+ " FROM calls"
+ " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+ " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+ " WHERE calls.id <> 0"
+ " AND symbols.name" + match +
+ " ORDER BY comm_id, thread_id, call_time, calls.id")
+
+ def FindPath(self, query):
+ # Turn the query result into a list of ids that the tree view can walk
+ # to open the tree at the right place.
+ ids = []
+ parent_id = query.value(0)
+ while parent_id:
+ ids.insert(0, parent_id)
+ q2 = QSqlQuery(self.glb.db)
+ QueryExec(q2, "SELECT parent_id"
+ " FROM calls"
+ " WHERE id = " + str(parent_id))
+ if not q2.next():
+ break
+ parent_id = q2.value(0)
+ ids.insert(0, query.value(2))
+ ids.insert(0, query.value(1))
+ return ids
+
+# Vertical layout
+
+class HBoxLayout(QHBoxLayout):
+
+ def __init__(self, *children):
+ super(HBoxLayout, self).__init__()
+
+ self.layout().setContentsMargins(0, 0, 0, 0)
+ for child in children:
+ if child.isWidgetType():
+ self.layout().addWidget(child)
+ else:
+ self.layout().addLayout(child)
+
+# Horizontal layout
+
+class VBoxLayout(QVBoxLayout):
+
+ def __init__(self, *children):
+ super(VBoxLayout, self).__init__()
+
+ self.layout().setContentsMargins(0, 0, 0, 0)
+ for child in children:
+ if child.isWidgetType():
+ self.layout().addWidget(child)
+ else:
+ self.layout().addLayout(child)
+
+# Vertical layout widget
+
+class VBox():
+
+ def __init__(self, *children):
+ self.vbox = QWidget()
+ self.vbox.setLayout(VBoxLayout(*children))
+
+ def Widget(self):
+ return self.vbox
+
+# Tree window base
+
+class TreeWindowBase(QMdiSubWindow):
+
+ def __init__(self, parent=None):
+ super(TreeWindowBase, self).__init__(parent)
+
+ self.model = None
+ self.find_bar = None
+
+ self.view = QTreeView()
+ self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
+ self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
+
+ self.context_menu = TreeContextMenu(self.view)
+
+ def DisplayFound(self, ids):
+ if not len(ids):
+ return False
+ parent = QModelIndex()
+ for dbid in ids:
+ found = False
+ n = self.model.rowCount(parent)
+ for row in range(n):
+ child = self.model.index(row, 0, parent)
+ if child.internalPointer().dbid == dbid:
+ found = True
+ self.view.setExpanded(parent, True)
+ self.view.setCurrentIndex(child)
+ parent = child
+ break
+ if not found:
+ break
+ return found
+
+ def Find(self, value, direction, pattern, context):
+ self.view.setFocus()
+ self.find_bar.Busy()
+ self.model.Find(value, direction, pattern, context, self.FindDone)
+
+ def FindDone(self, ids):
+ found = True
+ if not self.DisplayFound(ids):
+ found = False
+ self.find_bar.Idle()
+ if not found:
+ self.find_bar.NotFound()
+
+
+# Context-sensitive call graph window
+
+class CallGraphWindow(TreeWindowBase):
+
+ def __init__(self, glb, parent=None):
+ super(CallGraphWindow, self).__init__(parent)
+
+ self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
+
+ self.view.setModel(self.model)
+
+ for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)):
+ self.view.setColumnWidth(c, w)
+
+ self.find_bar = FindBar(self, self)
+
+ self.vbox = VBox(self.view, self.find_bar.Widget())
+
+ self.setWidget(self.vbox.Widget())
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
+
+# Call tree window
+
+class CallTreeWindow(TreeWindowBase):
+
+ def __init__(self, glb, parent=None, thread_at_time=None):
+ super(CallTreeWindow, self).__init__(parent)
+
+ self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
+
+ self.view.setModel(self.model)
+
+ for c, w in ((0, 230), (1, 100), (2, 100), (3, 70), (4, 70), (5, 100)):
+ self.view.setColumnWidth(c, w)
+
+ self.find_bar = FindBar(self, self)
+
+ self.vbox = VBox(self.view, self.find_bar.Widget())
+
+ self.setWidget(self.vbox.Widget())
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
+
+ if thread_at_time:
+ self.DisplayThreadAtTime(*thread_at_time)
+
+ def DisplayThreadAtTime(self, comm_id, thread_id, time):
+ parent = QModelIndex()
+ for dbid in (comm_id, thread_id):
+ found = False
+ n = self.model.rowCount(parent)
+ for row in range(n):
+ child = self.model.index(row, 0, parent)
+ if child.internalPointer().dbid == dbid:
+ found = True
+ self.view.setExpanded(parent, True)
+ self.view.setCurrentIndex(child)
+ parent = child
+ break
+ if not found:
+ return
+ found = False
+ while True:
+ n = self.model.rowCount(parent)
+ if not n:
+ return
+ last_child = None
+ for row in range(n):
+ self.view.setExpanded(parent, True)
+ child = self.model.index(row, 0, parent)
+ child_call_time = child.internalPointer().call_time
+ if child_call_time < time:
+ last_child = child
+ elif child_call_time == time:
+ self.view.setCurrentIndex(child)
+ return
+ elif child_call_time > time:
+ break
+ if not last_child:
+ if not found:
+ child = self.model.index(0, 0, parent)
+ self.view.setExpanded(parent, True)
+ self.view.setCurrentIndex(child)
+ return
+ found = True
+ self.view.setExpanded(parent, True)
+ self.view.setCurrentIndex(last_child)
+ parent = last_child
+
+# ExecComm() gets the comm_id of the command string that was set when the process exec'd i.e. the program name
+
+def ExecComm(db, thread_id, time):
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT comm_threads.comm_id, comms.c_time, comms.exec_flag"
+ " FROM comm_threads"
+ " INNER JOIN comms ON comms.id = comm_threads.comm_id"
+ " WHERE comm_threads.thread_id = " + str(thread_id) +
+ " ORDER BY comms.c_time, comms.id")
+ first = None
+ last = None
+ while query.next():
+ if first is None:
+ first = query.value(0)
+ if query.value(2) and Decimal(query.value(1)) <= Decimal(time):
+ last = query.value(0)
+ if not(last is None):
+ return last
+ return first
+
+# Container for (x, y) data
+
+class XY():
+ def __init__(self, x=0, y=0):
+ self.x = x
+ self.y = y
+
+ def __str__(self):
+ return "XY({}, {})".format(str(self.x), str(self.y))
+
+# Container for sub-range data
+
+class Subrange():
+ def __init__(self, lo=0, hi=0):
+ self.lo = lo
+ self.hi = hi
+
+ def __str__(self):
+ return "Subrange({}, {})".format(str(self.lo), str(self.hi))
+
+# Graph data region base class
+
+class GraphDataRegion(object):
+
+ def __init__(self, key, title = "", ordinal = ""):
+ self.key = key
+ self.title = title
+ self.ordinal = ordinal
+
+# Function to sort GraphDataRegion
+
+def GraphDataRegionOrdinal(data_region):
+ return data_region.ordinal
+
+# Attributes for a graph region
+
+class GraphRegionAttribute():
+
+ def __init__(self, colour):
+ self.colour = colour
+
+# Switch graph data region represents a task
+
+class SwitchGraphDataRegion(GraphDataRegion):
+
+ def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):
+ super(SwitchGraphDataRegion, self).__init__(key)
+
+ self.title = str(pid) + " / " + str(tid) + " " + comm
+ # Order graph legend within exec comm by pid / tid / time
+ self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
+ self.exec_comm_id = exec_comm_id
+ self.pid = pid
+ self.tid = tid
+ self.comm = comm
+ self.thread_id = thread_id
+ self.comm_id = comm_id
+
+# Graph data point
+
+class GraphDataPoint():
+
+ def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):
+ self.data = data
+ self.index = index
+ self.x = x
+ self.y = y
+ self.altx = altx
+ self.alty = alty
+ self.hregion = hregion
+ self.vregion = vregion
+
+# Graph data (single graph) base class
+
+class GraphData(object):
+
+ def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):
+ self.collection = collection
+ self.points = []
+ self.xbase = xbase
+ self.ybase = ybase
+ self.title = ""
+
+ def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):
+ index = len(self.points)
+
+ x = float(Decimal(x) - self.xbase)
+ y = float(Decimal(y) - self.ybase)
+
+ self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))
+
+ def XToData(self, x):
+ return Decimal(x) + self.xbase
+
+ def YToData(self, y):
+ return Decimal(y) + self.ybase
+
+# Switch graph data (for one CPU)
+
+class SwitchGraphData(GraphData):
+
+ def __init__(self, db, collection, cpu, xbase):
+ super(SwitchGraphData, self).__init__(collection, xbase)
+
+ self.cpu = cpu
+ self.title = "CPU " + str(cpu)
+ self.SelectSwitches(db)
+
+ def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT id, c_time"
+ " FROM comms"
+ " WHERE c_thread_id = " + str(thread_id) +
+ " AND exec_flag = " + self.collection.glb.dbref.TRUE +
+ " AND c_time >= " + str(start_time) +
+ " AND c_time <= " + str(end_time) +
+ " ORDER BY c_time, id")
+ while query.next():
+ comm_id = query.value(0)
+ if comm_id == last_comm_id:
+ continue
+ time = query.value(1)
+ hregion = self.HRegion(db, thread_id, comm_id, time)
+ self.AddPoint(time, 1000, None, None, hregion)
+
+ def SelectSwitches(self, db):
+ last_time = None
+ last_comm_id = None
+ last_thread_id = None
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT time, thread_out_id, thread_in_id, comm_out_id, comm_in_id, flags"
+ " FROM context_switches"
+ " WHERE machine_id = " + str(self.collection.machine_id) +
+ " AND cpu = " + str(self.cpu) +
+ " ORDER BY time, id")
+ while query.next():
+ flags = int(query.value(5))
+ if flags & 1:
+ # Schedule-out: detect and add exec's
+ if last_thread_id == query.value(1) and last_comm_id is not None and last_comm_id != query.value(3):
+ self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
+ continue
+ # Schedule-in: add data point
+ if len(self.points) == 0:
+ start_time = self.collection.glb.StartTime(self.collection.machine_id)
+ hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
+ self.AddPoint(start_time, 1000, None, None, hregion)
+ time = query.value(0)
+ comm_id = query.value(4)
+ thread_id = query.value(2)
+ hregion = self.HRegion(db, thread_id, comm_id, time)
+ self.AddPoint(time, 1000, None, None, hregion)
+ last_time = time
+ last_comm_id = comm_id
+ last_thread_id = thread_id
+
+ def NewHRegion(self, db, key, thread_id, comm_id, time):
+ exec_comm_id = ExecComm(db, thread_id, time)
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT pid, tid FROM threads WHERE id = " + str(thread_id))
+ if query.next():
+ pid = query.value(0)
+ tid = query.value(1)
+ else:
+ pid = -1
+ tid = -1
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT comm FROM comms WHERE id = " + str(comm_id))
+ if query.next():
+ comm = query.value(0)
+ else:
+ comm = ""
+ return SwitchGraphDataRegion(key, exec_comm_id, pid, tid, comm, thread_id, comm_id)
+
+ def HRegion(self, db, thread_id, comm_id, time):
+ key = str(thread_id) + ":" + str(comm_id)
+ hregion = self.collection.LookupHRegion(key)
+ if hregion is None:
+ hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
+ self.collection.AddHRegion(key, hregion)
+ return hregion
+
+# Graph data collection (multiple related graphs) base class
+
+class GraphDataCollection(object):
+
+ def __init__(self, glb):
+ self.glb = glb
+ self.data = []
+ self.hregions = {}
+ self.xrangelo = None
+ self.xrangehi = None
+ self.yrangelo = None
+ self.yrangehi = None
+ self.dp = XY(0, 0)
+
+ def AddGraphData(self, data):
+ self.data.append(data)
+
+ def LookupHRegion(self, key):
+ if key in self.hregions:
+ return self.hregions[key]
+ return None
+
+ def AddHRegion(self, key, hregion):
+ self.hregions[key] = hregion
+
+# Switch graph data collection (SwitchGraphData for each CPU)
+
+class SwitchGraphDataCollection(GraphDataCollection):
+
+ def __init__(self, glb, db, machine_id):
+ super(SwitchGraphDataCollection, self).__init__(glb)
+
+ self.machine_id = machine_id
+ self.cpus = self.SelectCPUs(db)
+
+ self.xrangelo = glb.StartTime(machine_id)
+ self.xrangehi = glb.FinishTime(machine_id)
+
+ self.yrangelo = Decimal(0)
+ self.yrangehi = Decimal(1000)
+
+ for cpu in self.cpus:
+ self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))
+
+ def SelectCPUs(self, db):
+ cpus = []
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT DISTINCT cpu"
+ " FROM context_switches"
+ " WHERE machine_id = " + str(self.machine_id))
+ while query.next():
+ cpus.append(int(query.value(0)))
+ return sorted(cpus)
+
+# Switch graph data graphics item displays the graphed data
+
+class SwitchGraphDataGraphicsItem(QGraphicsItem):
+
+ def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):
+ super(SwitchGraphDataGraphicsItem, self).__init__(parent)
+
+ self.data = data
+ self.graph_width = graph_width
+ self.graph_height = graph_height
+ self.attrs = attrs
+ self.event_handler = event_handler
+ self.setAcceptHoverEvents(True)
+
+ def boundingRect(self):
+ return QRectF(0, 0, self.graph_width, self.graph_height)
+
+ def PaintPoint(self, painter, last, x):
+ if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
+ if last.x < self.attrs.subrange.x.lo:
+ x0 = self.attrs.subrange.x.lo
+ else:
+ x0 = last.x
+ if x > self.attrs.subrange.x.hi:
+ x1 = self.attrs.subrange.x.hi
+ else:
+ x1 = x - 1
+ x0 = self.attrs.XToPixel(x0)
+ x1 = self.attrs.XToPixel(x1)
+
+ y0 = self.attrs.YToPixel(last.y)
+
+ colour = self.attrs.region_attributes[last.hregion.key].colour
+
+ width = x1 - x0 + 1
+ if width < 2:
+ painter.setPen(colour)
+ painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
+ else:
+ painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)
+
+ def paint(self, painter, _option, _widget):
+ last = None
+ for point in self.data.points:
+ self.PaintPoint(painter, last, point.x)
+ if point.x > self.attrs.subrange.x.hi:
+ break
+ last = point
+ self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)
+
+ def BinarySearchPoint(self, target):
+ lower_pos = 0
+ higher_pos = len(self.data.points)
+ while True:
+ pos = int((lower_pos + higher_pos) / 2)
+ val = self.data.points[pos].x
+ if target >= val:
+ lower_pos = pos
+ else:
+ higher_pos = pos
+ if higher_pos <= lower_pos + 1:
+ return lower_pos
+
+ def XPixelToData(self, x):
+ x = self.attrs.PixelToX(x)
+ if x < self.data.points[0].x:
+ x = 0
+ pos = 0
+ low = True
+ else:
+ pos = self.BinarySearchPoint(x)
+ low = False
+ return (low, pos, self.data.XToData(x))
+
+ def EventToData(self, event):
+ no_data = (None,) * 4
+ if len(self.data.points) < 1:
+ return no_data
+ x = event.pos().x()
+ if x < 0:
+ return no_data
+ _low0, pos0, time_from = self.XPixelToData(x)
+ low1, pos1, time_to = self.XPixelToData(x + 1)
+ hregions = set()
+ hregion_times = []
+ if not low1:
+ for i in range(pos0, pos1 + 1):
+ hregion = self.data.points[i].hregion
+ hregions.add(hregion)
+ if i == pos0:
+ time = time_from
+ else:
+ time = self.data.XToData(self.data.points[i].x)
+ hregion_times.append((hregion, time))
+ return (time_from, time_to, hregions, hregion_times)
+
+ def hoverMoveEvent(self, event):
+ time_from, time_to, hregions, _hregion_times = self.EventToData(event)
+ if time_from is not None:
+ self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)
+
+ def hoverLeaveEvent(self, _event):
+ self.event_handler.NoPointEvent()
+
+ def mousePressEvent(self, event):
+ if event.button() != Qt.RightButton:
+ super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
+ return
+ _time_from, _time_to, _hregions, hregion_times = self.EventToData(event)
+ if hregion_times:
+ self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())
+
+# X-axis graphics item
+
+class XAxisGraphicsItem(QGraphicsItem):
+
+ def __init__(self, width, parent=None):
+ super(XAxisGraphicsItem, self).__init__(parent)
+
+ self.width = width
+ self.max_mark_sz = 4
+ self.height = self.max_mark_sz + 1
+
+ def boundingRect(self):
+ return QRectF(0, 0, self.width, self.height)
+
+ def Step(self):
+ attrs = self.parentItem().attrs
+ subrange = attrs.subrange.x
+ t = subrange.hi - subrange.lo
+ s = (3.0 * t) / self.width
+ n = 1.0
+ while s > n:
+ n = n * 10.0
+ return n
+
+ def PaintMarks(self, painter, at_y, lo, hi, step, i):
+ attrs = self.parentItem().attrs
+ x = lo
+ while x <= hi:
+ xp = attrs.XToPixel(x)
+ if i % 10:
+ if i % 5:
+ sz = 1
+ else:
+ sz = 2
+ else:
+ sz = self.max_mark_sz
+ i = 0
+ painter.drawLine(xp, at_y, xp, at_y + sz)
+ x += step
+ i += 1
+
+ def paint(self, painter, _option, _widget):
+ # Using QPainter::drawLine(int x1, int y1, int x2, int y2) so x2 = width -1
+ painter.drawLine(0, 0, self.width - 1, 0)
+ n = self.Step()
+ attrs = self.parentItem().attrs
+ subrange = attrs.subrange.x
+ if subrange.lo:
+ x_offset = n - (subrange.lo % n)
+ else:
+ x_offset = 0.0
+ x = subrange.lo + x_offset
+ i = (x / n) % 10
+ self.PaintMarks(painter, 0, x, subrange.hi, n, i)
+
+ def ScaleDimensions(self):
+ n = self.Step()
+ attrs = self.parentItem().attrs
+ lo = attrs.subrange.x.lo
+ hi = (n * 10.0) + lo
+ width = attrs.XToPixel(hi)
+ if width > 500:
+ width = 0
+ return (n, lo, hi, width)
+
+ def PaintScale(self, painter, at_x, at_y):
+ n, lo, hi, width = self.ScaleDimensions()
+ if not width:
+ return
+ painter.drawLine(at_x, at_y, at_x + width, at_y)
+ self.PaintMarks(painter, at_y, lo, hi, n, 0)
+
+ def ScaleWidth(self):
+ _n, _lo, _hi, width = self.ScaleDimensions()
+ return width
+
+ def ScaleHeight(self):
+ return self.height
+
+ def ScaleUnit(self):
+ return self.Step() * 10
+
+# Scale graphics item base class
+
+class ScaleGraphicsItem(QGraphicsItem):
+
+ def __init__(self, axis, parent=None):
+ super(ScaleGraphicsItem, self).__init__(parent)
+ self.axis = axis
+
+ def boundingRect(self):
+ scale_width = self.axis.ScaleWidth()
+ if not scale_width:
+ return QRectF()
+ return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())
+
+ def paint(self, painter, _option, _widget):
+ scale_width = self.axis.ScaleWidth()
+ if not scale_width:
+ return
+ self.axis.PaintScale(painter, 0, 5)
+ x = scale_width + 4
+ painter.drawText(QPointF(x, 10), self.Text())
+
+ def Unit(self):
+ return self.axis.ScaleUnit()
+
+ def Text(self):
+ return ""
+
+# Switch graph scale graphics item
+
+class SwitchScaleGraphicsItem(ScaleGraphicsItem):
+
+ def Text(self):
+ unit = self.Unit()
+ if unit >= 1000000000:
+ unit = int(unit / 1000000000)
+ us = "s"
+ elif unit >= 1000000:
+ unit = int(unit / 1000000)
+ us = "ms"
+ elif unit >= 1000:
+ unit = int(unit / 1000)
+ us = "us"
+ else:
+ unit = int(unit)
+ us = "ns"
+ return " = " + str(unit) + " " + us
+
+# Switch graph graphics item contains graph title, scale, x/y-axis, and the graphed data
+
+class SwitchGraphGraphicsItem(QGraphicsItem):
+
+ def __init__(self, collection, data, attrs, event_handler, first, parent=None):
+ super(SwitchGraphGraphicsItem, self).__init__(parent)
+ self.collection = collection
+ self.data = data
+ self.attrs = attrs
+ self.event_handler = event_handler
+
+ margin = 20
+ title_width = 50
+
+ self.title_graphics = QGraphicsSimpleTextItem(data.title, self)
+
+ self.title_graphics.setPos(margin, margin)
+ graph_width = attrs.XToPixel(attrs.subrange.x.hi) + 1
+ graph_height = attrs.YToPixel(attrs.subrange.y.hi) + 1
+
+ self.graph_origin_x = margin + title_width + margin
+ self.graph_origin_y = graph_height + margin
+
+ _x_axis_size = 1
+ y_axis_size = 1
+ self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)
+
+ self.x_axis = XAxisGraphicsItem(graph_width, self)
+ self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)
+
+ if first:
+ self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
+ self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)
+
+ self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)
+
+ self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
+ self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)
+
+ self.width = self.graph_origin_x + graph_width + margin
+ self.height = self.graph_origin_y + margin
+
+ self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, self)
+ self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)
+
+ if parent and 'EnableRubberBand' in dir(parent):
+ parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)
+
+ def boundingRect(self):
+ return QRectF(0, 0, self.width, self.height)
+
+ def paint(self, painter, option, widget):
+ pass
+
+ def RBXToPixel(self, x):
+ return self.attrs.PixelToX(x - self.graph_origin_x)
+
+ def RBXRangeToPixel(self, x0, x1):
+ return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))
+
+ def RBPixelToTime(self, x):
+ if x < self.data.points[0].x:
+ return self.data.XToData(0)
+ return self.data.XToData(x)
+
+ def RBEventTimes(self, x0, x1):
+ x0, x1 = self.RBXRangeToPixel(x0, x1)
+ time_from = self.RBPixelToTime(x0)
+ time_to = self.RBPixelToTime(x1)
+ return (time_from, time_to)
+
+ def RBEvent(self, x0, x1):
+ time_from, time_to = self.RBEventTimes(x0, x1)
+ self.event_handler.RangeEvent(time_from, time_to)
+
+ def RBMoveEvent(self, x0, x1):
+ if x1 < x0:
+ x0, x1 = x1, x0
+ self.RBEvent(x0, x1)
+
+ def RBReleaseEvent(self, x0, x1, selection_state):
+ if x1 < x0:
+ x0, x1 = x1, x0
+ x0, x1 = self.RBXRangeToPixel(x0, x1)
+ self.event_handler.SelectEvent(x0, x1, selection_state)
+
+# Graphics item to draw a vertical bracket (used to highlight "forward" sub-range)
+
+class VerticalBracketGraphicsItem(QGraphicsItem):
+
+ def __init__(self, parent=None):
+ super(VerticalBracketGraphicsItem, self).__init__(parent)
+
+ self.width = 0
+ self.height = 0
+ self.hide()
+
+ def SetSize(self, width, height):
+ self.width = width + 1
+ self.height = height + 1
+
+ def boundingRect(self):
+ return QRectF(0, 0, self.width, self.height)
+
+ def paint(self, painter, _option, _widget):
+ colour = QColor(255, 255, 0, 32)
+ painter.fillRect(0, 0, self.width, self.height, colour)
+ x1 = self.width - 1
+ y1 = self.height - 1
+ painter.drawLine(0, 0, x1, 0)
+ painter.drawLine(0, 0, 0, 3)
+ painter.drawLine(x1, 0, x1, 3)
+ painter.drawLine(0, y1, x1, y1)
+ painter.drawLine(0, y1, 0, y1 - 3)
+ painter.drawLine(x1, y1, x1, y1 - 3)
+
+# Graphics item to contain graphs arranged vertically
+
+class VertcalGraphSetGraphicsItem(QGraphicsItem):
+
+ def __init__(self, collection, attrs, event_handler, child_class, parent=None):
+ super(VertcalGraphSetGraphicsItem, self).__init__(parent)
+
+ self.collection = collection
+
+ self.top = 10
+
+ self.width = 0
+ self.height = self.top
+
+ self.rubber_band = None
+ self.rb_enabled = False
+ self.rb_in_view = False
+ self.rb_xlo = 0
+ self.rb_xhi = 0
+ self.rb_event_handler = None
+ self.rb_origin = None
+
+ first = True
+ for data in collection.data:
+ child = child_class(collection, data, attrs, event_handler, first, self)
+ child.setPos(0, self.height + 1)
+ rect = child.boundingRect()
+ if rect.right() > self.width:
+ self.width = rect.right()
+ self.height = self.height + rect.bottom() + 1
+ first = False
+
+ self.bracket = VerticalBracketGraphicsItem(self)
+
+ def EnableRubberBand(self, xlo, xhi, rb_event_handler):
+ if self.rb_enabled:
+ return
+ self.rb_enabled = True
+ self.rb_in_view = False
+ self.setAcceptedMouseButtons(Qt.LeftButton)
+ self.rb_xlo = xlo
+ self.rb_xhi = xhi
+ self.rb_event_handler = rb_event_handler
+
+ def mousePressEvent(self, event):
+ if self.rb_enabled:
+ self.MousePressEvent(event)
+
+ def mouseMoveEvent(self, event):
+ if self.rb_enabled:
+ self.MouseMoveEvent(event)
+
+ def mouseReleaseEvent(self, event):
+ if self.rb_enabled:
+ self.MouseReleaseEvent(event)
+
+ def boundingRect(self):
+ return QRectF(0, 0, self.width, self.height)
+
+ def paint(self, painter, option, widget):
+ pass
+
+ def RubberBandParent(self):
+ scene = self.scene()
+ view = scene.views()[0]
+ viewport = view.viewport()
+ return viewport
+
+ def RubberBandSetGeometry(self, rect):
+ scene_rectf = self.mapRectToScene(QRectF(rect))
+ scene = self.scene()
+ view = scene.views()[0]
+ poly = view.mapFromScene(scene_rectf)
+ self.rubber_band.setGeometry(poly.boundingRect())
+
+ def SetSelection(self, selection_state):
+ if self.rubber_band:
+ if selection_state:
+ self.RubberBandSetGeometry(selection_state)
+ self.rubber_band.show()
+ else:
+ self.rubber_band.hide()
+
+ def SetBracket(self, rect):
+ if rect:
+ x, y, width, height = rect.x(), rect.y(), rect.width(), rect.height()
+ self.bracket.setPos(x, y)
+ self.bracket.SetSize(width, height)
+ self.bracket.show()
+ else:
+ self.bracket.hide()
+
+ def RubberBandX(self, event):
+ x = event.pos().toPoint().x()
+ if x < self.rb_xlo:
+ x = self.rb_xlo
+ elif x > self.rb_xhi:
+ x = self.rb_xhi
+ else:
+ self.rb_in_view = True
+ return x
+
+ def RubberBandRect(self, x):
+ if self.rb_origin.x() <= x:
+ width = x - self.rb_origin.x()
+ rect = QRect(self.rb_origin, QSize(width, self.height))
+ else:
+ width = self.rb_origin.x() - x
+ top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
+ rect = QRect(top_left, QSize(width, self.height))
+ return rect
+
+ def MousePressEvent(self, event):
+ self.rb_in_view = False
+ x = self.RubberBandX(event)
+ self.rb_origin = QPoint(x, self.top)
+ if self.rubber_band is None:
+ self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
+ self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
+ if self.rb_in_view:
+ self.rubber_band.show()
+ self.rb_event_handler.RBMoveEvent(x, x)
+ else:
+ self.rubber_band.hide()
+
+ def MouseMoveEvent(self, event):
+ x = self.RubberBandX(event)
+ rect = self.RubberBandRect(x)
+ self.RubberBandSetGeometry(rect)
+ if self.rb_in_view:
+ self.rubber_band.show()
+ self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)
+
+ def MouseReleaseEvent(self, event):
+ x = self.RubberBandX(event)
+ if self.rb_in_view:
+ selection_state = self.RubberBandRect(x)
+ else:
+ selection_state = None
+ self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)
+
+# Switch graph legend data model
+
+class SwitchGraphLegendModel(QAbstractTableModel):
+
+ def __init__(self, collection, region_attributes, parent=None):
+ super(SwitchGraphLegendModel, self).__init__(parent)
+
+ self.region_attributes = region_attributes
+
+ self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
+ self.child_count = len(self.child_items)
+
+ self.highlight_set = set()
+
+ self.column_headers = ("pid", "tid", "comm")
+
+ def rowCount(self, _parent):
+ return self.child_count
+
+ def headerData(self, section, orientation, role):
+ if role != Qt.DisplayRole:
+ return None
+ if orientation != Qt.Horizontal:
+ return None
+ return self.columnHeader(section)
+
+ def index(self, row, column, _parent):
+ return self.createIndex(row, column, self.child_items[row])
+
+ def columnCount(self, _parent=None):
+ return len(self.column_headers)
+
+ def columnHeader(self, column):
+ return self.column_headers[column]
+
+ def data(self, index, role):
+ if role == Qt.BackgroundRole:
+ child = self.child_items[index.row()]
+ if child in self.highlight_set:
+ return self.region_attributes[child.key].colour
+ return None
+ if role == Qt.ForegroundRole:
+ child = self.child_items[index.row()]
+ if child in self.highlight_set:
+ return QColor(255, 255, 255)
+ return self.region_attributes[child.key].colour
+ if role != Qt.DisplayRole:
+ return None
+ hregion = self.child_items[index.row()]
+ col = index.column()
+ if col == 0:
+ return hregion.pid
+ if col == 1:
+ return hregion.tid
+ if col == 2:
+ return hregion.comm
+ return None
+
+ def SetHighlight(self, row, _set_highlight):
+ child = self.child_items[row]
+ top_left = self.createIndex(row, 0, child)
+ bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
+ self.dataChanged.emit(top_left, bottom_right)
+
+ def Highlight(self, highlight_set):
+ for row in range(self.child_count):
+ child = self.child_items[row]
+ if child in self.highlight_set:
+ if child not in highlight_set:
+ self.SetHighlight(row, False)
+ elif child in highlight_set:
+ self.SetHighlight(row, True)
+ self.highlight_set = highlight_set
+
+# Switch graph legend is a table
+
+class SwitchGraphLegend(QWidget):
+
+ def __init__(self, collection, region_attributes, parent=None):
+ super(SwitchGraphLegend, self).__init__(parent)
+
+ self.data_model = SwitchGraphLegendModel(collection, region_attributes)
+
+ self.model = QSortFilterProxyModel()
+ self.model.setSourceModel(self.data_model)
+
+ self.view = QTableView()
+ self.view.setModel(self.model)
+ self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
+ self.view.verticalHeader().setVisible(False)
+ self.view.sortByColumn(-1, Qt.AscendingOrder)
+ self.view.setSortingEnabled(True)
+ self.view.resizeColumnsToContents()
+ self.view.resizeRowsToContents()
+
+ self.vbox = VBoxLayout(self.view)
+ self.setLayout(self.vbox)
+
+ sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
+ sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
+ self.saved_size = sz1
+
+ def resizeEvent(self, event):
+ self.saved_size = self.size().width()
+ super(SwitchGraphLegend, self).resizeEvent(event)
+
+ def Highlight(self, highlight_set):
+ self.data_model.Highlight(highlight_set)
+ self.update()
+
+ def changeEvent(self, event):
+ if event.type() == QEvent.FontChange:
+ self.view.resizeRowsToContents()
+ self.view.resizeColumnsToContents()
+ # Need to resize rows again after column resize
+ self.view.resizeRowsToContents()
+ super(SwitchGraphLegend, self).changeEvent(event)
+
+# Random colour generation
+
+def RGBColourTooLight(r, g, _b):
+ if g > 230:
+ return True
+ if g <= 160:
+ return False
+ if r <= 180 and g <= 180:
+ return False
+ if r < 60:
+ return False
+ return True
+
+def GenerateColours(x):
+ cs = [0]
+ for i in range(1, x):
+ cs.append(int((255.0 / i) + 0.5))
+ colours = []
+ for r in cs:
+ for g in cs:
+ for b in cs:
+ # Exclude black and colours that look too light against a white background
+ if (r, g, b) == (0, 0, 0) or RGBColourTooLight(r, g, b):
+ continue
+ colours.append(QColor(r, g, b))
+ return colours
+
+def GenerateNColours(n):
+ for x in range(2, n + 2):
+ colours = GenerateColours(x)
+ if len(colours) >= n:
+ return colours
+ return []
+
+def GenerateNRandomColours(n, seed):
+ colours = GenerateNColours(n)
+ random.seed(seed)
+ random.shuffle(colours)
+ return colours
+
+# Graph attributes, in particular the scale and subrange that change when zooming
+
+class GraphAttributes():
+
+ def __init__(self, scale, subrange, region_attributes, dp):
+ self.scale = scale
+ self.subrange = subrange
+ self.region_attributes = region_attributes
+ # Rounding avoids errors due to finite floating point precision
+ self.dp = dp # data decimal places
+ self.Update()
+
+ def XToPixel(self, x):
+ return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))
+
+ def YToPixel(self, y):
+ return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))
+
+ def PixelToXRounded(self, px):
+ return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo
+
+ def PixelToYRounded(self, py):
+ return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo
+
+ def PixelToX(self, px):
+ x = self.PixelToXRounded(px)
+ if self.pdp.x == 0:
+ rt = self.XToPixel(x)
+ if rt > px:
+ return x - 1
+ return x
+
+ def PixelToY(self, py):
+ y = self.PixelToYRounded(py)
+ if self.pdp.y == 0:
+ rt = self.YToPixel(y)
+ if rt > py:
+ return y - 1
+ return y
+
+ def ToPDP(self, dp, scale):
+ # Calculate pixel decimal places:
+ # (10 ** dp) is the minimum delta in the data
+ # scale it to get the minimum delta in pixels
+ # log10 gives the number of decimals places negatively
+ # subtrace 1 to divide by 10
+ # round to the lower negative number
+ # change the sign to get the number of decimals positively
+ x = math.log10((10 ** dp) * scale)
+ if x < 0:
+ x -= 1
+ x = -int(math.floor(x) - 0.1)
+ else:
+ x = 0
+ return x
+
+ def Update(self):
+ x = self.ToPDP(self.dp.x, self.scale.x)
+ y = self.ToPDP(self.dp.y, self.scale.y)
+ self.pdp = XY(x, y) # pixel decimal places
+
+# Switch graph splitter which divides the CPU graphs from the legend
+
+class SwitchGraphSplitter(QSplitter):
+
+ def __init__(self, parent=None):
+ super(SwitchGraphSplitter, self).__init__(parent)
+
+ self.first_time = False
+
+ def resizeEvent(self, event):
+ if self.first_time:
+ self.first_time = False
+ sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).view.columnWidth(2) + 2
+ sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
+ sz0 = self.size().width() - self.handleWidth() - sz1
+ self.setSizes([sz0, sz1])
+ elif not(self.widget(1).saved_size is None):
+ sz1 = self.widget(1).saved_size
+ sz0 = self.size().width() - self.handleWidth() - sz1
+ self.setSizes([sz0, sz1])
+ super(SwitchGraphSplitter, self).resizeEvent(event)
+
+# Graph widget base class
+
+class GraphWidget(QWidget):
+
+ graph_title_changed = Signal(object)
+
+ def __init__(self, parent=None):
+ super(GraphWidget, self).__init__(parent)
+
+ def GraphTitleChanged(self, title):
+ self.graph_title_changed.emit(title)
+
+ def Title(self):
+ return ""
+
+# Display time in s, ms, us or ns
+
+def ToTimeStr(val):
+ val = Decimal(val)
+ if val >= 1000000000:
+ return "{} s".format((val / 1000000000).quantize(Decimal("0.000000001")))
+ if val >= 1000000:
+ return "{} ms".format((val / 1000000).quantize(Decimal("0.000001")))
+ if val >= 1000:
+ return "{} us".format((val / 1000).quantize(Decimal("0.001")))
+ return "{} ns".format(val.quantize(Decimal("1")))
+
+# Switch (i.e. context switch i.e. Time Chart by CPU) graph widget which contains the CPU graphs and the legend and control buttons
+
+class SwitchGraphWidget(GraphWidget):
+
+ def __init__(self, glb, collection, parent=None):
+ super(SwitchGraphWidget, self).__init__(parent)
+
+ self.glb = glb
+ self.collection = collection
+
+ self.back_state = []
+ self.forward_state = []
+ self.selection_state = (None, None)
+ self.fwd_rect = None
+ self.start_time = self.glb.StartTime(collection.machine_id)
+
+ i = 0
+ hregions = collection.hregions.values()
+ colours = GenerateNRandomColours(len(hregions), 1013)
+ region_attributes = {}
+ for hregion in hregions:
+ if hregion.pid == 0 and hregion.tid == 0:
+ region_attributes[hregion.key] = GraphRegionAttribute(QColor(0, 0, 0))
+ else:
+ region_attributes[hregion.key] = GraphRegionAttribute(colours[i])
+ i = i + 1
+
+ # Default to entire range
+ xsubrange = Subrange(0.0, float(collection.xrangehi - collection.xrangelo) + 1.0)
+ ysubrange = Subrange(0.0, float(collection.yrangehi - collection.yrangelo) + 1.0)
+ subrange = XY(xsubrange, ysubrange)
+
+ scale = self.GetScaleForRange(subrange)
+
+ self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)
+
+ self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)
+
+ self.scene = QGraphicsScene()
+ self.scene.addItem(self.item)
+
+ self.view = QGraphicsView(self.scene)
+ self.view.centerOn(0, 0)
+ self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+
+ self.legend = SwitchGraphLegend(collection, region_attributes)
+
+ self.splitter = SwitchGraphSplitter()
+ self.splitter.addWidget(self.view)
+ self.splitter.addWidget(self.legend)
+
+ self.point_label = QLabel("")
+ self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
+
+ self.back_button = QToolButton()
+ self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
+ self.back_button.setDisabled(True)
+ self.back_button.released.connect(self.Back)
+
+ self.forward_button = QToolButton()
+ self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
+ self.forward_button.setDisabled(True)
+ self.forward_button.released.connect(self.Forward)
+
+ self.zoom_button = QToolButton()
+ self.zoom_button.setText("Zoom")
+ self.zoom_button.setDisabled(True)
+ self.zoom_button.released.connect(self.Zoom)
+
+ self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)
+
+ self.vbox = VBoxLayout(self.splitter, self.hbox)
+
+ self.setLayout(self.vbox)
+
+ def GetScaleForRangeX(self, xsubrange):
+ # Default graph 1000 pixels wide
+ dflt = 1000.0
+ r = xsubrange.hi - xsubrange.lo
+ return dflt / r
+
+ def GetScaleForRangeY(self, ysubrange):
+ # Default graph 50 pixels high
+ dflt = 50.0
+ r = ysubrange.hi - ysubrange.lo
+ return dflt / r
+
+ def GetScaleForRange(self, subrange):
+ # Default graph 1000 pixels wide, 50 pixels high
+ xscale = self.GetScaleForRangeX(subrange.x)
+ yscale = self.GetScaleForRangeY(subrange.y)
+ return XY(xscale, yscale)
+
+ def PointEvent(self, cpu, time_from, _time_to, hregions):
+ text = "CPU: " + str(cpu)
+ time_from = time_from.quantize(Decimal(1))
+ rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
+ text = text + " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ")"
+ self.point_label.setText(text)
+ self.legend.Highlight(hregions)
+
+ def RightClickEvent(self, _cpu, hregion_times, pos):
+ if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
+ return
+ menu = QMenu(self.view)
+ for hregion, time in hregion_times:
+ thread_at_time = (hregion.exec_comm_id, hregion.thread_id, time)
+ menu_text = "Show Call Tree for {} {}:{} at {}".format(hregion.comm, hregion.pid, hregion.tid, time)
+ menu.addAction(CreateAction(menu_text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view))
+ menu.exec_(pos)
+
+ def RightClickSelect(self, args):
+ CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)
+
+ def NoPointEvent(self):
+ self.point_label.setText("")
+ self.legend.Highlight({})
+
+ def RangeEvent(self, time_from, time_to):
+ time_from = time_from.quantize(Decimal(1))
+ time_to = time_to.quantize(Decimal(1))
+ if time_to <= time_from:
+ self.point_label.setText("")
+ return
+ rel_time_from = time_from - self.start_time
+ rel_time_to = time_to - self.start_time
+ text = " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ") to: " + str(time_to) + " (+" + ToTimeStr(rel_time_to) + ")"
+ text = text + " duration: " + ToTimeStr(time_to - time_from)
+ self.point_label.setText(text)
+
+ def BackState(self):
+ return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)
+
+ def PushBackState(self):
+ state = copy.deepcopy(self.BackState())
+ self.back_state.append(state)
+ self.back_button.setEnabled(True)
+
+ def PopBackState(self):
+ self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
+ self.attrs.Update()
+ if not self.back_state:
+ self.back_button.setDisabled(True)
+
+ def PushForwardState(self):
+ state = copy.deepcopy(self.BackState())
+ self.forward_state.append(state)
+ self.forward_button.setEnabled(True)
+
+ def PopForwardState(self):
+ self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.pop()
+ self.attrs.Update()
+ if not self.forward_state:
+ self.forward_button.setDisabled(True)
+
+ def Title(self):
+ time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
+ time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
+ rel_time_from = time_from - self.start_time
+ rel_time_to = time_to - self.start_time
+ title = "+" + ToTimeStr(rel_time_from) + " to +" + ToTimeStr(rel_time_to)
+ title = title + " (" + ToTimeStr(time_to - time_from) + ")"
+ return title
+
+ def Update(self):
+ selected_subrange, selection_state = self.selection_state
+ self.item.SetSelection(selection_state)
+ self.item.SetBracket(self.fwd_rect)
+ self.zoom_button.setDisabled(selected_subrange is None)
+ self.GraphTitleChanged(self.Title())
+ self.item.update(self.item.boundingRect())
+
+ def Back(self):
+ if not self.back_state:
+ return
+ self.PushForwardState()
+ self.PopBackState()
+ self.Update()
+
+ def Forward(self):
+ if not self.forward_state:
+ return
+ self.PushBackState()
+ self.PopForwardState()
+ self.Update()
+
+ def SelectEvent(self, x0, x1, selection_state):
+ if selection_state is None:
+ selected_subrange = None
+ else:
+ if x1 - x0 < 1.0:
+ x1 += 1.0
+ selected_subrange = Subrange(x0, x1)
+ self.selection_state = (selected_subrange, selection_state)
+ self.zoom_button.setDisabled(selected_subrange is None)
+
+ def Zoom(self):
+ selected_subrange, selection_state = self.selection_state
+ if selected_subrange is None:
+ return
+ self.fwd_rect = selection_state
+ self.item.SetSelection(None)
+ self.PushBackState()
+ self.attrs.subrange.x = selected_subrange
+ self.forward_state = []
+ self.forward_button.setDisabled(True)
+ self.selection_state = (None, None)
+ self.fwd_rect = None
+ self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
+ self.attrs.Update()
+ self.Update()
+
+# Slow initialization - perform non-GUI initialization in a separate thread and put up a modal message box while waiting
+
+class SlowInitClass():
+
+ def __init__(self, glb, title, init_fn):
+ self.init_fn = init_fn
+ self.done = False
+ self.result = None
+
+ self.msg_box = QMessageBox(glb.mainwindow)
+ self.msg_box.setText("Initializing " + title + ". Please wait.")
+ self.msg_box.setWindowTitle("Initializing " + title)
+ self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))
+
+ self.init_thread = Thread(self.ThreadFn, glb)
+ self.init_thread.done.connect(self.Done, Qt.QueuedConnection)
+
+ self.init_thread.start()
+
+ def Done(self):
+ self.msg_box.done(0)
+
+ def ThreadFn(self, glb):
+ conn_name = "SlowInitClass" + str(os.getpid())
+ db, _dbname = glb.dbref.Open(conn_name)
+ self.result = self.init_fn(db)
+ self.done = True
+ return (True, 0)
+
+ def Result(self):
+ while not self.done:
+ self.msg_box.exec_()
+ self.init_thread.wait()
+ return self.result
+
+def SlowInit(glb, title, init_fn):
+ init = SlowInitClass(glb, title, init_fn)
+ return init.Result()
+
+# Time chart by CPU window
+
+class TimeChartByCPUWindow(QMdiSubWindow):
+
+ def __init__(self, glb, parent=None):
+ super(TimeChartByCPUWindow, self).__init__(parent)
+
+ self.glb = glb
+ self.machine_id = glb.HostMachineId()
+ self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)
+
+ collection = LookupModel(self.collection_name)
+ if collection is None:
+ collection = SlowInit(glb, "Time Chart", self.Init)
+
+ self.widget = SwitchGraphWidget(glb, collection, self)
+ self.view = self.widget
+
+ self.base_title = "Time Chart by CPU"
+ self.setWindowTitle(self.base_title + self.widget.Title())
+ self.widget.graph_title_changed.connect(self.GraphTitleChanged)
+
+ self.setWidget(self.widget)
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())
+
+ def Init(self, db):
+ return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, self.machine_id))
+
+ def GraphTitleChanged(self, title):
+ self.setWindowTitle(self.base_title + " : " + title)
+
+# Child data item finder
+
+class ChildDataItemFinder():
+
+ def __init__(self, root):
+ self.root = root
+ self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
+ self.rows = []
+ self.pos = 0
+
+ def FindSelect(self):
+ self.rows = []
+ if self.pattern:
+ pattern = re.compile(self.value)
+ for child in self.root.child_items:
+ for column_data in child.data:
+ if re.search(pattern, str(column_data)) is not None:
+ self.rows.append(child.row)
+ break
+ else:
+ for child in self.root.child_items:
+ for column_data in child.data:
+ if self.value in str(column_data):
+ self.rows.append(child.row)
+ break
+
+ def FindValue(self):
+ self.pos = 0
+ if self.last_value != self.value or self.pattern != self.last_pattern:
+ self.FindSelect()
+ if not len(self.rows):
+ return -1
+ return self.rows[self.pos]
+
+ def FindThread(self):
+ if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
+ row = self.FindValue()
+ elif len(self.rows):
+ if self.direction > 0:
+ self.pos += 1
+ if self.pos >= len(self.rows):
+ self.pos = 0
+ else:
+ self.pos -= 1
+ if self.pos < 0:
+ self.pos = len(self.rows) - 1
+ row = self.rows[self.pos]
+ else:
+ row = -1
+ return (True, row)
+
+ def Find(self, value, direction, pattern, _context, callback):
+ self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern)
+ # Use a thread so the UI is not blocked
+ thread = Thread(self.FindThread)
+ thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection)
+ thread.start()
+
+ def FindDone(self, _thread, callback, row):
+ callback(row)
+
+# Number of database records to fetch in one go
+
+glb_chunk_sz = 10000
+
+# Background process for SQL data fetcher
+
+class SQLFetcherProcess():
+
+ def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep):
+ # Need a unique connection name
+ conn_name = "SQLFetcher" + str(os.getpid())
+ self.db, _dbname = dbref.Open(conn_name)
+ self.sql = sql
+ self.buffer = buffer
+ self.head = head
+ self.tail = tail
+ self.fetch_count = fetch_count
+ self.fetching_done = fetching_done
+ self.process_target = process_target
+ self.wait_event = wait_event
+ self.fetched_event = fetched_event
+ self.prep = prep
+ self.query = QSqlQuery(self.db)
+ self.query_limit = 0 if "$$last_id$$" in sql else 2
+ self.last_id = -1
+ self.fetched = 0
+ self.more = True
+ self.local_head = self.head.value
+ self.local_tail = self.tail.value
+
+ def Select(self):
+ if self.query_limit:
+ if self.query_limit == 1:
+ return
+ self.query_limit -= 1
+ stmt = self.sql.replace("$$last_id$$", str(self.last_id))
+ QueryExec(self.query, stmt)
+
+ def Next(self):
+ if not self.query.next():
+ self.Select()
+ if not self.query.next():
+ return None
+ self.last_id = self.query.value(0)
+ return self.prep(self.query)
+
+ def WaitForTarget(self):
+ while True:
+ self.wait_event.clear()
+ target = self.process_target.value
+ if target > self.fetched or target < 0:
+ break
+ self.wait_event.wait()
+ return target
+
+ def HasSpace(self, sz):
+ if self.local_tail <= self.local_head:
+ space = len(self.buffer) - self.local_head
+ if space > sz:
+ return True
+ if space >= glb_nsz:
+ # Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer
+ nd = pickle.dumps(0, pickle.HIGHEST_PROTOCOL)
+ self.buffer[self.local_head : self.local_head + len(nd)] = nd
+ self.local_head = 0
+ if self.local_tail - self.local_head > sz:
+ return True
+ return False
+
+ def WaitForSpace(self, sz):
+ if self.HasSpace(sz):
+ return
+ while True:
+ self.wait_event.clear()
+ self.local_tail = self.tail.value
+ if self.HasSpace(sz):
+ return
+ self.wait_event.wait()
+
+ def AddToBuffer(self, obj):
+ d = pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
+ n = len(d)
+ nd = pickle.dumps(n, pickle.HIGHEST_PROTOCOL)
+ sz = n + glb_nsz
+ self.WaitForSpace(sz)
+ pos = self.local_head
+ self.buffer[pos : pos + len(nd)] = nd
+ self.buffer[pos + glb_nsz : pos + sz] = d
+ self.local_head += sz
+
+ def FetchBatch(self, batch_size):
+ fetched = 0
+ while batch_size > fetched:
+ obj = self.Next()
+ if obj is None:
+ self.more = False
+ break
+ self.AddToBuffer(obj)
+ fetched += 1
+ if fetched:
+ self.fetched += fetched
+ with self.fetch_count.get_lock():
+ self.fetch_count.value += fetched
+ self.head.value = self.local_head
+ self.fetched_event.set()
+
+ def Run(self):
+ while self.more:
+ target = self.WaitForTarget()
+ if target < 0:
+ break
+ batch_size = min(glb_chunk_sz, target - self.fetched)
+ self.FetchBatch(batch_size)
+ self.fetching_done.value = True
+ self.fetched_event.set()
+
+def SQLFetcherFn(*x):
+ process = SQLFetcherProcess(*x)
+ process.Run()
+
+# SQL data fetcher
+
+class SQLFetcher(QObject):
+
+ done = Signal(object)
+
+ def __init__(self, glb, sql, prep, process_data, parent=None):
+ super(SQLFetcher, self).__init__(parent)
+ self.process_data = process_data
+ self.more = True
+ self.target = 0
+ self.last_target = 0
+ self.fetched = 0
+ self.buffer_size = 16 * 1024 * 1024
+ self.buffer = Array(c_char, self.buffer_size, lock=False)
+ self.head = Value(c_longlong)
+ self.tail = Value(c_longlong)
+ self.local_tail = 0
+ self.fetch_count = Value(c_longlong)
+ self.fetching_done = Value(c_bool)
+ self.last_count = 0
+ self.process_target = Value(c_longlong)
+ self.wait_event = Event()
+ self.fetched_event = Event()
+ glb.AddInstanceToShutdownOnExit(self)
+ self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tail, self.fetch_count, self.fetching_done, self.process_target, self.wait_event, self.fetched_event, prep))
+ self.process.start()
+ self.thread = Thread(self.Thread)
+ self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
+ self.thread.start()
+
+ def Shutdown(self):
+ # Tell the thread and process to exit
+ self.process_target.value = -1
+ self.wait_event.set()
+ self.more = False
+ self.fetching_done.value = True
+ self.fetched_event.set()
+
+ def Thread(self):
+ if not self.more:
+ return True, 0
+ while True:
+ self.fetched_event.clear()
+ fetch_count = self.fetch_count.value
+ if fetch_count != self.last_count:
+ break
+ if self.fetching_done.value:
+ self.more = False
+ return True, 0
+ self.fetched_event.wait()
+ count = fetch_count - self.last_count
+ self.last_count = fetch_count
+ self.fetched += count
+ return False, count
+
+ def Fetch(self, nr):
+ if not self.more:
+ # -1 inidcates there are no more
+ return -1
+ result = self.fetched
+ extra = result + nr - self.target
+ if extra > 0:
+ self.target += extra
+ # process_target < 0 indicates shutting down
+ if self.process_target.value >= 0:
+ self.process_target.value = self.target
+ self.wait_event.set()
+ return result
+
+ def RemoveFromBuffer(self):
+ pos = self.local_tail
+ if len(self.buffer) - pos < glb_nsz:
+ pos = 0
+ n = pickle.loads(self.buffer[pos : pos + glb_nsz])
+ if n == 0:
+ pos = 0
+ n = pickle.loads(self.buffer[0 : glb_nsz])
+ pos += glb_nsz
+ obj = pickle.loads(self.buffer[pos : pos + n])
+ self.local_tail = pos + n
+ return obj
+
+ def ProcessData(self, count):
+ for _i in range(count):
+ obj = self.RemoveFromBuffer()
+ self.process_data(obj)
+ self.tail.value = self.local_tail
+ self.wait_event.set()
+ self.done.emit(count)
+
+# Fetch more records bar
+
+class FetchMoreRecordsBar():
+
+ def __init__(self, model, parent):
+ self.model = model
+
+ self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
+ self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+ self.fetch_count = QSpinBox()
+ self.fetch_count.setRange(1, 1000000)
+ self.fetch_count.setValue(10)
+ self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+ self.fetch = QPushButton("Go!")
+ self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+ self.fetch.released.connect(self.FetchMoreRecords)
+
+ self.progress = QProgressBar()
+ self.progress.setRange(0, 100)
+ self.progress.hide()
+
+ self.done_label = QLabel("All records fetched")
+ self.done_label.hide()
+
+ self.spacer = QLabel("")
+
+ self.close_button = QToolButton()
+ self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
+ self.close_button.released.connect(self.Deactivate)
+
+ self.hbox = QHBoxLayout()
+ self.hbox.setContentsMargins(0, 0, 0, 0)
+
+ self.hbox.addWidget(self.label)
+ self.hbox.addWidget(self.fetch_count)
+ self.hbox.addWidget(self.fetch)
+ self.hbox.addWidget(self.spacer)
+ self.hbox.addWidget(self.progress)
+ self.hbox.addWidget(self.done_label)
+ self.hbox.addWidget(self.close_button)
+
+ self.bar = QWidget()
+ self.bar.setLayout(self.hbox)
+ self.bar.show()
+
+ self.in_progress = False
+ self.start = 0
+ self.model.progress.connect(self.Progress)
+
+ self.done = False
+
+ if not model.HasMoreRecords():
+ self.Done()
+
+ def Widget(self):
+ return self.bar
+
+ def Activate(self):
+ self.bar.show()
+ self.fetch.setFocus()
+
+ def Deactivate(self):
+ self.bar.hide()
+
+ def Enable(self, enable):
+ self.fetch.setEnabled(enable)
+ self.fetch_count.setEnabled(enable)
+
+ def Busy(self):
+ self.Enable(False)
+ self.fetch.hide()
+ self.spacer.hide()
+ self.progress.show()
+
+ def Idle(self):
+ self.in_progress = False
+ self.Enable(True)
+ self.progress.hide()
+ self.fetch.show()
+ self.spacer.show()
+
+ def Target(self):
+ return self.fetch_count.value() * glb_chunk_sz
+
+ def Done(self):
+ self.done = True
+ self.Idle()
+ self.label.hide()
+ self.fetch_count.hide()
+ self.fetch.hide()
+ self.spacer.hide()
+ self.done_label.show()
+
+ def Progress(self, count):
+ if self.in_progress:
+ if count:
+ percent = ((count - self.start) * 100) / self.Target()
+ if percent >= 100:
+ self.Idle()
+ else:
+ self.progress.setValue(percent)
+ if not count:
+ # Count value of zero means no more records
+ self.Done()
+
+ def FetchMoreRecords(self):
+ if self.done:
+ return
+ self.progress.setValue(0)
+ self.Busy()
+ self.in_progress = True
+ self.start = self.model.FetchMoreRecords(self.Target())
+
+# Brance data model level two item
+
+class BranchLevelTwoItem():
+
+ def __init__(self, row, col, text, parent_item):
+ self.row = row
+ self.parent_item = parent_item
+ self.data = [""] * (col + 1)
+ self.data[col] = text
+ self.level = 2
+
+ def getParentItem(self):
+ return self.parent_item
+
+ def getRow(self):
+ return self.row
+
+ def childCount(self):
+ return 0
+
+ def hasChildren(self):
+ return False
+
+ def getData(self, column):
+ return self.data[column]
+
+# Brance data model level one item
+
+class BranchLevelOneItem():
+
+ def __init__(self, glb, row, data, parent_item):
+ self.glb = glb
+ self.row = row
+ self.parent_item = parent_item
+ self.child_count = 0
+ self.child_items = []
+ self.data = data[1:]
+ self.dbid = data[0]
+ self.level = 1
+ self.query_done = False
+ self.br_col = len(self.data) - 1
+
+ def getChildItem(self, row):
+ return self.child_items[row]
+
+ def getParentItem(self):
+ return self.parent_item
+
+ def getRow(self):
+ return self.row
+
+ def Select(self):
+ self.query_done = True
+
+ if not self.glb.have_disassembler:
+ return
+
+ query = QSqlQuery(self.glb.db)
+
+ QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip"
+ " FROM samples"
+ " INNER JOIN dsos ON samples.to_dso_id = dsos.id"
+ " INNER JOIN symbols ON samples.to_symbol_id = symbols.id"
+ " WHERE samples.id = " + str(self.dbid))
+ if not query.next():
+ return
+ cpu = query.value(0)
+ dso = query.value(1)
+ sym = query.value(2)
+ if dso == 0 or sym == 0:
+ return
+ off = query.value(3)
+ short_name = query.value(4)
+ long_name = query.value(5)
+ build_id = query.value(6)
+ sym_start = query.value(7)
+ ip = query.value(8)
+
+ QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start"
+ " FROM samples"
+ " INNER JOIN symbols ON samples.symbol_id = symbols.id"
+ " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
+ " ORDER BY samples.id"
+ " LIMIT 1")
+ if not query.next():
+ return
+ if query.value(0) != dso:
+ # Cannot disassemble from one dso to another
+ return
+ bsym = query.value(1)
+ boff = query.value(2)
+ bsym_start = query.value(3)
+ if bsym == 0:
+ return
+ tot = bsym_start + boff + 1 - sym_start - off
+ if tot <= 0 or tot > 16384:
+ return
+
+ inst = self.glb.disassembler.Instruction()
+ f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
+ if not f:
+ return
+ mode = 0 if Is64Bit(f) else 1
+ self.glb.disassembler.SetMode(inst, mode)
+
+ buf_sz = tot + 16
+ buf = create_string_buffer(tot + 16)
+ f.seek(sym_start + off)
+ buf.value = f.read(buf_sz)
+ buf_ptr = addressof(buf)
+ i = 0
+ while tot > 0:
+ cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
+ if cnt:
+ byte_str = tohex(ip).rjust(16)
+ for k in range(cnt):
+ byte_str += " %02x" % ord(buf[i])
+ i += 1
+ while k < 15:
+ byte_str += " "
+ k += 1
+ self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
+ self.child_count += 1
+ else:
+ return
+ buf_ptr += cnt
+ tot -= cnt
+ buf_sz -= cnt
+ ip += cnt
+
+ def childCount(self):
+ if not self.query_done:
+ self.Select()
+ if not self.child_count:
+ return -1
+ return self.child_count
+
+ def hasChildren(self):
+ if not self.query_done:
+ return True
+ return self.child_count > 0
+
+ def getData(self, column):
+ return self.data[column]
+
+# Brance data model root item
+
+class BranchRootItem():
+
+ def __init__(self):
+ self.child_count = 0
+ self.child_items = []
+ self.level = 0
+
+ def getChildItem(self, row):
+ return self.child_items[row]
+
+ def getParentItem(self):
+ return None
+
+ def getRow(self):
+ return 0
+
+ def childCount(self):
+ return self.child_count
+
+ def hasChildren(self):
+ return self.child_count > 0
+
+ def getData(self, _column):
+ return ""
+
+# Calculate instructions per cycle
+
+def CalcIPC(cyc_cnt, insn_cnt):
+ if cyc_cnt and insn_cnt:
+ ipc = Decimal(float(insn_cnt) / cyc_cnt)
+ ipc = str(ipc.quantize(Decimal(".01"), rounding=ROUND_HALF_UP))
+ else:
+ ipc = "0"
+ return ipc
+
+# Branch data preparation
+
+def BranchDataPrepBr(query, data):
+ data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) +
+ " (" + dsoname(query.value(11)) + ")" + " -> " +
+ tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) +
+ " (" + dsoname(query.value(15)) + ")")
+
+def BranchDataPrepIPC(query, data):
+ insn_cnt = query.value(16)
+ cyc_cnt = query.value(17)
+ ipc = CalcIPC(cyc_cnt, insn_cnt)
+ data.append(insn_cnt)
+ data.append(cyc_cnt)
+ data.append(ipc)
+
+def BranchDataPrep(query):
+ data = []
+ for i in range(0, 8):
+ data.append(query.value(i))
+ BranchDataPrepBr(query, data)
+ return data
+
+def BranchDataPrepWA(query):
+ data = []
+ data.append(query.value(0))
+ # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
+ data.append("{:>19}".format(query.value(1)))
+ for i in range(2, 8):
+ data.append(query.value(i))
+ BranchDataPrepBr(query, data)
+ return data
+
+def BranchDataWithIPCPrep(query):
+ data = []
+ for i in range(0, 8):
+ data.append(query.value(i))
+ BranchDataPrepIPC(query, data)
+ BranchDataPrepBr(query, data)
+ return data
+
+def BranchDataWithIPCPrepWA(query):
+ data = []
+ data.append(query.value(0))
+ # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
+ data.append("{:>19}".format(query.value(1)))
+ for i in range(2, 8):
+ data.append(query.value(i))
+ BranchDataPrepIPC(query, data)
+ BranchDataPrepBr(query, data)
+ return data
+
+# Branch data model
+
+class BranchModel(TreeModel):
+
+ progress = Signal(object)
+
+ def __init__(self, glb, event_id, where_clause, parent=None):
+ super(BranchModel, self).__init__(glb, None, parent)
+ self.event_id = event_id
+ self.more = True
+ self.populated = 0
+ self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
+ if self.have_ipc:
+ select_ipc = ", insn_count, cyc_count"
+ prep_fn = BranchDataWithIPCPrep
+ prep_wa_fn = BranchDataWithIPCPrepWA
+ else:
+ select_ipc = ""
+ prep_fn = BranchDataPrep
+ prep_wa_fn = BranchDataPrepWA
+ sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name,"
+ " CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END,"
+ " ip, symbols.name, sym_offset, dsos.short_name,"
+ " to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name"
+ + select_ipc +
+ " FROM samples"
+ " INNER JOIN comms ON comm_id = comms.id"
+ " INNER JOIN threads ON thread_id = threads.id"
+ " INNER JOIN branch_types ON branch_type = branch_types.id"
+ " INNER JOIN symbols ON symbol_id = symbols.id"
+ " INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id"
+ " INNER JOIN dsos ON samples.dso_id = dsos.id"
+ " INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id"
+ " WHERE samples.id > $$last_id$$" + where_clause +
+ " AND evsel_id = " + str(self.event_id) +
+ " ORDER BY samples.id"
+ " LIMIT " + str(glb_chunk_sz))
+ if pyside_version_1 and sys.version_info[0] == 3:
+ prep = prep_fn
+ else:
+ prep = prep_wa_fn
+ self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
+ self.fetcher.done.connect(self.Update)
+ self.fetcher.Fetch(glb_chunk_sz)
+
+ def GetRoot(self):
+ return BranchRootItem()
+
+ def columnCount(self, _parent=None):
+ if self.have_ipc:
+ return 11
+ else:
+ return 8
+
+ def columnHeader(self, column):
+ if self.have_ipc:
+ return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Insn Cnt", "Cyc Cnt", "IPC", "Branch")[column]
+ else:
+ return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column]
+
+ def columnFont(self, column):
+ if self.have_ipc:
+ br_col = 10
+ else:
+ br_col = 7
+ if column != br_col:
+ return None
+ return QFont("Monospace")
+
+ def DisplayData(self, item, index):
+ if item.level == 1:
+ self.FetchIfNeeded(item.row)
+ return item.getData(index.column())
+
+ def AddSample(self, data):
+ child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
+ self.root.child_items.append(child)
+ self.populated += 1
+
+ def Update(self, fetched):
+ if not fetched:
+ self.more = False
+ self.progress.emit(0)
+ child_count = self.root.child_count
+ count = self.populated - child_count
+ if count > 0:
+ parent = QModelIndex()
+ self.beginInsertRows(parent, child_count, child_count + count - 1)
+ self.insertRows(child_count, count, parent)
+ self.root.child_count += count
+ self.endInsertRows()
+ self.progress.emit(self.root.child_count)
+
+ def FetchMoreRecords(self, count):
+ current = self.root.child_count
+ if self.more:
+ self.fetcher.Fetch(count)
+ else:
+ self.progress.emit(0)
+ return current
+
+ def HasMoreRecords(self):
+ return self.more
+
+# Report Variables
+
+class ReportVars():
+
+ def __init__(self, name = "", where_clause = "", limit = ""):
+ self.name = name
+ self.where_clause = where_clause
+ self.limit = limit
+
+ def UniqueId(self):
+ return str(self.where_clause + ";" + self.limit)
+
+# Branch window
+
+class BranchWindow(QMdiSubWindow):
+
+ def __init__(self, glb, event_id, report_vars, parent=None):
+ super(BranchWindow, self).__init__(parent)
+
+ model_name = "Branch Events " + str(event_id) + " " + report_vars.UniqueId()
+
+ self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_clause))
+
+ self.view = QTreeView()
+ self.view.setUniformRowHeights(True)
+ self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
+ self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
+ self.view.setModel(self.model)
+
+ self.ResizeColumnsToContents()
+
+ self.context_menu = TreeContextMenu(self.view)
+
+ self.find_bar = FindBar(self, self, True)
+
+ self.finder = ChildDataItemFinder(self.model.root)
+
+ self.fetch_bar = FetchMoreRecordsBar(self.model, self)
+
+ self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
+
+ self.setWidget(self.vbox.Widget())
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
+
+ def ResizeColumnToContents(self, column, n):
+ # Using the view's resizeColumnToContents() here is extrememly slow
+ # so implement a crude alternative
+ mm = "MM" if column else "MMMM"
+ font = self.view.font()
+ metrics = QFontMetrics(font)
+ max_w = 0
+ for row in range(n):
+ val = self.model.root.child_items[row].data[column]
+ width = metrics.width(str(val) + mm)
+ max_w = width if width > max_w else max_w
+ val = self.model.columnHeader(column)
+ width = metrics.width(str(val) + mm)
+ max_w = width if width > max_w else max_w
+ self.view.setColumnWidth(column, max_w)
+
+ def ResizeColumnsToContents(self):
+ n = min(self.model.root.child_count, 100)
+ if n < 1:
+ # No data yet, so connect a signal to notify when there is
+ self.model.rowsInserted.connect(self.UpdateColumnWidths)
+ return
+ columns = self.model.columnCount()
+ for i in range(columns):
+ self.ResizeColumnToContents(i, n)
+
+ def UpdateColumnWidths(self, *_x):
+ # This only needs to be done once, so disconnect the signal now
+ self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
+ self.ResizeColumnsToContents()
+
+ def Find(self, value, direction, pattern, context):
+ self.view.setFocus()
+ self.find_bar.Busy()
+ self.finder.Find(value, direction, pattern, context, self.FindDone)
+
+ def FindDone(self, row):
+ self.find_bar.Idle()
+ if row >= 0:
+ self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
+ else:
+ self.find_bar.NotFound()
+
+# Line edit data item
+
+class LineEditDataItem(object):
+
+ def __init__(self, glb, label, placeholder_text, parent, item_id = "", default = ""):
+ self.glb = glb
+ self.label = label
+ self.placeholder_text = placeholder_text
+ self.parent = parent
+ self.id = item_id
+
+ self.value = default
+
+ self.widget = QLineEdit(default)
+ self.widget.editingFinished.connect(self.Validate)
+ self.widget.textChanged.connect(self.Invalidate)
+ self.red = False
+ self.error = ""
+ self.validated = True
+
+ if placeholder_text:
+ self.widget.setPlaceholderText(placeholder_text)
+
+ def TurnTextRed(self):
+ if not self.red:
+ palette = QPalette()
+ palette.setColor(QPalette.Text,Qt.red)
+ self.widget.setPalette(palette)
+ self.red = True
+
+ def TurnTextNormal(self):
+ if self.red:
+ palette = QPalette()
+ self.widget.setPalette(palette)
+ self.red = False
+
+ def InvalidValue(self, value):
+ self.value = ""
+ self.TurnTextRed()
+ self.error = self.label + " invalid value '" + value + "'"
+ self.parent.ShowMessage(self.error)
+
+ def Invalidate(self):
+ self.validated = False
+
+ def DoValidate(self, input_string):
+ self.value = input_string.strip()
+
+ def Validate(self):
+ self.validated = True
+ self.error = ""
+ self.TurnTextNormal()
+ self.parent.ClearMessage()
+ input_string = self.widget.text()
+ if not len(input_string.strip()):
+ self.value = ""
+ return
+ self.DoValidate(input_string)
+
+ def IsValid(self):
+ if not self.validated:
+ self.Validate()
+ if len(self.error):
+ self.parent.ShowMessage(self.error)
+ return False
+ return True
+
+ def IsNumber(self, value):
+ try:
+ x = int(value)
+ except ValueError:
+ x = 0
+ return str(x) == value
+
+# Non-negative integer ranges dialog data item
+
+class NonNegativeIntegerRangesDataItem(LineEditDataItem):
+
+ def __init__(self, glb, label, placeholder_text, column_name, parent):
+ super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
+
+ self.column_name = column_name
+
+ def DoValidate(self, input_string):
+ singles = []
+ ranges = []
+ for value in [x.strip() for x in input_string.split(",")]:
+ if "-" in value:
+ vrange = value.split("-")
+ if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
+ return self.InvalidValue(value)
+ ranges.append(vrange)
+ else:
+ if not self.IsNumber(value):
+ return self.InvalidValue(value)
+ singles.append(value)
+ ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
+ if len(singles):
+ ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
+ self.value = " OR ".join(ranges)
+
+# Positive integer dialog data item
+
+class PositiveIntegerDataItem(LineEditDataItem):
+
+ def DoValidate(self, input_string):
+ if not self.IsNumber(input_string.strip()):
+ return self.InvalidValue(input_string)
+ value = int(input_string.strip())
+ if value <= 0:
+ return self.InvalidValue(input_string)
+ self.value = str(value)
+
+# Dialog data item converted and validated using a SQL table
+
+class SQLTableDataItem(LineEditDataItem):
+
+ def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_name2, parent):
+ super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
+
+ self.table_name = table_name
+ self.match_column = match_column
+ self.column_name1 = column_name1
+ self.column_name2 = column_name2
+
+ def ValueToIds(self, value):
+ ids = []
+ query = QSqlQuery(self.glb.db)
+ stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
+ ret = query.exec_(stmt)
+ if ret:
+ while query.next():
+ ids.append(str(query.value(0)))
+ return ids
+
+ def DoValidate(self, input_string):
+ all_ids = []
+ for value in [x.strip() for x in input_string.split(",")]:
+ ids = self.ValueToIds(value)
+ if len(ids):
+ all_ids.extend(ids)
+ else:
+ return self.InvalidValue(value)
+ self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
+ if self.column_name2:
+ self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
+
+# Sample time ranges dialog data item converted and validated using 'samples' SQL table
+
+class SampleTimeRangesDataItem(LineEditDataItem):
+
+ def __init__(self, glb, label, placeholder_text, column_name, parent):
+ self.column_name = column_name
+
+ self.last_id = 0
+ self.first_time = 0
+ self.last_time = 2 ** 64
+
+ query = QSqlQuery(glb.db)
+ QueryExec(query, "SELECT id, time FROM samples ORDER BY id DESC LIMIT 1")
+ if query.next():
+ self.last_id = int(query.value(0))
+ self.first_time = int(glb.HostStartTime())
+ self.last_time = int(glb.HostFinishTime())
+ if placeholder_text:
+ placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
+
+ super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
+
+ def IdBetween(self, query, lower_id, higher_id, order):
+ QueryExec(query, "SELECT id FROM samples WHERE id > " + str(lower_id) + " AND id < " + str(higher_id) + " ORDER BY id " + order + " LIMIT 1")
+ if query.next():
+ return True, int(query.value(0))
+ else:
+ return False, 0
+
+ def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):
+ query = QSqlQuery(self.glb.db)
+ while True:
+ next_id = int((lower_id + higher_id) / 2)
+ QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
+ if not query.next():
+ ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
+ if not ok:
+ ok, dbid = self.IdBetween(query, next_id, higher_id, "")
+ if not ok:
+ return str(higher_id)
+ next_id = dbid
+ QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
+ next_time = int(query.value(0))
+ if get_floor:
+ if target_time > next_time:
+ lower_id = next_id
+ else:
+ higher_id = next_id
+ if higher_id <= lower_id + 1:
+ return str(higher_id)
+ else:
+ if target_time >= next_time:
+ lower_id = next_id
+ else:
+ higher_id = next_id
+ if higher_id <= lower_id + 1:
+ return str(lower_id)
+
+ def ConvertRelativeTime(self, val):
+ mult = 1
+ suffix = val[-2:]
+ if suffix == "ms":
+ mult = 1000000
+ elif suffix == "us":
+ mult = 1000
+ elif suffix == "ns":
+ mult = 1
+ else:
+ return val
+ val = val[:-2].strip()
+ if not self.IsNumber(val):
+ return val
+ val = int(val) * mult
+ if val >= 0:
+ val += self.first_time
+ else:
+ val += self.last_time
+ return str(val)
+
+ def ConvertTimeRange(self, vrange):
+ if vrange[0] == "":
+ vrange[0] = str(self.first_time)
+ if vrange[1] == "":
+ vrange[1] = str(self.last_time)
+ vrange[0] = self.ConvertRelativeTime(vrange[0])
+ vrange[1] = self.ConvertRelativeTime(vrange[1])
+ if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
+ return False
+ beg_range = max(int(vrange[0]), self.first_time)
+ end_range = min(int(vrange[1]), self.last_time)
+ if beg_range > self.last_time or end_range < self.first_time:
+ return False
+ vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
+ vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
+ return True
+
+ def AddTimeRange(self, value, ranges):
+ n = value.count("-")
+ if n == 1:
+ pass
+ elif n == 2:
+ if value.split("-")[1].strip() == "":
+ n = 1
+ elif n == 3:
+ n = 2
+ else:
+ return False
+ pos = findnth(value, "-", n)
+ vrange = [value[:pos].strip() ,value[pos+1:].strip()]
+ if self.ConvertTimeRange(vrange):
+ ranges.append(vrange)
+ return True
+ return False
+
+ def DoValidate(self, input_string):
+ ranges = []
+ for value in [x.strip() for x in input_string.split(",")]:
+ if not self.AddTimeRange(value, ranges):
+ return self.InvalidValue(value)
+ ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
+ self.value = " OR ".join(ranges)
+
+# Report Dialog Base
+
+class ReportDialogBase(QDialog):
+
+ def __init__(self, glb, title, items, partial, parent=None):
+ super(ReportDialogBase, self).__init__(parent)
+
+ self.glb = glb
+
+ self.report_vars = ReportVars()
+
+ self.setWindowTitle(title)
+ self.setMinimumWidth(600)
+
+ self.data_items = [x(glb, self) for x in items]
+
+ self.partial = partial
+
+ self.grid = QGridLayout()
+
+ for row in range(len(self.data_items)):
+ self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
+ self.grid.addWidget(self.data_items[row].widget, row, 1)
+
+ self.status = QLabel()
+
+ self.ok_button = QPushButton("Ok", self)
+ self.ok_button.setDefault(True)
+ self.ok_button.released.connect(self.Ok)
+ self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+ self.cancel_button = QPushButton("Cancel", self)
+ self.cancel_button.released.connect(self.reject)
+ self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+ self.hbox = QHBoxLayout()
+ #self.hbox.addStretch()
+ self.hbox.addWidget(self.status)
+ self.hbox.addWidget(self.ok_button)
+ self.hbox.addWidget(self.cancel_button)
+
+ self.vbox = QVBoxLayout()
+ self.vbox.addLayout(self.grid)
+ self.vbox.addLayout(self.hbox)
+
+ self.setLayout(self.vbox)
+
+ def Ok(self):
+ rep_vars = self.report_vars
+ for d in self.data_items:
+ if d.id == "REPORTNAME":
+ rep_vars.name = d.value
+ if not rep_vars.name:
+ self.ShowMessage("Report name is required")
+ return
+ for d in self.data_items:
+ if not d.IsValid():
+ return
+ for d in self.data_items[1:]:
+ if d.id == "LIMIT":
+ rep_vars.limit = d.value
+ elif len(d.value):
+ if len(rep_vars.where_clause):
+ rep_vars.where_clause += " AND "
+ rep_vars.where_clause += d.value
+ if len(rep_vars.where_clause):
+ if self.partial:
+ rep_vars.where_clause = " AND ( " + rep_vars.where_clause + " ) "
+ else:
+ rep_vars.where_clause = " WHERE " + rep_vars.where_clause + " "
+ self.accept()
+
+ def ShowMessage(self, msg):
+ self.status.setText("<font color=#FF0000>" + msg)
+
+ def ClearMessage(self):
+ self.status.setText("")
+
+# Selected branch report creation dialog
+
+class SelectedBranchDialog(ReportDialogBase):
+
+ def __init__(self, glb, parent=None):
+ title = "Selected Branches"
+ items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
+ lambda g, p: SampleTimeRangesDataItem(g, "Time ranges:", "Enter time ranges", "samples.id", p),
+ lambda g, p: NonNegativeIntegerRangesDataItem(g, "CPUs:", "Enter CPUs or ranges e.g. 0,5-6", "cpu", p),
+ lambda g, p: SQLTableDataItem(g, "Commands:", "Only branches with these commands will be included", "comms", "comm", "comm_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "PIDs:", "Only branches with these process IDs will be included", "threads", "pid", "thread_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "TIDs:", "Only branches with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "DSOs:", "Only branches with these DSOs will be included", "dsos", "short_name", "samples.dso_id", "to_dso_id", p),
+ lambda g, p: SQLTableDataItem(g, "Symbols:", "Only branches with these symbols will be included", "symbols", "name", "symbol_id", "to_symbol_id", p),
+ lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p))
+ super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
+
+# Event list
+
+def GetEventList(db):
+ events = []
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id")
+ while query.next():
+ events.append(query.value(0))
+ return events
+
+# Is a table selectable
+
+def IsSelectable(db, table, sql = "", columns = "*"):
+ query = QSqlQuery(db)
+ try:
+ QueryExec(query, "SELECT " + columns + " FROM " + table + " " + sql + " LIMIT 1")
+ except RuntimeError:
+ return False
+ return True
+
+# SQL table data model item
+
+class SQLTableItem():
+
+ def __init__(self, row, data):
+ self.row = row
+ self.data = data
+
+ def getData(self, column):
+ return self.data[column]
+
+# SQL table data model
+
+class SQLTableModel(TableModel):
+
+ progress = Signal(object)
+
+ def __init__(self, glb, sql, column_headers, parent=None):
+ super(SQLTableModel, self).__init__(parent)
+ self.glb = glb
+ self.more = True
+ self.populated = 0
+ self.column_headers = column_headers
+ self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), self.AddSample)
+ self.fetcher.done.connect(self.Update)
+ self.fetcher.Fetch(glb_chunk_sz)
+
+ def DisplayData(self, item, index):
+ self.FetchIfNeeded(item.row)
+ return item.getData(index.column())
+
+ def AddSample(self, data):
+ child = SQLTableItem(self.populated, data)
+ self.child_items.append(child)
+ self.populated += 1
+
+ def Update(self, fetched):
+ if not fetched:
+ self.more = False
+ self.progress.emit(0)
+ child_count = self.child_count
+ count = self.populated - child_count
+ if count > 0:
+ parent = QModelIndex()
+ self.beginInsertRows(parent, child_count, child_count + count - 1)
+ self.insertRows(child_count, count, parent)
+ self.child_count += count
+ self.endInsertRows()
+ self.progress.emit(self.child_count)
+
+ def FetchMoreRecords(self, count):
+ current = self.child_count
+ if self.more:
+ self.fetcher.Fetch(count)
+ else:
+ self.progress.emit(0)
+ return current
+
+ def HasMoreRecords(self):
+ return self.more
+
+ def columnCount(self, _parent=None):
+ return len(self.column_headers)
+
+ def columnHeader(self, column):
+ return self.column_headers[column]
+
+ def SQLTableDataPrep(self, query, count):
+ data = []
+ for i in range(count):
+ data.append(query.value(i))
+ return data
+
+# SQL automatic table data model
+
+class SQLAutoTableModel(SQLTableModel):
+
+ def __init__(self, glb, table_name, parent=None):
+ sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz)
+ if table_name == "comm_threads_view":
+ # For now, comm_threads_view has no id column
+ sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz)
+ column_headers = []
+ query = QSqlQuery(glb.db)
+ if glb.dbref.is_sqlite3:
+ QueryExec(query, "PRAGMA table_info(" + table_name + ")")
+ while query.next():
+ column_headers.append(query.value(1))
+ if table_name == "sqlite_master":
+ sql = "SELECT * FROM " + table_name
+ else:
+ if table_name[:19] == "information_schema.":
+ sql = "SELECT * FROM " + table_name
+ select_table_name = table_name[19:]
+ schema = "information_schema"
+ else:
+ select_table_name = table_name
+ schema = "public"
+ QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'")
+ while query.next():
+ column_headers.append(query.value(0))
+ if pyside_version_1 and sys.version_info[0] == 3:
+ if table_name == "samples_view":
+ self.SQLTableDataPrep = self.samples_view_DataPrep
+ if table_name == "samples":
+ self.SQLTableDataPrep = self.samples_DataPrep
+ super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
+
+ def samples_view_DataPrep(self, query, count):
+ data = []
+ data.append(query.value(0))
+ # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
+ data.append("{:>19}".format(query.value(1)))
+ for i in range(2, count):
+ data.append(query.value(i))
+ return data
+
+ def samples_DataPrep(self, query, count):
+ data = []
+ for i in range(9):
+ data.append(query.value(i))
+ # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
+ data.append("{:>19}".format(query.value(9)))
+ for i in range(10, count):
+ data.append(query.value(i))
+ return data
+
+# Base class for custom ResizeColumnsToContents
+
+class ResizeColumnsToContentsBase(QObject):
+
+ def __init__(self, parent=None):
+ super(ResizeColumnsToContentsBase, self).__init__(parent)
+
+ def ResizeColumnToContents(self, column, n):
+ # Using the view's resizeColumnToContents() here is extrememly slow
+ # so implement a crude alternative
+ font = self.view.font()
+ metrics = QFontMetrics(font)
+ max_w = 0
+ for row in range(n):
+ val = self.data_model.child_items[row].data[column]
+ width = metrics.width(str(val) + "MM")
+ max_w = width if width > max_w else max_w
+ val = self.data_model.columnHeader(column)
+ width = metrics.width(str(val) + "MM")
+ max_w = width if width > max_w else max_w
+ self.view.setColumnWidth(column, max_w)
+
+ def ResizeColumnsToContents(self):
+ n = min(self.data_model.child_count, 100)
+ if n < 1:
+ # No data yet, so connect a signal to notify when there is
+ self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
+ return
+ columns = self.data_model.columnCount()
+ for i in range(columns):
+ self.ResizeColumnToContents(i, n)
+
+ def UpdateColumnWidths(self, *_x):
+ # This only needs to be done once, so disconnect the signal now
+ self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
+ self.ResizeColumnsToContents()
+
+# Convert value to CSV
+
+def ToCSValue(val):
+ if '"' in val:
+ val = val.replace('"', '""')
+ if "," in val or '"' in val:
+ val = '"' + val + '"'
+ return val
+
+# Key to sort table model indexes by row / column, assuming fewer than 1000 columns
+
+glb_max_cols = 1000
+
+def RowColumnKey(a):
+ return a.row() * glb_max_cols + a.column()
+
+# Copy selected table cells to clipboard
+
+def CopyTableCellsToClipboard(view, as_csv=False, with_hdr=False):
+ indexes = sorted(view.selectedIndexes(), key=RowColumnKey)
+ idx_cnt = len(indexes)
+ if not idx_cnt:
+ return
+ if idx_cnt == 1:
+ with_hdr=False
+ min_row = indexes[0].row()
+ max_row = indexes[0].row()
+ min_col = indexes[0].column()
+ max_col = indexes[0].column()
+ for i in indexes:
+ min_row = min(min_row, i.row())
+ max_row = max(max_row, i.row())
+ min_col = min(min_col, i.column())
+ max_col = max(max_col, i.column())
+ if max_col > glb_max_cols:
+ raise RuntimeError("glb_max_cols is too low")
+ max_width = [0] * (1 + max_col - min_col)
+ for i in indexes:
+ c = i.column() - min_col
+ max_width[c] = max(max_width[c], len(str(i.data())))
+ text = ""
+ pad = ""
+ sep = ""
+ if with_hdr:
+ model = indexes[0].model()
+ for col in range(min_col, max_col + 1):
+ val = model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
+ if as_csv:
+ text += sep + ToCSValue(val)
+ sep = ","
+ else:
+ c = col - min_col
+ max_width[c] = max(max_width[c], len(val))
+ width = max_width[c]
+ align = model.headerData(col, Qt.Horizontal, Qt.TextAlignmentRole)
+ if align & Qt.AlignRight:
+ val = val.rjust(width)
+ text += pad + sep + val
+ pad = " " * (width - len(val))
+ sep = " "
+ text += "\n"
+ pad = ""
+ sep = ""
+ last_row = min_row
+ for i in indexes:
+ if i.row() > last_row:
+ last_row = i.row()
+ text += "\n"
+ pad = ""
+ sep = ""
+ if as_csv:
+ text += sep + ToCSValue(str(i.data()))
+ sep = ","
+ else:
+ width = max_width[i.column() - min_col]
+ if i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
+ val = str(i.data()).rjust(width)
+ else:
+ val = str(i.data())
+ text += pad + sep + val
+ pad = " " * (width - len(val))
+ sep = " "
+ QApplication.clipboard().setText(text)
+
+def CopyTreeCellsToClipboard(view, as_csv=False, with_hdr=False):
+ indexes = view.selectedIndexes()
+ if not len(indexes):
+ return
+
+ selection = view.selectionModel()
+
+ first = None
+ for i in indexes:
+ above = view.indexAbove(i)
+ if not selection.isSelected(above):
+ first = i
+ break
+
+ if first is None:
+ raise RuntimeError("CopyTreeCellsToClipboard internal error")
+
+ model = first.model()
+ row_cnt = 0
+ col_cnt = model.columnCount(first)
+ max_width = [0] * col_cnt
+
+ indent_sz = 2
+ indent_str = " " * indent_sz
+
+ expanded_mark_sz = 2
+ if sys.version_info[0] == 3:
+ expanded_mark = "\u25BC "
+ not_expanded_mark = "\u25B6 "
+ else:
+ expanded_mark = chr(0x25BC) + " "
+ not_expanded_mark = chr(0x25B6) + " "
+ leaf_mark = " "
+
+ if not as_csv:
+ pos = first
+ while True:
+ row_cnt += 1
+ row = pos.row()
+ for c in range(col_cnt):
+ i = pos.sibling(row, c)
+ if c:
+ n = len(str(i.data()))
+ else:
+ n = len(str(i.data()).strip())
+ n += (i.internalPointer().level - 1) * indent_sz
+ n += expanded_mark_sz
+ max_width[c] = max(max_width[c], n)
+ pos = view.indexBelow(pos)
+ if not selection.isSelected(pos):
+ break
+
+ text = ""
+ pad = ""
+ sep = ""
+ if with_hdr:
+ for c in range(col_cnt):
+ val = model.headerData(c, Qt.Horizontal, Qt.DisplayRole).strip()
+ if as_csv:
+ text += sep + ToCSValue(val)
+ sep = ","
+ else:
+ max_width[c] = max(max_width[c], len(val))
+ width = max_width[c]
+ align = model.headerData(c, Qt.Horizontal, Qt.TextAlignmentRole)
+ if align & Qt.AlignRight:
+ val = val.rjust(width)
+ text += pad + sep + val
+ pad = " " * (width - len(val))
+ sep = " "
+ text += "\n"
+ pad = ""
+ sep = ""
+
+ pos = first
+ while True:
+ row = pos.row()
+ for c in range(col_cnt):
+ i = pos.sibling(row, c)
+ val = str(i.data())
+ if not c:
+ if model.hasChildren(i):
+ if view.isExpanded(i):
+ mark = expanded_mark
+ else:
+ mark = not_expanded_mark
+ else:
+ mark = leaf_mark
+ val = indent_str * (i.internalPointer().level - 1) + mark + val.strip()
+ if as_csv:
+ text += sep + ToCSValue(val)
+ sep = ","
+ else:
+ width = max_width[c]
+ if c and i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
+ val = val.rjust(width)
+ text += pad + sep + val
+ pad = " " * (width - len(val))
+ sep = " "
+ pos = view.indexBelow(pos)
+ if not selection.isSelected(pos):
+ break
+ text = text.rstrip() + "\n"
+ pad = ""
+ sep = ""
+
+ QApplication.clipboard().setText(text)
+
+def CopyCellsToClipboard(view, as_csv=False, with_hdr=False):
+ view.CopyCellsToClipboard(view, as_csv, with_hdr)
+
+def CopyCellsToClipboardHdr(view):
+ CopyCellsToClipboard(view, False, True)
+
+def CopyCellsToClipboardCSV(view):
+ CopyCellsToClipboard(view, True, True)
+
+# Context menu
+
+class ContextMenu(object):
+
+ def __init__(self, view):
+ self.view = view
+ self.view.setContextMenuPolicy(Qt.CustomContextMenu)
+ self.view.customContextMenuRequested.connect(self.ShowContextMenu)
+
+ def ShowContextMenu(self, pos):
+ menu = QMenu(self.view)
+ self.AddActions(menu)
+ menu.exec_(self.view.mapToGlobal(pos))
+
+ def AddCopy(self, menu):
+ menu.addAction(CreateAction("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
+ menu.addAction(CreateAction("Copy selection as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
+
+ def AddActions(self, menu):
+ self.AddCopy(menu)
+
+class TreeContextMenu(ContextMenu):
+
+ def AddActions(self, menu):
+ i = self.view.currentIndex()
+ text = str(i.data()).strip()
+ if len(text):
+ menu.addAction(CreateAction('Copy "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
+ self.AddCopy(menu)
+
+# Table window
+
+class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
+
+ def __init__(self, glb, table_name, parent=None):
+ super(TableWindow, self).__init__(parent)
+
+ self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name))
+
+ self.model = QSortFilterProxyModel()
+ self.model.setSourceModel(self.data_model)
+
+ self.view = QTableView()
+ self.view.setModel(self.model)
+ self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
+ self.view.verticalHeader().setVisible(False)
+ self.view.sortByColumn(-1, Qt.AscendingOrder)
+ self.view.setSortingEnabled(True)
+ self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
+ self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
+
+ self.ResizeColumnsToContents()
+
+ self.context_menu = ContextMenu(self.view)
+
+ self.find_bar = FindBar(self, self, True)
+
+ self.finder = ChildDataItemFinder(self.data_model)
+
+ self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
+
+ self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
+
+ self.setWidget(self.vbox.Widget())
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
+
+ def Find(self, value, direction, pattern, context):
+ self.view.setFocus()
+ self.find_bar.Busy()
+ self.finder.Find(value, direction, pattern, context, self.FindDone)
+
+ def FindDone(self, row):
+ self.find_bar.Idle()
+ if row >= 0:
+ self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
+ else:
+ self.find_bar.NotFound()
+
+# Table list
+
+def GetTableList(glb):
+ tables = []
+ query = QSqlQuery(glb.db)
+ if glb.dbref.is_sqlite3:
+ QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name")
+ else:
+ QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name")
+ while query.next():
+ tables.append(query.value(0))
+ if glb.dbref.is_sqlite3:
+ tables.append("sqlite_master")
+ else:
+ tables.append("information_schema.tables")
+ tables.append("information_schema.views")
+ tables.append("information_schema.columns")
+ return tables
+
+# Top Calls data model
+
+class TopCallsModel(SQLTableModel):
+
+ def __init__(self, glb, report_vars, parent=None):
+ text = ""
+ if not glb.dbref.is_sqlite3:
+ text = "::text"
+ limit = ""
+ if len(report_vars.limit):
+ limit = " LIMIT " + report_vars.limit
+ sql = ("SELECT comm, pid, tid, name,"
+ " CASE"
+ " WHEN (short_name = '[kernel.kallsyms]') THEN '[kernel]'" + text +
+ " ELSE short_name"
+ " END AS dso,"
+ " call_time, return_time, (return_time - call_time) AS elapsed_time, branch_count, "
+ " CASE"
+ " WHEN (calls.flags = 1) THEN 'no call'" + text +
+ " WHEN (calls.flags = 2) THEN 'no return'" + text +
+ " WHEN (calls.flags = 3) THEN 'no call/return'" + text +
+ " ELSE ''" + text +
+ " END AS flags"
+ " FROM calls"
+ " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+ " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+ " INNER JOIN dsos ON symbols.dso_id = dsos.id"
+ " INNER JOIN comms ON calls.comm_id = comms.id"
+ " INNER JOIN threads ON calls.thread_id = threads.id" +
+ report_vars.where_clause +
+ " ORDER BY elapsed_time DESC" +
+ limit
+ )
+ column_headers = ("Command", "PID", "TID", "Symbol", "Object", "Call Time", "Return Time", "Elapsed Time (ns)", "Branch Count", "Flags")
+ self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignLeft)
+ super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
+
+ def columnAlignment(self, column):
+ return self.alignment[column]
+
+# Top Calls report creation dialog
+
+class TopCallsDialog(ReportDialogBase):
+
+ def __init__(self, glb, parent=None):
+ title = "Top Calls by Elapsed Time"
+ items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
+ lambda g, p: SQLTableDataItem(g, "Commands:", "Only calls with these commands will be included", "comms", "comm", "comm_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "PIDs:", "Only calls with these process IDs will be included", "threads", "pid", "thread_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "TIDs:", "Only calls with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "DSOs:", "Only calls with these DSOs will be included", "dsos", "short_name", "dso_id", "", p),
+ lambda g, p: SQLTableDataItem(g, "Symbols:", "Only calls with these symbols will be included", "symbols", "name", "symbol_id", "", p),
+ lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p),
+ lambda g, p: PositiveIntegerDataItem(g, "Record limit:", "Limit selection to this number of records", p, "LIMIT", "100"))
+ super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
+
+# Top Calls window
+
+class TopCallsWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
+
+ def __init__(self, glb, report_vars, parent=None):
+ super(TopCallsWindow, self).__init__(parent)
+
+ self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(glb, report_vars))
+ self.model = self.data_model
+
+ self.view = QTableView()
+ self.view.setModel(self.model)
+ self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
+ self.view.verticalHeader().setVisible(False)
+ self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
+ self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
+
+ self.context_menu = ContextMenu(self.view)
+
+ self.ResizeColumnsToContents()
+
+ self.find_bar = FindBar(self, self, True)
+
+ self.finder = ChildDataItemFinder(self.model)
+
+ self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
+
+ self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
+
+ self.setWidget(self.vbox.Widget())
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
+
+ def Find(self, value, direction, pattern, context):
+ self.view.setFocus()
+ self.find_bar.Busy()
+ self.finder.Find(value, direction, pattern, context, self.FindDone)
+
+ def FindDone(self, row):
+ self.find_bar.Idle()
+ if row >= 0:
+ self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
+ else:
+ self.find_bar.NotFound()
+
+# Action Definition
+
+def CreateAction(label, tip, callback, parent=None, shortcut=None):
+ action = QAction(label, parent)
+ if shortcut != None:
+ action.setShortcuts(shortcut)
+ action.setStatusTip(tip)
+ action.triggered.connect(callback)
+ return action
+
+# Typical application actions
+
+def CreateExitAction(app, parent=None):
+ return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit)
+
+# Typical MDI actions
+
+def CreateCloseActiveWindowAction(mdi_area):
+ return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area)
+
+def CreateCloseAllWindowsAction(mdi_area):
+ return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area)
+
+def CreateTileWindowsAction(mdi_area):
+ return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area)
+
+def CreateCascadeWindowsAction(mdi_area):
+ return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area)
+
+def CreateNextWindowAction(mdi_area):
+ return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild)
+
+def CreatePreviousWindowAction(mdi_area):
+ return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild)
+
+# Typical MDI window menu
+
+class WindowMenu():
+
+ def __init__(self, mdi_area, menu):
+ self.mdi_area = mdi_area
+ self.window_menu = menu.addMenu("&Windows")
+ self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
+ self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
+ self.tile_windows = CreateTileWindowsAction(mdi_area)
+ self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
+ self.next_window = CreateNextWindowAction(mdi_area)
+ self.previous_window = CreatePreviousWindowAction(mdi_area)
+ self.window_menu.aboutToShow.connect(self.Update)
+
+ def Update(self):
+ self.window_menu.clear()
+ sub_window_count = len(self.mdi_area.subWindowList())
+ have_sub_windows = sub_window_count != 0
+ self.close_active_window.setEnabled(have_sub_windows)
+ self.close_all_windows.setEnabled(have_sub_windows)
+ self.tile_windows.setEnabled(have_sub_windows)
+ self.cascade_windows.setEnabled(have_sub_windows)
+ self.next_window.setEnabled(have_sub_windows)
+ self.previous_window.setEnabled(have_sub_windows)
+ self.window_menu.addAction(self.close_active_window)
+ self.window_menu.addAction(self.close_all_windows)
+ self.window_menu.addSeparator()
+ self.window_menu.addAction(self.tile_windows)
+ self.window_menu.addAction(self.cascade_windows)
+ self.window_menu.addSeparator()
+ self.window_menu.addAction(self.next_window)
+ self.window_menu.addAction(self.previous_window)
+ if sub_window_count == 0:
+ return
+ self.window_menu.addSeparator()
+ nr = 1
+ for sub_window in self.mdi_area.subWindowList():
+ label = str(nr) + " " + sub_window.name
+ if nr < 10:
+ label = "&" + label
+ action = self.window_menu.addAction(label)
+ action.setCheckable(True)
+ action.setChecked(sub_window == self.mdi_area.activeSubWindow())
+ action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
+ self.window_menu.addAction(action)
+ nr += 1
+
+ def setActiveSubWindow(self, nr):
+ self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
+
+# Help text
+
+glb_help_text = """
+<h1>Contents</h1>
+<style>
+p.c1 {
+ text-indent: 40px;
+}
+p.c2 {
+ text-indent: 80px;
+}
+}
+</style>
+<p class=c1><a href=#reports>1. Reports</a></p>
+<p class=c2><a href=#callgraph>1.1 Context-Sensitive Call Graph</a></p>
+<p class=c2><a href=#calltree>1.2 Call Tree</a></p>
+<p class=c2><a href=#allbranches>1.3 All branches</a></p>
+<p class=c2><a href=#selectedbranches>1.4 Selected branches</a></p>
+<p class=c2><a href=#topcallsbyelapsedtime>1.5 Top calls by elapsed time</a></p>
+<p class=c1><a href=#charts>2. Charts</a></p>
+<p class=c2><a href=#timechartbycpu>2.1 Time chart by CPU</a></p>
+<p class=c1><a href=#tables>3. Tables</a></p>
+<h1 id=reports>1. Reports</h1>
+<h2 id=callgraph>1.1 Context-Sensitive Call Graph</h2>
+The result is a GUI window with a tree representing a context-sensitive
+call-graph. Expanding a couple of levels of the tree and adjusting column
+widths to suit will display something like:
+<pre>
+ Call Graph: pt_example
+Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
+v- ls
+ v- 2638:2638
+ v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
+ |- unknown unknown 1 13198 0.1 1 0.0
+ >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
+ >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
+ v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
+ >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
+ >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
+ >- __libc_csu_init ls 1 10354 0.1 10 0.0
+ |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
+ v- main ls 1 8182043 99.6 180254 99.9
+</pre>
+<h3>Points to note:</h3>
+<ul>
+<li>The top level is a command name (comm)</li>
+<li>The next level is a thread (pid:tid)</li>
+<li>Subsequent levels are functions</li>
+<li>'Count' is the number of calls</li>
+<li>'Time' is the elapsed time until the function returns</li>
+<li>Percentages are relative to the level above</li>
+<li>'Branch Count' is the total number of branches for that function and all functions that it calls
+</ul>
+<h3>Find</h3>
+Ctrl-F displays a Find bar which finds function names by either an exact match or a pattern match.
+The pattern matching symbols are ? for any character and * for zero or more characters.
+<h2 id=calltree>1.2 Call Tree</h2>
+The Call Tree report is very similar to the Context-Sensitive Call Graph, but the data is not aggregated.
+Also the 'Count' column, which would be always 1, is replaced by the 'Call Time'.
+<h2 id=allbranches>1.3 All branches</h2>
+The All branches report displays all branches in chronological order.
+Not all data is fetched immediately. More records can be fetched using the Fetch bar provided.
+<h3>Disassembly</h3>
+Open a branch to display disassembly. This only works if:
+<ol>
+<li>The disassembler is available. Currently, only Intel XED is supported - see <a href=#xed>Intel XED Setup</a></li>
+<li>The object code is available. Currently, only the perf build ID cache is searched for object code.
+The default directory ~/.debug can be overridden by setting environment variable PERF_BUILDID_DIR.
+One exception is kcore where the DSO long name is used (refer dsos_view on the Tables menu),
+or alternatively, set environment variable PERF_KCORE to the kcore file name.</li>
+</ol>
+<h4 id=xed>Intel XED Setup</h4>
+To use Intel XED, libxed.so must be present. To build and install libxed.so:
+<pre>
+git clone https://github.com/intelxed/mbuild.git mbuild
+git clone https://github.com/intelxed/xed
+cd xed
+./mfile.py --share
+sudo ./mfile.py --prefix=/usr/local install
+sudo ldconfig
+</pre>
+<h3>Instructions per Cycle (IPC)</h3>
+If available, IPC information is displayed in columns 'insn_cnt', 'cyc_cnt' and 'IPC'.
+<p><b>Intel PT note:</b> The information applies to the blocks of code ending with, and including, that branch.
+Due to the granularity of timing information, the number of cycles for some code blocks will not be known.
+In that case, 'insn_cnt', 'cyc_cnt' and 'IPC' are zero, but when 'IPC' is displayed it covers the period
+since the previous displayed 'IPC'.
+<h3>Find</h3>
+Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
+Refer to Python documentation for the regular expression syntax.
+All columns are searched, but only currently fetched rows are searched.
+<h2 id=selectedbranches>1.4 Selected branches</h2>
+This is the same as the <a href=#allbranches>All branches</a> report but with the data reduced
+by various selection criteria. A dialog box displays available criteria which are AND'ed together.
+<h3>1.4.1 Time ranges</h3>
+The time ranges hint text shows the total time range. Relative time ranges can also be entered in
+ms, us or ns. Also, negative values are relative to the end of trace. Examples:
+<pre>
+ 81073085947329-81073085958238 From 81073085947329 to 81073085958238
+ 100us-200us From 100us to 200us
+ 10ms- From 10ms to the end
+ -100ns The first 100ns
+ -10ms- The last 10ms
+</pre>
+N.B. Due to the granularity of timestamps, there could be no branches in any given time range.
+<h2 id=topcallsbyelapsedtime>1.5 Top calls by elapsed time</h2>
+The Top calls by elapsed time report displays calls in descending order of time elapsed between when the function was called and when it returned.
+The data is reduced by various selection criteria. A dialog box displays available criteria which are AND'ed together.
+If not all data is fetched, a Fetch bar is provided. Ctrl-F displays a Find bar.
+<h1 id=charts>2. Charts</h1>
+<h2 id=timechartbycpu>2.1 Time chart by CPU</h2>
+This chart displays context switch information when that data is available. Refer to context_switches_view on the Tables menu.
+<h3>Features</h3>
+<ol>
+<li>Mouse over to highight the task and show the time</li>
+<li>Drag the mouse to select a region and zoom by pushing the Zoom button</li>
+<li>Go back and forward by pressing the arrow buttons</li>
+<li>If call information is available, right-click to show a call tree opened to that task and time.
+Note, the call tree may take some time to appear, and there may not be call information for the task or time selected.
+</li>
+</ol>
+<h3>Important</h3>
+The graph can be misleading in the following respects:
+<ol>
+<li>The graph shows the first task on each CPU as running from the beginning of the time range.
+Because tracing might start on different CPUs at different times, that is not necessarily the case.
+Refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
+<li>Similarly, the last task on each CPU can be showing running longer than it really was.
+Again, refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
+<li>When the mouse is over a task, the highlighted task might not be visible on the legend without scrolling if the legend does not fit fully in the window</li>
+</ol>
+<h1 id=tables>3. Tables</h1>
+The Tables menu shows all tables and views in the database. Most tables have an associated view
+which displays the information in a more friendly way. Not all data for large tables is fetched
+immediately. More records can be fetched using the Fetch bar provided. Columns can be sorted,
+but that can be slow for large tables.
+<p>There are also tables of database meta-information.
+For SQLite3 databases, the sqlite_master table is included.
+For PostgreSQL databases, information_schema.tables/views/columns are included.
+<h3>Find</h3>
+Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
+Refer to Python documentation for the regular expression syntax.
+All columns are searched, but only currently fetched rows are searched.
+<p>N.B. Results are found in id order, so if the table is re-ordered, find-next and find-previous
+will go to the next/previous result in id order, instead of display order.
+"""
+
+# Help window
+
+class HelpWindow(QMdiSubWindow):
+
+ def __init__(self, glb, parent=None):
+ super(HelpWindow, self).__init__(parent)
+
+ self.text = QTextBrowser()
+ self.text.setHtml(glb_help_text)
+ self.text.setReadOnly(True)
+ self.text.setOpenExternalLinks(True)
+
+ self.setWidget(self.text)
+
+ AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
+
+# Main window that only displays the help text
+
+class HelpOnlyWindow(QMainWindow):
+
+ def __init__(self, parent=None):
+ super(HelpOnlyWindow, self).__init__(parent)
+
+ self.setMinimumSize(200, 100)
+ self.resize(800, 600)
+ self.setWindowTitle("Exported SQL Viewer Help")
+ self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
+
+ self.text = QTextBrowser()
+ self.text.setHtml(glb_help_text)
+ self.text.setReadOnly(True)
+ self.text.setOpenExternalLinks(True)
+
+ self.setCentralWidget(self.text)
+
+# PostqreSQL server version
+
+def PostqreSQLServerVersion(db):
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT VERSION()")
+ if query.next():
+ v_str = query.value(0)
+ v_list = v_str.strip().split(" ")
+ if v_list[0] == "PostgreSQL" and v_list[2] == "on":
+ return v_list[1]
+ return v_str
+ return "Unknown"
+
+# SQLite version
+
+def SQLiteVersion(db):
+ query = QSqlQuery(db)
+ QueryExec(query, "SELECT sqlite_version()")
+ if query.next():
+ return query.value(0)
+ return "Unknown"
+
+# About dialog
+
+class AboutDialog(QDialog):
+
+ def __init__(self, glb, parent=None):
+ super(AboutDialog, self).__init__(parent)
+
+ self.setWindowTitle("About Exported SQL Viewer")
+ self.setMinimumWidth(300)
+
+ pyside_version = "1" if pyside_version_1 else "2"
+
+ text = "<pre>"
+ text += "Python version: " + sys.version.split(" ")[0] + "\n"
+ text += "PySide version: " + pyside_version + "\n"
+ text += "Qt version: " + qVersion() + "\n"
+ if glb.dbref.is_sqlite3:
+ text += "SQLite version: " + SQLiteVersion(glb.db) + "\n"
+ else:
+ text += "PostqreSQL version: " + PostqreSQLServerVersion(glb.db) + "\n"
+ text += "</pre>"
+
+ self.text = QTextBrowser()
+ self.text.setHtml(text)
+ self.text.setReadOnly(True)
+ self.text.setOpenExternalLinks(True)
+
+ self.vbox = QVBoxLayout()
+ self.vbox.addWidget(self.text)
+
+ self.setLayout(self.vbox)
+
+# Font resize
+
+def ResizeFont(widget, diff):
+ font = widget.font()
+ sz = font.pointSize()
+ font.setPointSize(sz + diff)
+ widget.setFont(font)
+
+def ShrinkFont(widget):
+ ResizeFont(widget, -1)
+
+def EnlargeFont(widget):
+ ResizeFont(widget, 1)
+
+# Unique name for sub-windows
+
+def NumberedWindowName(name, nr):
+ if nr > 1:
+ name += " <" + str(nr) + ">"
+ return name
+
+def UniqueSubWindowName(mdi_area, name):
+ nr = 1
+ while True:
+ unique_name = NumberedWindowName(name, nr)
+ ok = True
+ for sub_window in mdi_area.subWindowList():
+ if sub_window.name == unique_name:
+ ok = False
+ break
+ if ok:
+ return unique_name
+ nr += 1
+
+# Add a sub-window
+
+def AddSubWindow(mdi_area, sub_window, name):
+ unique_name = UniqueSubWindowName(mdi_area, name)
+ sub_window.setMinimumSize(200, 100)
+ sub_window.resize(800, 600)
+ sub_window.setWindowTitle(unique_name)
+ sub_window.setAttribute(Qt.WA_DeleteOnClose)
+ sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon))
+ sub_window.name = unique_name
+ mdi_area.addSubWindow(sub_window)
+ sub_window.show()
+
+# Main window
+
+class MainWindow(QMainWindow):
+
+ def __init__(self, glb, parent=None):
+ super(MainWindow, self).__init__(parent)
+
+ self.glb = glb
+
+ self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
+ self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
+ self.setMinimumSize(200, 100)
+
+ self.mdi_area = QMdiArea()
+ self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+ self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+
+ self.setCentralWidget(self.mdi_area)
+
+ menu = self.menuBar()
+
+ file_menu = menu.addMenu("&File")
+ file_menu.addAction(CreateExitAction(glb.app, self))
+
+ edit_menu = menu.addMenu("&Edit")
+ edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySequence.Copy))
+ edit_menu.addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
+ edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
+ edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)]))
+ edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")]))
+ edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")]))
+
+ reports_menu = menu.addMenu("&Reports")
+ if IsSelectable(glb.db, "calls"):
+ reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
+
+ if IsSelectable(glb.db, "calls", "WHERE parent_id >= 0"):
+ reports_menu.addAction(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
+
+ self.EventMenu(GetEventList(glb.db), reports_menu)
+
+ if IsSelectable(glb.db, "calls"):
+ reports_menu.addAction(CreateAction("&Top calls by elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
+
+ if IsSelectable(glb.db, "context_switches"):
+ charts_menu = menu.addMenu("&Charts")
+ charts_menu.addAction(CreateAction("&Time chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))
+
+ self.TableMenu(GetTableList(glb), menu)
+
+ self.window_menu = WindowMenu(self.mdi_area, menu)
+
+ help_menu = menu.addMenu("&Help")
+ help_menu.addAction(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence.HelpContents))
+ help_menu.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
+
+ def Try(self, fn):
+ win = self.mdi_area.activeSubWindow()
+ if win:
+ try:
+ fn(win.view)
+ except AttributeError:
+ pass
+
+ def CopyToClipboard(self):
+ self.Try(CopyCellsToClipboardHdr)
+
+ def CopyToClipboardCSV(self):
+ self.Try(CopyCellsToClipboardCSV)
+
+ def Find(self):
+ win = self.mdi_area.activeSubWindow()
+ if win:
+ try:
+ win.find_bar.Activate()
+ except AttributeError:
+ pass
+
+ def FetchMoreRecords(self):
+ win = self.mdi_area.activeSubWindow()
+ if win:
+ try:
+ win.fetch_bar.Activate()
+ except AttributeError:
+ pass
+
+ def ShrinkFont(self):
+ self.Try(ShrinkFont)
+
+ def EnlargeFont(self):
+ self.Try(EnlargeFont)
+
+ def EventMenu(self, events, reports_menu):
+ branches_events = 0
+ for event in events:
+ event = event.split(":")[0]
+ if event == "branches":
+ branches_events += 1
+ dbid = 0
+ for event in events:
+ dbid += 1
+ event = event.split(":")[0]
+ if event == "branches":
+ label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")"
+ reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
+ label = "Selected branches" if branches_events == 1 else "Selected branches " + "(id=" + dbid + ")"
+ reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
+
+ def TimeChartByCPU(self):
+ TimeChartByCPUWindow(self.glb, self)
+
+ def TableMenu(self, tables, menu):
+ table_menu = menu.addMenu("&Tables")
+ for table in tables:
+ table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
+
+ def NewCallGraph(self):
+ CallGraphWindow(self.glb, self)
+
+ def NewCallTree(self):
+ CallTreeWindow(self.glb, self)
+
+ def NewTopCalls(self):
+ dialog = TopCallsDialog(self.glb, self)
+ ret = dialog.exec_()
+ if ret:
+ TopCallsWindow(self.glb, dialog.report_vars, self)
+
+ def NewBranchView(self, event_id):
+ BranchWindow(self.glb, event_id, ReportVars(), self)
+
+ def NewSelectedBranchView(self, event_id):
+ dialog = SelectedBranchDialog(self.glb, self)
+ ret = dialog.exec_()
+ if ret:
+ BranchWindow(self.glb, event_id, dialog.report_vars, self)
+
+ def NewTableView(self, table_name):
+ TableWindow(self.glb, table_name, self)
+
+ def Help(self):
+ HelpWindow(self.glb, self)
+
+ def About(self):
+ dialog = AboutDialog(self.glb, self)
+ dialog.exec_()
+
+def TryOpen(file_name):
+ try:
+ return open(file_name, "rb")
+ except OSError:
+ return None
+
+def Is64Bit(f):
+ result = sizeof(c_void_p)
+ # ELF support only
+ pos = f.tell()
+ f.seek(0)
+ header = f.read(7)
+ f.seek(pos)
+ magic = header[0:4]
+ if sys.version_info[0] == 2:
+ eclass = ord(header[4])
+ encoding = ord(header[5])
+ version = ord(header[6])
+ else:
+ eclass = header[4]
+ encoding = header[5]
+ version = header[6]
+ if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1:
+ result = True if eclass == 2 else False
+ return result
+
+# Global data
+
+class Glb():
+
+ def __init__(self, dbref, db, dbname):
+ self.dbref = dbref
+ self.db = db
+ self.dbname = dbname
+ self.home_dir = os.path.expanduser("~")
+ self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
+ if self.buildid_dir:
+ self.buildid_dir += "/.build-id/"
+ else:
+ self.buildid_dir = self.home_dir + "/.debug/.build-id/"
+ self.app = None
+ self.mainwindow = None
+ self.instances_to_shutdown_on_exit = weakref.WeakSet()
+ try:
+ self.disassembler = LibXED()
+ self.have_disassembler = True
+ except (OSError, RuntimeError, AttributeError):
+ self.have_disassembler = False
+ self.host_machine_id = 0
+ self.host_start_time = 0
+ self.host_finish_time = 0
+
+ def FileFromBuildId(self, build_id):
+ file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
+ return TryOpen(file_name)
+
+ def FileFromNamesAndBuildId(self, short_name, long_name, build_id):
+ # Assume current machine i.e. no support for virtualization
+ if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore":
+ file_name = os.getenv("PERF_KCORE")
+ f = TryOpen(file_name) if file_name else None
+ if f:
+ return f
+ # For now, no special handling if long_name is /proc/kcore
+ f = TryOpen(long_name)
+ if f:
+ return f
+ f = self.FileFromBuildId(build_id)
+ if f:
+ return f
+ return None
+
+ def AddInstanceToShutdownOnExit(self, instance):
+ self.instances_to_shutdown_on_exit.add(instance)
+
+ # Shutdown any background processes or threads
+ def ShutdownInstances(self):
+ for x in self.instances_to_shutdown_on_exit:
+ try:
+ x.Shutdown()
+ except AttributeError:
+ pass
+
+ def GetHostMachineId(self):
+ query = QSqlQuery(self.db)
+ QueryExec(query, "SELECT id FROM machines WHERE pid = -1")
+ if query.next():
+ self.host_machine_id = query.value(0)
+ else:
+ self.host_machine_id = 0
+ return self.host_machine_id
+
+ def HostMachineId(self):
+ if self.host_machine_id:
+ return self.host_machine_id
+ return self.GetHostMachineId()
+
+ def SelectValue(self, sql):
+ query = QSqlQuery(self.db)
+ try:
+ QueryExec(query, sql)
+ except RuntimeError:
+ return None
+ if query.next():
+ return Decimal(query.value(0))
+ return None
+
+ def SwitchesMinTime(self, machine_id):
+ return self.SelectValue("SELECT time"
+ " FROM context_switches"
+ " WHERE time != 0 AND machine_id = " + str(machine_id) +
+ " ORDER BY id LIMIT 1")
+
+ def SwitchesMaxTime(self, machine_id):
+ return self.SelectValue("SELECT time"
+ " FROM context_switches"
+ " WHERE time != 0 AND machine_id = " + str(machine_id) +
+ " ORDER BY id DESC LIMIT 1")
+
+ def SamplesMinTime(self, machine_id):
+ return self.SelectValue("SELECT time"
+ " FROM samples"
+ " WHERE time != 0 AND machine_id = " + str(machine_id) +
+ " ORDER BY id LIMIT 1")
+
+ def SamplesMaxTime(self, machine_id):
+ return self.SelectValue("SELECT time"
+ " FROM samples"
+ " WHERE time != 0 AND machine_id = " + str(machine_id) +
+ " ORDER BY id DESC LIMIT 1")
+
+ def CallsMinTime(self, machine_id):
+ return self.SelectValue("SELECT calls.call_time"
+ " FROM calls"
+ " INNER JOIN threads ON threads.id = calls.thread_id"
+ " WHERE calls.call_time != 0 AND threads.machine_id = " + str(machine_id) +
+ " ORDER BY calls.id LIMIT 1")
+
+ def CallsMaxTime(self, machine_id):
+ return self.SelectValue("SELECT calls.return_time"
+ " FROM calls"
+ " INNER JOIN threads ON threads.id = calls.thread_id"
+ " WHERE calls.return_time != 0 AND threads.machine_id = " + str(machine_id) +
+ " ORDER BY calls.return_time DESC LIMIT 1")
+
+ def GetStartTime(self, machine_id):
+ t0 = self.SwitchesMinTime(machine_id)
+ t1 = self.SamplesMinTime(machine_id)
+ t2 = self.CallsMinTime(machine_id)
+ if t0 is None or (not(t1 is None) and t1 < t0):
+ t0 = t1
+ if t0 is None or (not(t2 is None) and t2 < t0):
+ t0 = t2
+ return t0
+
+ def GetFinishTime(self, machine_id):
+ t0 = self.SwitchesMaxTime(machine_id)
+ t1 = self.SamplesMaxTime(machine_id)
+ t2 = self.CallsMaxTime(machine_id)
+ if t0 is None or (not(t1 is None) and t1 > t0):
+ t0 = t1
+ if t0 is None or (not(t2 is None) and t2 > t0):
+ t0 = t2
+ return t0
+
+ def HostStartTime(self):
+ if self.host_start_time:
+ return self.host_start_time
+ self.host_start_time = self.GetStartTime(self.HostMachineId())
+ return self.host_start_time
+
+ def HostFinishTime(self):
+ if self.host_finish_time:
+ return self.host_finish_time
+ self.host_finish_time = self.GetFinishTime(self.HostMachineId())
+ return self.host_finish_time
+
+ def StartTime(self, machine_id):
+ if machine_id == self.HostMachineId():
+ return self.HostStartTime()
+ return self.GetStartTime(machine_id)
+
+ def FinishTime(self, machine_id):
+ if machine_id == self.HostMachineId():
+ return self.HostFinishTime()
+ return self.GetFinishTime(machine_id)
+
+# Database reference
+
+class DBRef():
+
+ def __init__(self, is_sqlite3, dbname):
+ self.is_sqlite3 = is_sqlite3
+ self.dbname = dbname
+ self.TRUE = "TRUE"
+ self.FALSE = "FALSE"
+ # SQLite prior to version 3.23 does not support TRUE and FALSE
+ if self.is_sqlite3:
+ self.TRUE = "1"
+ self.FALSE = "0"
+
+ def Open(self, connection_name):
+ dbname = self.dbname
+ if self.is_sqlite3:
+ db = QSqlDatabase.addDatabase("QSQLITE", connection_name)
+ else:
+ db = QSqlDatabase.addDatabase("QPSQL", connection_name)
+ opts = dbname.split()
+ for opt in opts:
+ if "=" in opt:
+ opt = opt.split("=")
+ if opt[0] == "hostname":
+ db.setHostName(opt[1])
+ elif opt[0] == "port":
+ db.setPort(int(opt[1]))
+ elif opt[0] == "username":
+ db.setUserName(opt[1])
+ elif opt[0] == "password":
+ db.setPassword(opt[1])
+ elif opt[0] == "dbname":
+ dbname = opt[1]
+ else:
+ dbname = opt
+
+ db.setDatabaseName(dbname)
+ if not db.open():
+ raise RuntimeError("Failed to open database " + dbname + " error: " + db.lastError().text())
+ return db, dbname
+
+# Main
+
+def Main():
+ usage_str = "exported-sql-viewer.py [--pyside-version-1] <database name>\n" \
+ " or: exported-sql-viewer.py --help-only"
+ ap = argparse.ArgumentParser(usage = usage_str, add_help = False)
+ ap.add_argument("--pyside-version-1", action='store_true')
+ ap.add_argument("dbname", nargs="?")
+ ap.add_argument("--help-only", action='store_true')
+ args = ap.parse_args()
+
+ if args.help_only:
+ app = QApplication(sys.argv)
+ mainwindow = HelpOnlyWindow()
+ mainwindow.show()
+ err = app.exec_()
+ sys.exit(err)
+
+ dbname = args.dbname
+ if dbname is None:
+ ap.print_usage()
+ print("Too few arguments")
+ sys.exit(1)
+
+ is_sqlite3 = False
+ try:
+ f = open(dbname, "rb")
+ if f.read(15) == b'SQLite format 3':
+ is_sqlite3 = True
+ f.close()
+ except OSError:
+ pass
+
+ dbref = DBRef(is_sqlite3, dbname)
+ db, dbname = dbref.Open("main")
+ glb = Glb(dbref, db, dbname)
+ app = QApplication(sys.argv)
+ glb.app = app
+ mainwindow = MainWindow(glb)
+ glb.mainwindow = mainwindow
+ mainwindow.show()
+ err = app.exec_()
+ glb.ShutdownInstances()
+ db.close()
+ sys.exit(err)
+
+if __name__ == "__main__":
+ Main()
diff --git a/tools/perf/scripts/python/exported-sql-viewer.py b/tools/perf/scripts/python/exported-sql-viewer.py
deleted file mode 100755
index e0b2e7268ef6..000000000000
--- a/tools/perf/scripts/python/exported-sql-viewer.py
+++ /dev/null
@@ -1,5030 +0,0 @@
-#!/usr/bin/env python
-# SPDX-License-Identifier: GPL-2.0
-# exported-sql-viewer.py: view data from sql database
-# Copyright (c) 2014-2018, Intel Corporation.
-
-# To use this script you will need to have exported data using either the
-# export-to-sqlite.py or the export-to-postgresql.py script. Refer to those
-# scripts for details.
-#
-# Following on from the example in the export scripts, a
-# call-graph can be displayed for the pt_example database like this:
-#
-# python tools/perf/scripts/python/exported-sql-viewer.py pt_example
-#
-# Note that for PostgreSQL, this script supports connecting to remote databases
-# by setting hostname, port, username, password, and dbname e.g.
-#
-# python tools/perf/scripts/python/exported-sql-viewer.py "hostname=myhost username=myuser password=mypassword dbname=pt_example"
-#
-# The result is a GUI window with a tree representing a context-sensitive
-# call-graph. Expanding a couple of levels of the tree and adjusting column
-# widths to suit will display something like:
-#
-# Call Graph: pt_example
-# Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
-# v- ls
-# v- 2638:2638
-# v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
-# |- unknown unknown 1 13198 0.1 1 0.0
-# >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
-# >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
-# v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
-# >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
-# >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
-# >- __libc_csu_init ls 1 10354 0.1 10 0.0
-# |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
-# v- main ls 1 8182043 99.6 180254 99.9
-#
-# Points to note:
-# The top level is a command name (comm)
-# The next level is a thread (pid:tid)
-# Subsequent levels are functions
-# 'Count' is the number of calls
-# 'Time' is the elapsed time until the function returns
-# Percentages are relative to the level above
-# 'Branch Count' is the total number of branches for that function and all
-# functions that it calls
-
-# There is also a "All branches" report, which displays branches and
-# possibly disassembly. However, presently, the only supported disassembler is
-# Intel XED, and additionally the object code must be present in perf build ID
-# cache. To use Intel XED, libxed.so must be present. To build and install
-# libxed.so:
-# git clone https://github.com/intelxed/mbuild.git mbuild
-# git clone https://github.com/intelxed/xed
-# cd xed
-# ./mfile.py --share
-# sudo ./mfile.py --prefix=/usr/local install
-# sudo ldconfig
-#
-# Example report:
-#
-# Time CPU Command PID TID Branch Type In Tx Branch
-# 8107675239590 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
-# 7fab593ea260 48 89 e7 mov %rsp, %rdi
-# 8107675239899 2 ls 22011 22011 hardware interrupt No 7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
-# 8107675241900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
-# 7fab593ea260 48 89 e7 mov %rsp, %rdi
-# 7fab593ea263 e8 c8 06 00 00 callq 0x7fab593ea930
-# 8107675241900 2 ls 22011 22011 call No 7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so)
-# 7fab593ea930 55 pushq %rbp
-# 7fab593ea931 48 89 e5 mov %rsp, %rbp
-# 7fab593ea934 41 57 pushq %r15
-# 7fab593ea936 41 56 pushq %r14
-# 7fab593ea938 41 55 pushq %r13
-# 7fab593ea93a 41 54 pushq %r12
-# 7fab593ea93c 53 pushq %rbx
-# 7fab593ea93d 48 89 fb mov %rdi, %rbx
-# 7fab593ea940 48 83 ec 68 sub $0x68, %rsp
-# 7fab593ea944 0f 31 rdtsc
-# 7fab593ea946 48 c1 e2 20 shl $0x20, %rdx
-# 7fab593ea94a 89 c0 mov %eax, %eax
-# 7fab593ea94c 48 09 c2 or %rax, %rdx
-# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
-# 8107675242232 2 ls 22011 22011 hardware interrupt No 7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
-# 8107675242900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so)
-# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
-# 7fab593ea956 48 89 15 3b 13 22 00 movq %rdx, 0x22133b(%rip)
-# 8107675243232 2 ls 22011 22011 hardware interrupt No 7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
-
-from __future__ import print_function
-
-import sys
-# Only change warnings if the python -W option was not used
-if not sys.warnoptions:
- import warnings
- # PySide2 causes deprecation warnings, ignore them.
- warnings.filterwarnings("ignore", category=DeprecationWarning)
-import argparse
-import weakref
-import threading
-import string
-try:
- # Python2
- import cPickle as pickle
- # size of pickled integer big enough for record size
- glb_nsz = 8
-except ImportError:
- import pickle
- glb_nsz = 16
-import re
-import os
-import random
-import copy
-import math
-from libxed import LibXED
-
-pyside_version_1 = True
-if not "--pyside-version-1" in sys.argv:
- try:
- from PySide2.QtCore import *
- from PySide2.QtGui import *
- from PySide2.QtSql import *
- from PySide2.QtWidgets import *
- pyside_version_1 = False
- except:
- pass
-
-if pyside_version_1:
- from PySide.QtCore import *
- from PySide.QtGui import *
- from PySide.QtSql import *
-
-from decimal import Decimal, ROUND_HALF_UP
-from ctypes import CDLL, Structure, create_string_buffer, addressof, sizeof, \
- c_void_p, c_bool, c_byte, c_char, c_int, c_uint, c_longlong, c_ulonglong
-from multiprocessing import Process, Array, Value, Event
-
-# xrange is range in Python3
-try:
- xrange
-except NameError:
- xrange = range
-
-def printerr(*args, **keyword_args):
- print(*args, file=sys.stderr, **keyword_args)
-
-# Data formatting helpers
-
-def tohex(ip):
- if ip < 0:
- ip += 1 << 64
- return "%x" % ip
-
-def offstr(offset):
- if offset:
- return "+0x%x" % offset
- return ""
-
-def dsoname(name):
- if name == "[kernel.kallsyms]":
- return "[kernel]"
- return name
-
-def findnth(s, sub, n, offs=0):
- pos = s.find(sub)
- if pos < 0:
- return pos
- if n <= 1:
- return offs + pos
- return findnth(s[pos + 1:], sub, n - 1, offs + pos + 1)
-
-# Percent to one decimal place
-
-def PercentToOneDP(n, d):
- if not d:
- return "0.0"
- x = (n * Decimal(100)) / d
- return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP))
-
-# Helper for queries that must not fail
-
-def QueryExec(query, stmt):
- ret = query.exec_(stmt)
- if not ret:
- raise Exception("Query failed: " + query.lastError().text())
-
-# Background thread
-
-class Thread(QThread):
-
- done = Signal(object)
-
- def __init__(self, task, param=None, parent=None):
- super(Thread, self).__init__(parent)
- self.task = task
- self.param = param
-
- def run(self):
- while True:
- if self.param is None:
- done, result = self.task()
- else:
- done, result = self.task(self.param)
- self.done.emit(result)
- if done:
- break
-
-# Tree data model
-
-class TreeModel(QAbstractItemModel):
-
- def __init__(self, glb, params, parent=None):
- super(TreeModel, self).__init__(parent)
- self.glb = glb
- self.params = params
- self.root = self.GetRoot()
- self.last_row_read = 0
-
- def Item(self, parent):
- if parent.isValid():
- return parent.internalPointer()
- else:
- return self.root
-
- def rowCount(self, parent):
- result = self.Item(parent).childCount()
- if result < 0:
- result = 0
- self.dataChanged.emit(parent, parent)
- return result
-
- def hasChildren(self, parent):
- return self.Item(parent).hasChildren()
-
- def headerData(self, section, orientation, role):
- if role == Qt.TextAlignmentRole:
- return self.columnAlignment(section)
- if role != Qt.DisplayRole:
- return None
- if orientation != Qt.Horizontal:
- return None
- return self.columnHeader(section)
-
- def parent(self, child):
- child_item = child.internalPointer()
- if child_item is self.root:
- return QModelIndex()
- parent_item = child_item.getParentItem()
- return self.createIndex(parent_item.getRow(), 0, parent_item)
-
- def index(self, row, column, parent):
- child_item = self.Item(parent).getChildItem(row)
- return self.createIndex(row, column, child_item)
-
- def DisplayData(self, item, index):
- return item.getData(index.column())
-
- def FetchIfNeeded(self, row):
- if row > self.last_row_read:
- self.last_row_read = row
- if row + 10 >= self.root.child_count:
- self.fetcher.Fetch(glb_chunk_sz)
-
- def columnAlignment(self, column):
- return Qt.AlignLeft
-
- def columnFont(self, column):
- return None
-
- def data(self, index, role):
- if role == Qt.TextAlignmentRole:
- return self.columnAlignment(index.column())
- if role == Qt.FontRole:
- return self.columnFont(index.column())
- if role != Qt.DisplayRole:
- return None
- item = index.internalPointer()
- return self.DisplayData(item, index)
-
-# Table data model
-
-class TableModel(QAbstractTableModel):
-
- def __init__(self, parent=None):
- super(TableModel, self).__init__(parent)
- self.child_count = 0
- self.child_items = []
- self.last_row_read = 0
-
- def Item(self, parent):
- if parent.isValid():
- return parent.internalPointer()
- else:
- return self
-
- def rowCount(self, parent):
- return self.child_count
-
- def headerData(self, section, orientation, role):
- if role == Qt.TextAlignmentRole:
- return self.columnAlignment(section)
- if role != Qt.DisplayRole:
- return None
- if orientation != Qt.Horizontal:
- return None
- return self.columnHeader(section)
-
- def index(self, row, column, parent):
- return self.createIndex(row, column, self.child_items[row])
-
- def DisplayData(self, item, index):
- return item.getData(index.column())
-
- def FetchIfNeeded(self, row):
- if row > self.last_row_read:
- self.last_row_read = row
- if row + 10 >= self.child_count:
- self.fetcher.Fetch(glb_chunk_sz)
-
- def columnAlignment(self, column):
- return Qt.AlignLeft
-
- def columnFont(self, column):
- return None
-
- def data(self, index, role):
- if role == Qt.TextAlignmentRole:
- return self.columnAlignment(index.column())
- if role == Qt.FontRole:
- return self.columnFont(index.column())
- if role != Qt.DisplayRole:
- return None
- item = index.internalPointer()
- return self.DisplayData(item, index)
-
-# Model cache
-
-model_cache = weakref.WeakValueDictionary()
-model_cache_lock = threading.Lock()
-
-def LookupCreateModel(model_name, create_fn):
- model_cache_lock.acquire()
- try:
- model = model_cache[model_name]
- except:
- model = None
- if model is None:
- model = create_fn()
- model_cache[model_name] = model
- model_cache_lock.release()
- return model
-
-def LookupModel(model_name):
- model_cache_lock.acquire()
- try:
- model = model_cache[model_name]
- except:
- model = None
- model_cache_lock.release()
- return model
-
-# Find bar
-
-class FindBar():
-
- def __init__(self, parent, finder, is_reg_expr=False):
- self.finder = finder
- self.context = []
- self.last_value = None
- self.last_pattern = None
-
- label = QLabel("Find:")
- label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
- self.textbox = QComboBox()
- self.textbox.setEditable(True)
- self.textbox.currentIndexChanged.connect(self.ValueChanged)
-
- self.progress = QProgressBar()
- self.progress.setRange(0, 0)
- self.progress.hide()
-
- if is_reg_expr:
- self.pattern = QCheckBox("Regular Expression")
- else:
- self.pattern = QCheckBox("Pattern")
- self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
- self.next_button = QToolButton()
- self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
- self.next_button.released.connect(lambda: self.NextPrev(1))
-
- self.prev_button = QToolButton()
- self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
- self.prev_button.released.connect(lambda: self.NextPrev(-1))
-
- self.close_button = QToolButton()
- self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
- self.close_button.released.connect(self.Deactivate)
-
- self.hbox = QHBoxLayout()
- self.hbox.setContentsMargins(0, 0, 0, 0)
-
- self.hbox.addWidget(label)
- self.hbox.addWidget(self.textbox)
- self.hbox.addWidget(self.progress)
- self.hbox.addWidget(self.pattern)
- self.hbox.addWidget(self.next_button)
- self.hbox.addWidget(self.prev_button)
- self.hbox.addWidget(self.close_button)
-
- self.bar = QWidget()
- self.bar.setLayout(self.hbox)
- self.bar.hide()
-
- def Widget(self):
- return self.bar
-
- def Activate(self):
- self.bar.show()
- self.textbox.lineEdit().selectAll()
- self.textbox.setFocus()
-
- def Deactivate(self):
- self.bar.hide()
-
- def Busy(self):
- self.textbox.setEnabled(False)
- self.pattern.hide()
- self.next_button.hide()
- self.prev_button.hide()
- self.progress.show()
-
- def Idle(self):
- self.textbox.setEnabled(True)
- self.progress.hide()
- self.pattern.show()
- self.next_button.show()
- self.prev_button.show()
-
- def Find(self, direction):
- value = self.textbox.currentText()
- pattern = self.pattern.isChecked()
- self.last_value = value
- self.last_pattern = pattern
- self.finder.Find(value, direction, pattern, self.context)
-
- def ValueChanged(self):
- value = self.textbox.currentText()
- pattern = self.pattern.isChecked()
- index = self.textbox.currentIndex()
- data = self.textbox.itemData(index)
- # Store the pattern in the combo box to keep it with the text value
- if data == None:
- self.textbox.setItemData(index, pattern)
- else:
- self.pattern.setChecked(data)
- self.Find(0)
-
- def NextPrev(self, direction):
- value = self.textbox.currentText()
- pattern = self.pattern.isChecked()
- if value != self.last_value:
- index = self.textbox.findText(value)
- # Allow for a button press before the value has been added to the combo box
- if index < 0:
- index = self.textbox.count()
- self.textbox.addItem(value, pattern)
- self.textbox.setCurrentIndex(index)
- return
- else:
- self.textbox.setItemData(index, pattern)
- elif pattern != self.last_pattern:
- # Keep the pattern recorded in the combo box up to date
- index = self.textbox.currentIndex()
- self.textbox.setItemData(index, pattern)
- self.Find(direction)
-
- def NotFound(self):
- QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
-
-# Context-sensitive call graph data model item base
-
-class CallGraphLevelItemBase(object):
-
- def __init__(self, glb, params, row, parent_item):
- self.glb = glb
- self.params = params
- self.row = row
- self.parent_item = parent_item
- self.query_done = False
- self.child_count = 0
- self.child_items = []
- if parent_item:
- self.level = parent_item.level + 1
- else:
- self.level = 0
-
- def getChildItem(self, row):
- return self.child_items[row]
-
- def getParentItem(self):
- return self.parent_item
-
- def getRow(self):
- return self.row
-
- def childCount(self):
- if not self.query_done:
- self.Select()
- if not self.child_count:
- return -1
- return self.child_count
-
- def hasChildren(self):
- if not self.query_done:
- return True
- return self.child_count > 0
-
- def getData(self, column):
- return self.data[column]
-
-# Context-sensitive call graph data model level 2+ item base
-
-class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase):
-
- def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item):
- super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
- self.comm_id = comm_id
- self.thread_id = thread_id
- self.call_path_id = call_path_id
- self.insn_cnt = insn_cnt
- self.cyc_cnt = cyc_cnt
- self.branch_count = branch_count
- self.time = time
-
- def Select(self):
- self.query_done = True
- query = QSqlQuery(self.glb.db)
- if self.params.have_ipc:
- ipc_str = ", SUM(insn_count), SUM(cyc_count)"
- else:
- ipc_str = ""
- QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time)" + ipc_str + ", SUM(branch_count)"
- " FROM calls"
- " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
- " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
- " INNER JOIN dsos ON symbols.dso_id = dsos.id"
- " WHERE parent_call_path_id = " + str(self.call_path_id) +
- " AND comm_id = " + str(self.comm_id) +
- " AND thread_id = " + str(self.thread_id) +
- " GROUP BY call_path_id, name, short_name"
- " ORDER BY call_path_id")
- while query.next():
- if self.params.have_ipc:
- insn_cnt = int(query.value(5))
- cyc_cnt = int(query.value(6))
- branch_count = int(query.value(7))
- else:
- insn_cnt = 0
- cyc_cnt = 0
- branch_count = int(query.value(5))
- child_item = CallGraphLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
- self.child_items.append(child_item)
- self.child_count += 1
-
-# Context-sensitive call graph data model level three item
-
-class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase):
-
- def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, insn_cnt, cyc_cnt, branch_count, parent_item):
- super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item)
- dso = dsoname(dso)
- if self.params.have_ipc:
- insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
- cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
- br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
- ipc = CalcIPC(cyc_cnt, insn_cnt)
- self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
- else:
- self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
- self.dbid = call_path_id
-
-# Context-sensitive call graph data model level two item
-
-class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase):
-
- def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
- super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, parent_item)
- if self.params.have_ipc:
- self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
- else:
- self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
- self.dbid = thread_id
-
- def Select(self):
- super(CallGraphLevelTwoItem, self).Select()
- for child_item in self.child_items:
- self.time += child_item.time
- self.insn_cnt += child_item.insn_cnt
- self.cyc_cnt += child_item.cyc_cnt
- self.branch_count += child_item.branch_count
- for child_item in self.child_items:
- child_item.data[4] = PercentToOneDP(child_item.time, self.time)
- if self.params.have_ipc:
- child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
- child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
- child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
- else:
- child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
-
-# Context-sensitive call graph data model level one item
-
-class CallGraphLevelOneItem(CallGraphLevelItemBase):
-
- def __init__(self, glb, params, row, comm_id, comm, parent_item):
- super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
- if self.params.have_ipc:
- self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
- else:
- self.data = [comm, "", "", "", "", "", ""]
- self.dbid = comm_id
-
- def Select(self):
- self.query_done = True
- query = QSqlQuery(self.glb.db)
- QueryExec(query, "SELECT thread_id, pid, tid"
- " FROM comm_threads"
- " INNER JOIN threads ON thread_id = threads.id"
- " WHERE comm_id = " + str(self.dbid))
- while query.next():
- child_item = CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
- self.child_items.append(child_item)
- self.child_count += 1
-
-# Context-sensitive call graph data model root item
-
-class CallGraphRootItem(CallGraphLevelItemBase):
-
- def __init__(self, glb, params):
- super(CallGraphRootItem, self).__init__(glb, params, 0, None)
- self.dbid = 0
- self.query_done = True
- if_has_calls = ""
- if IsSelectable(glb.db, "comms", columns = "has_calls"):
- if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
- query = QSqlQuery(glb.db)
- QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
- while query.next():
- if not query.value(0):
- continue
- child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
- self.child_items.append(child_item)
- self.child_count += 1
-
-# Call graph model parameters
-
-class CallGraphModelParams():
-
- def __init__(self, glb, parent=None):
- self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
-
-# Context-sensitive call graph data model base
-
-class CallGraphModelBase(TreeModel):
-
- def __init__(self, glb, parent=None):
- super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
-
- def FindSelect(self, value, pattern, query):
- if pattern:
- # postgresql and sqlite pattern patching differences:
- # postgresql LIKE is case sensitive but sqlite LIKE is not
- # postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not
- # postgresql supports ILIKE which is case insensitive
- # sqlite supports GLOB (text only) which uses * and ? and is case sensitive
- if not self.glb.dbref.is_sqlite3:
- # Escape % and _
- s = value.replace("%", "\\%")
- s = s.replace("_", "\\_")
- # Translate * and ? into SQL LIKE pattern characters % and _
- if sys.version_info[0] == 3:
- trans = str.maketrans("*?", "%_")
- else:
- trans = string.maketrans("*?", "%_")
- match = " LIKE '" + str(s).translate(trans) + "'"
- else:
- match = " GLOB '" + str(value) + "'"
- else:
- match = " = '" + str(value) + "'"
- self.DoFindSelect(query, match)
-
- def Found(self, query, found):
- if found:
- return self.FindPath(query)
- return []
-
- def FindValue(self, value, pattern, query, last_value, last_pattern):
- if last_value == value and pattern == last_pattern:
- found = query.first()
- else:
- self.FindSelect(value, pattern, query)
- found = query.next()
- return self.Found(query, found)
-
- def FindNext(self, query):
- found = query.next()
- if not found:
- found = query.first()
- return self.Found(query, found)
-
- def FindPrev(self, query):
- found = query.previous()
- if not found:
- found = query.last()
- return self.Found(query, found)
-
- def FindThread(self, c):
- if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern:
- ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
- elif c.direction > 0:
- ids = self.FindNext(c.query)
- else:
- ids = self.FindPrev(c.query)
- return (True, ids)
-
- def Find(self, value, direction, pattern, context, callback):
- class Context():
- def __init__(self, *x):
- self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
- def Update(self, *x):
- self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern)
- if len(context):
- context[0].Update(value, direction, pattern)
- else:
- context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
- # Use a thread so the UI is not blocked during the SELECT
- thread = Thread(self.FindThread, context[0])
- thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection)
- thread.start()
-
- def FindDone(self, thread, callback, ids):
- callback(ids)
-
-# Context-sensitive call graph data model
-
-class CallGraphModel(CallGraphModelBase):
-
- def __init__(self, glb, parent=None):
- super(CallGraphModel, self).__init__(glb, parent)
-
- def GetRoot(self):
- return CallGraphRootItem(self.glb, self.params)
-
- def columnCount(self, parent=None):
- if self.params.have_ipc:
- return 12
- else:
- return 7
-
- def columnHeader(self, column):
- if self.params.have_ipc:
- headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
- else:
- headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
- return headers[column]
-
- def columnAlignment(self, column):
- if self.params.have_ipc:
- alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
- else:
- alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
- return alignment[column]
-
- def DoFindSelect(self, query, match):
- QueryExec(query, "SELECT call_path_id, comm_id, thread_id"
- " FROM calls"
- " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
- " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
- " WHERE calls.id <> 0"
- " AND symbols.name" + match +
- " GROUP BY comm_id, thread_id, call_path_id"
- " ORDER BY comm_id, thread_id, call_path_id")
-
- def FindPath(self, query):
- # Turn the query result into a list of ids that the tree view can walk
- # to open the tree at the right place.
- ids = []
- parent_id = query.value(0)
- while parent_id:
- ids.insert(0, parent_id)
- q2 = QSqlQuery(self.glb.db)
- QueryExec(q2, "SELECT parent_id"
- " FROM call_paths"
- " WHERE id = " + str(parent_id))
- if not q2.next():
- break
- parent_id = q2.value(0)
- # The call path root is not used
- if ids[0] == 1:
- del ids[0]
- ids.insert(0, query.value(2))
- ids.insert(0, query.value(1))
- return ids
-
-# Call tree data model level 2+ item base
-
-class CallTreeLevelTwoPlusItemBase(CallGraphLevelItemBase):
-
- def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
- super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
- self.comm_id = comm_id
- self.thread_id = thread_id
- self.calls_id = calls_id
- self.call_time = call_time
- self.time = time
- self.insn_cnt = insn_cnt
- self.cyc_cnt = cyc_cnt
- self.branch_count = branch_count
-
- def Select(self):
- self.query_done = True
- if self.calls_id == 0:
- comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
- else:
- comm_thread = ""
- if self.params.have_ipc:
- ipc_str = ", insn_count, cyc_count"
- else:
- ipc_str = ""
- query = QSqlQuery(self.glb.db)
- QueryExec(query, "SELECT calls.id, name, short_name, call_time, return_time - call_time" + ipc_str + ", branch_count"
- " FROM calls"
- " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
- " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
- " INNER JOIN dsos ON symbols.dso_id = dsos.id"
- " WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
- " ORDER BY call_time, calls.id")
- while query.next():
- if self.params.have_ipc:
- insn_cnt = int(query.value(5))
- cyc_cnt = int(query.value(6))
- branch_count = int(query.value(7))
- else:
- insn_cnt = 0
- cyc_cnt = 0
- branch_count = int(query.value(5))
- child_item = CallTreeLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
- self.child_items.append(child_item)
- self.child_count += 1
-
-# Call tree data model level three item
-
-class CallTreeLevelThreeItem(CallTreeLevelTwoPlusItemBase):
-
- def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
- super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item)
- dso = dsoname(dso)
- if self.params.have_ipc:
- insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
- cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
- br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
- ipc = CalcIPC(cyc_cnt, insn_cnt)
- self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
- else:
- self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
- self.dbid = calls_id
-
-# Call tree data model level two item
-
-class CallTreeLevelTwoItem(CallTreeLevelTwoPlusItemBase):
-
- def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
- super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0, parent_item)
- if self.params.have_ipc:
- self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
- else:
- self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
- self.dbid = thread_id
-
- def Select(self):
- super(CallTreeLevelTwoItem, self).Select()
- for child_item in self.child_items:
- self.time += child_item.time
- self.insn_cnt += child_item.insn_cnt
- self.cyc_cnt += child_item.cyc_cnt
- self.branch_count += child_item.branch_count
- for child_item in self.child_items:
- child_item.data[4] = PercentToOneDP(child_item.time, self.time)
- if self.params.have_ipc:
- child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
- child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
- child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
- else:
- child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
-
-# Call tree data model level one item
-
-class CallTreeLevelOneItem(CallGraphLevelItemBase):
-
- def __init__(self, glb, params, row, comm_id, comm, parent_item):
- super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
- if self.params.have_ipc:
- self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
- else:
- self.data = [comm, "", "", "", "", "", ""]
- self.dbid = comm_id
-
- def Select(self):
- self.query_done = True
- query = QSqlQuery(self.glb.db)
- QueryExec(query, "SELECT thread_id, pid, tid"
- " FROM comm_threads"
- " INNER JOIN threads ON thread_id = threads.id"
- " WHERE comm_id = " + str(self.dbid))
- while query.next():
- child_item = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
- self.child_items.append(child_item)
- self.child_count += 1
-
-# Call tree data model root item
-
-class CallTreeRootItem(CallGraphLevelItemBase):
-
- def __init__(self, glb, params):
- super(CallTreeRootItem, self).__init__(glb, params, 0, None)
- self.dbid = 0
- self.query_done = True
- if_has_calls = ""
- if IsSelectable(glb.db, "comms", columns = "has_calls"):
- if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
- query = QSqlQuery(glb.db)
- QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
- while query.next():
- if not query.value(0):
- continue
- child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
- self.child_items.append(child_item)
- self.child_count += 1
-
-# Call Tree data model
-
-class CallTreeModel(CallGraphModelBase):
-
- def __init__(self, glb, parent=None):
- super(CallTreeModel, self).__init__(glb, parent)
-
- def GetRoot(self):
- return CallTreeRootItem(self.glb, self.params)
-
- def columnCount(self, parent=None):
- if self.params.have_ipc:
- return 12
- else:
- return 7
-
- def columnHeader(self, column):
- if self.params.have_ipc:
- headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
- else:
- headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
- return headers[column]
-
- def columnAlignment(self, column):
- if self.params.have_ipc:
- alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
- else:
- alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
- return alignment[column]
-
- def DoFindSelect(self, query, match):
- QueryExec(query, "SELECT calls.id, comm_id, thread_id"
- " FROM calls"
- " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
- " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
- " WHERE calls.id <> 0"
- " AND symbols.name" + match +
- " ORDER BY comm_id, thread_id, call_time, calls.id")
-
- def FindPath(self, query):
- # Turn the query result into a list of ids that the tree view can walk
- # to open the tree at the right place.
- ids = []
- parent_id = query.value(0)
- while parent_id:
- ids.insert(0, parent_id)
- q2 = QSqlQuery(self.glb.db)
- QueryExec(q2, "SELECT parent_id"
- " FROM calls"
- " WHERE id = " + str(parent_id))
- if not q2.next():
- break
- parent_id = q2.value(0)
- ids.insert(0, query.value(2))
- ids.insert(0, query.value(1))
- return ids
-
-# Vertical layout
-
-class HBoxLayout(QHBoxLayout):
-
- def __init__(self, *children):
- super(HBoxLayout, self).__init__()
-
- self.layout().setContentsMargins(0, 0, 0, 0)
- for child in children:
- if child.isWidgetType():
- self.layout().addWidget(child)
- else:
- self.layout().addLayout(child)
-
-# Horizontal layout
-
-class VBoxLayout(QVBoxLayout):
-
- def __init__(self, *children):
- super(VBoxLayout, self).__init__()
-
- self.layout().setContentsMargins(0, 0, 0, 0)
- for child in children:
- if child.isWidgetType():
- self.layout().addWidget(child)
- else:
- self.layout().addLayout(child)
-
-# Vertical layout widget
-
-class VBox():
-
- def __init__(self, *children):
- self.vbox = QWidget()
- self.vbox.setLayout(VBoxLayout(*children))
-
- def Widget(self):
- return self.vbox
-
-# Tree window base
-
-class TreeWindowBase(QMdiSubWindow):
-
- def __init__(self, parent=None):
- super(TreeWindowBase, self).__init__(parent)
-
- self.model = None
- self.find_bar = None
-
- self.view = QTreeView()
- self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
- self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
-
- self.context_menu = TreeContextMenu(self.view)
-
- def DisplayFound(self, ids):
- if not len(ids):
- return False
- parent = QModelIndex()
- for dbid in ids:
- found = False
- n = self.model.rowCount(parent)
- for row in xrange(n):
- child = self.model.index(row, 0, parent)
- if child.internalPointer().dbid == dbid:
- found = True
- self.view.setExpanded(parent, True)
- self.view.setCurrentIndex(child)
- parent = child
- break
- if not found:
- break
- return found
-
- def Find(self, value, direction, pattern, context):
- self.view.setFocus()
- self.find_bar.Busy()
- self.model.Find(value, direction, pattern, context, self.FindDone)
-
- def FindDone(self, ids):
- found = True
- if not self.DisplayFound(ids):
- found = False
- self.find_bar.Idle()
- if not found:
- self.find_bar.NotFound()
-
-
-# Context-sensitive call graph window
-
-class CallGraphWindow(TreeWindowBase):
-
- def __init__(self, glb, parent=None):
- super(CallGraphWindow, self).__init__(parent)
-
- self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
-
- self.view.setModel(self.model)
-
- for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)):
- self.view.setColumnWidth(c, w)
-
- self.find_bar = FindBar(self, self)
-
- self.vbox = VBox(self.view, self.find_bar.Widget())
-
- self.setWidget(self.vbox.Widget())
-
- AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
-
-# Call tree window
-
-class CallTreeWindow(TreeWindowBase):
-
- def __init__(self, glb, parent=None, thread_at_time=None):
- super(CallTreeWindow, self).__init__(parent)
-
- self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
-
- self.view.setModel(self.model)
-
- for c, w in ((0, 230), (1, 100), (2, 100), (3, 70), (4, 70), (5, 100)):
- self.view.setColumnWidth(c, w)
-
- self.find_bar = FindBar(self, self)
-
- self.vbox = VBox(self.view, self.find_bar.Widget())
-
- self.setWidget(self.vbox.Widget())
-
- AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
-
- if thread_at_time:
- self.DisplayThreadAtTime(*thread_at_time)
-
- def DisplayThreadAtTime(self, comm_id, thread_id, time):
- parent = QModelIndex()
- for dbid in (comm_id, thread_id):
- found = False
- n = self.model.rowCount(parent)
- for row in xrange(n):
- child = self.model.index(row, 0, parent)
- if child.internalPointer().dbid == dbid:
- found = True
- self.view.setExpanded(parent, True)
- self.view.setCurrentIndex(child)
- parent = child
- break
- if not found:
- return
- found = False
- while True:
- n = self.model.rowCount(parent)
- if not n:
- return
- last_child = None
- for row in xrange(n):
- self.view.setExpanded(parent, True)
- child = self.model.index(row, 0, parent)
- child_call_time = child.internalPointer().call_time
- if child_call_time < time:
- last_child = child
- elif child_call_time == time:
- self.view.setCurrentIndex(child)
- return
- elif child_call_time > time:
- break
- if not last_child:
- if not found:
- child = self.model.index(0, 0, parent)
- self.view.setExpanded(parent, True)
- self.view.setCurrentIndex(child)
- return
- found = True
- self.view.setExpanded(parent, True)
- self.view.setCurrentIndex(last_child)
- parent = last_child
-
-# ExecComm() gets the comm_id of the command string that was set when the process exec'd i.e. the program name
-
-def ExecComm(db, thread_id, time):
- query = QSqlQuery(db)
- QueryExec(query, "SELECT comm_threads.comm_id, comms.c_time, comms.exec_flag"
- " FROM comm_threads"
- " INNER JOIN comms ON comms.id = comm_threads.comm_id"
- " WHERE comm_threads.thread_id = " + str(thread_id) +
- " ORDER BY comms.c_time, comms.id")
- first = None
- last = None
- while query.next():
- if first is None:
- first = query.value(0)
- if query.value(2) and Decimal(query.value(1)) <= Decimal(time):
- last = query.value(0)
- if not(last is None):
- return last
- return first
-
-# Container for (x, y) data
-
-class XY():
- def __init__(self, x=0, y=0):
- self.x = x
- self.y = y
-
- def __str__(self):
- return "XY({}, {})".format(str(self.x), str(self.y))
-
-# Container for sub-range data
-
-class Subrange():
- def __init__(self, lo=0, hi=0):
- self.lo = lo
- self.hi = hi
-
- def __str__(self):
- return "Subrange({}, {})".format(str(self.lo), str(self.hi))
-
-# Graph data region base class
-
-class GraphDataRegion(object):
-
- def __init__(self, key, title = "", ordinal = ""):
- self.key = key
- self.title = title
- self.ordinal = ordinal
-
-# Function to sort GraphDataRegion
-
-def GraphDataRegionOrdinal(data_region):
- return data_region.ordinal
-
-# Attributes for a graph region
-
-class GraphRegionAttribute():
-
- def __init__(self, colour):
- self.colour = colour
-
-# Switch graph data region represents a task
-
-class SwitchGraphDataRegion(GraphDataRegion):
-
- def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):
- super(SwitchGraphDataRegion, self).__init__(key)
-
- self.title = str(pid) + " / " + str(tid) + " " + comm
- # Order graph legend within exec comm by pid / tid / time
- self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
- self.exec_comm_id = exec_comm_id
- self.pid = pid
- self.tid = tid
- self.comm = comm
- self.thread_id = thread_id
- self.comm_id = comm_id
-
-# Graph data point
-
-class GraphDataPoint():
-
- def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):
- self.data = data
- self.index = index
- self.x = x
- self.y = y
- self.altx = altx
- self.alty = alty
- self.hregion = hregion
- self.vregion = vregion
-
-# Graph data (single graph) base class
-
-class GraphData(object):
-
- def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):
- self.collection = collection
- self.points = []
- self.xbase = xbase
- self.ybase = ybase
- self.title = ""
-
- def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):
- index = len(self.points)
-
- x = float(Decimal(x) - self.xbase)
- y = float(Decimal(y) - self.ybase)
-
- self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))
-
- def XToData(self, x):
- return Decimal(x) + self.xbase
-
- def YToData(self, y):
- return Decimal(y) + self.ybase
-
-# Switch graph data (for one CPU)
-
-class SwitchGraphData(GraphData):
-
- def __init__(self, db, collection, cpu, xbase):
- super(SwitchGraphData, self).__init__(collection, xbase)
-
- self.cpu = cpu
- self.title = "CPU " + str(cpu)
- self.SelectSwitches(db)
-
- def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):
- query = QSqlQuery(db)
- QueryExec(query, "SELECT id, c_time"
- " FROM comms"
- " WHERE c_thread_id = " + str(thread_id) +
- " AND exec_flag = " + self.collection.glb.dbref.TRUE +
- " AND c_time >= " + str(start_time) +
- " AND c_time <= " + str(end_time) +
- " ORDER BY c_time, id")
- while query.next():
- comm_id = query.value(0)
- if comm_id == last_comm_id:
- continue
- time = query.value(1)
- hregion = self.HRegion(db, thread_id, comm_id, time)
- self.AddPoint(time, 1000, None, None, hregion)
-
- def SelectSwitches(self, db):
- last_time = None
- last_comm_id = None
- last_thread_id = None
- query = QSqlQuery(db)
- QueryExec(query, "SELECT time, thread_out_id, thread_in_id, comm_out_id, comm_in_id, flags"
- " FROM context_switches"
- " WHERE machine_id = " + str(self.collection.machine_id) +
- " AND cpu = " + str(self.cpu) +
- " ORDER BY time, id")
- while query.next():
- flags = int(query.value(5))
- if flags & 1:
- # Schedule-out: detect and add exec's
- if last_thread_id == query.value(1) and last_comm_id is not None and last_comm_id != query.value(3):
- self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
- continue
- # Schedule-in: add data point
- if len(self.points) == 0:
- start_time = self.collection.glb.StartTime(self.collection.machine_id)
- hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
- self.AddPoint(start_time, 1000, None, None, hregion)
- time = query.value(0)
- comm_id = query.value(4)
- thread_id = query.value(2)
- hregion = self.HRegion(db, thread_id, comm_id, time)
- self.AddPoint(time, 1000, None, None, hregion)
- last_time = time
- last_comm_id = comm_id
- last_thread_id = thread_id
-
- def NewHRegion(self, db, key, thread_id, comm_id, time):
- exec_comm_id = ExecComm(db, thread_id, time)
- query = QSqlQuery(db)
- QueryExec(query, "SELECT pid, tid FROM threads WHERE id = " + str(thread_id))
- if query.next():
- pid = query.value(0)
- tid = query.value(1)
- else:
- pid = -1
- tid = -1
- query = QSqlQuery(db)
- QueryExec(query, "SELECT comm FROM comms WHERE id = " + str(comm_id))
- if query.next():
- comm = query.value(0)
- else:
- comm = ""
- return SwitchGraphDataRegion(key, exec_comm_id, pid, tid, comm, thread_id, comm_id)
-
- def HRegion(self, db, thread_id, comm_id, time):
- key = str(thread_id) + ":" + str(comm_id)
- hregion = self.collection.LookupHRegion(key)
- if hregion is None:
- hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
- self.collection.AddHRegion(key, hregion)
- return hregion
-
-# Graph data collection (multiple related graphs) base class
-
-class GraphDataCollection(object):
-
- def __init__(self, glb):
- self.glb = glb
- self.data = []
- self.hregions = {}
- self.xrangelo = None
- self.xrangehi = None
- self.yrangelo = None
- self.yrangehi = None
- self.dp = XY(0, 0)
-
- def AddGraphData(self, data):
- self.data.append(data)
-
- def LookupHRegion(self, key):
- if key in self.hregions:
- return self.hregions[key]
- return None
-
- def AddHRegion(self, key, hregion):
- self.hregions[key] = hregion
-
-# Switch graph data collection (SwitchGraphData for each CPU)
-
-class SwitchGraphDataCollection(GraphDataCollection):
-
- def __init__(self, glb, db, machine_id):
- super(SwitchGraphDataCollection, self).__init__(glb)
-
- self.machine_id = machine_id
- self.cpus = self.SelectCPUs(db)
-
- self.xrangelo = glb.StartTime(machine_id)
- self.xrangehi = glb.FinishTime(machine_id)
-
- self.yrangelo = Decimal(0)
- self.yrangehi = Decimal(1000)
-
- for cpu in self.cpus:
- self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))
-
- def SelectCPUs(self, db):
- cpus = []
- query = QSqlQuery(db)
- QueryExec(query, "SELECT DISTINCT cpu"
- " FROM context_switches"
- " WHERE machine_id = " + str(self.machine_id))
- while query.next():
- cpus.append(int(query.value(0)))
- return sorted(cpus)
-
-# Switch graph data graphics item displays the graphed data
-
-class SwitchGraphDataGraphicsItem(QGraphicsItem):
-
- def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):
- super(SwitchGraphDataGraphicsItem, self).__init__(parent)
-
- self.data = data
- self.graph_width = graph_width
- self.graph_height = graph_height
- self.attrs = attrs
- self.event_handler = event_handler
- self.setAcceptHoverEvents(True)
-
- def boundingRect(self):
- return QRectF(0, 0, self.graph_width, self.graph_height)
-
- def PaintPoint(self, painter, last, x):
- if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
- if last.x < self.attrs.subrange.x.lo:
- x0 = self.attrs.subrange.x.lo
- else:
- x0 = last.x
- if x > self.attrs.subrange.x.hi:
- x1 = self.attrs.subrange.x.hi
- else:
- x1 = x - 1
- x0 = self.attrs.XToPixel(x0)
- x1 = self.attrs.XToPixel(x1)
-
- y0 = self.attrs.YToPixel(last.y)
-
- colour = self.attrs.region_attributes[last.hregion.key].colour
-
- width = x1 - x0 + 1
- if width < 2:
- painter.setPen(colour)
- painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
- else:
- painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)
-
- def paint(self, painter, option, widget):
- last = None
- for point in self.data.points:
- self.PaintPoint(painter, last, point.x)
- if point.x > self.attrs.subrange.x.hi:
- break;
- last = point
- self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)
-
- def BinarySearchPoint(self, target):
- lower_pos = 0
- higher_pos = len(self.data.points)
- while True:
- pos = int((lower_pos + higher_pos) / 2)
- val = self.data.points[pos].x
- if target >= val:
- lower_pos = pos
- else:
- higher_pos = pos
- if higher_pos <= lower_pos + 1:
- return lower_pos
-
- def XPixelToData(self, x):
- x = self.attrs.PixelToX(x)
- if x < self.data.points[0].x:
- x = 0
- pos = 0
- low = True
- else:
- pos = self.BinarySearchPoint(x)
- low = False
- return (low, pos, self.data.XToData(x))
-
- def EventToData(self, event):
- no_data = (None,) * 4
- if len(self.data.points) < 1:
- return no_data
- x = event.pos().x()
- if x < 0:
- return no_data
- low0, pos0, time_from = self.XPixelToData(x)
- low1, pos1, time_to = self.XPixelToData(x + 1)
- hregions = set()
- hregion_times = []
- if not low1:
- for i in xrange(pos0, pos1 + 1):
- hregion = self.data.points[i].hregion
- hregions.add(hregion)
- if i == pos0:
- time = time_from
- else:
- time = self.data.XToData(self.data.points[i].x)
- hregion_times.append((hregion, time))
- return (time_from, time_to, hregions, hregion_times)
-
- def hoverMoveEvent(self, event):
- time_from, time_to, hregions, hregion_times = self.EventToData(event)
- if time_from is not None:
- self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)
-
- def hoverLeaveEvent(self, event):
- self.event_handler.NoPointEvent()
-
- def mousePressEvent(self, event):
- if event.button() != Qt.RightButton:
- super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
- return
- time_from, time_to, hregions, hregion_times = self.EventToData(event)
- if hregion_times:
- self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())
-
-# X-axis graphics item
-
-class XAxisGraphicsItem(QGraphicsItem):
-
- def __init__(self, width, parent=None):
- super(XAxisGraphicsItem, self).__init__(parent)
-
- self.width = width
- self.max_mark_sz = 4
- self.height = self.max_mark_sz + 1
-
- def boundingRect(self):
- return QRectF(0, 0, self.width, self.height)
-
- def Step(self):
- attrs = self.parentItem().attrs
- subrange = attrs.subrange.x
- t = subrange.hi - subrange.lo
- s = (3.0 * t) / self.width
- n = 1.0
- while s > n:
- n = n * 10.0
- return n
-
- def PaintMarks(self, painter, at_y, lo, hi, step, i):
- attrs = self.parentItem().attrs
- x = lo
- while x <= hi:
- xp = attrs.XToPixel(x)
- if i % 10:
- if i % 5:
- sz = 1
- else:
- sz = 2
- else:
- sz = self.max_mark_sz
- i = 0
- painter.drawLine(xp, at_y, xp, at_y + sz)
- x += step
- i += 1
-
- def paint(self, painter, option, widget):
- # Using QPainter::drawLine(int x1, int y1, int x2, int y2) so x2 = width -1
- painter.drawLine(0, 0, self.width - 1, 0)
- n = self.Step()
- attrs = self.parentItem().attrs
- subrange = attrs.subrange.x
- if subrange.lo:
- x_offset = n - (subrange.lo % n)
- else:
- x_offset = 0.0
- x = subrange.lo + x_offset
- i = (x / n) % 10
- self.PaintMarks(painter, 0, x, subrange.hi, n, i)
-
- def ScaleDimensions(self):
- n = self.Step()
- attrs = self.parentItem().attrs
- lo = attrs.subrange.x.lo
- hi = (n * 10.0) + lo
- width = attrs.XToPixel(hi)
- if width > 500:
- width = 0
- return (n, lo, hi, width)
-
- def PaintScale(self, painter, at_x, at_y):
- n, lo, hi, width = self.ScaleDimensions()
- if not width:
- return
- painter.drawLine(at_x, at_y, at_x + width, at_y)
- self.PaintMarks(painter, at_y, lo, hi, n, 0)
-
- def ScaleWidth(self):
- n, lo, hi, width = self.ScaleDimensions()
- return width
-
- def ScaleHeight(self):
- return self.height
-
- def ScaleUnit(self):
- return self.Step() * 10
-
-# Scale graphics item base class
-
-class ScaleGraphicsItem(QGraphicsItem):
-
- def __init__(self, axis, parent=None):
- super(ScaleGraphicsItem, self).__init__(parent)
- self.axis = axis
-
- def boundingRect(self):
- scale_width = self.axis.ScaleWidth()
- if not scale_width:
- return QRectF()
- return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())
-
- def paint(self, painter, option, widget):
- scale_width = self.axis.ScaleWidth()
- if not scale_width:
- return
- self.axis.PaintScale(painter, 0, 5)
- x = scale_width + 4
- painter.drawText(QPointF(x, 10), self.Text())
-
- def Unit(self):
- return self.axis.ScaleUnit()
-
- def Text(self):
- return ""
-
-# Switch graph scale graphics item
-
-class SwitchScaleGraphicsItem(ScaleGraphicsItem):
-
- def __init__(self, axis, parent=None):
- super(SwitchScaleGraphicsItem, self).__init__(axis, parent)
-
- def Text(self):
- unit = self.Unit()
- if unit >= 1000000000:
- unit = int(unit / 1000000000)
- us = "s"
- elif unit >= 1000000:
- unit = int(unit / 1000000)
- us = "ms"
- elif unit >= 1000:
- unit = int(unit / 1000)
- us = "us"
- else:
- unit = int(unit)
- us = "ns"
- return " = " + str(unit) + " " + us
-
-# Switch graph graphics item contains graph title, scale, x/y-axis, and the graphed data
-
-class SwitchGraphGraphicsItem(QGraphicsItem):
-
- def __init__(self, collection, data, attrs, event_handler, first, parent=None):
- super(SwitchGraphGraphicsItem, self).__init__(parent)
- self.collection = collection
- self.data = data
- self.attrs = attrs
- self.event_handler = event_handler
-
- margin = 20
- title_width = 50
-
- self.title_graphics = QGraphicsSimpleTextItem(data.title, self)
-
- self.title_graphics.setPos(margin, margin)
- graph_width = attrs.XToPixel(attrs.subrange.x.hi) + 1
- graph_height = attrs.YToPixel(attrs.subrange.y.hi) + 1
-
- self.graph_origin_x = margin + title_width + margin
- self.graph_origin_y = graph_height + margin
-
- x_axis_size = 1
- y_axis_size = 1
- self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)
-
- self.x_axis = XAxisGraphicsItem(graph_width, self)
- self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)
-
- if first:
- self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
- self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)
-
- self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)
-
- self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
- self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)
-
- self.width = self.graph_origin_x + graph_width + margin
- self.height = self.graph_origin_y + margin
-
- self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, self)
- self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)
-
- if parent and 'EnableRubberBand' in dir(parent):
- parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)
-
- def boundingRect(self):
- return QRectF(0, 0, self.width, self.height)
-
- def paint(self, painter, option, widget):
- pass
-
- def RBXToPixel(self, x):
- return self.attrs.PixelToX(x - self.graph_origin_x)
-
- def RBXRangeToPixel(self, x0, x1):
- return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))
-
- def RBPixelToTime(self, x):
- if x < self.data.points[0].x:
- return self.data.XToData(0)
- return self.data.XToData(x)
-
- def RBEventTimes(self, x0, x1):
- x0, x1 = self.RBXRangeToPixel(x0, x1)
- time_from = self.RBPixelToTime(x0)
- time_to = self.RBPixelToTime(x1)
- return (time_from, time_to)
-
- def RBEvent(self, x0, x1):
- time_from, time_to = self.RBEventTimes(x0, x1)
- self.event_handler.RangeEvent(time_from, time_to)
-
- def RBMoveEvent(self, x0, x1):
- if x1 < x0:
- x0, x1 = x1, x0
- self.RBEvent(x0, x1)
-
- def RBReleaseEvent(self, x0, x1, selection_state):
- if x1 < x0:
- x0, x1 = x1, x0
- x0, x1 = self.RBXRangeToPixel(x0, x1)
- self.event_handler.SelectEvent(x0, x1, selection_state)
-
-# Graphics item to draw a vertical bracket (used to highlight "forward" sub-range)
-
-class VerticalBracketGraphicsItem(QGraphicsItem):
-
- def __init__(self, parent=None):
- super(VerticalBracketGraphicsItem, self).__init__(parent)
-
- self.width = 0
- self.height = 0
- self.hide()
-
- def SetSize(self, width, height):
- self.width = width + 1
- self.height = height + 1
-
- def boundingRect(self):
- return QRectF(0, 0, self.width, self.height)
-
- def paint(self, painter, option, widget):
- colour = QColor(255, 255, 0, 32)
- painter.fillRect(0, 0, self.width, self.height, colour)
- x1 = self.width - 1
- y1 = self.height - 1
- painter.drawLine(0, 0, x1, 0)
- painter.drawLine(0, 0, 0, 3)
- painter.drawLine(x1, 0, x1, 3)
- painter.drawLine(0, y1, x1, y1)
- painter.drawLine(0, y1, 0, y1 - 3)
- painter.drawLine(x1, y1, x1, y1 - 3)
-
-# Graphics item to contain graphs arranged vertically
-
-class VertcalGraphSetGraphicsItem(QGraphicsItem):
-
- def __init__(self, collection, attrs, event_handler, child_class, parent=None):
- super(VertcalGraphSetGraphicsItem, self).__init__(parent)
-
- self.collection = collection
-
- self.top = 10
-
- self.width = 0
- self.height = self.top
-
- self.rubber_band = None
- self.rb_enabled = False
-
- first = True
- for data in collection.data:
- child = child_class(collection, data, attrs, event_handler, first, self)
- child.setPos(0, self.height + 1)
- rect = child.boundingRect()
- if rect.right() > self.width:
- self.width = rect.right()
- self.height = self.height + rect.bottom() + 1
- first = False
-
- self.bracket = VerticalBracketGraphicsItem(self)
-
- def EnableRubberBand(self, xlo, xhi, rb_event_handler):
- if self.rb_enabled:
- return
- self.rb_enabled = True
- self.rb_in_view = False
- self.setAcceptedMouseButtons(Qt.LeftButton)
- self.rb_xlo = xlo
- self.rb_xhi = xhi
- self.rb_event_handler = rb_event_handler
- self.mousePressEvent = self.MousePressEvent
- self.mouseMoveEvent = self.MouseMoveEvent
- self.mouseReleaseEvent = self.MouseReleaseEvent
-
- def boundingRect(self):
- return QRectF(0, 0, self.width, self.height)
-
- def paint(self, painter, option, widget):
- pass
-
- def RubberBandParent(self):
- scene = self.scene()
- view = scene.views()[0]
- viewport = view.viewport()
- return viewport
-
- def RubberBandSetGeometry(self, rect):
- scene_rectf = self.mapRectToScene(QRectF(rect))
- scene = self.scene()
- view = scene.views()[0]
- poly = view.mapFromScene(scene_rectf)
- self.rubber_band.setGeometry(poly.boundingRect())
-
- def SetSelection(self, selection_state):
- if self.rubber_band:
- if selection_state:
- self.RubberBandSetGeometry(selection_state)
- self.rubber_band.show()
- else:
- self.rubber_band.hide()
-
- def SetBracket(self, rect):
- if rect:
- x, y, width, height = rect.x(), rect.y(), rect.width(), rect.height()
- self.bracket.setPos(x, y)
- self.bracket.SetSize(width, height)
- self.bracket.show()
- else:
- self.bracket.hide()
-
- def RubberBandX(self, event):
- x = event.pos().toPoint().x()
- if x < self.rb_xlo:
- x = self.rb_xlo
- elif x > self.rb_xhi:
- x = self.rb_xhi
- else:
- self.rb_in_view = True
- return x
-
- def RubberBandRect(self, x):
- if self.rb_origin.x() <= x:
- width = x - self.rb_origin.x()
- rect = QRect(self.rb_origin, QSize(width, self.height))
- else:
- width = self.rb_origin.x() - x
- top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
- rect = QRect(top_left, QSize(width, self.height))
- return rect
-
- def MousePressEvent(self, event):
- self.rb_in_view = False
- x = self.RubberBandX(event)
- self.rb_origin = QPoint(x, self.top)
- if self.rubber_band is None:
- self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
- self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
- if self.rb_in_view:
- self.rubber_band.show()
- self.rb_event_handler.RBMoveEvent(x, x)
- else:
- self.rubber_band.hide()
-
- def MouseMoveEvent(self, event):
- x = self.RubberBandX(event)
- rect = self.RubberBandRect(x)
- self.RubberBandSetGeometry(rect)
- if self.rb_in_view:
- self.rubber_band.show()
- self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)
-
- def MouseReleaseEvent(self, event):
- x = self.RubberBandX(event)
- if self.rb_in_view:
- selection_state = self.RubberBandRect(x)
- else:
- selection_state = None
- self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)
-
-# Switch graph legend data model
-
-class SwitchGraphLegendModel(QAbstractTableModel):
-
- def __init__(self, collection, region_attributes, parent=None):
- super(SwitchGraphLegendModel, self).__init__(parent)
-
- self.region_attributes = region_attributes
-
- self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
- self.child_count = len(self.child_items)
-
- self.highlight_set = set()
-
- self.column_headers = ("pid", "tid", "comm")
-
- def rowCount(self, parent):
- return self.child_count
-
- def headerData(self, section, orientation, role):
- if role != Qt.DisplayRole:
- return None
- if orientation != Qt.Horizontal:
- return None
- return self.columnHeader(section)
-
- def index(self, row, column, parent):
- return self.createIndex(row, column, self.child_items[row])
-
- def columnCount(self, parent=None):
- return len(self.column_headers)
-
- def columnHeader(self, column):
- return self.column_headers[column]
-
- def data(self, index, role):
- if role == Qt.BackgroundRole:
- child = self.child_items[index.row()]
- if child in self.highlight_set:
- return self.region_attributes[child.key].colour
- return None
- if role == Qt.ForegroundRole:
- child = self.child_items[index.row()]
- if child in self.highlight_set:
- return QColor(255, 255, 255)
- return self.region_attributes[child.key].colour
- if role != Qt.DisplayRole:
- return None
- hregion = self.child_items[index.row()]
- col = index.column()
- if col == 0:
- return hregion.pid
- if col == 1:
- return hregion.tid
- if col == 2:
- return hregion.comm
- return None
-
- def SetHighlight(self, row, set_highlight):
- child = self.child_items[row]
- top_left = self.createIndex(row, 0, child)
- bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
- self.dataChanged.emit(top_left, bottom_right)
-
- def Highlight(self, highlight_set):
- for row in xrange(self.child_count):
- child = self.child_items[row]
- if child in self.highlight_set:
- if child not in highlight_set:
- self.SetHighlight(row, False)
- elif child in highlight_set:
- self.SetHighlight(row, True)
- self.highlight_set = highlight_set
-
-# Switch graph legend is a table
-
-class SwitchGraphLegend(QWidget):
-
- def __init__(self, collection, region_attributes, parent=None):
- super(SwitchGraphLegend, self).__init__(parent)
-
- self.data_model = SwitchGraphLegendModel(collection, region_attributes)
-
- self.model = QSortFilterProxyModel()
- self.model.setSourceModel(self.data_model)
-
- self.view = QTableView()
- self.view.setModel(self.model)
- self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
- self.view.verticalHeader().setVisible(False)
- self.view.sortByColumn(-1, Qt.AscendingOrder)
- self.view.setSortingEnabled(True)
- self.view.resizeColumnsToContents()
- self.view.resizeRowsToContents()
-
- self.vbox = VBoxLayout(self.view)
- self.setLayout(self.vbox)
-
- sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
- sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
- self.saved_size = sz1
-
- def resizeEvent(self, event):
- self.saved_size = self.size().width()
- super(SwitchGraphLegend, self).resizeEvent(event)
-
- def Highlight(self, highlight_set):
- self.data_model.Highlight(highlight_set)
- self.update()
-
- def changeEvent(self, event):
- if event.type() == QEvent.FontChange:
- self.view.resizeRowsToContents()
- self.view.resizeColumnsToContents()
- # Need to resize rows again after column resize
- self.view.resizeRowsToContents()
- super(SwitchGraphLegend, self).changeEvent(event)
-
-# Random colour generation
-
-def RGBColourTooLight(r, g, b):
- if g > 230:
- return True
- if g <= 160:
- return False
- if r <= 180 and g <= 180:
- return False
- if r < 60:
- return False
- return True
-
-def GenerateColours(x):
- cs = [0]
- for i in xrange(1, x):
- cs.append(int((255.0 / i) + 0.5))
- colours = []
- for r in cs:
- for g in cs:
- for b in cs:
- # Exclude black and colours that look too light against a white background
- if (r, g, b) == (0, 0, 0) or RGBColourTooLight(r, g, b):
- continue
- colours.append(QColor(r, g, b))
- return colours
-
-def GenerateNColours(n):
- for x in xrange(2, n + 2):
- colours = GenerateColours(x)
- if len(colours) >= n:
- return colours
- return []
-
-def GenerateNRandomColours(n, seed):
- colours = GenerateNColours(n)
- random.seed(seed)
- random.shuffle(colours)
- return colours
-
-# Graph attributes, in particular the scale and subrange that change when zooming
-
-class GraphAttributes():
-
- def __init__(self, scale, subrange, region_attributes, dp):
- self.scale = scale
- self.subrange = subrange
- self.region_attributes = region_attributes
- # Rounding avoids errors due to finite floating point precision
- self.dp = dp # data decimal places
- self.Update()
-
- def XToPixel(self, x):
- return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))
-
- def YToPixel(self, y):
- return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))
-
- def PixelToXRounded(self, px):
- return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo
-
- def PixelToYRounded(self, py):
- return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo
-
- def PixelToX(self, px):
- x = self.PixelToXRounded(px)
- if self.pdp.x == 0:
- rt = self.XToPixel(x)
- if rt > px:
- return x - 1
- return x
-
- def PixelToY(self, py):
- y = self.PixelToYRounded(py)
- if self.pdp.y == 0:
- rt = self.YToPixel(y)
- if rt > py:
- return y - 1
- return y
-
- def ToPDP(self, dp, scale):
- # Calculate pixel decimal places:
- # (10 ** dp) is the minimum delta in the data
- # scale it to get the minimum delta in pixels
- # log10 gives the number of decimals places negatively
- # subtrace 1 to divide by 10
- # round to the lower negative number
- # change the sign to get the number of decimals positively
- x = math.log10((10 ** dp) * scale)
- if x < 0:
- x -= 1
- x = -int(math.floor(x) - 0.1)
- else:
- x = 0
- return x
-
- def Update(self):
- x = self.ToPDP(self.dp.x, self.scale.x)
- y = self.ToPDP(self.dp.y, self.scale.y)
- self.pdp = XY(x, y) # pixel decimal places
-
-# Switch graph splitter which divides the CPU graphs from the legend
-
-class SwitchGraphSplitter(QSplitter):
-
- def __init__(self, parent=None):
- super(SwitchGraphSplitter, self).__init__(parent)
-
- self.first_time = False
-
- def resizeEvent(self, ev):
- if self.first_time:
- self.first_time = False
- sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).view.columnWidth(2) + 2
- sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
- sz0 = self.size().width() - self.handleWidth() - sz1
- self.setSizes([sz0, sz1])
- elif not(self.widget(1).saved_size is None):
- sz1 = self.widget(1).saved_size
- sz0 = self.size().width() - self.handleWidth() - sz1
- self.setSizes([sz0, sz1])
- super(SwitchGraphSplitter, self).resizeEvent(ev)
-
-# Graph widget base class
-
-class GraphWidget(QWidget):
-
- graph_title_changed = Signal(object)
-
- def __init__(self, parent=None):
- super(GraphWidget, self).__init__(parent)
-
- def GraphTitleChanged(self, title):
- self.graph_title_changed.emit(title)
-
- def Title(self):
- return ""
-
-# Display time in s, ms, us or ns
-
-def ToTimeStr(val):
- val = Decimal(val)
- if val >= 1000000000:
- return "{} s".format((val / 1000000000).quantize(Decimal("0.000000001")))
- if val >= 1000000:
- return "{} ms".format((val / 1000000).quantize(Decimal("0.000001")))
- if val >= 1000:
- return "{} us".format((val / 1000).quantize(Decimal("0.001")))
- return "{} ns".format(val.quantize(Decimal("1")))
-
-# Switch (i.e. context switch i.e. Time Chart by CPU) graph widget which contains the CPU graphs and the legend and control buttons
-
-class SwitchGraphWidget(GraphWidget):
-
- def __init__(self, glb, collection, parent=None):
- super(SwitchGraphWidget, self).__init__(parent)
-
- self.glb = glb
- self.collection = collection
-
- self.back_state = []
- self.forward_state = []
- self.selection_state = (None, None)
- self.fwd_rect = None
- self.start_time = self.glb.StartTime(collection.machine_id)
-
- i = 0
- hregions = collection.hregions.values()
- colours = GenerateNRandomColours(len(hregions), 1013)
- region_attributes = {}
- for hregion in hregions:
- if hregion.pid == 0 and hregion.tid == 0:
- region_attributes[hregion.key] = GraphRegionAttribute(QColor(0, 0, 0))
- else:
- region_attributes[hregion.key] = GraphRegionAttribute(colours[i])
- i = i + 1
-
- # Default to entire range
- xsubrange = Subrange(0.0, float(collection.xrangehi - collection.xrangelo) + 1.0)
- ysubrange = Subrange(0.0, float(collection.yrangehi - collection.yrangelo) + 1.0)
- subrange = XY(xsubrange, ysubrange)
-
- scale = self.GetScaleForRange(subrange)
-
- self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)
-
- self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)
-
- self.scene = QGraphicsScene()
- self.scene.addItem(self.item)
-
- self.view = QGraphicsView(self.scene)
- self.view.centerOn(0, 0)
- self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
-
- self.legend = SwitchGraphLegend(collection, region_attributes)
-
- self.splitter = SwitchGraphSplitter()
- self.splitter.addWidget(self.view)
- self.splitter.addWidget(self.legend)
-
- self.point_label = QLabel("")
- self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
-
- self.back_button = QToolButton()
- self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
- self.back_button.setDisabled(True)
- self.back_button.released.connect(lambda: self.Back())
-
- self.forward_button = QToolButton()
- self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
- self.forward_button.setDisabled(True)
- self.forward_button.released.connect(lambda: self.Forward())
-
- self.zoom_button = QToolButton()
- self.zoom_button.setText("Zoom")
- self.zoom_button.setDisabled(True)
- self.zoom_button.released.connect(lambda: self.Zoom())
-
- self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)
-
- self.vbox = VBoxLayout(self.splitter, self.hbox)
-
- self.setLayout(self.vbox)
-
- def GetScaleForRangeX(self, xsubrange):
- # Default graph 1000 pixels wide
- dflt = 1000.0
- r = xsubrange.hi - xsubrange.lo
- return dflt / r
-
- def GetScaleForRangeY(self, ysubrange):
- # Default graph 50 pixels high
- dflt = 50.0
- r = ysubrange.hi - ysubrange.lo
- return dflt / r
-
- def GetScaleForRange(self, subrange):
- # Default graph 1000 pixels wide, 50 pixels high
- xscale = self.GetScaleForRangeX(subrange.x)
- yscale = self.GetScaleForRangeY(subrange.y)
- return XY(xscale, yscale)
-
- def PointEvent(self, cpu, time_from, time_to, hregions):
- text = "CPU: " + str(cpu)
- time_from = time_from.quantize(Decimal(1))
- rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
- text = text + " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ")"
- self.point_label.setText(text)
- self.legend.Highlight(hregions)
-
- def RightClickEvent(self, cpu, hregion_times, pos):
- if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
- return
- menu = QMenu(self.view)
- for hregion, time in hregion_times:
- thread_at_time = (hregion.exec_comm_id, hregion.thread_id, time)
- menu_text = "Show Call Tree for {} {}:{} at {}".format(hregion.comm, hregion.pid, hregion.tid, time)
- menu.addAction(CreateAction(menu_text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view))
- menu.exec_(pos)
-
- def RightClickSelect(self, args):
- CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)
-
- def NoPointEvent(self):
- self.point_label.setText("")
- self.legend.Highlight({})
-
- def RangeEvent(self, time_from, time_to):
- time_from = time_from.quantize(Decimal(1))
- time_to = time_to.quantize(Decimal(1))
- if time_to <= time_from:
- self.point_label.setText("")
- return
- rel_time_from = time_from - self.start_time
- rel_time_to = time_to - self.start_time
- text = " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ") to: " + str(time_to) + " (+" + ToTimeStr(rel_time_to) + ")"
- text = text + " duration: " + ToTimeStr(time_to - time_from)
- self.point_label.setText(text)
-
- def BackState(self):
- return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)
-
- def PushBackState(self):
- state = copy.deepcopy(self.BackState())
- self.back_state.append(state)
- self.back_button.setEnabled(True)
-
- def PopBackState(self):
- self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
- self.attrs.Update()
- if not self.back_state:
- self.back_button.setDisabled(True)
-
- def PushForwardState(self):
- state = copy.deepcopy(self.BackState())
- self.forward_state.append(state)
- self.forward_button.setEnabled(True)
-
- def PopForwardState(self):
- self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.pop()
- self.attrs.Update()
- if not self.forward_state:
- self.forward_button.setDisabled(True)
-
- def Title(self):
- time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
- time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
- rel_time_from = time_from - self.start_time
- rel_time_to = time_to - self.start_time
- title = "+" + ToTimeStr(rel_time_from) + " to +" + ToTimeStr(rel_time_to)
- title = title + " (" + ToTimeStr(time_to - time_from) + ")"
- return title
-
- def Update(self):
- selected_subrange, selection_state = self.selection_state
- self.item.SetSelection(selection_state)
- self.item.SetBracket(self.fwd_rect)
- self.zoom_button.setDisabled(selected_subrange is None)
- self.GraphTitleChanged(self.Title())
- self.item.update(self.item.boundingRect())
-
- def Back(self):
- if not self.back_state:
- return
- self.PushForwardState()
- self.PopBackState()
- self.Update()
-
- def Forward(self):
- if not self.forward_state:
- return
- self.PushBackState()
- self.PopForwardState()
- self.Update()
-
- def SelectEvent(self, x0, x1, selection_state):
- if selection_state is None:
- selected_subrange = None
- else:
- if x1 - x0 < 1.0:
- x1 += 1.0
- selected_subrange = Subrange(x0, x1)
- self.selection_state = (selected_subrange, selection_state)
- self.zoom_button.setDisabled(selected_subrange is None)
-
- def Zoom(self):
- selected_subrange, selection_state = self.selection_state
- if selected_subrange is None:
- return
- self.fwd_rect = selection_state
- self.item.SetSelection(None)
- self.PushBackState()
- self.attrs.subrange.x = selected_subrange
- self.forward_state = []
- self.forward_button.setDisabled(True)
- self.selection_state = (None, None)
- self.fwd_rect = None
- self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
- self.attrs.Update()
- self.Update()
-
-# Slow initialization - perform non-GUI initialization in a separate thread and put up a modal message box while waiting
-
-class SlowInitClass():
-
- def __init__(self, glb, title, init_fn):
- self.init_fn = init_fn
- self.done = False
- self.result = None
-
- self.msg_box = QMessageBox(glb.mainwindow)
- self.msg_box.setText("Initializing " + title + ". Please wait.")
- self.msg_box.setWindowTitle("Initializing " + title)
- self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))
-
- self.init_thread = Thread(self.ThreadFn, glb)
- self.init_thread.done.connect(lambda: self.Done(), Qt.QueuedConnection)
-
- self.init_thread.start()
-
- def Done(self):
- self.msg_box.done(0)
-
- def ThreadFn(self, glb):
- conn_name = "SlowInitClass" + str(os.getpid())
- db, dbname = glb.dbref.Open(conn_name)
- self.result = self.init_fn(db)
- self.done = True
- return (True, 0)
-
- def Result(self):
- while not self.done:
- self.msg_box.exec_()
- self.init_thread.wait()
- return self.result
-
-def SlowInit(glb, title, init_fn):
- init = SlowInitClass(glb, title, init_fn)
- return init.Result()
-
-# Time chart by CPU window
-
-class TimeChartByCPUWindow(QMdiSubWindow):
-
- def __init__(self, glb, parent=None):
- super(TimeChartByCPUWindow, self).__init__(parent)
-
- self.glb = glb
- self.machine_id = glb.HostMachineId()
- self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)
-
- collection = LookupModel(self.collection_name)
- if collection is None:
- collection = SlowInit(glb, "Time Chart", self.Init)
-
- self.widget = SwitchGraphWidget(glb, collection, self)
- self.view = self.widget
-
- self.base_title = "Time Chart by CPU"
- self.setWindowTitle(self.base_title + self.widget.Title())
- self.widget.graph_title_changed.connect(self.GraphTitleChanged)
-
- self.setWidget(self.widget)
-
- AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())
-
- def Init(self, db):
- return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, self.machine_id))
-
- def GraphTitleChanged(self, title):
- self.setWindowTitle(self.base_title + " : " + title)
-
-# Child data item finder
-
-class ChildDataItemFinder():
-
- def __init__(self, root):
- self.root = root
- self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
- self.rows = []
- self.pos = 0
-
- def FindSelect(self):
- self.rows = []
- if self.pattern:
- pattern = re.compile(self.value)
- for child in self.root.child_items:
- for column_data in child.data:
- if re.search(pattern, str(column_data)) is not None:
- self.rows.append(child.row)
- break
- else:
- for child in self.root.child_items:
- for column_data in child.data:
- if self.value in str(column_data):
- self.rows.append(child.row)
- break
-
- def FindValue(self):
- self.pos = 0
- if self.last_value != self.value or self.pattern != self.last_pattern:
- self.FindSelect()
- if not len(self.rows):
- return -1
- return self.rows[self.pos]
-
- def FindThread(self):
- if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
- row = self.FindValue()
- elif len(self.rows):
- if self.direction > 0:
- self.pos += 1
- if self.pos >= len(self.rows):
- self.pos = 0
- else:
- self.pos -= 1
- if self.pos < 0:
- self.pos = len(self.rows) - 1
- row = self.rows[self.pos]
- else:
- row = -1
- return (True, row)
-
- def Find(self, value, direction, pattern, context, callback):
- self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern)
- # Use a thread so the UI is not blocked
- thread = Thread(self.FindThread)
- thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection)
- thread.start()
-
- def FindDone(self, thread, callback, row):
- callback(row)
-
-# Number of database records to fetch in one go
-
-glb_chunk_sz = 10000
-
-# Background process for SQL data fetcher
-
-class SQLFetcherProcess():
-
- def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep):
- # Need a unique connection name
- conn_name = "SQLFetcher" + str(os.getpid())
- self.db, dbname = dbref.Open(conn_name)
- self.sql = sql
- self.buffer = buffer
- self.head = head
- self.tail = tail
- self.fetch_count = fetch_count
- self.fetching_done = fetching_done
- self.process_target = process_target
- self.wait_event = wait_event
- self.fetched_event = fetched_event
- self.prep = prep
- self.query = QSqlQuery(self.db)
- self.query_limit = 0 if "$$last_id$$" in sql else 2
- self.last_id = -1
- self.fetched = 0
- self.more = True
- self.local_head = self.head.value
- self.local_tail = self.tail.value
-
- def Select(self):
- if self.query_limit:
- if self.query_limit == 1:
- return
- self.query_limit -= 1
- stmt = self.sql.replace("$$last_id$$", str(self.last_id))
- QueryExec(self.query, stmt)
-
- def Next(self):
- if not self.query.next():
- self.Select()
- if not self.query.next():
- return None
- self.last_id = self.query.value(0)
- return self.prep(self.query)
-
- def WaitForTarget(self):
- while True:
- self.wait_event.clear()
- target = self.process_target.value
- if target > self.fetched or target < 0:
- break
- self.wait_event.wait()
- return target
-
- def HasSpace(self, sz):
- if self.local_tail <= self.local_head:
- space = len(self.buffer) - self.local_head
- if space > sz:
- return True
- if space >= glb_nsz:
- # Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer
- nd = pickle.dumps(0, pickle.HIGHEST_PROTOCOL)
- self.buffer[self.local_head : self.local_head + len(nd)] = nd
- self.local_head = 0
- if self.local_tail - self.local_head > sz:
- return True
- return False
-
- def WaitForSpace(self, sz):
- if self.HasSpace(sz):
- return
- while True:
- self.wait_event.clear()
- self.local_tail = self.tail.value
- if self.HasSpace(sz):
- return
- self.wait_event.wait()
-
- def AddToBuffer(self, obj):
- d = pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
- n = len(d)
- nd = pickle.dumps(n, pickle.HIGHEST_PROTOCOL)
- sz = n + glb_nsz
- self.WaitForSpace(sz)
- pos = self.local_head
- self.buffer[pos : pos + len(nd)] = nd
- self.buffer[pos + glb_nsz : pos + sz] = d
- self.local_head += sz
-
- def FetchBatch(self, batch_size):
- fetched = 0
- while batch_size > fetched:
- obj = self.Next()
- if obj is None:
- self.more = False
- break
- self.AddToBuffer(obj)
- fetched += 1
- if fetched:
- self.fetched += fetched
- with self.fetch_count.get_lock():
- self.fetch_count.value += fetched
- self.head.value = self.local_head
- self.fetched_event.set()
-
- def Run(self):
- while self.more:
- target = self.WaitForTarget()
- if target < 0:
- break
- batch_size = min(glb_chunk_sz, target - self.fetched)
- self.FetchBatch(batch_size)
- self.fetching_done.value = True
- self.fetched_event.set()
-
-def SQLFetcherFn(*x):
- process = SQLFetcherProcess(*x)
- process.Run()
-
-# SQL data fetcher
-
-class SQLFetcher(QObject):
-
- done = Signal(object)
-
- def __init__(self, glb, sql, prep, process_data, parent=None):
- super(SQLFetcher, self).__init__(parent)
- self.process_data = process_data
- self.more = True
- self.target = 0
- self.last_target = 0
- self.fetched = 0
- self.buffer_size = 16 * 1024 * 1024
- self.buffer = Array(c_char, self.buffer_size, lock=False)
- self.head = Value(c_longlong)
- self.tail = Value(c_longlong)
- self.local_tail = 0
- self.fetch_count = Value(c_longlong)
- self.fetching_done = Value(c_bool)
- self.last_count = 0
- self.process_target = Value(c_longlong)
- self.wait_event = Event()
- self.fetched_event = Event()
- glb.AddInstanceToShutdownOnExit(self)
- self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tail, self.fetch_count, self.fetching_done, self.process_target, self.wait_event, self.fetched_event, prep))
- self.process.start()
- self.thread = Thread(self.Thread)
- self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
- self.thread.start()
-
- def Shutdown(self):
- # Tell the thread and process to exit
- self.process_target.value = -1
- self.wait_event.set()
- self.more = False
- self.fetching_done.value = True
- self.fetched_event.set()
-
- def Thread(self):
- if not self.more:
- return True, 0
- while True:
- self.fetched_event.clear()
- fetch_count = self.fetch_count.value
- if fetch_count != self.last_count:
- break
- if self.fetching_done.value:
- self.more = False
- return True, 0
- self.fetched_event.wait()
- count = fetch_count - self.last_count
- self.last_count = fetch_count
- self.fetched += count
- return False, count
-
- def Fetch(self, nr):
- if not self.more:
- # -1 inidcates there are no more
- return -1
- result = self.fetched
- extra = result + nr - self.target
- if extra > 0:
- self.target += extra
- # process_target < 0 indicates shutting down
- if self.process_target.value >= 0:
- self.process_target.value = self.target
- self.wait_event.set()
- return result
-
- def RemoveFromBuffer(self):
- pos = self.local_tail
- if len(self.buffer) - pos < glb_nsz:
- pos = 0
- n = pickle.loads(self.buffer[pos : pos + glb_nsz])
- if n == 0:
- pos = 0
- n = pickle.loads(self.buffer[0 : glb_nsz])
- pos += glb_nsz
- obj = pickle.loads(self.buffer[pos : pos + n])
- self.local_tail = pos + n
- return obj
-
- def ProcessData(self, count):
- for i in xrange(count):
- obj = self.RemoveFromBuffer()
- self.process_data(obj)
- self.tail.value = self.local_tail
- self.wait_event.set()
- self.done.emit(count)
-
-# Fetch more records bar
-
-class FetchMoreRecordsBar():
-
- def __init__(self, model, parent):
- self.model = model
-
- self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
- self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
- self.fetch_count = QSpinBox()
- self.fetch_count.setRange(1, 1000000)
- self.fetch_count.setValue(10)
- self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
- self.fetch = QPushButton("Go!")
- self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
- self.fetch.released.connect(self.FetchMoreRecords)
-
- self.progress = QProgressBar()
- self.progress.setRange(0, 100)
- self.progress.hide()
-
- self.done_label = QLabel("All records fetched")
- self.done_label.hide()
-
- self.spacer = QLabel("")
-
- self.close_button = QToolButton()
- self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
- self.close_button.released.connect(self.Deactivate)
-
- self.hbox = QHBoxLayout()
- self.hbox.setContentsMargins(0, 0, 0, 0)
-
- self.hbox.addWidget(self.label)
- self.hbox.addWidget(self.fetch_count)
- self.hbox.addWidget(self.fetch)
- self.hbox.addWidget(self.spacer)
- self.hbox.addWidget(self.progress)
- self.hbox.addWidget(self.done_label)
- self.hbox.addWidget(self.close_button)
-
- self.bar = QWidget()
- self.bar.setLayout(self.hbox)
- self.bar.show()
-
- self.in_progress = False
- self.model.progress.connect(self.Progress)
-
- self.done = False
-
- if not model.HasMoreRecords():
- self.Done()
-
- def Widget(self):
- return self.bar
-
- def Activate(self):
- self.bar.show()
- self.fetch.setFocus()
-
- def Deactivate(self):
- self.bar.hide()
-
- def Enable(self, enable):
- self.fetch.setEnabled(enable)
- self.fetch_count.setEnabled(enable)
-
- def Busy(self):
- self.Enable(False)
- self.fetch.hide()
- self.spacer.hide()
- self.progress.show()
-
- def Idle(self):
- self.in_progress = False
- self.Enable(True)
- self.progress.hide()
- self.fetch.show()
- self.spacer.show()
-
- def Target(self):
- return self.fetch_count.value() * glb_chunk_sz
-
- def Done(self):
- self.done = True
- self.Idle()
- self.label.hide()
- self.fetch_count.hide()
- self.fetch.hide()
- self.spacer.hide()
- self.done_label.show()
-
- def Progress(self, count):
- if self.in_progress:
- if count:
- percent = ((count - self.start) * 100) / self.Target()
- if percent >= 100:
- self.Idle()
- else:
- self.progress.setValue(percent)
- if not count:
- # Count value of zero means no more records
- self.Done()
-
- def FetchMoreRecords(self):
- if self.done:
- return
- self.progress.setValue(0)
- self.Busy()
- self.in_progress = True
- self.start = self.model.FetchMoreRecords(self.Target())
-
-# Brance data model level two item
-
-class BranchLevelTwoItem():
-
- def __init__(self, row, col, text, parent_item):
- self.row = row
- self.parent_item = parent_item
- self.data = [""] * (col + 1)
- self.data[col] = text
- self.level = 2
-
- def getParentItem(self):
- return self.parent_item
-
- def getRow(self):
- return self.row
-
- def childCount(self):
- return 0
-
- def hasChildren(self):
- return False
-
- def getData(self, column):
- return self.data[column]
-
-# Brance data model level one item
-
-class BranchLevelOneItem():
-
- def __init__(self, glb, row, data, parent_item):
- self.glb = glb
- self.row = row
- self.parent_item = parent_item
- self.child_count = 0
- self.child_items = []
- self.data = data[1:]
- self.dbid = data[0]
- self.level = 1
- self.query_done = False
- self.br_col = len(self.data) - 1
-
- def getChildItem(self, row):
- return self.child_items[row]
-
- def getParentItem(self):
- return self.parent_item
-
- def getRow(self):
- return self.row
-
- def Select(self):
- self.query_done = True
-
- if not self.glb.have_disassembler:
- return
-
- query = QSqlQuery(self.glb.db)
-
- QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip"
- " FROM samples"
- " INNER JOIN dsos ON samples.to_dso_id = dsos.id"
- " INNER JOIN symbols ON samples.to_symbol_id = symbols.id"
- " WHERE samples.id = " + str(self.dbid))
- if not query.next():
- return
- cpu = query.value(0)
- dso = query.value(1)
- sym = query.value(2)
- if dso == 0 or sym == 0:
- return
- off = query.value(3)
- short_name = query.value(4)
- long_name = query.value(5)
- build_id = query.value(6)
- sym_start = query.value(7)
- ip = query.value(8)
-
- QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start"
- " FROM samples"
- " INNER JOIN symbols ON samples.symbol_id = symbols.id"
- " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
- " ORDER BY samples.id"
- " LIMIT 1")
- if not query.next():
- return
- if query.value(0) != dso:
- # Cannot disassemble from one dso to another
- return
- bsym = query.value(1)
- boff = query.value(2)
- bsym_start = query.value(3)
- if bsym == 0:
- return
- tot = bsym_start + boff + 1 - sym_start - off
- if tot <= 0 or tot > 16384:
- return
-
- inst = self.glb.disassembler.Instruction()
- f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
- if not f:
- return
- mode = 0 if Is64Bit(f) else 1
- self.glb.disassembler.SetMode(inst, mode)
-
- buf_sz = tot + 16
- buf = create_string_buffer(tot + 16)
- f.seek(sym_start + off)
- buf.value = f.read(buf_sz)
- buf_ptr = addressof(buf)
- i = 0
- while tot > 0:
- cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
- if cnt:
- byte_str = tohex(ip).rjust(16)
- for k in xrange(cnt):
- byte_str += " %02x" % ord(buf[i])
- i += 1
- while k < 15:
- byte_str += " "
- k += 1
- self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
- self.child_count += 1
- else:
- return
- buf_ptr += cnt
- tot -= cnt
- buf_sz -= cnt
- ip += cnt
-
- def childCount(self):
- if not self.query_done:
- self.Select()
- if not self.child_count:
- return -1
- return self.child_count
-
- def hasChildren(self):
- if not self.query_done:
- return True
- return self.child_count > 0
-
- def getData(self, column):
- return self.data[column]
-
-# Brance data model root item
-
-class BranchRootItem():
-
- def __init__(self):
- self.child_count = 0
- self.child_items = []
- self.level = 0
-
- def getChildItem(self, row):
- return self.child_items[row]
-
- def getParentItem(self):
- return None
-
- def getRow(self):
- return 0
-
- def childCount(self):
- return self.child_count
-
- def hasChildren(self):
- return self.child_count > 0
-
- def getData(self, column):
- return ""
-
-# Calculate instructions per cycle
-
-def CalcIPC(cyc_cnt, insn_cnt):
- if cyc_cnt and insn_cnt:
- ipc = Decimal(float(insn_cnt) / cyc_cnt)
- ipc = str(ipc.quantize(Decimal(".01"), rounding=ROUND_HALF_UP))
- else:
- ipc = "0"
- return ipc
-
-# Branch data preparation
-
-def BranchDataPrepBr(query, data):
- data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) +
- " (" + dsoname(query.value(11)) + ")" + " -> " +
- tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) +
- " (" + dsoname(query.value(15)) + ")")
-
-def BranchDataPrepIPC(query, data):
- insn_cnt = query.value(16)
- cyc_cnt = query.value(17)
- ipc = CalcIPC(cyc_cnt, insn_cnt)
- data.append(insn_cnt)
- data.append(cyc_cnt)
- data.append(ipc)
-
-def BranchDataPrep(query):
- data = []
- for i in xrange(0, 8):
- data.append(query.value(i))
- BranchDataPrepBr(query, data)
- return data
-
-def BranchDataPrepWA(query):
- data = []
- data.append(query.value(0))
- # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
- data.append("{:>19}".format(query.value(1)))
- for i in xrange(2, 8):
- data.append(query.value(i))
- BranchDataPrepBr(query, data)
- return data
-
-def BranchDataWithIPCPrep(query):
- data = []
- for i in xrange(0, 8):
- data.append(query.value(i))
- BranchDataPrepIPC(query, data)
- BranchDataPrepBr(query, data)
- return data
-
-def BranchDataWithIPCPrepWA(query):
- data = []
- data.append(query.value(0))
- # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
- data.append("{:>19}".format(query.value(1)))
- for i in xrange(2, 8):
- data.append(query.value(i))
- BranchDataPrepIPC(query, data)
- BranchDataPrepBr(query, data)
- return data
-
-# Branch data model
-
-class BranchModel(TreeModel):
-
- progress = Signal(object)
-
- def __init__(self, glb, event_id, where_clause, parent=None):
- super(BranchModel, self).__init__(glb, None, parent)
- self.event_id = event_id
- self.more = True
- self.populated = 0
- self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
- if self.have_ipc:
- select_ipc = ", insn_count, cyc_count"
- prep_fn = BranchDataWithIPCPrep
- prep_wa_fn = BranchDataWithIPCPrepWA
- else:
- select_ipc = ""
- prep_fn = BranchDataPrep
- prep_wa_fn = BranchDataPrepWA
- sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name,"
- " CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END,"
- " ip, symbols.name, sym_offset, dsos.short_name,"
- " to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name"
- + select_ipc +
- " FROM samples"
- " INNER JOIN comms ON comm_id = comms.id"
- " INNER JOIN threads ON thread_id = threads.id"
- " INNER JOIN branch_types ON branch_type = branch_types.id"
- " INNER JOIN symbols ON symbol_id = symbols.id"
- " INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id"
- " INNER JOIN dsos ON samples.dso_id = dsos.id"
- " INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id"
- " WHERE samples.id > $$last_id$$" + where_clause +
- " AND evsel_id = " + str(self.event_id) +
- " ORDER BY samples.id"
- " LIMIT " + str(glb_chunk_sz))
- if pyside_version_1 and sys.version_info[0] == 3:
- prep = prep_fn
- else:
- prep = prep_wa_fn
- self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
- self.fetcher.done.connect(self.Update)
- self.fetcher.Fetch(glb_chunk_sz)
-
- def GetRoot(self):
- return BranchRootItem()
-
- def columnCount(self, parent=None):
- if self.have_ipc:
- return 11
- else:
- return 8
-
- def columnHeader(self, column):
- if self.have_ipc:
- return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Insn Cnt", "Cyc Cnt", "IPC", "Branch")[column]
- else:
- return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column]
-
- def columnFont(self, column):
- if self.have_ipc:
- br_col = 10
- else:
- br_col = 7
- if column != br_col:
- return None
- return QFont("Monospace")
-
- def DisplayData(self, item, index):
- if item.level == 1:
- self.FetchIfNeeded(item.row)
- return item.getData(index.column())
-
- def AddSample(self, data):
- child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
- self.root.child_items.append(child)
- self.populated += 1
-
- def Update(self, fetched):
- if not fetched:
- self.more = False
- self.progress.emit(0)
- child_count = self.root.child_count
- count = self.populated - child_count
- if count > 0:
- parent = QModelIndex()
- self.beginInsertRows(parent, child_count, child_count + count - 1)
- self.insertRows(child_count, count, parent)
- self.root.child_count += count
- self.endInsertRows()
- self.progress.emit(self.root.child_count)
-
- def FetchMoreRecords(self, count):
- current = self.root.child_count
- if self.more:
- self.fetcher.Fetch(count)
- else:
- self.progress.emit(0)
- return current
-
- def HasMoreRecords(self):
- return self.more
-
-# Report Variables
-
-class ReportVars():
-
- def __init__(self, name = "", where_clause = "", limit = ""):
- self.name = name
- self.where_clause = where_clause
- self.limit = limit
-
- def UniqueId(self):
- return str(self.where_clause + ";" + self.limit)
-
-# Branch window
-
-class BranchWindow(QMdiSubWindow):
-
- def __init__(self, glb, event_id, report_vars, parent=None):
- super(BranchWindow, self).__init__(parent)
-
- model_name = "Branch Events " + str(event_id) + " " + report_vars.UniqueId()
-
- self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_clause))
-
- self.view = QTreeView()
- self.view.setUniformRowHeights(True)
- self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
- self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
- self.view.setModel(self.model)
-
- self.ResizeColumnsToContents()
-
- self.context_menu = TreeContextMenu(self.view)
-
- self.find_bar = FindBar(self, self, True)
-
- self.finder = ChildDataItemFinder(self.model.root)
-
- self.fetch_bar = FetchMoreRecordsBar(self.model, self)
-
- self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
-
- self.setWidget(self.vbox.Widget())
-
- AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
-
- def ResizeColumnToContents(self, column, n):
- # Using the view's resizeColumnToContents() here is extrememly slow
- # so implement a crude alternative
- mm = "MM" if column else "MMMM"
- font = self.view.font()
- metrics = QFontMetrics(font)
- max = 0
- for row in xrange(n):
- val = self.model.root.child_items[row].data[column]
- len = metrics.width(str(val) + mm)
- max = len if len > max else max
- val = self.model.columnHeader(column)
- len = metrics.width(str(val) + mm)
- max = len if len > max else max
- self.view.setColumnWidth(column, max)
-
- def ResizeColumnsToContents(self):
- n = min(self.model.root.child_count, 100)
- if n < 1:
- # No data yet, so connect a signal to notify when there is
- self.model.rowsInserted.connect(self.UpdateColumnWidths)
- return
- columns = self.model.columnCount()
- for i in xrange(columns):
- self.ResizeColumnToContents(i, n)
-
- def UpdateColumnWidths(self, *x):
- # This only needs to be done once, so disconnect the signal now
- self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
- self.ResizeColumnsToContents()
-
- def Find(self, value, direction, pattern, context):
- self.view.setFocus()
- self.find_bar.Busy()
- self.finder.Find(value, direction, pattern, context, self.FindDone)
-
- def FindDone(self, row):
- self.find_bar.Idle()
- if row >= 0:
- self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
- else:
- self.find_bar.NotFound()
-
-# Line edit data item
-
-class LineEditDataItem(object):
-
- def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):
- self.glb = glb
- self.label = label
- self.placeholder_text = placeholder_text
- self.parent = parent
- self.id = id
-
- self.value = default
-
- self.widget = QLineEdit(default)
- self.widget.editingFinished.connect(self.Validate)
- self.widget.textChanged.connect(self.Invalidate)
- self.red = False
- self.error = ""
- self.validated = True
-
- if placeholder_text:
- self.widget.setPlaceholderText(placeholder_text)
-
- def TurnTextRed(self):
- if not self.red:
- palette = QPalette()
- palette.setColor(QPalette.Text,Qt.red)
- self.widget.setPalette(palette)
- self.red = True
-
- def TurnTextNormal(self):
- if self.red:
- palette = QPalette()
- self.widget.setPalette(palette)
- self.red = False
-
- def InvalidValue(self, value):
- self.value = ""
- self.TurnTextRed()
- self.error = self.label + " invalid value '" + value + "'"
- self.parent.ShowMessage(self.error)
-
- def Invalidate(self):
- self.validated = False
-
- def DoValidate(self, input_string):
- self.value = input_string.strip()
-
- def Validate(self):
- self.validated = True
- self.error = ""
- self.TurnTextNormal()
- self.parent.ClearMessage()
- input_string = self.widget.text()
- if not len(input_string.strip()):
- self.value = ""
- return
- self.DoValidate(input_string)
-
- def IsValid(self):
- if not self.validated:
- self.Validate()
- if len(self.error):
- self.parent.ShowMessage(self.error)
- return False
- return True
-
- def IsNumber(self, value):
- try:
- x = int(value)
- except:
- x = 0
- return str(x) == value
-
-# Non-negative integer ranges dialog data item
-
-class NonNegativeIntegerRangesDataItem(LineEditDataItem):
-
- def __init__(self, glb, label, placeholder_text, column_name, parent):
- super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
-
- self.column_name = column_name
-
- def DoValidate(self, input_string):
- singles = []
- ranges = []
- for value in [x.strip() for x in input_string.split(",")]:
- if "-" in value:
- vrange = value.split("-")
- if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
- return self.InvalidValue(value)
- ranges.append(vrange)
- else:
- if not self.IsNumber(value):
- return self.InvalidValue(value)
- singles.append(value)
- ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
- if len(singles):
- ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
- self.value = " OR ".join(ranges)
-
-# Positive integer dialog data item
-
-class PositiveIntegerDataItem(LineEditDataItem):
-
- def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):
- super(PositiveIntegerDataItem, self).__init__(glb, label, placeholder_text, parent, id, default)
-
- def DoValidate(self, input_string):
- if not self.IsNumber(input_string.strip()):
- return self.InvalidValue(input_string)
- value = int(input_string.strip())
- if value <= 0:
- return self.InvalidValue(input_string)
- self.value = str(value)
-
-# Dialog data item converted and validated using a SQL table
-
-class SQLTableDataItem(LineEditDataItem):
-
- def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_name2, parent):
- super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
-
- self.table_name = table_name
- self.match_column = match_column
- self.column_name1 = column_name1
- self.column_name2 = column_name2
-
- def ValueToIds(self, value):
- ids = []
- query = QSqlQuery(self.glb.db)
- stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
- ret = query.exec_(stmt)
- if ret:
- while query.next():
- ids.append(str(query.value(0)))
- return ids
-
- def DoValidate(self, input_string):
- all_ids = []
- for value in [x.strip() for x in input_string.split(",")]:
- ids = self.ValueToIds(value)
- if len(ids):
- all_ids.extend(ids)
- else:
- return self.InvalidValue(value)
- self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
- if self.column_name2:
- self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
-
-# Sample time ranges dialog data item converted and validated using 'samples' SQL table
-
-class SampleTimeRangesDataItem(LineEditDataItem):
-
- def __init__(self, glb, label, placeholder_text, column_name, parent):
- self.column_name = column_name
-
- self.last_id = 0
- self.first_time = 0
- self.last_time = 2 ** 64
-
- query = QSqlQuery(glb.db)
- QueryExec(query, "SELECT id, time FROM samples ORDER BY id DESC LIMIT 1")
- if query.next():
- self.last_id = int(query.value(0))
- self.first_time = int(glb.HostStartTime())
- self.last_time = int(glb.HostFinishTime())
- if placeholder_text:
- placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
-
- super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
-
- def IdBetween(self, query, lower_id, higher_id, order):
- QueryExec(query, "SELECT id FROM samples WHERE id > " + str(lower_id) + " AND id < " + str(higher_id) + " ORDER BY id " + order + " LIMIT 1")
- if query.next():
- return True, int(query.value(0))
- else:
- return False, 0
-
- def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):
- query = QSqlQuery(self.glb.db)
- while True:
- next_id = int((lower_id + higher_id) / 2)
- QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
- if not query.next():
- ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
- if not ok:
- ok, dbid = self.IdBetween(query, next_id, higher_id, "")
- if not ok:
- return str(higher_id)
- next_id = dbid
- QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
- next_time = int(query.value(0))
- if get_floor:
- if target_time > next_time:
- lower_id = next_id
- else:
- higher_id = next_id
- if higher_id <= lower_id + 1:
- return str(higher_id)
- else:
- if target_time >= next_time:
- lower_id = next_id
- else:
- higher_id = next_id
- if higher_id <= lower_id + 1:
- return str(lower_id)
-
- def ConvertRelativeTime(self, val):
- mult = 1
- suffix = val[-2:]
- if suffix == "ms":
- mult = 1000000
- elif suffix == "us":
- mult = 1000
- elif suffix == "ns":
- mult = 1
- else:
- return val
- val = val[:-2].strip()
- if not self.IsNumber(val):
- return val
- val = int(val) * mult
- if val >= 0:
- val += self.first_time
- else:
- val += self.last_time
- return str(val)
-
- def ConvertTimeRange(self, vrange):
- if vrange[0] == "":
- vrange[0] = str(self.first_time)
- if vrange[1] == "":
- vrange[1] = str(self.last_time)
- vrange[0] = self.ConvertRelativeTime(vrange[0])
- vrange[1] = self.ConvertRelativeTime(vrange[1])
- if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
- return False
- beg_range = max(int(vrange[0]), self.first_time)
- end_range = min(int(vrange[1]), self.last_time)
- if beg_range > self.last_time or end_range < self.first_time:
- return False
- vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
- vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
- return True
-
- def AddTimeRange(self, value, ranges):
- n = value.count("-")
- if n == 1:
- pass
- elif n == 2:
- if value.split("-")[1].strip() == "":
- n = 1
- elif n == 3:
- n = 2
- else:
- return False
- pos = findnth(value, "-", n)
- vrange = [value[:pos].strip() ,value[pos+1:].strip()]
- if self.ConvertTimeRange(vrange):
- ranges.append(vrange)
- return True
- return False
-
- def DoValidate(self, input_string):
- ranges = []
- for value in [x.strip() for x in input_string.split(",")]:
- if not self.AddTimeRange(value, ranges):
- return self.InvalidValue(value)
- ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
- self.value = " OR ".join(ranges)
-
-# Report Dialog Base
-
-class ReportDialogBase(QDialog):
-
- def __init__(self, glb, title, items, partial, parent=None):
- super(ReportDialogBase, self).__init__(parent)
-
- self.glb = glb
-
- self.report_vars = ReportVars()
-
- self.setWindowTitle(title)
- self.setMinimumWidth(600)
-
- self.data_items = [x(glb, self) for x in items]
-
- self.partial = partial
-
- self.grid = QGridLayout()
-
- for row in xrange(len(self.data_items)):
- self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
- self.grid.addWidget(self.data_items[row].widget, row, 1)
-
- self.status = QLabel()
-
- self.ok_button = QPushButton("Ok", self)
- self.ok_button.setDefault(True)
- self.ok_button.released.connect(self.Ok)
- self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
- self.cancel_button = QPushButton("Cancel", self)
- self.cancel_button.released.connect(self.reject)
- self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
- self.hbox = QHBoxLayout()
- #self.hbox.addStretch()
- self.hbox.addWidget(self.status)
- self.hbox.addWidget(self.ok_button)
- self.hbox.addWidget(self.cancel_button)
-
- self.vbox = QVBoxLayout()
- self.vbox.addLayout(self.grid)
- self.vbox.addLayout(self.hbox)
-
- self.setLayout(self.vbox)
-
- def Ok(self):
- vars = self.report_vars
- for d in self.data_items:
- if d.id == "REPORTNAME":
- vars.name = d.value
- if not vars.name:
- self.ShowMessage("Report name is required")
- return
- for d in self.data_items:
- if not d.IsValid():
- return
- for d in self.data_items[1:]:
- if d.id == "LIMIT":
- vars.limit = d.value
- elif len(d.value):
- if len(vars.where_clause):
- vars.where_clause += " AND "
- vars.where_clause += d.value
- if len(vars.where_clause):
- if self.partial:
- vars.where_clause = " AND ( " + vars.where_clause + " ) "
- else:
- vars.where_clause = " WHERE " + vars.where_clause + " "
- self.accept()
-
- def ShowMessage(self, msg):
- self.status.setText("<font color=#FF0000>" + msg)
-
- def ClearMessage(self):
- self.status.setText("")
-
-# Selected branch report creation dialog
-
-class SelectedBranchDialog(ReportDialogBase):
-
- def __init__(self, glb, parent=None):
- title = "Selected Branches"
- items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
- lambda g, p: SampleTimeRangesDataItem(g, "Time ranges:", "Enter time ranges", "samples.id", p),
- lambda g, p: NonNegativeIntegerRangesDataItem(g, "CPUs:", "Enter CPUs or ranges e.g. 0,5-6", "cpu", p),
- lambda g, p: SQLTableDataItem(g, "Commands:", "Only branches with these commands will be included", "comms", "comm", "comm_id", "", p),
- lambda g, p: SQLTableDataItem(g, "PIDs:", "Only branches with these process IDs will be included", "threads", "pid", "thread_id", "", p),
- lambda g, p: SQLTableDataItem(g, "TIDs:", "Only branches with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
- lambda g, p: SQLTableDataItem(g, "DSOs:", "Only branches with these DSOs will be included", "dsos", "short_name", "samples.dso_id", "to_dso_id", p),
- lambda g, p: SQLTableDataItem(g, "Symbols:", "Only branches with these symbols will be included", "symbols", "name", "symbol_id", "to_symbol_id", p),
- lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p))
- super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
-
-# Event list
-
-def GetEventList(db):
- events = []
- query = QSqlQuery(db)
- QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id")
- while query.next():
- events.append(query.value(0))
- return events
-
-# Is a table selectable
-
-def IsSelectable(db, table, sql = "", columns = "*"):
- query = QSqlQuery(db)
- try:
- QueryExec(query, "SELECT " + columns + " FROM " + table + " " + sql + " LIMIT 1")
- except:
- return False
- return True
-
-# SQL table data model item
-
-class SQLTableItem():
-
- def __init__(self, row, data):
- self.row = row
- self.data = data
-
- def getData(self, column):
- return self.data[column]
-
-# SQL table data model
-
-class SQLTableModel(TableModel):
-
- progress = Signal(object)
-
- def __init__(self, glb, sql, column_headers, parent=None):
- super(SQLTableModel, self).__init__(parent)
- self.glb = glb
- self.more = True
- self.populated = 0
- self.column_headers = column_headers
- self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), self.AddSample)
- self.fetcher.done.connect(self.Update)
- self.fetcher.Fetch(glb_chunk_sz)
-
- def DisplayData(self, item, index):
- self.FetchIfNeeded(item.row)
- return item.getData(index.column())
-
- def AddSample(self, data):
- child = SQLTableItem(self.populated, data)
- self.child_items.append(child)
- self.populated += 1
-
- def Update(self, fetched):
- if not fetched:
- self.more = False
- self.progress.emit(0)
- child_count = self.child_count
- count = self.populated - child_count
- if count > 0:
- parent = QModelIndex()
- self.beginInsertRows(parent, child_count, child_count + count - 1)
- self.insertRows(child_count, count, parent)
- self.child_count += count
- self.endInsertRows()
- self.progress.emit(self.child_count)
-
- def FetchMoreRecords(self, count):
- current = self.child_count
- if self.more:
- self.fetcher.Fetch(count)
- else:
- self.progress.emit(0)
- return current
-
- def HasMoreRecords(self):
- return self.more
-
- def columnCount(self, parent=None):
- return len(self.column_headers)
-
- def columnHeader(self, column):
- return self.column_headers[column]
-
- def SQLTableDataPrep(self, query, count):
- data = []
- for i in xrange(count):
- data.append(query.value(i))
- return data
-
-# SQL automatic table data model
-
-class SQLAutoTableModel(SQLTableModel):
-
- def __init__(self, glb, table_name, parent=None):
- sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz)
- if table_name == "comm_threads_view":
- # For now, comm_threads_view has no id column
- sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz)
- column_headers = []
- query = QSqlQuery(glb.db)
- if glb.dbref.is_sqlite3:
- QueryExec(query, "PRAGMA table_info(" + table_name + ")")
- while query.next():
- column_headers.append(query.value(1))
- if table_name == "sqlite_master":
- sql = "SELECT * FROM " + table_name
- else:
- if table_name[:19] == "information_schema.":
- sql = "SELECT * FROM " + table_name
- select_table_name = table_name[19:]
- schema = "information_schema"
- else:
- select_table_name = table_name
- schema = "public"
- QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'")
- while query.next():
- column_headers.append(query.value(0))
- if pyside_version_1 and sys.version_info[0] == 3:
- if table_name == "samples_view":
- self.SQLTableDataPrep = self.samples_view_DataPrep
- if table_name == "samples":
- self.SQLTableDataPrep = self.samples_DataPrep
- super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
-
- def samples_view_DataPrep(self, query, count):
- data = []
- data.append(query.value(0))
- # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
- data.append("{:>19}".format(query.value(1)))
- for i in xrange(2, count):
- data.append(query.value(i))
- return data
-
- def samples_DataPrep(self, query, count):
- data = []
- for i in xrange(9):
- data.append(query.value(i))
- # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
- data.append("{:>19}".format(query.value(9)))
- for i in xrange(10, count):
- data.append(query.value(i))
- return data
-
-# Base class for custom ResizeColumnsToContents
-
-class ResizeColumnsToContentsBase(QObject):
-
- def __init__(self, parent=None):
- super(ResizeColumnsToContentsBase, self).__init__(parent)
-
- def ResizeColumnToContents(self, column, n):
- # Using the view's resizeColumnToContents() here is extrememly slow
- # so implement a crude alternative
- font = self.view.font()
- metrics = QFontMetrics(font)
- max = 0
- for row in xrange(n):
- val = self.data_model.child_items[row].data[column]
- len = metrics.width(str(val) + "MM")
- max = len if len > max else max
- val = self.data_model.columnHeader(column)
- len = metrics.width(str(val) + "MM")
- max = len if len > max else max
- self.view.setColumnWidth(column, max)
-
- def ResizeColumnsToContents(self):
- n = min(self.data_model.child_count, 100)
- if n < 1:
- # No data yet, so connect a signal to notify when there is
- self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
- return
- columns = self.data_model.columnCount()
- for i in xrange(columns):
- self.ResizeColumnToContents(i, n)
-
- def UpdateColumnWidths(self, *x):
- # This only needs to be done once, so disconnect the signal now
- self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
- self.ResizeColumnsToContents()
-
-# Convert value to CSV
-
-def ToCSValue(val):
- if '"' in val:
- val = val.replace('"', '""')
- if "," in val or '"' in val:
- val = '"' + val + '"'
- return val
-
-# Key to sort table model indexes by row / column, assuming fewer than 1000 columns
-
-glb_max_cols = 1000
-
-def RowColumnKey(a):
- return a.row() * glb_max_cols + a.column()
-
-# Copy selected table cells to clipboard
-
-def CopyTableCellsToClipboard(view, as_csv=False, with_hdr=False):
- indexes = sorted(view.selectedIndexes(), key=RowColumnKey)
- idx_cnt = len(indexes)
- if not idx_cnt:
- return
- if idx_cnt == 1:
- with_hdr=False
- min_row = indexes[0].row()
- max_row = indexes[0].row()
- min_col = indexes[0].column()
- max_col = indexes[0].column()
- for i in indexes:
- min_row = min(min_row, i.row())
- max_row = max(max_row, i.row())
- min_col = min(min_col, i.column())
- max_col = max(max_col, i.column())
- if max_col > glb_max_cols:
- raise RuntimeError("glb_max_cols is too low")
- max_width = [0] * (1 + max_col - min_col)
- for i in indexes:
- c = i.column() - min_col
- max_width[c] = max(max_width[c], len(str(i.data())))
- text = ""
- pad = ""
- sep = ""
- if with_hdr:
- model = indexes[0].model()
- for col in range(min_col, max_col + 1):
- val = model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
- if as_csv:
- text += sep + ToCSValue(val)
- sep = ","
- else:
- c = col - min_col
- max_width[c] = max(max_width[c], len(val))
- width = max_width[c]
- align = model.headerData(col, Qt.Horizontal, Qt.TextAlignmentRole)
- if align & Qt.AlignRight:
- val = val.rjust(width)
- text += pad + sep + val
- pad = " " * (width - len(val))
- sep = " "
- text += "\n"
- pad = ""
- sep = ""
- last_row = min_row
- for i in indexes:
- if i.row() > last_row:
- last_row = i.row()
- text += "\n"
- pad = ""
- sep = ""
- if as_csv:
- text += sep + ToCSValue(str(i.data()))
- sep = ","
- else:
- width = max_width[i.column() - min_col]
- if i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
- val = str(i.data()).rjust(width)
- else:
- val = str(i.data())
- text += pad + sep + val
- pad = " " * (width - len(val))
- sep = " "
- QApplication.clipboard().setText(text)
-
-def CopyTreeCellsToClipboard(view, as_csv=False, with_hdr=False):
- indexes = view.selectedIndexes()
- if not len(indexes):
- return
-
- selection = view.selectionModel()
-
- first = None
- for i in indexes:
- above = view.indexAbove(i)
- if not selection.isSelected(above):
- first = i
- break
-
- if first is None:
- raise RuntimeError("CopyTreeCellsToClipboard internal error")
-
- model = first.model()
- row_cnt = 0
- col_cnt = model.columnCount(first)
- max_width = [0] * col_cnt
-
- indent_sz = 2
- indent_str = " " * indent_sz
-
- expanded_mark_sz = 2
- if sys.version_info[0] == 3:
- expanded_mark = "\u25BC "
- not_expanded_mark = "\u25B6 "
- else:
- expanded_mark = unicode(chr(0xE2) + chr(0x96) + chr(0xBC) + " ", "utf-8")
- not_expanded_mark = unicode(chr(0xE2) + chr(0x96) + chr(0xB6) + " ", "utf-8")
- leaf_mark = " "
-
- if not as_csv:
- pos = first
- while True:
- row_cnt += 1
- row = pos.row()
- for c in range(col_cnt):
- i = pos.sibling(row, c)
- if c:
- n = len(str(i.data()))
- else:
- n = len(str(i.data()).strip())
- n += (i.internalPointer().level - 1) * indent_sz
- n += expanded_mark_sz
- max_width[c] = max(max_width[c], n)
- pos = view.indexBelow(pos)
- if not selection.isSelected(pos):
- break
-
- text = ""
- pad = ""
- sep = ""
- if with_hdr:
- for c in range(col_cnt):
- val = model.headerData(c, Qt.Horizontal, Qt.DisplayRole).strip()
- if as_csv:
- text += sep + ToCSValue(val)
- sep = ","
- else:
- max_width[c] = max(max_width[c], len(val))
- width = max_width[c]
- align = model.headerData(c, Qt.Horizontal, Qt.TextAlignmentRole)
- if align & Qt.AlignRight:
- val = val.rjust(width)
- text += pad + sep + val
- pad = " " * (width - len(val))
- sep = " "
- text += "\n"
- pad = ""
- sep = ""
-
- pos = first
- while True:
- row = pos.row()
- for c in range(col_cnt):
- i = pos.sibling(row, c)
- val = str(i.data())
- if not c:
- if model.hasChildren(i):
- if view.isExpanded(i):
- mark = expanded_mark
- else:
- mark = not_expanded_mark
- else:
- mark = leaf_mark
- val = indent_str * (i.internalPointer().level - 1) + mark + val.strip()
- if as_csv:
- text += sep + ToCSValue(val)
- sep = ","
- else:
- width = max_width[c]
- if c and i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
- val = val.rjust(width)
- text += pad + sep + val
- pad = " " * (width - len(val))
- sep = " "
- pos = view.indexBelow(pos)
- if not selection.isSelected(pos):
- break
- text = text.rstrip() + "\n"
- pad = ""
- sep = ""
-
- QApplication.clipboard().setText(text)
-
-def CopyCellsToClipboard(view, as_csv=False, with_hdr=False):
- view.CopyCellsToClipboard(view, as_csv, with_hdr)
-
-def CopyCellsToClipboardHdr(view):
- CopyCellsToClipboard(view, False, True)
-
-def CopyCellsToClipboardCSV(view):
- CopyCellsToClipboard(view, True, True)
-
-# Context menu
-
-class ContextMenu(object):
-
- def __init__(self, view):
- self.view = view
- self.view.setContextMenuPolicy(Qt.CustomContextMenu)
- self.view.customContextMenuRequested.connect(self.ShowContextMenu)
-
- def ShowContextMenu(self, pos):
- menu = QMenu(self.view)
- self.AddActions(menu)
- menu.exec_(self.view.mapToGlobal(pos))
-
- def AddCopy(self, menu):
- menu.addAction(CreateAction("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
- menu.addAction(CreateAction("Copy selection as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
-
- def AddActions(self, menu):
- self.AddCopy(menu)
-
-class TreeContextMenu(ContextMenu):
-
- def __init__(self, view):
- super(TreeContextMenu, self).__init__(view)
-
- def AddActions(self, menu):
- i = self.view.currentIndex()
- text = str(i.data()).strip()
- if len(text):
- menu.addAction(CreateAction('Copy "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
- self.AddCopy(menu)
-
-# Table window
-
-class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
-
- def __init__(self, glb, table_name, parent=None):
- super(TableWindow, self).__init__(parent)
-
- self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name))
-
- self.model = QSortFilterProxyModel()
- self.model.setSourceModel(self.data_model)
-
- self.view = QTableView()
- self.view.setModel(self.model)
- self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
- self.view.verticalHeader().setVisible(False)
- self.view.sortByColumn(-1, Qt.AscendingOrder)
- self.view.setSortingEnabled(True)
- self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
- self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
-
- self.ResizeColumnsToContents()
-
- self.context_menu = ContextMenu(self.view)
-
- self.find_bar = FindBar(self, self, True)
-
- self.finder = ChildDataItemFinder(self.data_model)
-
- self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
-
- self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
-
- self.setWidget(self.vbox.Widget())
-
- AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
-
- def Find(self, value, direction, pattern, context):
- self.view.setFocus()
- self.find_bar.Busy()
- self.finder.Find(value, direction, pattern, context, self.FindDone)
-
- def FindDone(self, row):
- self.find_bar.Idle()
- if row >= 0:
- self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
- else:
- self.find_bar.NotFound()
-
-# Table list
-
-def GetTableList(glb):
- tables = []
- query = QSqlQuery(glb.db)
- if glb.dbref.is_sqlite3:
- QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name")
- else:
- QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name")
- while query.next():
- tables.append(query.value(0))
- if glb.dbref.is_sqlite3:
- tables.append("sqlite_master")
- else:
- tables.append("information_schema.tables")
- tables.append("information_schema.views")
- tables.append("information_schema.columns")
- return tables
-
-# Top Calls data model
-
-class TopCallsModel(SQLTableModel):
-
- def __init__(self, glb, report_vars, parent=None):
- text = ""
- if not glb.dbref.is_sqlite3:
- text = "::text"
- limit = ""
- if len(report_vars.limit):
- limit = " LIMIT " + report_vars.limit
- sql = ("SELECT comm, pid, tid, name,"
- " CASE"
- " WHEN (short_name = '[kernel.kallsyms]') THEN '[kernel]'" + text +
- " ELSE short_name"
- " END AS dso,"
- " call_time, return_time, (return_time - call_time) AS elapsed_time, branch_count, "
- " CASE"
- " WHEN (calls.flags = 1) THEN 'no call'" + text +
- " WHEN (calls.flags = 2) THEN 'no return'" + text +
- " WHEN (calls.flags = 3) THEN 'no call/return'" + text +
- " ELSE ''" + text +
- " END AS flags"
- " FROM calls"
- " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
- " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
- " INNER JOIN dsos ON symbols.dso_id = dsos.id"
- " INNER JOIN comms ON calls.comm_id = comms.id"
- " INNER JOIN threads ON calls.thread_id = threads.id" +
- report_vars.where_clause +
- " ORDER BY elapsed_time DESC" +
- limit
- )
- column_headers = ("Command", "PID", "TID", "Symbol", "Object", "Call Time", "Return Time", "Elapsed Time (ns)", "Branch Count", "Flags")
- self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignLeft)
- super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
-
- def columnAlignment(self, column):
- return self.alignment[column]
-
-# Top Calls report creation dialog
-
-class TopCallsDialog(ReportDialogBase):
-
- def __init__(self, glb, parent=None):
- title = "Top Calls by Elapsed Time"
- items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
- lambda g, p: SQLTableDataItem(g, "Commands:", "Only calls with these commands will be included", "comms", "comm", "comm_id", "", p),
- lambda g, p: SQLTableDataItem(g, "PIDs:", "Only calls with these process IDs will be included", "threads", "pid", "thread_id", "", p),
- lambda g, p: SQLTableDataItem(g, "TIDs:", "Only calls with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
- lambda g, p: SQLTableDataItem(g, "DSOs:", "Only calls with these DSOs will be included", "dsos", "short_name", "dso_id", "", p),
- lambda g, p: SQLTableDataItem(g, "Symbols:", "Only calls with these symbols will be included", "symbols", "name", "symbol_id", "", p),
- lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p),
- lambda g, p: PositiveIntegerDataItem(g, "Record limit:", "Limit selection to this number of records", p, "LIMIT", "100"))
- super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
-
-# Top Calls window
-
-class TopCallsWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
-
- def __init__(self, glb, report_vars, parent=None):
- super(TopCallsWindow, self).__init__(parent)
-
- self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(glb, report_vars))
- self.model = self.data_model
-
- self.view = QTableView()
- self.view.setModel(self.model)
- self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
- self.view.verticalHeader().setVisible(False)
- self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
- self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
-
- self.context_menu = ContextMenu(self.view)
-
- self.ResizeColumnsToContents()
-
- self.find_bar = FindBar(self, self, True)
-
- self.finder = ChildDataItemFinder(self.model)
-
- self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
-
- self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
-
- self.setWidget(self.vbox.Widget())
-
- AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
-
- def Find(self, value, direction, pattern, context):
- self.view.setFocus()
- self.find_bar.Busy()
- self.finder.Find(value, direction, pattern, context, self.FindDone)
-
- def FindDone(self, row):
- self.find_bar.Idle()
- if row >= 0:
- self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
- else:
- self.find_bar.NotFound()
-
-# Action Definition
-
-def CreateAction(label, tip, callback, parent=None, shortcut=None):
- action = QAction(label, parent)
- if shortcut != None:
- action.setShortcuts(shortcut)
- action.setStatusTip(tip)
- action.triggered.connect(callback)
- return action
-
-# Typical application actions
-
-def CreateExitAction(app, parent=None):
- return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit)
-
-# Typical MDI actions
-
-def CreateCloseActiveWindowAction(mdi_area):
- return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area)
-
-def CreateCloseAllWindowsAction(mdi_area):
- return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area)
-
-def CreateTileWindowsAction(mdi_area):
- return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area)
-
-def CreateCascadeWindowsAction(mdi_area):
- return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area)
-
-def CreateNextWindowAction(mdi_area):
- return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild)
-
-def CreatePreviousWindowAction(mdi_area):
- return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild)
-
-# Typical MDI window menu
-
-class WindowMenu():
-
- def __init__(self, mdi_area, menu):
- self.mdi_area = mdi_area
- self.window_menu = menu.addMenu("&Windows")
- self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
- self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
- self.tile_windows = CreateTileWindowsAction(mdi_area)
- self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
- self.next_window = CreateNextWindowAction(mdi_area)
- self.previous_window = CreatePreviousWindowAction(mdi_area)
- self.window_menu.aboutToShow.connect(self.Update)
-
- def Update(self):
- self.window_menu.clear()
- sub_window_count = len(self.mdi_area.subWindowList())
- have_sub_windows = sub_window_count != 0
- self.close_active_window.setEnabled(have_sub_windows)
- self.close_all_windows.setEnabled(have_sub_windows)
- self.tile_windows.setEnabled(have_sub_windows)
- self.cascade_windows.setEnabled(have_sub_windows)
- self.next_window.setEnabled(have_sub_windows)
- self.previous_window.setEnabled(have_sub_windows)
- self.window_menu.addAction(self.close_active_window)
- self.window_menu.addAction(self.close_all_windows)
- self.window_menu.addSeparator()
- self.window_menu.addAction(self.tile_windows)
- self.window_menu.addAction(self.cascade_windows)
- self.window_menu.addSeparator()
- self.window_menu.addAction(self.next_window)
- self.window_menu.addAction(self.previous_window)
- if sub_window_count == 0:
- return
- self.window_menu.addSeparator()
- nr = 1
- for sub_window in self.mdi_area.subWindowList():
- label = str(nr) + " " + sub_window.name
- if nr < 10:
- label = "&" + label
- action = self.window_menu.addAction(label)
- action.setCheckable(True)
- action.setChecked(sub_window == self.mdi_area.activeSubWindow())
- action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
- self.window_menu.addAction(action)
- nr += 1
-
- def setActiveSubWindow(self, nr):
- self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
-
-# Help text
-
-glb_help_text = """
-<h1>Contents</h1>
-<style>
-p.c1 {
- text-indent: 40px;
-}
-p.c2 {
- text-indent: 80px;
-}
-}
-</style>
-<p class=c1><a href=#reports>1. Reports</a></p>
-<p class=c2><a href=#callgraph>1.1 Context-Sensitive Call Graph</a></p>
-<p class=c2><a href=#calltree>1.2 Call Tree</a></p>
-<p class=c2><a href=#allbranches>1.3 All branches</a></p>
-<p class=c2><a href=#selectedbranches>1.4 Selected branches</a></p>
-<p class=c2><a href=#topcallsbyelapsedtime>1.5 Top calls by elapsed time</a></p>
-<p class=c1><a href=#charts>2. Charts</a></p>
-<p class=c2><a href=#timechartbycpu>2.1 Time chart by CPU</a></p>
-<p class=c1><a href=#tables>3. Tables</a></p>
-<h1 id=reports>1. Reports</h1>
-<h2 id=callgraph>1.1 Context-Sensitive Call Graph</h2>
-The result is a GUI window with a tree representing a context-sensitive
-call-graph. Expanding a couple of levels of the tree and adjusting column
-widths to suit will display something like:
-<pre>
- Call Graph: pt_example
-Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
-v- ls
- v- 2638:2638
- v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
- |- unknown unknown 1 13198 0.1 1 0.0
- >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
- >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
- v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
- >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
- >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
- >- __libc_csu_init ls 1 10354 0.1 10 0.0
- |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
- v- main ls 1 8182043 99.6 180254 99.9
-</pre>
-<h3>Points to note:</h3>
-<ul>
-<li>The top level is a command name (comm)</li>
-<li>The next level is a thread (pid:tid)</li>
-<li>Subsequent levels are functions</li>
-<li>'Count' is the number of calls</li>
-<li>'Time' is the elapsed time until the function returns</li>
-<li>Percentages are relative to the level above</li>
-<li>'Branch Count' is the total number of branches for that function and all functions that it calls
-</ul>
-<h3>Find</h3>
-Ctrl-F displays a Find bar which finds function names by either an exact match or a pattern match.
-The pattern matching symbols are ? for any character and * for zero or more characters.
-<h2 id=calltree>1.2 Call Tree</h2>
-The Call Tree report is very similar to the Context-Sensitive Call Graph, but the data is not aggregated.
-Also the 'Count' column, which would be always 1, is replaced by the 'Call Time'.
-<h2 id=allbranches>1.3 All branches</h2>
-The All branches report displays all branches in chronological order.
-Not all data is fetched immediately. More records can be fetched using the Fetch bar provided.
-<h3>Disassembly</h3>
-Open a branch to display disassembly. This only works if:
-<ol>
-<li>The disassembler is available. Currently, only Intel XED is supported - see <a href=#xed>Intel XED Setup</a></li>
-<li>The object code is available. Currently, only the perf build ID cache is searched for object code.
-The default directory ~/.debug can be overridden by setting environment variable PERF_BUILDID_DIR.
-One exception is kcore where the DSO long name is used (refer dsos_view on the Tables menu),
-or alternatively, set environment variable PERF_KCORE to the kcore file name.</li>
-</ol>
-<h4 id=xed>Intel XED Setup</h4>
-To use Intel XED, libxed.so must be present. To build and install libxed.so:
-<pre>
-git clone https://github.com/intelxed/mbuild.git mbuild
-git clone https://github.com/intelxed/xed
-cd xed
-./mfile.py --share
-sudo ./mfile.py --prefix=/usr/local install
-sudo ldconfig
-</pre>
-<h3>Instructions per Cycle (IPC)</h3>
-If available, IPC information is displayed in columns 'insn_cnt', 'cyc_cnt' and 'IPC'.
-<p><b>Intel PT note:</b> The information applies to the blocks of code ending with, and including, that branch.
-Due to the granularity of timing information, the number of cycles for some code blocks will not be known.
-In that case, 'insn_cnt', 'cyc_cnt' and 'IPC' are zero, but when 'IPC' is displayed it covers the period
-since the previous displayed 'IPC'.
-<h3>Find</h3>
-Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
-Refer to Python documentation for the regular expression syntax.
-All columns are searched, but only currently fetched rows are searched.
-<h2 id=selectedbranches>1.4 Selected branches</h2>
-This is the same as the <a href=#allbranches>All branches</a> report but with the data reduced
-by various selection criteria. A dialog box displays available criteria which are AND'ed together.
-<h3>1.4.1 Time ranges</h3>
-The time ranges hint text shows the total time range. Relative time ranges can also be entered in
-ms, us or ns. Also, negative values are relative to the end of trace. Examples:
-<pre>
- 81073085947329-81073085958238 From 81073085947329 to 81073085958238
- 100us-200us From 100us to 200us
- 10ms- From 10ms to the end
- -100ns The first 100ns
- -10ms- The last 10ms
-</pre>
-N.B. Due to the granularity of timestamps, there could be no branches in any given time range.
-<h2 id=topcallsbyelapsedtime>1.5 Top calls by elapsed time</h2>
-The Top calls by elapsed time report displays calls in descending order of time elapsed between when the function was called and when it returned.
-The data is reduced by various selection criteria. A dialog box displays available criteria which are AND'ed together.
-If not all data is fetched, a Fetch bar is provided. Ctrl-F displays a Find bar.
-<h1 id=charts>2. Charts</h1>
-<h2 id=timechartbycpu>2.1 Time chart by CPU</h2>
-This chart displays context switch information when that data is available. Refer to context_switches_view on the Tables menu.
-<h3>Features</h3>
-<ol>
-<li>Mouse over to highight the task and show the time</li>
-<li>Drag the mouse to select a region and zoom by pushing the Zoom button</li>
-<li>Go back and forward by pressing the arrow buttons</li>
-<li>If call information is available, right-click to show a call tree opened to that task and time.
-Note, the call tree may take some time to appear, and there may not be call information for the task or time selected.
-</li>
-</ol>
-<h3>Important</h3>
-The graph can be misleading in the following respects:
-<ol>
-<li>The graph shows the first task on each CPU as running from the beginning of the time range.
-Because tracing might start on different CPUs at different times, that is not necessarily the case.
-Refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
-<li>Similarly, the last task on each CPU can be showing running longer than it really was.
-Again, refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
-<li>When the mouse is over a task, the highlighted task might not be visible on the legend without scrolling if the legend does not fit fully in the window</li>
-</ol>
-<h1 id=tables>3. Tables</h1>
-The Tables menu shows all tables and views in the database. Most tables have an associated view
-which displays the information in a more friendly way. Not all data for large tables is fetched
-immediately. More records can be fetched using the Fetch bar provided. Columns can be sorted,
-but that can be slow for large tables.
-<p>There are also tables of database meta-information.
-For SQLite3 databases, the sqlite_master table is included.
-For PostgreSQL databases, information_schema.tables/views/columns are included.
-<h3>Find</h3>
-Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
-Refer to Python documentation for the regular expression syntax.
-All columns are searched, but only currently fetched rows are searched.
-<p>N.B. Results are found in id order, so if the table is re-ordered, find-next and find-previous
-will go to the next/previous result in id order, instead of display order.
-"""
-
-# Help window
-
-class HelpWindow(QMdiSubWindow):
-
- def __init__(self, glb, parent=None):
- super(HelpWindow, self).__init__(parent)
-
- self.text = QTextBrowser()
- self.text.setHtml(glb_help_text)
- self.text.setReadOnly(True)
- self.text.setOpenExternalLinks(True)
-
- self.setWidget(self.text)
-
- AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
-
-# Main window that only displays the help text
-
-class HelpOnlyWindow(QMainWindow):
-
- def __init__(self, parent=None):
- super(HelpOnlyWindow, self).__init__(parent)
-
- self.setMinimumSize(200, 100)
- self.resize(800, 600)
- self.setWindowTitle("Exported SQL Viewer Help")
- self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
-
- self.text = QTextBrowser()
- self.text.setHtml(glb_help_text)
- self.text.setReadOnly(True)
- self.text.setOpenExternalLinks(True)
-
- self.setCentralWidget(self.text)
-
-# PostqreSQL server version
-
-def PostqreSQLServerVersion(db):
- query = QSqlQuery(db)
- QueryExec(query, "SELECT VERSION()")
- if query.next():
- v_str = query.value(0)
- v_list = v_str.strip().split(" ")
- if v_list[0] == "PostgreSQL" and v_list[2] == "on":
- return v_list[1]
- return v_str
- return "Unknown"
-
-# SQLite version
-
-def SQLiteVersion(db):
- query = QSqlQuery(db)
- QueryExec(query, "SELECT sqlite_version()")
- if query.next():
- return query.value(0)
- return "Unknown"
-
-# About dialog
-
-class AboutDialog(QDialog):
-
- def __init__(self, glb, parent=None):
- super(AboutDialog, self).__init__(parent)
-
- self.setWindowTitle("About Exported SQL Viewer")
- self.setMinimumWidth(300)
-
- pyside_version = "1" if pyside_version_1 else "2"
-
- text = "<pre>"
- text += "Python version: " + sys.version.split(" ")[0] + "\n"
- text += "PySide version: " + pyside_version + "\n"
- text += "Qt version: " + qVersion() + "\n"
- if glb.dbref.is_sqlite3:
- text += "SQLite version: " + SQLiteVersion(glb.db) + "\n"
- else:
- text += "PostqreSQL version: " + PostqreSQLServerVersion(glb.db) + "\n"
- text += "</pre>"
-
- self.text = QTextBrowser()
- self.text.setHtml(text)
- self.text.setReadOnly(True)
- self.text.setOpenExternalLinks(True)
-
- self.vbox = QVBoxLayout()
- self.vbox.addWidget(self.text)
-
- self.setLayout(self.vbox)
-
-# Font resize
-
-def ResizeFont(widget, diff):
- font = widget.font()
- sz = font.pointSize()
- font.setPointSize(sz + diff)
- widget.setFont(font)
-
-def ShrinkFont(widget):
- ResizeFont(widget, -1)
-
-def EnlargeFont(widget):
- ResizeFont(widget, 1)
-
-# Unique name for sub-windows
-
-def NumberedWindowName(name, nr):
- if nr > 1:
- name += " <" + str(nr) + ">"
- return name
-
-def UniqueSubWindowName(mdi_area, name):
- nr = 1
- while True:
- unique_name = NumberedWindowName(name, nr)
- ok = True
- for sub_window in mdi_area.subWindowList():
- if sub_window.name == unique_name:
- ok = False
- break
- if ok:
- return unique_name
- nr += 1
-
-# Add a sub-window
-
-def AddSubWindow(mdi_area, sub_window, name):
- unique_name = UniqueSubWindowName(mdi_area, name)
- sub_window.setMinimumSize(200, 100)
- sub_window.resize(800, 600)
- sub_window.setWindowTitle(unique_name)
- sub_window.setAttribute(Qt.WA_DeleteOnClose)
- sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon))
- sub_window.name = unique_name
- mdi_area.addSubWindow(sub_window)
- sub_window.show()
-
-# Main window
-
-class MainWindow(QMainWindow):
-
- def __init__(self, glb, parent=None):
- super(MainWindow, self).__init__(parent)
-
- self.glb = glb
-
- self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
- self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
- self.setMinimumSize(200, 100)
-
- self.mdi_area = QMdiArea()
- self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
- self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-
- self.setCentralWidget(self.mdi_area)
-
- menu = self.menuBar()
-
- file_menu = menu.addMenu("&File")
- file_menu.addAction(CreateExitAction(glb.app, self))
-
- edit_menu = menu.addMenu("&Edit")
- edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySequence.Copy))
- edit_menu.addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
- edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
- edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)]))
- edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")]))
- edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")]))
-
- reports_menu = menu.addMenu("&Reports")
- if IsSelectable(glb.db, "calls"):
- reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
-
- if IsSelectable(glb.db, "calls", "WHERE parent_id >= 0"):
- reports_menu.addAction(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
-
- self.EventMenu(GetEventList(glb.db), reports_menu)
-
- if IsSelectable(glb.db, "calls"):
- reports_menu.addAction(CreateAction("&Top calls by elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
-
- if IsSelectable(glb.db, "context_switches"):
- charts_menu = menu.addMenu("&Charts")
- charts_menu.addAction(CreateAction("&Time chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))
-
- self.TableMenu(GetTableList(glb), menu)
-
- self.window_menu = WindowMenu(self.mdi_area, menu)
-
- help_menu = menu.addMenu("&Help")
- help_menu.addAction(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence.HelpContents))
- help_menu.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
-
- def Try(self, fn):
- win = self.mdi_area.activeSubWindow()
- if win:
- try:
- fn(win.view)
- except:
- pass
-
- def CopyToClipboard(self):
- self.Try(CopyCellsToClipboardHdr)
-
- def CopyToClipboardCSV(self):
- self.Try(CopyCellsToClipboardCSV)
-
- def Find(self):
- win = self.mdi_area.activeSubWindow()
- if win:
- try:
- win.find_bar.Activate()
- except:
- pass
-
- def FetchMoreRecords(self):
- win = self.mdi_area.activeSubWindow()
- if win:
- try:
- win.fetch_bar.Activate()
- except:
- pass
-
- def ShrinkFont(self):
- self.Try(ShrinkFont)
-
- def EnlargeFont(self):
- self.Try(EnlargeFont)
-
- def EventMenu(self, events, reports_menu):
- branches_events = 0
- for event in events:
- event = event.split(":")[0]
- if event == "branches":
- branches_events += 1
- dbid = 0
- for event in events:
- dbid += 1
- event = event.split(":")[0]
- if event == "branches":
- label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")"
- reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
- label = "Selected branches" if branches_events == 1 else "Selected branches " + "(id=" + dbid + ")"
- reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
-
- def TimeChartByCPU(self):
- TimeChartByCPUWindow(self.glb, self)
-
- def TableMenu(self, tables, menu):
- table_menu = menu.addMenu("&Tables")
- for table in tables:
- table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
-
- def NewCallGraph(self):
- CallGraphWindow(self.glb, self)
-
- def NewCallTree(self):
- CallTreeWindow(self.glb, self)
-
- def NewTopCalls(self):
- dialog = TopCallsDialog(self.glb, self)
- ret = dialog.exec_()
- if ret:
- TopCallsWindow(self.glb, dialog.report_vars, self)
-
- def NewBranchView(self, event_id):
- BranchWindow(self.glb, event_id, ReportVars(), self)
-
- def NewSelectedBranchView(self, event_id):
- dialog = SelectedBranchDialog(self.glb, self)
- ret = dialog.exec_()
- if ret:
- BranchWindow(self.glb, event_id, dialog.report_vars, self)
-
- def NewTableView(self, table_name):
- TableWindow(self.glb, table_name, self)
-
- def Help(self):
- HelpWindow(self.glb, self)
-
- def About(self):
- dialog = AboutDialog(self.glb, self)
- dialog.exec_()
-
-def TryOpen(file_name):
- try:
- return open(file_name, "rb")
- except:
- return None
-
-def Is64Bit(f):
- result = sizeof(c_void_p)
- # ELF support only
- pos = f.tell()
- f.seek(0)
- header = f.read(7)
- f.seek(pos)
- magic = header[0:4]
- if sys.version_info[0] == 2:
- eclass = ord(header[4])
- encoding = ord(header[5])
- version = ord(header[6])
- else:
- eclass = header[4]
- encoding = header[5]
- version = header[6]
- if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1:
- result = True if eclass == 2 else False
- return result
-
-# Global data
-
-class Glb():
-
- def __init__(self, dbref, db, dbname):
- self.dbref = dbref
- self.db = db
- self.dbname = dbname
- self.home_dir = os.path.expanduser("~")
- self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
- if self.buildid_dir:
- self.buildid_dir += "/.build-id/"
- else:
- self.buildid_dir = self.home_dir + "/.debug/.build-id/"
- self.app = None
- self.mainwindow = None
- self.instances_to_shutdown_on_exit = weakref.WeakSet()
- try:
- self.disassembler = LibXED()
- self.have_disassembler = True
- except:
- self.have_disassembler = False
- self.host_machine_id = 0
- self.host_start_time = 0
- self.host_finish_time = 0
-
- def FileFromBuildId(self, build_id):
- file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
- return TryOpen(file_name)
-
- def FileFromNamesAndBuildId(self, short_name, long_name, build_id):
- # Assume current machine i.e. no support for virtualization
- if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore":
- file_name = os.getenv("PERF_KCORE")
- f = TryOpen(file_name) if file_name else None
- if f:
- return f
- # For now, no special handling if long_name is /proc/kcore
- f = TryOpen(long_name)
- if f:
- return f
- f = self.FileFromBuildId(build_id)
- if f:
- return f
- return None
-
- def AddInstanceToShutdownOnExit(self, instance):
- self.instances_to_shutdown_on_exit.add(instance)
-
- # Shutdown any background processes or threads
- def ShutdownInstances(self):
- for x in self.instances_to_shutdown_on_exit:
- try:
- x.Shutdown()
- except:
- pass
-
- def GetHostMachineId(self):
- query = QSqlQuery(self.db)
- QueryExec(query, "SELECT id FROM machines WHERE pid = -1")
- if query.next():
- self.host_machine_id = query.value(0)
- else:
- self.host_machine_id = 0
- return self.host_machine_id
-
- def HostMachineId(self):
- if self.host_machine_id:
- return self.host_machine_id
- return self.GetHostMachineId()
-
- def SelectValue(self, sql):
- query = QSqlQuery(self.db)
- try:
- QueryExec(query, sql)
- except:
- return None
- if query.next():
- return Decimal(query.value(0))
- return None
-
- def SwitchesMinTime(self, machine_id):
- return self.SelectValue("SELECT time"
- " FROM context_switches"
- " WHERE time != 0 AND machine_id = " + str(machine_id) +
- " ORDER BY id LIMIT 1")
-
- def SwitchesMaxTime(self, machine_id):
- return self.SelectValue("SELECT time"
- " FROM context_switches"
- " WHERE time != 0 AND machine_id = " + str(machine_id) +
- " ORDER BY id DESC LIMIT 1")
-
- def SamplesMinTime(self, machine_id):
- return self.SelectValue("SELECT time"
- " FROM samples"
- " WHERE time != 0 AND machine_id = " + str(machine_id) +
- " ORDER BY id LIMIT 1")
-
- def SamplesMaxTime(self, machine_id):
- return self.SelectValue("SELECT time"
- " FROM samples"
- " WHERE time != 0 AND machine_id = " + str(machine_id) +
- " ORDER BY id DESC LIMIT 1")
-
- def CallsMinTime(self, machine_id):
- return self.SelectValue("SELECT calls.call_time"
- " FROM calls"
- " INNER JOIN threads ON threads.thread_id = calls.thread_id"
- " WHERE calls.call_time != 0 AND threads.machine_id = " + str(machine_id) +
- " ORDER BY calls.id LIMIT 1")
-
- def CallsMaxTime(self, machine_id):
- return self.SelectValue("SELECT calls.return_time"
- " FROM calls"
- " INNER JOIN threads ON threads.thread_id = calls.thread_id"
- " WHERE calls.return_time != 0 AND threads.machine_id = " + str(machine_id) +
- " ORDER BY calls.return_time DESC LIMIT 1")
-
- def GetStartTime(self, machine_id):
- t0 = self.SwitchesMinTime(machine_id)
- t1 = self.SamplesMinTime(machine_id)
- t2 = self.CallsMinTime(machine_id)
- if t0 is None or (not(t1 is None) and t1 < t0):
- t0 = t1
- if t0 is None or (not(t2 is None) and t2 < t0):
- t0 = t2
- return t0
-
- def GetFinishTime(self, machine_id):
- t0 = self.SwitchesMaxTime(machine_id)
- t1 = self.SamplesMaxTime(machine_id)
- t2 = self.CallsMaxTime(machine_id)
- if t0 is None or (not(t1 is None) and t1 > t0):
- t0 = t1
- if t0 is None or (not(t2 is None) and t2 > t0):
- t0 = t2
- return t0
-
- def HostStartTime(self):
- if self.host_start_time:
- return self.host_start_time
- self.host_start_time = self.GetStartTime(self.HostMachineId())
- return self.host_start_time
-
- def HostFinishTime(self):
- if self.host_finish_time:
- return self.host_finish_time
- self.host_finish_time = self.GetFinishTime(self.HostMachineId())
- return self.host_finish_time
-
- def StartTime(self, machine_id):
- if machine_id == self.HostMachineId():
- return self.HostStartTime()
- return self.GetStartTime(machine_id)
-
- def FinishTime(self, machine_id):
- if machine_id == self.HostMachineId():
- return self.HostFinishTime()
- return self.GetFinishTime(machine_id)
-
-# Database reference
-
-class DBRef():
-
- def __init__(self, is_sqlite3, dbname):
- self.is_sqlite3 = is_sqlite3
- self.dbname = dbname
- self.TRUE = "TRUE"
- self.FALSE = "FALSE"
- # SQLite prior to version 3.23 does not support TRUE and FALSE
- if self.is_sqlite3:
- self.TRUE = "1"
- self.FALSE = "0"
-
- def Open(self, connection_name):
- dbname = self.dbname
- if self.is_sqlite3:
- db = QSqlDatabase.addDatabase("QSQLITE", connection_name)
- else:
- db = QSqlDatabase.addDatabase("QPSQL", connection_name)
- opts = dbname.split()
- for opt in opts:
- if "=" in opt:
- opt = opt.split("=")
- if opt[0] == "hostname":
- db.setHostName(opt[1])
- elif opt[0] == "port":
- db.setPort(int(opt[1]))
- elif opt[0] == "username":
- db.setUserName(opt[1])
- elif opt[0] == "password":
- db.setPassword(opt[1])
- elif opt[0] == "dbname":
- dbname = opt[1]
- else:
- dbname = opt
-
- db.setDatabaseName(dbname)
- if not db.open():
- raise Exception("Failed to open database " + dbname + " error: " + db.lastError().text())
- return db, dbname
-
-# Main
-
-def Main():
- usage_str = "exported-sql-viewer.py [--pyside-version-1] <database name>\n" \
- " or: exported-sql-viewer.py --help-only"
- ap = argparse.ArgumentParser(usage = usage_str, add_help = False)
- ap.add_argument("--pyside-version-1", action='store_true')
- ap.add_argument("dbname", nargs="?")
- ap.add_argument("--help-only", action='store_true')
- args = ap.parse_args()
-
- if args.help_only:
- app = QApplication(sys.argv)
- mainwindow = HelpOnlyWindow()
- mainwindow.show()
- err = app.exec_()
- sys.exit(err)
-
- dbname = args.dbname
- if dbname is None:
- ap.print_usage()
- print("Too few arguments")
- sys.exit(1)
-
- is_sqlite3 = False
- try:
- f = open(dbname, "rb")
- if f.read(15) == b'SQLite format 3':
- is_sqlite3 = True
- f.close()
- except:
- pass
-
- dbref = DBRef(is_sqlite3, dbname)
- db, dbname = dbref.Open("main")
- glb = Glb(dbref, db, dbname)
- app = QApplication(sys.argv)
- glb.app = app
- mainwindow = MainWindow(glb)
- glb.mainwindow = mainwindow
- mainwindow.show()
- err = app.exec_()
- glb.ShutdownInstances()
- db.close()
- sys.exit(err)
-
-if __name__ == "__main__":
- Main()
--
2.56.0.rc1.310.g51773c2048-goog
next prev parent reply other threads:[~2026-09-23 18:15 UTC|newest]
Thread overview: 410+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-09-20 5:20 [PATCH v1 00/49] perf: Complete transition to standalone Python scripts Ian Rogers
2026-09-20 5:20 ` [PATCH v1 01/49] perf python: Update syscall format string to optional positional Ian Rogers
2026-09-20 5:28 ` sashiko-bot
2026-09-20 5:20 ` [PATCH v1 02/49] perf python: Update callchain stubs and session thread lookup Ian Rogers
2026-09-20 5:30 ` sashiko-bot
2026-09-20 5:20 ` [PATCH v1 03/49] perf python: Clean up pylint warnings in ilist.py Ian Rogers
2026-09-20 5:31 ` sashiko-bot
2026-09-20 5:20 ` [PATCH v1 04/49] perf python: Clean up pylint warnings in treport.py Ian Rogers
2026-09-20 5:32 ` sashiko-bot
2026-09-20 5:20 ` [PATCH v1 05/49] perf python: Clean up pylint warnings in tracepoint.py Ian Rogers
2026-09-20 5:26 ` sashiko-bot
2026-09-20 5:20 ` [PATCH v1 06/49] perf python: Clean up pylint warnings in twatch.py Ian Rogers
2026-09-20 5:26 ` sashiko-bot
2026-09-20 5:20 ` [PATCH v1 07/49] perf python: Improve perf script -l descriptions Ian Rogers
2026-09-20 5:35 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 08/49] perf python: Expose addr location, transaction, and context_switch Ian Rogers
2026-09-20 5:34 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 09/49] perf python: Add Intel PT call_return and itrace capability Ian Rogers
2026-09-20 5:35 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 10/49] perf python: Allow KeyboardInterrupt to propagate in LiveSession Ian Rogers
2026-09-20 5:32 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 11/49] perf pmu-events: Clean up mypy and pylint issues Ian Rogers
2026-09-20 5:29 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 12/49] perf test: Clean up mypy and pylint issues in shell test libraries Ian Rogers
2026-09-20 5:29 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 13/49] perf build: Make mypy build test opt-out (NO_MYPY=1) Ian Rogers
2026-09-20 5:31 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 14/49] perf build: Make pylint build test opt-out (NO_PYLINT=1) Ian Rogers
2026-09-20 5:32 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 15/49] perf Makefile: Install standalone Python scripts during transition Ian Rogers
2026-09-20 5:32 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 16/49] perf python: Port stat-cpi to perf module Ian Rogers
2026-09-20 5:34 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 17/49] perf python: Port mem-phys-addr " Ian Rogers
2026-09-20 5:29 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 18/49] perf python: Port stackcollapse " Ian Rogers
2026-09-20 5:30 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 19/49] perf python: Port flamegraph " Ian Rogers
2026-09-20 5:29 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 20/49] perf python: Port gecko " Ian Rogers
2026-09-20 5:31 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 21/49] perf python: Port event_analyzing_sample " Ian Rogers
2026-09-20 5:35 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 22/49] perf python: Port syscall-counts " Ian Rogers
2026-09-20 5:39 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 23/49] perf python: Port syscall-counts-by-pid " Ian Rogers
2026-09-20 5:37 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 24/49] perf python: Port failed-syscalls-by-pid " Ian Rogers
2026-09-20 5:34 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 25/49] perf python: Port failed-syscalls from Perl " Ian Rogers
2026-09-20 5:33 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 26/49] perf python: Port sctop " Ian Rogers
2026-09-20 5:39 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 27/49] perf python: Port rw-by-file from Perl " Ian Rogers
2026-09-20 5:36 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 28/49] perf python: Port rw-by-pid " Ian Rogers
2026-09-20 5:36 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 29/49] perf python: Port rwtop " Ian Rogers
2026-09-20 5:35 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 30/49] perf python: Port futex-contention " Ian Rogers
2026-09-20 5:35 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 31/49] perf python: Port task-analyzer " Ian Rogers
2026-09-20 5:37 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 32/49] perf python: Port sched-migration and SchedGui " Ian Rogers
2026-09-20 5:36 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 33/49] perf python: Port wakeup-latency from Perl " Ian Rogers
2026-09-20 5:39 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 34/49] perf python: Port compaction-times " Ian Rogers
2026-09-20 5:36 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 35/49] perf python: Port net_dropmonitor " Ian Rogers
2026-09-20 5:37 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 36/49] perf python: Port netdev-times " Ian Rogers
2026-09-20 5:39 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 37/49] perf python: Port check-perf-trace " Ian Rogers
2026-09-20 5:37 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 38/49] perf python: Port arm-cs-trace-disasm " Ian Rogers
2026-09-20 5:42 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 39/49] perf python: Port powerpc-hcalls " Ian Rogers
2026-09-20 5:38 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 40/49] perf python: Port intel-pt-events and libxed " Ian Rogers
2026-09-20 5:42 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 41/49] perf test: Migrate Intel PT virtual LBR test to Python API Ian Rogers
2026-09-20 5:38 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 42/49] perf python: Port export-to-sqlite to perf module Ian Rogers
2026-09-20 5:46 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 43/49] perf python: Port export-to-postgresql " Ian Rogers
2026-09-20 5:39 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 44/49] perf python: Move and clean up exported-sql-viewer.py Ian Rogers
2026-09-20 5:21 ` [PATCH v1 45/49] perf python: Move and clean up parallel-perf.py Ian Rogers
2026-09-20 5:40 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 46/49] perf: Remove libpython support and legacy Python scripts Ian Rogers
2026-09-20 5:21 ` [PATCH v1 47/49] perf Makefile: Update Python script installation path Ian Rogers
2026-09-20 5:41 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 48/49] perf script: Support standalone scripts and remove embedded scripting Ian Rogers
2026-09-20 5:45 ` sashiko-bot
2026-09-20 5:21 ` [PATCH v1 49/49] perf Documentation: Update for standalone Python scripts Ian Rogers
2026-09-20 5:37 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 00/49] perf: Complete transition to " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 01/49] perf python: Update syscall format string to optional positional Ian Rogers
2026-09-21 5:26 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 02/49] perf python: Update callchain stubs and session thread lookup Ian Rogers
2026-09-21 5:27 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 03/49] perf python: Clean up pylint warnings in ilist.py Ian Rogers
2026-09-21 5:28 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 04/49] perf python: Clean up pylint warnings in treport.py Ian Rogers
2026-09-21 5:27 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 05/49] perf python: Clean up pylint warnings in tracepoint.py Ian Rogers
2026-09-21 5:23 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 06/49] perf python: Clean up pylint warnings in twatch.py Ian Rogers
2026-09-21 5:23 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 07/49] perf python: Improve perf script -l descriptions Ian Rogers
2026-09-21 5:33 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 08/49] perf python: Expose addr location, transaction, and context_switch Ian Rogers
2026-09-21 5:34 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 09/49] perf python: Add Intel PT call_return and itrace capability Ian Rogers
2026-09-21 5:31 ` sashiko-bot
2026-09-22 13:11 ` James Clark
2026-09-22 17:00 ` Ian Rogers
2026-09-21 5:06 ` [PATCH v2 10/49] perf python: Allow KeyboardInterrupt to propagate in LiveSession Ian Rogers
2026-09-21 5:27 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 11/49] perf pmu-events: Clean up mypy and pylint issues Ian Rogers
2026-09-21 5:26 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 12/49] perf test: Clean up mypy and pylint issues in shell test libraries Ian Rogers
2026-09-21 5:26 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 13/49] perf build: Make mypy build test opt-out (NO_MYPY=1) Ian Rogers
2026-09-21 5:30 ` sashiko-bot
2026-09-22 13:11 ` James Clark
2026-09-22 16:59 ` Ian Rogers
2026-09-21 5:06 ` [PATCH v2 14/49] perf build: Make pylint build test opt-out (NO_PYLINT=1) Ian Rogers
2026-09-21 5:29 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 15/49] perf Makefile: Install standalone Python scripts during transition Ian Rogers
2026-09-21 5:28 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 16/49] perf python: Port stat-cpi to perf module Ian Rogers
2026-09-21 5:40 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 17/49] perf python: Port mem-phys-addr " Ian Rogers
2026-09-21 5:30 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 18/49] perf python: Port stackcollapse " Ian Rogers
2026-09-21 5:32 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 19/49] perf python: Port flamegraph " Ian Rogers
2026-09-21 5:31 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 20/49] perf python: Port gecko " Ian Rogers
2026-09-21 5:34 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 21/49] perf python: Port event_analyzing_sample " Ian Rogers
2026-09-21 5:36 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 22/49] perf python: Port syscall-counts " Ian Rogers
2026-09-21 5:36 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 23/49] perf python: Port syscall-counts-by-pid " Ian Rogers
2026-09-21 5:33 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 24/49] perf python: Port failed-syscalls-by-pid " Ian Rogers
2026-09-21 5:38 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 25/49] perf python: Port failed-syscalls from Perl " Ian Rogers
2026-09-21 5:33 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 26/49] perf python: Port sctop " Ian Rogers
2026-09-21 5:41 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 27/49] perf python: Port rw-by-file from Perl " Ian Rogers
2026-09-21 5:39 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 28/49] perf python: Port rw-by-pid " Ian Rogers
2026-09-21 5:38 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 29/49] perf python: Port rwtop " Ian Rogers
2026-09-21 5:39 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 30/49] perf python: Port futex-contention " Ian Rogers
2026-09-21 5:38 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 31/49] perf python: Port task-analyzer " Ian Rogers
2026-09-21 5:42 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 32/49] perf python: Port sched-migration and SchedGui " Ian Rogers
2026-09-21 5:38 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 33/49] perf python: Port wakeup-latency from Perl " Ian Rogers
2026-09-21 5:39 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 34/49] perf python: Port compaction-times " Ian Rogers
2026-09-21 5:41 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 35/49] perf python: Port net_dropmonitor " Ian Rogers
2026-09-21 5:38 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 36/49] perf python: Port netdev-times " Ian Rogers
2026-09-21 5:47 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 37/49] perf python: Port check-perf-trace " Ian Rogers
2026-09-21 5:44 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 38/49] perf python: Port arm-cs-trace-disasm " Ian Rogers
2026-09-21 5:48 ` sashiko-bot
2026-09-22 13:12 ` James Clark
2026-09-23 5:23 ` Ian Rogers
2026-09-23 8:16 ` James Clark
2026-09-23 9:00 ` Leo Yan
2026-09-23 9:08 ` Leo Yan
2026-09-23 13:16 ` Ian Rogers
2026-09-23 13:40 ` Ian Rogers
2026-09-24 15:41 ` Leo Yan
2026-09-25 21:45 ` Ian Rogers
2026-09-21 5:06 ` [PATCH v2 39/49] perf python: Port powerpc-hcalls " Ian Rogers
2026-09-21 5:41 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 40/49] perf python: Port intel-pt-events and libxed " Ian Rogers
2026-09-21 5:42 ` sashiko-bot
2026-09-21 5:06 ` [PATCH v2 41/49] perf test: Migrate Intel PT virtual LBR test to Python API Ian Rogers
2026-09-21 5:42 ` sashiko-bot
2026-09-21 5:07 ` [PATCH v2 42/49] perf python: Port export-to-sqlite to perf module Ian Rogers
2026-09-21 5:46 ` sashiko-bot
2026-09-21 5:07 ` [PATCH v2 43/49] perf python: Port export-to-postgresql " Ian Rogers
2026-09-21 5:49 ` sashiko-bot
2026-09-21 5:07 ` [PATCH v2 44/49] perf python: Move and clean up exported-sql-viewer.py Ian Rogers
2026-09-21 5:07 ` [PATCH v2 45/49] perf python: Move and clean up parallel-perf.py Ian Rogers
2026-09-21 5:45 ` sashiko-bot
2026-09-21 5:07 ` [PATCH v2 46/49] perf: Remove libpython support and legacy Python scripts Ian Rogers
2026-09-21 5:07 ` [PATCH v2 47/49] perf Makefile: Update Python script installation path Ian Rogers
2026-09-21 5:50 ` sashiko-bot
2026-09-21 5:07 ` [PATCH v2 48/49] perf script: Support standalone scripts and remove embedded scripting Ian Rogers
2026-09-21 5:56 ` sashiko-bot
2026-09-21 5:07 ` [PATCH v2 49/49] perf Documentation: Update for standalone Python scripts Ian Rogers
2026-09-21 5:45 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 00/49] perf: Complete transition to " Ian Rogers
2026-09-23 18:11 ` [PATCH v3 01/49] perf python: Update syscall helpers and expose arch_strerrno Ian Rogers
2026-09-23 18:23 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 02/49] perf python: Update callchain stubs and session thread lookup Ian Rogers
2026-09-23 18:22 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 03/49] perf python: Clean up pylint warnings in ilist.py Ian Rogers
2026-09-23 18:26 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 04/49] perf python: Clean up pylint warnings in treport.py Ian Rogers
2026-09-23 18:22 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 05/49] perf python: Clean up pylint warnings in tracepoint.py Ian Rogers
2026-09-23 18:19 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 06/49] perf python: Clean up pylint warnings in twatch.py Ian Rogers
2026-09-23 18:19 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 07/49] perf python: Improve perf script -l descriptions Ian Rogers
2026-09-23 18:20 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 08/49] perf python: Expose addr location, transaction, and context_switch Ian Rogers
2026-09-23 18:28 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 09/49] perf python: Add Intel PT call_return and itrace capability Ian Rogers
2026-09-23 18:30 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 10/49] perf python: Allow KeyboardInterrupt to propagate in LiveSession Ian Rogers
2026-09-23 18:22 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 11/49] perf pmu-events: Clean up mypy and pylint issues Ian Rogers
2026-09-23 18:24 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 12/49] perf test: Clean up mypy and pylint issues in shell test libraries Ian Rogers
2026-09-23 18:23 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 13/49] perf build: Make mypy build test opt-out (NO_MYPY=1) Ian Rogers
2026-09-23 18:25 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 14/49] perf build: Make pylint build test opt-out (NO_PYLINT=1) Ian Rogers
2026-09-23 18:27 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 15/49] perf Makefile: Install standalone Python scripts during transition Ian Rogers
2026-09-23 18:26 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 16/49] perf python: Port stat-cpi to perf module Ian Rogers
2026-09-23 18:28 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 17/49] perf python: Port mem-phys-addr " Ian Rogers
2026-09-23 18:26 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 18/49] perf python: Port stackcollapse " Ian Rogers
2026-09-23 18:30 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 19/49] perf python: Port flamegraph " Ian Rogers
2026-09-23 18:27 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 20/49] perf python: Port gecko " Ian Rogers
2026-09-23 18:32 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 21/49] perf python: Port event_analyzing_sample " Ian Rogers
2026-09-23 18:32 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 22/49] perf python: Port syscall-counts " Ian Rogers
2026-09-23 18:30 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 23/49] perf python: Port syscall-counts-by-pid " Ian Rogers
2026-09-23 18:33 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 24/49] perf python: Port failed-syscalls-by-pid " Ian Rogers
2026-09-23 18:33 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 25/49] perf python: Port failed-syscalls from Perl " Ian Rogers
2026-09-23 18:33 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 26/49] perf python: Port sctop " Ian Rogers
2026-09-23 18:35 ` sashiko-bot
2026-09-23 19:08 ` Ian Rogers
2026-09-23 18:11 ` [PATCH v3 27/49] perf python: Port rw-by-file from Perl " Ian Rogers
2026-09-23 18:35 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 28/49] perf python: Port rw-by-pid " Ian Rogers
2026-09-23 18:36 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 29/49] perf python: Port rwtop " Ian Rogers
2026-09-23 18:36 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 30/49] perf python: Port futex-contention " Ian Rogers
2026-09-23 18:35 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 31/49] perf python: Port task-analyzer " Ian Rogers
2026-09-23 18:38 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 32/49] perf python: Port sched-migration and SchedGui " Ian Rogers
2026-09-23 18:35 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 33/49] perf python: Port wakeup-latency from Perl " Ian Rogers
2026-09-23 18:39 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 34/49] perf python: Port compaction-times " Ian Rogers
2026-09-23 18:37 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 35/49] perf python: Port net_dropmonitor " Ian Rogers
2026-09-23 18:39 ` sashiko-bot
2026-09-23 18:11 ` [PATCH v3 36/49] perf python: Port netdev-times " Ian Rogers
2026-09-23 18:39 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 37/49] perf python: Port check-perf-trace " Ian Rogers
2026-09-23 18:38 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 38/49] perf python: Port arm-cs-trace-disasm " Ian Rogers
2026-09-23 18:40 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 39/49] perf python: Port powerpc-hcalls " Ian Rogers
2026-09-23 18:39 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 40/49] perf python: Port intel-pt-events and libxed " Ian Rogers
2026-09-23 18:40 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 41/49] perf test: Migrate Intel PT virtual LBR test to Python API Ian Rogers
2026-09-23 18:40 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 42/49] perf python: Port export-to-sqlite to perf module Ian Rogers
2026-09-23 18:42 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 43/49] perf python: Port export-to-postgresql " Ian Rogers
2026-09-23 18:47 ` sashiko-bot
2026-09-23 18:12 ` Ian Rogers [this message]
2026-09-23 18:12 ` [PATCH v3 45/49] perf python: Move and clean up parallel-perf.py Ian Rogers
2026-09-23 18:41 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 46/49] perf: Remove libpython support and legacy Python scripts Ian Rogers
2026-09-23 18:12 ` [PATCH v3 47/49] perf Makefile: Update Python script installation path Ian Rogers
2026-09-23 18:49 ` sashiko-bot
2026-09-23 18:12 ` [PATCH v3 48/49] perf script: Support standalone scripts and remove embedded scripting Ian Rogers
2026-09-23 18:49 ` sashiko-bot
2026-09-23 19:11 ` Ian Rogers
2026-09-23 18:12 ` [PATCH v3 49/49] perf Documentation: Update for standalone Python scripts Ian Rogers
2026-09-23 18:44 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 00/49] perf: Complete transition to " Ian Rogers
2026-09-26 6:19 ` [PATCH v4 01/49] perf python: Update syscall helpers and expose arch_strerrno Ian Rogers
2026-09-26 6:30 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 02/49] perf python: Update callchain stubs and session thread lookup Ian Rogers
2026-09-26 6:32 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 03/49] perf python: Clean up pylint warnings in ilist.py Ian Rogers
2026-09-26 6:32 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 04/49] perf python: Clean up pylint warnings in treport.py Ian Rogers
2026-09-26 6:30 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 05/49] perf python: Clean up pylint warnings in tracepoint.py Ian Rogers
2026-09-26 6:26 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 06/49] perf python: Clean up pylint warnings in twatch.py Ian Rogers
2026-09-26 6:26 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 07/49] perf python: Improve perf script -l descriptions Ian Rogers
2026-09-26 6:26 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 08/49] perf python: Expose addr location, transaction, and context_switch Ian Rogers
2026-09-26 6:36 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 09/49] perf python: Add Intel PT call_return and itrace capability Ian Rogers
2026-09-26 6:35 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 10/49] perf python: Allow KeyboardInterrupt to propagate in LiveSession Ian Rogers
2026-09-26 6:32 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 11/49] perf pmu-events: Clean up mypy and pylint issues Ian Rogers
2026-09-26 6:29 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 12/49] perf test: Clean up mypy and pylint issues in shell test libraries Ian Rogers
2026-09-26 6:29 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 13/49] perf build: Make mypy build test opt-out (NO_MYPY=1) Ian Rogers
2026-09-26 6:33 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 14/49] perf build: Make pylint build test opt-out (NO_PYLINT=1) Ian Rogers
2026-09-26 6:33 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 15/49] perf Makefile: Install standalone Python scripts during transition Ian Rogers
2026-09-26 6:28 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 16/49] perf python: Port stat-cpi to perf module Ian Rogers
2026-09-26 6:31 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 17/49] perf python: Port mem-phys-addr " Ian Rogers
2026-09-26 6:29 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 18/49] perf python: Port stackcollapse " Ian Rogers
2026-09-26 6:33 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 19/49] perf python: Port flamegraph " Ian Rogers
2026-09-26 6:30 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 20/49] perf python: Port gecko " Ian Rogers
2026-09-26 6:30 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 21/49] perf python: Port event_analyzing_sample " Ian Rogers
2026-09-26 6:34 ` sashiko-bot
2026-09-26 13:46 ` Ian Rogers
2026-09-26 6:19 ` [PATCH v4 22/49] perf python: Port syscall-counts " Ian Rogers
2026-09-26 6:31 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 23/49] perf python: Port syscall-counts-by-pid " Ian Rogers
2026-09-26 6:29 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 24/49] perf python: Port failed-syscalls-by-pid " Ian Rogers
2026-09-26 6:29 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 25/49] perf python: Port failed-syscalls from Perl " Ian Rogers
2026-09-26 6:32 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 26/49] perf python: Port sctop " Ian Rogers
2026-09-26 6:30 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 27/49] perf python: Port rw-by-file from Perl " Ian Rogers
2026-09-26 6:32 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 28/49] perf python: Port rw-by-pid " Ian Rogers
2026-09-26 6:34 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 29/49] perf python: Port rwtop " Ian Rogers
2026-09-26 6:35 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 30/49] perf python: Port futex-contention " Ian Rogers
2026-09-26 6:33 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 31/49] perf python: Port task-analyzer " Ian Rogers
2026-09-26 6:34 ` sashiko-bot
2026-09-26 6:19 ` [PATCH v4 32/49] perf python: Port sched-migration and SchedGui " Ian Rogers
2026-09-26 6:34 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 33/49] perf python: Port wakeup-latency from Perl " Ian Rogers
2026-09-26 6:35 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 34/49] perf python: Port compaction-times " Ian Rogers
2026-09-26 6:33 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 35/49] perf python: Port net_dropmonitor " Ian Rogers
2026-09-26 6:33 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 36/49] perf python: Port netdev-times " Ian Rogers
2026-09-26 6:34 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 37/49] perf python: Port check-perf-trace " Ian Rogers
2026-09-26 6:34 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 38/49] perf python: Port arm-cs-trace-disasm " Ian Rogers
2026-09-26 6:35 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 39/49] perf python: Port powerpc-hcalls " Ian Rogers
2026-09-26 6:35 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 40/49] perf python: Port intel-pt-events and libxed " Ian Rogers
2026-09-26 6:35 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 41/49] perf test: Migrate Intel PT virtual LBR test to Python API Ian Rogers
2026-09-26 6:36 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 42/49] perf python: Port export-to-sqlite to perf module Ian Rogers
2026-09-26 6:38 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 43/49] perf python: Port export-to-postgresql " Ian Rogers
2026-09-26 6:37 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 44/49] perf python: Move and clean up exported-sql-viewer.py Ian Rogers
2026-09-26 6:20 ` [PATCH v4 45/49] perf python: Move and clean up parallel-perf.py Ian Rogers
2026-09-26 6:37 ` sashiko-bot
2026-09-26 6:20 ` [PATCH v4 46/49] perf: Remove libpython support and legacy Python scripts Ian Rogers
2026-09-26 18:56 ` Arnaldo Carvalho de Melo
2026-09-26 6:20 ` [PATCH v4 47/49] perf Makefile: Update Python script installation path Ian Rogers
2026-09-26 6:43 ` sashiko-bot
2026-09-26 19:05 ` Arnaldo Carvalho de Melo
2026-09-26 6:20 ` [PATCH v4 48/49] perf script: Support standalone scripts and remove embedded scripting Ian Rogers
2026-09-26 6:42 ` sashiko-bot
2026-09-26 19:17 ` Arnaldo Carvalho de Melo
2026-09-26 6:20 ` [PATCH v4 49/49] perf Documentation: Update for standalone Python scripts Ian Rogers
2026-09-26 6:37 ` sashiko-bot
2026-09-26 20:41 ` [PATCH v4 00/49] perf: Complete transition to " Arnaldo Carvalho de Melo
2026-09-26 22:46 ` Ian Rogers
2026-09-26 23:11 ` Ian Rogers
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260923181213.3032038-45-irogers@google.com \
--to=irogers@google.com \
--cc=acme@kernel.org \
--cc=adrian.hunter@intel.com \
--cc=alice.mei.rogers@gmail.com \
--cc=dapeng1.mi@linux.intel.com \
--cc=james.clark@linaro.org \
--cc=leo.yan@linux.dev \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=mingo@redhat.com \
--cc=namhyung@kernel.org \
--cc=peterz@infradead.org \
--cc=tmricht@linux.ibm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.