From: Ian Rogers <irogers@google.com>
To: irogers@google.com, acme@kernel.org, alice.mei.rogers@gmail.com,
linux-perf-users@vger.kernel.org, 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, mingo@redhat.com,
peterz@infradead.org, tmricht@linux.ibm.com
Subject: [PATCH v2 44/49] perf python: Move and clean up exported-sql-viewer.py
Date: Sun, 20 Sep 2026 22:07:02 -0700 [thread overview]
Message-ID: <0ef7df36fe09988162fa1210fe5c73527d4de214.1789966896.git.irogers@google.com> (raw)
In-Reply-To: <cover.1789966896.git.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 | 5104 +++++++++++++++++
.../scripts/python/exported-sql-viewer.py | 5030 ----------------
2 files changed, 5104 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..bdd03c7fd5b6
--- /dev/null
+++ b/tools/perf/python/exported-sql-viewer.py
@@ -0,0 +1,5104 @@
+#!/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.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 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.55.0.1082.g2b9226bbc0-goog
next prev parent reply other threads:[~2026-09-21 5:08 UTC|newest]
Thread overview: 100+ 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:20 ` [PATCH v1 02/49] perf python: Update callchain stubs and session thread lookup Ian Rogers
2026-09-20 5:20 ` [PATCH v1 03/49] perf python: Clean up pylint warnings in ilist.py Ian Rogers
2026-09-20 5:20 ` [PATCH v1 04/49] perf python: Clean up pylint warnings in treport.py Ian Rogers
2026-09-20 5:20 ` [PATCH v1 05/49] perf python: Clean up pylint warnings in tracepoint.py Ian Rogers
2026-09-20 5:20 ` [PATCH v1 06/49] perf python: Clean up pylint warnings in twatch.py Ian Rogers
2026-09-20 5:20 ` [PATCH v1 07/49] perf python: Improve perf script -l descriptions Ian Rogers
2026-09-20 5:21 ` [PATCH v1 08/49] perf python: Expose addr location, transaction, and context_switch Ian Rogers
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:21 ` [PATCH v1 10/49] perf python: Allow KeyboardInterrupt to propagate in LiveSession Ian Rogers
2026-09-20 5:21 ` [PATCH v1 11/49] perf pmu-events: Clean up mypy and pylint issues Ian Rogers
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:21 ` [PATCH v1 13/49] perf build: Make mypy build test opt-out (NO_MYPY=1) Ian Rogers
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:21 ` [PATCH v1 15/49] perf Makefile: Install standalone Python scripts during transition Ian Rogers
2026-09-20 5:21 ` [PATCH v1 16/49] perf python: Port stat-cpi to perf module Ian Rogers
2026-09-20 5:21 ` [PATCH v1 17/49] perf python: Port mem-phys-addr " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 18/49] perf python: Port stackcollapse " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 19/49] perf python: Port flamegraph " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 20/49] perf python: Port gecko " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 21/49] perf python: Port event_analyzing_sample " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 22/49] perf python: Port syscall-counts " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 23/49] perf python: Port syscall-counts-by-pid " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 24/49] perf python: Port failed-syscalls-by-pid " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 25/49] perf python: Port failed-syscalls from Perl " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 26/49] perf python: Port sctop " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 27/49] perf python: Port rw-by-file from Perl " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 28/49] perf python: Port rw-by-pid " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 29/49] perf python: Port rwtop " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 30/49] perf python: Port futex-contention " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 31/49] perf python: Port task-analyzer " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 32/49] perf python: Port sched-migration and SchedGui " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 33/49] perf python: Port wakeup-latency from Perl " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 34/49] perf python: Port compaction-times " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 35/49] perf python: Port net_dropmonitor " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 36/49] perf python: Port netdev-times " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 37/49] perf python: Port check-perf-trace " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 38/49] perf python: Port arm-cs-trace-disasm " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 39/49] perf python: Port powerpc-hcalls " Ian Rogers
2026-09-20 5:21 ` [PATCH v1 40/49] perf python: Port intel-pt-events and libxed " Ian Rogers
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:21 ` [PATCH v1 42/49] perf python: Port export-to-sqlite to perf module Ian Rogers
2026-09-20 5:21 ` [PATCH v1 43/49] perf python: Port export-to-postgresql " Ian Rogers
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: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:21 ` [PATCH v1 48/49] perf script: Support standalone scripts and remove embedded scripting Ian Rogers
2026-09-20 5:21 ` [PATCH v1 49/49] perf Documentation: Update for standalone Python scripts Ian Rogers
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:06 ` [PATCH v2 02/49] perf python: Update callchain stubs and session thread lookup Ian Rogers
2026-09-21 5:06 ` [PATCH v2 03/49] perf python: Clean up pylint warnings in ilist.py Ian Rogers
2026-09-21 5:06 ` [PATCH v2 04/49] perf python: Clean up pylint warnings in treport.py Ian Rogers
2026-09-21 5:06 ` [PATCH v2 05/49] perf python: Clean up pylint warnings in tracepoint.py Ian Rogers
2026-09-21 5:06 ` [PATCH v2 06/49] perf python: Clean up pylint warnings in twatch.py Ian Rogers
2026-09-21 5:06 ` [PATCH v2 07/49] perf python: Improve perf script -l descriptions Ian Rogers
2026-09-21 5:06 ` [PATCH v2 08/49] perf python: Expose addr location, transaction, and context_switch Ian Rogers
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:06 ` [PATCH v2 10/49] perf python: Allow KeyboardInterrupt to propagate in LiveSession Ian Rogers
2026-09-21 5:06 ` [PATCH v2 11/49] perf pmu-events: Clean up mypy and pylint issues Ian Rogers
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:06 ` [PATCH v2 13/49] perf build: Make mypy build test opt-out (NO_MYPY=1) 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:06 ` [PATCH v2 15/49] perf Makefile: Install standalone Python scripts during transition Ian Rogers
2026-09-21 5:06 ` [PATCH v2 16/49] perf python: Port stat-cpi to perf module Ian Rogers
2026-09-21 5:06 ` [PATCH v2 17/49] perf python: Port mem-phys-addr " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 18/49] perf python: Port stackcollapse " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 19/49] perf python: Port flamegraph " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 20/49] perf python: Port gecko " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 21/49] perf python: Port event_analyzing_sample " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 22/49] perf python: Port syscall-counts " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 23/49] perf python: Port syscall-counts-by-pid " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 24/49] perf python: Port failed-syscalls-by-pid " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 25/49] perf python: Port failed-syscalls from Perl " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 26/49] perf python: Port sctop " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 27/49] perf python: Port rw-by-file from Perl " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 28/49] perf python: Port rw-by-pid " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 29/49] perf python: Port rwtop " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 30/49] perf python: Port futex-contention " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 31/49] perf python: Port task-analyzer " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 32/49] perf python: Port sched-migration and SchedGui " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 33/49] perf python: Port wakeup-latency from Perl " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 34/49] perf python: Port compaction-times " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 35/49] perf python: Port net_dropmonitor " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 36/49] perf python: Port netdev-times " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 37/49] perf python: Port check-perf-trace " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 38/49] perf python: Port arm-cs-trace-disasm " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 39/49] perf python: Port powerpc-hcalls " Ian Rogers
2026-09-21 5:06 ` [PATCH v2 40/49] perf python: Port intel-pt-events and libxed " Ian Rogers
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:07 ` [PATCH v2 42/49] perf python: Port export-to-sqlite to perf module Ian Rogers
2026-09-21 5:07 ` [PATCH v2 43/49] perf python: Port export-to-postgresql " Ian Rogers
2026-09-21 5:07 ` Ian Rogers [this message]
2026-09-21 5:07 ` [PATCH v2 45/49] perf python: Move and clean up parallel-perf.py Ian Rogers
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:07 ` [PATCH v2 48/49] perf script: Support standalone scripts and remove embedded scripting Ian Rogers
2026-09-21 5:07 ` [PATCH v2 49/49] perf Documentation: Update for standalone Python scripts 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=0ef7df36fe09988162fa1210fe5c73527d4de214.1789966896.git.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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®