1#!/usr/bin/env python2 2# SPDX-License-Identifier: GPL-2.0 3# exported-sql-viewer.py: view data from sql database 4# Copyright (c) 2014-2018, Intel Corporation. 5 6# To use this script you will need to have exported data using either the 7# export-to-sqlite.py or the export-to-postgresql.py script. Refer to those 8# scripts for details. 9# 10# Following on from the example in the export scripts, a 11# call-graph can be displayed for the pt_example database like this: 12# 13# python tools/perf/scripts/python/exported-sql-viewer.py pt_example 14# 15# Note that for PostgreSQL, this script supports connecting to remote databases 16# by setting hostname, port, username, password, and dbname e.g. 17# 18# python tools/perf/scripts/python/exported-sql-viewer.py "hostname=myhost username=myuser password=mypassword dbname=pt_example" 19# 20# The result is a GUI window with a tree representing a context-sensitive 21# call-graph. Expanding a couple of levels of the tree and adjusting column 22# widths to suit will display something like: 23# 24# Call Graph: pt_example 25# Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%) 26# v- ls 27# v- 2638:2638 28# v- _start ld-2.19.so 1 10074071 100.0 211135 100.0 29# |- unknown unknown 1 13198 0.1 1 0.0 30# >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3 31# >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3 32# v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4 33# >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1 34# >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0 35# >- __libc_csu_init ls 1 10354 0.1 10 0.0 36# |- _setjmp libc-2.19.so 1 0 0.0 4 0.0 37# v- main ls 1 8182043 99.6 180254 99.9 38# 39# Points to note: 40# The top level is a command name (comm) 41# The next level is a thread (pid:tid) 42# Subsequent levels are functions 43# 'Count' is the number of calls 44# 'Time' is the elapsed time until the function returns 45# Percentages are relative to the level above 46# 'Branch Count' is the total number of branches for that function and all 47# functions that it calls 48 49# There is also a "All branches" report, which displays branches and 50# possibly disassembly. However, presently, the only supported disassembler is 51# Intel XED, and additionally the object code must be present in perf build ID 52# cache. To use Intel XED, libxed.so must be present. To build and install 53# libxed.so: 54# git clone https://github.com/intelxed/mbuild.git mbuild 55# git clone https://github.com/intelxed/xed 56# cd xed 57# ./mfile.py --share 58# sudo ./mfile.py --prefix=/usr/local install 59# sudo ldconfig 60# 61# Example report: 62# 63# Time CPU Command PID TID Branch Type In Tx Branch 64# 8107675239590 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so) 65# 7fab593ea260 48 89 e7 mov %rsp, %rdi 66# 8107675239899 2 ls 22011 22011 hardware interrupt No 7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel]) 67# 8107675241900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so) 68# 7fab593ea260 48 89 e7 mov %rsp, %rdi 69# 7fab593ea263 e8 c8 06 00 00 callq 0x7fab593ea930 70# 8107675241900 2 ls 22011 22011 call No 7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so) 71# 7fab593ea930 55 pushq %rbp 72# 7fab593ea931 48 89 e5 mov %rsp, %rbp 73# 7fab593ea934 41 57 pushq %r15 74# 7fab593ea936 41 56 pushq %r14 75# 7fab593ea938 41 55 pushq %r13 76# 7fab593ea93a 41 54 pushq %r12 77# 7fab593ea93c 53 pushq %rbx 78# 7fab593ea93d 48 89 fb mov %rdi, %rbx 79# 7fab593ea940 48 83 ec 68 sub $0x68, %rsp 80# 7fab593ea944 0f 31 rdtsc 81# 7fab593ea946 48 c1 e2 20 shl $0x20, %rdx 82# 7fab593ea94a 89 c0 mov %eax, %eax 83# 7fab593ea94c 48 09 c2 or %rax, %rdx 84# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax 85# 8107675242232 2 ls 22011 22011 hardware interrupt No 7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel]) 86# 8107675242900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so) 87# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax 88# 7fab593ea956 48 89 15 3b 13 22 00 movq %rdx, 0x22133b(%rip) 89# 8107675243232 2 ls 22011 22011 hardware interrupt No 7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel]) 90 91import sys 92import weakref 93import threading 94import string 95import cPickle 96import re 97import os 98from PySide.QtCore import * 99from PySide.QtGui import * 100from PySide.QtSql import * 101from decimal import * 102from ctypes import * 103from multiprocessing import Process, Array, Value, Event 104 105# Data formatting helpers 106 107def tohex(ip): 108 if ip < 0: 109 ip += 1 << 64 110 return "%x" % ip 111 112def offstr(offset): 113 if offset: 114 return "+0x%x" % offset 115 return "" 116 117def dsoname(name): 118 if name == "[kernel.kallsyms]": 119 return "[kernel]" 120 return name 121 122def findnth(s, sub, n, offs=0): 123 pos = s.find(sub) 124 if pos < 0: 125 return pos 126 if n <= 1: 127 return offs + pos 128 return findnth(s[pos + 1:], sub, n - 1, offs + pos + 1) 129 130# Percent to one decimal place 131 132def PercentToOneDP(n, d): 133 if not d: 134 return "0.0" 135 x = (n * Decimal(100)) / d 136 return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP)) 137 138# Helper for queries that must not fail 139 140def QueryExec(query, stmt): 141 ret = query.exec_(stmt) 142 if not ret: 143 raise Exception("Query failed: " + query.lastError().text()) 144 145# Background thread 146 147class Thread(QThread): 148 149 done = Signal(object) 150 151 def __init__(self, task, param=None, parent=None): 152 super(Thread, self).__init__(parent) 153 self.task = task 154 self.param = param 155 156 def run(self): 157 while True: 158 if self.param is None: 159 done, result = self.task() 160 else: 161 done, result = self.task(self.param) 162 self.done.emit(result) 163 if done: 164 break 165 166# Tree data model 167 168class TreeModel(QAbstractItemModel): 169 170 def __init__(self, root, parent=None): 171 super(TreeModel, self).__init__(parent) 172 self.root = root 173 self.last_row_read = 0 174 175 def Item(self, parent): 176 if parent.isValid(): 177 return parent.internalPointer() 178 else: 179 return self.root 180 181 def rowCount(self, parent): 182 result = self.Item(parent).childCount() 183 if result < 0: 184 result = 0 185 self.dataChanged.emit(parent, parent) 186 return result 187 188 def hasChildren(self, parent): 189 return self.Item(parent).hasChildren() 190 191 def headerData(self, section, orientation, role): 192 if role == Qt.TextAlignmentRole: 193 return self.columnAlignment(section) 194 if role != Qt.DisplayRole: 195 return None 196 if orientation != Qt.Horizontal: 197 return None 198 return self.columnHeader(section) 199 200 def parent(self, child): 201 child_item = child.internalPointer() 202 if child_item is self.root: 203 return QModelIndex() 204 parent_item = child_item.getParentItem() 205 return self.createIndex(parent_item.getRow(), 0, parent_item) 206 207 def index(self, row, column, parent): 208 child_item = self.Item(parent).getChildItem(row) 209 return self.createIndex(row, column, child_item) 210 211 def DisplayData(self, item, index): 212 return item.getData(index.column()) 213 214 def FetchIfNeeded(self, row): 215 if row > self.last_row_read: 216 self.last_row_read = row 217 if row + 10 >= self.root.child_count: 218 self.fetcher.Fetch(glb_chunk_sz) 219 220 def columnAlignment(self, column): 221 return Qt.AlignLeft 222 223 def columnFont(self, column): 224 return None 225 226 def data(self, index, role): 227 if role == Qt.TextAlignmentRole: 228 return self.columnAlignment(index.column()) 229 if role == Qt.FontRole: 230 return self.columnFont(index.column()) 231 if role != Qt.DisplayRole: 232 return None 233 item = index.internalPointer() 234 return self.DisplayData(item, index) 235 236# Table data model 237 238class TableModel(QAbstractTableModel): 239 240 def __init__(self, parent=None): 241 super(TableModel, self).__init__(parent) 242 self.child_count = 0 243 self.child_items = [] 244 self.last_row_read = 0 245 246 def Item(self, parent): 247 if parent.isValid(): 248 return parent.internalPointer() 249 else: 250 return self 251 252 def rowCount(self, parent): 253 return self.child_count 254 255 def headerData(self, section, orientation, role): 256 if role == Qt.TextAlignmentRole: 257 return self.columnAlignment(section) 258 if role != Qt.DisplayRole: 259 return None 260 if orientation != Qt.Horizontal: 261 return None 262 return self.columnHeader(section) 263 264 def index(self, row, column, parent): 265 return self.createIndex(row, column, self.child_items[row]) 266 267 def DisplayData(self, item, index): 268 return item.getData(index.column()) 269 270 def FetchIfNeeded(self, row): 271 if row > self.last_row_read: 272 self.last_row_read = row 273 if row + 10 >= self.child_count: 274 self.fetcher.Fetch(glb_chunk_sz) 275 276 def columnAlignment(self, column): 277 return Qt.AlignLeft 278 279 def columnFont(self, column): 280 return None 281 282 def data(self, index, role): 283 if role == Qt.TextAlignmentRole: 284 return self.columnAlignment(index.column()) 285 if role == Qt.FontRole: 286 return self.columnFont(index.column()) 287 if role != Qt.DisplayRole: 288 return None 289 item = index.internalPointer() 290 return self.DisplayData(item, index) 291 292# Model cache 293 294model_cache = weakref.WeakValueDictionary() 295model_cache_lock = threading.Lock() 296 297def LookupCreateModel(model_name, create_fn): 298 model_cache_lock.acquire() 299 try: 300 model = model_cache[model_name] 301 except: 302 model = None 303 if model is None: 304 model = create_fn() 305 model_cache[model_name] = model 306 model_cache_lock.release() 307 return model 308 309# Find bar 310 311class FindBar(): 312 313 def __init__(self, parent, finder, is_reg_expr=False): 314 self.finder = finder 315 self.context = [] 316 self.last_value = None 317 self.last_pattern = None 318 319 label = QLabel("Find:") 320 label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 321 322 self.textbox = QComboBox() 323 self.textbox.setEditable(True) 324 self.textbox.currentIndexChanged.connect(self.ValueChanged) 325 326 self.progress = QProgressBar() 327 self.progress.setRange(0, 0) 328 self.progress.hide() 329 330 if is_reg_expr: 331 self.pattern = QCheckBox("Regular Expression") 332 else: 333 self.pattern = QCheckBox("Pattern") 334 self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 335 336 self.next_button = QToolButton() 337 self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown)) 338 self.next_button.released.connect(lambda: self.NextPrev(1)) 339 340 self.prev_button = QToolButton() 341 self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp)) 342 self.prev_button.released.connect(lambda: self.NextPrev(-1)) 343 344 self.close_button = QToolButton() 345 self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton)) 346 self.close_button.released.connect(self.Deactivate) 347 348 self.hbox = QHBoxLayout() 349 self.hbox.setContentsMargins(0, 0, 0, 0) 350 351 self.hbox.addWidget(label) 352 self.hbox.addWidget(self.textbox) 353 self.hbox.addWidget(self.progress) 354 self.hbox.addWidget(self.pattern) 355 self.hbox.addWidget(self.next_button) 356 self.hbox.addWidget(self.prev_button) 357 self.hbox.addWidget(self.close_button) 358 359 self.bar = QWidget() 360 self.bar.setLayout(self.hbox); 361 self.bar.hide() 362 363 def Widget(self): 364 return self.bar 365 366 def Activate(self): 367 self.bar.show() 368 self.textbox.setFocus() 369 370 def Deactivate(self): 371 self.bar.hide() 372 373 def Busy(self): 374 self.textbox.setEnabled(False) 375 self.pattern.hide() 376 self.next_button.hide() 377 self.prev_button.hide() 378 self.progress.show() 379 380 def Idle(self): 381 self.textbox.setEnabled(True) 382 self.progress.hide() 383 self.pattern.show() 384 self.next_button.show() 385 self.prev_button.show() 386 387 def Find(self, direction): 388 value = self.textbox.currentText() 389 pattern = self.pattern.isChecked() 390 self.last_value = value 391 self.last_pattern = pattern 392 self.finder.Find(value, direction, pattern, self.context) 393 394 def ValueChanged(self): 395 value = self.textbox.currentText() 396 pattern = self.pattern.isChecked() 397 index = self.textbox.currentIndex() 398 data = self.textbox.itemData(index) 399 # Store the pattern in the combo box to keep it with the text value 400 if data == None: 401 self.textbox.setItemData(index, pattern) 402 else: 403 self.pattern.setChecked(data) 404 self.Find(0) 405 406 def NextPrev(self, direction): 407 value = self.textbox.currentText() 408 pattern = self.pattern.isChecked() 409 if value != self.last_value: 410 index = self.textbox.findText(value) 411 # Allow for a button press before the value has been added to the combo box 412 if index < 0: 413 index = self.textbox.count() 414 self.textbox.addItem(value, pattern) 415 self.textbox.setCurrentIndex(index) 416 return 417 else: 418 self.textbox.setItemData(index, pattern) 419 elif pattern != self.last_pattern: 420 # Keep the pattern recorded in the combo box up to date 421 index = self.textbox.currentIndex() 422 self.textbox.setItemData(index, pattern) 423 self.Find(direction) 424 425 def NotFound(self): 426 QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found") 427 428# Context-sensitive call graph data model item base 429 430class CallGraphLevelItemBase(object): 431 432 def __init__(self, glb, row, parent_item): 433 self.glb = glb 434 self.row = row 435 self.parent_item = parent_item 436 self.query_done = False; 437 self.child_count = 0 438 self.child_items = [] 439 440 def getChildItem(self, row): 441 return self.child_items[row] 442 443 def getParentItem(self): 444 return self.parent_item 445 446 def getRow(self): 447 return self.row 448 449 def childCount(self): 450 if not self.query_done: 451 self.Select() 452 if not self.child_count: 453 return -1 454 return self.child_count 455 456 def hasChildren(self): 457 if not self.query_done: 458 return True 459 return self.child_count > 0 460 461 def getData(self, column): 462 return self.data[column] 463 464# Context-sensitive call graph data model level 2+ item base 465 466class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase): 467 468 def __init__(self, glb, row, comm_id, thread_id, call_path_id, time, branch_count, parent_item): 469 super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, row, parent_item) 470 self.comm_id = comm_id 471 self.thread_id = thread_id 472 self.call_path_id = call_path_id 473 self.branch_count = branch_count 474 self.time = time 475 476 def Select(self): 477 self.query_done = True; 478 query = QSqlQuery(self.glb.db) 479 QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time), SUM(branch_count)" 480 " FROM calls" 481 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id" 482 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id" 483 " INNER JOIN dsos ON symbols.dso_id = dsos.id" 484 " WHERE parent_call_path_id = " + str(self.call_path_id) + 485 " AND comm_id = " + str(self.comm_id) + 486 " AND thread_id = " + str(self.thread_id) + 487 " GROUP BY call_path_id, name, short_name" 488 " ORDER BY call_path_id") 489 while query.next(): 490 child_item = CallGraphLevelThreeItem(self.glb, 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)), int(query.value(5)), self) 491 self.child_items.append(child_item) 492 self.child_count += 1 493 494# Context-sensitive call graph data model level three item 495 496class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase): 497 498 def __init__(self, glb, row, comm_id, thread_id, call_path_id, name, dso, count, time, branch_count, parent_item): 499 super(CallGraphLevelThreeItem, self).__init__(glb, row, comm_id, thread_id, call_path_id, time, branch_count, parent_item) 500 dso = dsoname(dso) 501 self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ] 502 self.dbid = call_path_id 503 504# Context-sensitive call graph data model level two item 505 506class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase): 507 508 def __init__(self, glb, row, comm_id, thread_id, pid, tid, parent_item): 509 super(CallGraphLevelTwoItem, self).__init__(glb, row, comm_id, thread_id, 1, 0, 0, parent_item) 510 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""] 511 self.dbid = thread_id 512 513 def Select(self): 514 super(CallGraphLevelTwoItem, self).Select() 515 for child_item in self.child_items: 516 self.time += child_item.time 517 self.branch_count += child_item.branch_count 518 for child_item in self.child_items: 519 child_item.data[4] = PercentToOneDP(child_item.time, self.time) 520 child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count) 521 522# Context-sensitive call graph data model level one item 523 524class CallGraphLevelOneItem(CallGraphLevelItemBase): 525 526 def __init__(self, glb, row, comm_id, comm, parent_item): 527 super(CallGraphLevelOneItem, self).__init__(glb, row, parent_item) 528 self.data = [comm, "", "", "", "", "", ""] 529 self.dbid = comm_id 530 531 def Select(self): 532 self.query_done = True; 533 query = QSqlQuery(self.glb.db) 534 QueryExec(query, "SELECT thread_id, pid, tid" 535 " FROM comm_threads" 536 " INNER JOIN threads ON thread_id = threads.id" 537 " WHERE comm_id = " + str(self.dbid)) 538 while query.next(): 539 child_item = CallGraphLevelTwoItem(self.glb, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self) 540 self.child_items.append(child_item) 541 self.child_count += 1 542 543# Context-sensitive call graph data model root item 544 545class CallGraphRootItem(CallGraphLevelItemBase): 546 547 def __init__(self, glb): 548 super(CallGraphRootItem, self).__init__(glb, 0, None) 549 self.dbid = 0 550 self.query_done = True; 551 query = QSqlQuery(glb.db) 552 QueryExec(query, "SELECT id, comm FROM comms") 553 while query.next(): 554 if not query.value(0): 555 continue 556 child_item = CallGraphLevelOneItem(glb, self.child_count, query.value(0), query.value(1), self) 557 self.child_items.append(child_item) 558 self.child_count += 1 559 560# Context-sensitive call graph data model 561 562class CallGraphModel(TreeModel): 563 564 def __init__(self, glb, parent=None): 565 super(CallGraphModel, self).__init__(CallGraphRootItem(glb), parent) 566 self.glb = glb 567 568 def columnCount(self, parent=None): 569 return 7 570 571 def columnHeader(self, column): 572 headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "] 573 return headers[column] 574 575 def columnAlignment(self, column): 576 alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ] 577 return alignment[column] 578 579 def FindSelect(self, value, pattern, query): 580 if pattern: 581 # postgresql and sqlite pattern patching differences: 582 # postgresql LIKE is case sensitive but sqlite LIKE is not 583 # postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not 584 # postgresql supports ILIKE which is case insensitive 585 # sqlite supports GLOB (text only) which uses * and ? and is case sensitive 586 if not self.glb.dbref.is_sqlite3: 587 # Escape % and _ 588 s = value.replace("%", "\%") 589 s = s.replace("_", "\_") 590 # Translate * and ? into SQL LIKE pattern characters % and _ 591 trans = string.maketrans("*?", "%_") 592 match = " LIKE '" + str(s).translate(trans) + "'" 593 else: 594 match = " GLOB '" + str(value) + "'" 595 else: 596 match = " = '" + str(value) + "'" 597 QueryExec(query, "SELECT call_path_id, comm_id, thread_id" 598 " FROM calls" 599 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id" 600 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id" 601 " WHERE symbols.name" + match + 602 " GROUP BY comm_id, thread_id, call_path_id" 603 " ORDER BY comm_id, thread_id, call_path_id") 604 605 def FindPath(self, query): 606 # Turn the query result into a list of ids that the tree view can walk 607 # to open the tree at the right place. 608 ids = [] 609 parent_id = query.value(0) 610 while parent_id: 611 ids.insert(0, parent_id) 612 q2 = QSqlQuery(self.glb.db) 613 QueryExec(q2, "SELECT parent_id" 614 " FROM call_paths" 615 " WHERE id = " + str(parent_id)) 616 if not q2.next(): 617 break 618 parent_id = q2.value(0) 619 # The call path root is not used 620 if ids[0] == 1: 621 del ids[0] 622 ids.insert(0, query.value(2)) 623 ids.insert(0, query.value(1)) 624 return ids 625 626 def Found(self, query, found): 627 if found: 628 return self.FindPath(query) 629 return [] 630 631 def FindValue(self, value, pattern, query, last_value, last_pattern): 632 if last_value == value and pattern == last_pattern: 633 found = query.first() 634 else: 635 self.FindSelect(value, pattern, query) 636 found = query.next() 637 return self.Found(query, found) 638 639 def FindNext(self, query): 640 found = query.next() 641 if not found: 642 found = query.first() 643 return self.Found(query, found) 644 645 def FindPrev(self, query): 646 found = query.previous() 647 if not found: 648 found = query.last() 649 return self.Found(query, found) 650 651 def FindThread(self, c): 652 if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern: 653 ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern) 654 elif c.direction > 0: 655 ids = self.FindNext(c.query) 656 else: 657 ids = self.FindPrev(c.query) 658 return (True, ids) 659 660 def Find(self, value, direction, pattern, context, callback): 661 class Context(): 662 def __init__(self, *x): 663 self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x 664 def Update(self, *x): 665 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern) 666 if len(context): 667 context[0].Update(value, direction, pattern) 668 else: 669 context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None)) 670 # Use a thread so the UI is not blocked during the SELECT 671 thread = Thread(self.FindThread, context[0]) 672 thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection) 673 thread.start() 674 675 def FindDone(self, thread, callback, ids): 676 callback(ids) 677 678# Vertical widget layout 679 680class VBox(): 681 682 def __init__(self, w1, w2, w3=None): 683 self.vbox = QWidget() 684 self.vbox.setLayout(QVBoxLayout()); 685 686 self.vbox.layout().setContentsMargins(0, 0, 0, 0) 687 688 self.vbox.layout().addWidget(w1) 689 self.vbox.layout().addWidget(w2) 690 if w3: 691 self.vbox.layout().addWidget(w3) 692 693 def Widget(self): 694 return self.vbox 695 696# Context-sensitive call graph window 697 698class CallGraphWindow(QMdiSubWindow): 699 700 def __init__(self, glb, parent=None): 701 super(CallGraphWindow, self).__init__(parent) 702 703 self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x)) 704 705 self.view = QTreeView() 706 self.view.setModel(self.model) 707 708 for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)): 709 self.view.setColumnWidth(c, w) 710 711 self.find_bar = FindBar(self, self) 712 713 self.vbox = VBox(self.view, self.find_bar.Widget()) 714 715 self.setWidget(self.vbox.Widget()) 716 717 AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph") 718 719 def DisplayFound(self, ids): 720 if not len(ids): 721 return False 722 parent = QModelIndex() 723 for dbid in ids: 724 found = False 725 n = self.model.rowCount(parent) 726 for row in xrange(n): 727 child = self.model.index(row, 0, parent) 728 if child.internalPointer().dbid == dbid: 729 found = True 730 self.view.setCurrentIndex(child) 731 parent = child 732 break 733 if not found: 734 break 735 return found 736 737 def Find(self, value, direction, pattern, context): 738 self.view.setFocus() 739 self.find_bar.Busy() 740 self.model.Find(value, direction, pattern, context, self.FindDone) 741 742 def FindDone(self, ids): 743 found = True 744 if not self.DisplayFound(ids): 745 found = False 746 self.find_bar.Idle() 747 if not found: 748 self.find_bar.NotFound() 749 750# Child data item finder 751 752class ChildDataItemFinder(): 753 754 def __init__(self, root): 755 self.root = root 756 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5 757 self.rows = [] 758 self.pos = 0 759 760 def FindSelect(self): 761 self.rows = [] 762 if self.pattern: 763 pattern = re.compile(self.value) 764 for child in self.root.child_items: 765 for column_data in child.data: 766 if re.search(pattern, str(column_data)) is not None: 767 self.rows.append(child.row) 768 break 769 else: 770 for child in self.root.child_items: 771 for column_data in child.data: 772 if self.value in str(column_data): 773 self.rows.append(child.row) 774 break 775 776 def FindValue(self): 777 self.pos = 0 778 if self.last_value != self.value or self.pattern != self.last_pattern: 779 self.FindSelect() 780 if not len(self.rows): 781 return -1 782 return self.rows[self.pos] 783 784 def FindThread(self): 785 if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern: 786 row = self.FindValue() 787 elif len(self.rows): 788 if self.direction > 0: 789 self.pos += 1 790 if self.pos >= len(self.rows): 791 self.pos = 0 792 else: 793 self.pos -= 1 794 if self.pos < 0: 795 self.pos = len(self.rows) - 1 796 row = self.rows[self.pos] 797 else: 798 row = -1 799 return (True, row) 800 801 def Find(self, value, direction, pattern, context, callback): 802 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern) 803 # Use a thread so the UI is not blocked 804 thread = Thread(self.FindThread) 805 thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection) 806 thread.start() 807 808 def FindDone(self, thread, callback, row): 809 callback(row) 810 811# Number of database records to fetch in one go 812 813glb_chunk_sz = 10000 814 815# size of pickled integer big enough for record size 816 817glb_nsz = 8 818 819# Background process for SQL data fetcher 820 821class SQLFetcherProcess(): 822 823 def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep): 824 # Need a unique connection name 825 conn_name = "SQLFetcher" + str(os.getpid()) 826 self.db, dbname = dbref.Open(conn_name) 827 self.sql = sql 828 self.buffer = buffer 829 self.head = head 830 self.tail = tail 831 self.fetch_count = fetch_count 832 self.fetching_done = fetching_done 833 self.process_target = process_target 834 self.wait_event = wait_event 835 self.fetched_event = fetched_event 836 self.prep = prep 837 self.query = QSqlQuery(self.db) 838 self.query_limit = 0 if "$$last_id$$" in sql else 2 839 self.last_id = -1 840 self.fetched = 0 841 self.more = True 842 self.local_head = self.head.value 843 self.local_tail = self.tail.value 844 845 def Select(self): 846 if self.query_limit: 847 if self.query_limit == 1: 848 return 849 self.query_limit -= 1 850 stmt = self.sql.replace("$$last_id$$", str(self.last_id)) 851 QueryExec(self.query, stmt) 852 853 def Next(self): 854 if not self.query.next(): 855 self.Select() 856 if not self.query.next(): 857 return None 858 self.last_id = self.query.value(0) 859 return self.prep(self.query) 860 861 def WaitForTarget(self): 862 while True: 863 self.wait_event.clear() 864 target = self.process_target.value 865 if target > self.fetched or target < 0: 866 break 867 self.wait_event.wait() 868 return target 869 870 def HasSpace(self, sz): 871 if self.local_tail <= self.local_head: 872 space = len(self.buffer) - self.local_head 873 if space > sz: 874 return True 875 if space >= glb_nsz: 876 # Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer 877 nd = cPickle.dumps(0, cPickle.HIGHEST_PROTOCOL) 878 self.buffer[self.local_head : self.local_head + len(nd)] = nd 879 self.local_head = 0 880 if self.local_tail - self.local_head > sz: 881 return True 882 return False 883 884 def WaitForSpace(self, sz): 885 if self.HasSpace(sz): 886 return 887 while True: 888 self.wait_event.clear() 889 self.local_tail = self.tail.value 890 if self.HasSpace(sz): 891 return 892 self.wait_event.wait() 893 894 def AddToBuffer(self, obj): 895 d = cPickle.dumps(obj, cPickle.HIGHEST_PROTOCOL) 896 n = len(d) 897 nd = cPickle.dumps(n, cPickle.HIGHEST_PROTOCOL) 898 sz = n + glb_nsz 899 self.WaitForSpace(sz) 900 pos = self.local_head 901 self.buffer[pos : pos + len(nd)] = nd 902 self.buffer[pos + glb_nsz : pos + sz] = d 903 self.local_head += sz 904 905 def FetchBatch(self, batch_size): 906 fetched = 0 907 while batch_size > fetched: 908 obj = self.Next() 909 if obj is None: 910 self.more = False 911 break 912 self.AddToBuffer(obj) 913 fetched += 1 914 if fetched: 915 self.fetched += fetched 916 with self.fetch_count.get_lock(): 917 self.fetch_count.value += fetched 918 self.head.value = self.local_head 919 self.fetched_event.set() 920 921 def Run(self): 922 while self.more: 923 target = self.WaitForTarget() 924 if target < 0: 925 break 926 batch_size = min(glb_chunk_sz, target - self.fetched) 927 self.FetchBatch(batch_size) 928 self.fetching_done.value = True 929 self.fetched_event.set() 930 931def SQLFetcherFn(*x): 932 process = SQLFetcherProcess(*x) 933 process.Run() 934 935# SQL data fetcher 936 937class SQLFetcher(QObject): 938 939 done = Signal(object) 940 941 def __init__(self, glb, sql, prep, process_data, parent=None): 942 super(SQLFetcher, self).__init__(parent) 943 self.process_data = process_data 944 self.more = True 945 self.target = 0 946 self.last_target = 0 947 self.fetched = 0 948 self.buffer_size = 16 * 1024 * 1024 949 self.buffer = Array(c_char, self.buffer_size, lock=False) 950 self.head = Value(c_longlong) 951 self.tail = Value(c_longlong) 952 self.local_tail = 0 953 self.fetch_count = Value(c_longlong) 954 self.fetching_done = Value(c_bool) 955 self.last_count = 0 956 self.process_target = Value(c_longlong) 957 self.wait_event = Event() 958 self.fetched_event = Event() 959 glb.AddInstanceToShutdownOnExit(self) 960 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)) 961 self.process.start() 962 self.thread = Thread(self.Thread) 963 self.thread.done.connect(self.ProcessData, Qt.QueuedConnection) 964 self.thread.start() 965 966 def Shutdown(self): 967 # Tell the thread and process to exit 968 self.process_target.value = -1 969 self.wait_event.set() 970 self.more = False 971 self.fetching_done.value = True 972 self.fetched_event.set() 973 974 def Thread(self): 975 if not self.more: 976 return True, 0 977 while True: 978 self.fetched_event.clear() 979 fetch_count = self.fetch_count.value 980 if fetch_count != self.last_count: 981 break 982 if self.fetching_done.value: 983 self.more = False 984 return True, 0 985 self.fetched_event.wait() 986 count = fetch_count - self.last_count 987 self.last_count = fetch_count 988 self.fetched += count 989 return False, count 990 991 def Fetch(self, nr): 992 if not self.more: 993 # -1 inidcates there are no more 994 return -1 995 result = self.fetched 996 extra = result + nr - self.target 997 if extra > 0: 998 self.target += extra 999 # process_target < 0 indicates shutting down 1000 if self.process_target.value >= 0: 1001 self.process_target.value = self.target 1002 self.wait_event.set() 1003 return result 1004 1005 def RemoveFromBuffer(self): 1006 pos = self.local_tail 1007 if len(self.buffer) - pos < glb_nsz: 1008 pos = 0 1009 n = cPickle.loads(self.buffer[pos : pos + glb_nsz]) 1010 if n == 0: 1011 pos = 0 1012 n = cPickle.loads(self.buffer[0 : glb_nsz]) 1013 pos += glb_nsz 1014 obj = cPickle.loads(self.buffer[pos : pos + n]) 1015 self.local_tail = pos + n 1016 return obj 1017 1018 def ProcessData(self, count): 1019 for i in xrange(count): 1020 obj = self.RemoveFromBuffer() 1021 self.process_data(obj) 1022 self.tail.value = self.local_tail 1023 self.wait_event.set() 1024 self.done.emit(count) 1025 1026# Fetch more records bar 1027 1028class FetchMoreRecordsBar(): 1029 1030 def __init__(self, model, parent): 1031 self.model = model 1032 1033 self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:") 1034 self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 1035 1036 self.fetch_count = QSpinBox() 1037 self.fetch_count.setRange(1, 1000000) 1038 self.fetch_count.setValue(10) 1039 self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 1040 1041 self.fetch = QPushButton("Go!") 1042 self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 1043 self.fetch.released.connect(self.FetchMoreRecords) 1044 1045 self.progress = QProgressBar() 1046 self.progress.setRange(0, 100) 1047 self.progress.hide() 1048 1049 self.done_label = QLabel("All records fetched") 1050 self.done_label.hide() 1051 1052 self.spacer = QLabel("") 1053 1054 self.close_button = QToolButton() 1055 self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton)) 1056 self.close_button.released.connect(self.Deactivate) 1057 1058 self.hbox = QHBoxLayout() 1059 self.hbox.setContentsMargins(0, 0, 0, 0) 1060 1061 self.hbox.addWidget(self.label) 1062 self.hbox.addWidget(self.fetch_count) 1063 self.hbox.addWidget(self.fetch) 1064 self.hbox.addWidget(self.spacer) 1065 self.hbox.addWidget(self.progress) 1066 self.hbox.addWidget(self.done_label) 1067 self.hbox.addWidget(self.close_button) 1068 1069 self.bar = QWidget() 1070 self.bar.setLayout(self.hbox); 1071 self.bar.show() 1072 1073 self.in_progress = False 1074 self.model.progress.connect(self.Progress) 1075 1076 self.done = False 1077 1078 if not model.HasMoreRecords(): 1079 self.Done() 1080 1081 def Widget(self): 1082 return self.bar 1083 1084 def Activate(self): 1085 self.bar.show() 1086 self.fetch.setFocus() 1087 1088 def Deactivate(self): 1089 self.bar.hide() 1090 1091 def Enable(self, enable): 1092 self.fetch.setEnabled(enable) 1093 self.fetch_count.setEnabled(enable) 1094 1095 def Busy(self): 1096 self.Enable(False) 1097 self.fetch.hide() 1098 self.spacer.hide() 1099 self.progress.show() 1100 1101 def Idle(self): 1102 self.in_progress = False 1103 self.Enable(True) 1104 self.progress.hide() 1105 self.fetch.show() 1106 self.spacer.show() 1107 1108 def Target(self): 1109 return self.fetch_count.value() * glb_chunk_sz 1110 1111 def Done(self): 1112 self.done = True 1113 self.Idle() 1114 self.label.hide() 1115 self.fetch_count.hide() 1116 self.fetch.hide() 1117 self.spacer.hide() 1118 self.done_label.show() 1119 1120 def Progress(self, count): 1121 if self.in_progress: 1122 if count: 1123 percent = ((count - self.start) * 100) / self.Target() 1124 if percent >= 100: 1125 self.Idle() 1126 else: 1127 self.progress.setValue(percent) 1128 if not count: 1129 # Count value of zero means no more records 1130 self.Done() 1131 1132 def FetchMoreRecords(self): 1133 if self.done: 1134 return 1135 self.progress.setValue(0) 1136 self.Busy() 1137 self.in_progress = True 1138 self.start = self.model.FetchMoreRecords(self.Target()) 1139 1140# Brance data model level two item 1141 1142class BranchLevelTwoItem(): 1143 1144 def __init__(self, row, text, parent_item): 1145 self.row = row 1146 self.parent_item = parent_item 1147 self.data = [""] * 8 1148 self.data[7] = text 1149 self.level = 2 1150 1151 def getParentItem(self): 1152 return self.parent_item 1153 1154 def getRow(self): 1155 return self.row 1156 1157 def childCount(self): 1158 return 0 1159 1160 def hasChildren(self): 1161 return False 1162 1163 def getData(self, column): 1164 return self.data[column] 1165 1166# Brance data model level one item 1167 1168class BranchLevelOneItem(): 1169 1170 def __init__(self, glb, row, data, parent_item): 1171 self.glb = glb 1172 self.row = row 1173 self.parent_item = parent_item 1174 self.child_count = 0 1175 self.child_items = [] 1176 self.data = data[1:] 1177 self.dbid = data[0] 1178 self.level = 1 1179 self.query_done = False 1180 1181 def getChildItem(self, row): 1182 return self.child_items[row] 1183 1184 def getParentItem(self): 1185 return self.parent_item 1186 1187 def getRow(self): 1188 return self.row 1189 1190 def Select(self): 1191 self.query_done = True 1192 1193 if not self.glb.have_disassembler: 1194 return 1195 1196 query = QSqlQuery(self.glb.db) 1197 1198 QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip" 1199 " FROM samples" 1200 " INNER JOIN dsos ON samples.to_dso_id = dsos.id" 1201 " INNER JOIN symbols ON samples.to_symbol_id = symbols.id" 1202 " WHERE samples.id = " + str(self.dbid)) 1203 if not query.next(): 1204 return 1205 cpu = query.value(0) 1206 dso = query.value(1) 1207 sym = query.value(2) 1208 if dso == 0 or sym == 0: 1209 return 1210 off = query.value(3) 1211 short_name = query.value(4) 1212 long_name = query.value(5) 1213 build_id = query.value(6) 1214 sym_start = query.value(7) 1215 ip = query.value(8) 1216 1217 QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start" 1218 " FROM samples" 1219 " INNER JOIN symbols ON samples.symbol_id = symbols.id" 1220 " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) + 1221 " ORDER BY samples.id" 1222 " LIMIT 1") 1223 if not query.next(): 1224 return 1225 if query.value(0) != dso: 1226 # Cannot disassemble from one dso to another 1227 return 1228 bsym = query.value(1) 1229 boff = query.value(2) 1230 bsym_start = query.value(3) 1231 if bsym == 0: 1232 return 1233 tot = bsym_start + boff + 1 - sym_start - off 1234 if tot <= 0 or tot > 16384: 1235 return 1236 1237 inst = self.glb.disassembler.Instruction() 1238 f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id) 1239 if not f: 1240 return 1241 mode = 0 if Is64Bit(f) else 1 1242 self.glb.disassembler.SetMode(inst, mode) 1243 1244 buf_sz = tot + 16 1245 buf = create_string_buffer(tot + 16) 1246 f.seek(sym_start + off) 1247 buf.value = f.read(buf_sz) 1248 buf_ptr = addressof(buf) 1249 i = 0 1250 while tot > 0: 1251 cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip) 1252 if cnt: 1253 byte_str = tohex(ip).rjust(16) 1254 for k in xrange(cnt): 1255 byte_str += " %02x" % ord(buf[i]) 1256 i += 1 1257 while k < 15: 1258 byte_str += " " 1259 k += 1 1260 self.child_items.append(BranchLevelTwoItem(0, byte_str + " " + text, self)) 1261 self.child_count += 1 1262 else: 1263 return 1264 buf_ptr += cnt 1265 tot -= cnt 1266 buf_sz -= cnt 1267 ip += cnt 1268 1269 def childCount(self): 1270 if not self.query_done: 1271 self.Select() 1272 if not self.child_count: 1273 return -1 1274 return self.child_count 1275 1276 def hasChildren(self): 1277 if not self.query_done: 1278 return True 1279 return self.child_count > 0 1280 1281 def getData(self, column): 1282 return self.data[column] 1283 1284# Brance data model root item 1285 1286class BranchRootItem(): 1287 1288 def __init__(self): 1289 self.child_count = 0 1290 self.child_items = [] 1291 self.level = 0 1292 1293 def getChildItem(self, row): 1294 return self.child_items[row] 1295 1296 def getParentItem(self): 1297 return None 1298 1299 def getRow(self): 1300 return 0 1301 1302 def childCount(self): 1303 return self.child_count 1304 1305 def hasChildren(self): 1306 return self.child_count > 0 1307 1308 def getData(self, column): 1309 return "" 1310 1311# Branch data preparation 1312 1313def BranchDataPrep(query): 1314 data = [] 1315 for i in xrange(0, 8): 1316 data.append(query.value(i)) 1317 data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) + 1318 " (" + dsoname(query.value(11)) + ")" + " -> " + 1319 tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) + 1320 " (" + dsoname(query.value(15)) + ")") 1321 return data 1322 1323# Branch data model 1324 1325class BranchModel(TreeModel): 1326 1327 progress = Signal(object) 1328 1329 def __init__(self, glb, event_id, where_clause, parent=None): 1330 super(BranchModel, self).__init__(BranchRootItem(), parent) 1331 self.glb = glb 1332 self.event_id = event_id 1333 self.more = True 1334 self.populated = 0 1335 sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name," 1336 " CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END," 1337 " ip, symbols.name, sym_offset, dsos.short_name," 1338 " to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name" 1339 " FROM samples" 1340 " INNER JOIN comms ON comm_id = comms.id" 1341 " INNER JOIN threads ON thread_id = threads.id" 1342 " INNER JOIN branch_types ON branch_type = branch_types.id" 1343 " INNER JOIN symbols ON symbol_id = symbols.id" 1344 " INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id" 1345 " INNER JOIN dsos ON samples.dso_id = dsos.id" 1346 " INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id" 1347 " WHERE samples.id > $$last_id$$" + where_clause + 1348 " AND evsel_id = " + str(self.event_id) + 1349 " ORDER BY samples.id" 1350 " LIMIT " + str(glb_chunk_sz)) 1351 self.fetcher = SQLFetcher(glb, sql, BranchDataPrep, self.AddSample) 1352 self.fetcher.done.connect(self.Update) 1353 self.fetcher.Fetch(glb_chunk_sz) 1354 1355 def columnCount(self, parent=None): 1356 return 8 1357 1358 def columnHeader(self, column): 1359 return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column] 1360 1361 def columnFont(self, column): 1362 if column != 7: 1363 return None 1364 return QFont("Monospace") 1365 1366 def DisplayData(self, item, index): 1367 if item.level == 1: 1368 self.FetchIfNeeded(item.row) 1369 return item.getData(index.column()) 1370 1371 def AddSample(self, data): 1372 child = BranchLevelOneItem(self.glb, self.populated, data, self.root) 1373 self.root.child_items.append(child) 1374 self.populated += 1 1375 1376 def Update(self, fetched): 1377 if not fetched: 1378 self.more = False 1379 self.progress.emit(0) 1380 child_count = self.root.child_count 1381 count = self.populated - child_count 1382 if count > 0: 1383 parent = QModelIndex() 1384 self.beginInsertRows(parent, child_count, child_count + count - 1) 1385 self.insertRows(child_count, count, parent) 1386 self.root.child_count += count 1387 self.endInsertRows() 1388 self.progress.emit(self.root.child_count) 1389 1390 def FetchMoreRecords(self, count): 1391 current = self.root.child_count 1392 if self.more: 1393 self.fetcher.Fetch(count) 1394 else: 1395 self.progress.emit(0) 1396 return current 1397 1398 def HasMoreRecords(self): 1399 return self.more 1400 1401# Report Variables 1402 1403class ReportVars(): 1404 1405 def __init__(self, name = "", where_clause = ""): 1406 self.name = name 1407 self.where_clause = where_clause 1408 1409 def UniqueId(self): 1410 return str(self.where_clause) 1411 1412# Branch window 1413 1414class BranchWindow(QMdiSubWindow): 1415 1416 def __init__(self, glb, event_id, report_vars, parent=None): 1417 super(BranchWindow, self).__init__(parent) 1418 1419 model_name = "Branch Events " + str(event_id) + " " + report_vars.UniqueId() 1420 1421 self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_clause)) 1422 1423 self.view = QTreeView() 1424 self.view.setUniformRowHeights(True) 1425 self.view.setModel(self.model) 1426 1427 self.ResizeColumnsToContents() 1428 1429 self.find_bar = FindBar(self, self, True) 1430 1431 self.finder = ChildDataItemFinder(self.model.root) 1432 1433 self.fetch_bar = FetchMoreRecordsBar(self.model, self) 1434 1435 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget()) 1436 1437 self.setWidget(self.vbox.Widget()) 1438 1439 AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events") 1440 1441 def ResizeColumnToContents(self, column, n): 1442 # Using the view's resizeColumnToContents() here is extrememly slow 1443 # so implement a crude alternative 1444 mm = "MM" if column else "MMMM" 1445 font = self.view.font() 1446 metrics = QFontMetrics(font) 1447 max = 0 1448 for row in xrange(n): 1449 val = self.model.root.child_items[row].data[column] 1450 len = metrics.width(str(val) + mm) 1451 max = len if len > max else max 1452 val = self.model.columnHeader(column) 1453 len = metrics.width(str(val) + mm) 1454 max = len if len > max else max 1455 self.view.setColumnWidth(column, max) 1456 1457 def ResizeColumnsToContents(self): 1458 n = min(self.model.root.child_count, 100) 1459 if n < 1: 1460 # No data yet, so connect a signal to notify when there is 1461 self.model.rowsInserted.connect(self.UpdateColumnWidths) 1462 return 1463 columns = self.model.columnCount() 1464 for i in xrange(columns): 1465 self.ResizeColumnToContents(i, n) 1466 1467 def UpdateColumnWidths(self, *x): 1468 # This only needs to be done once, so disconnect the signal now 1469 self.model.rowsInserted.disconnect(self.UpdateColumnWidths) 1470 self.ResizeColumnsToContents() 1471 1472 def Find(self, value, direction, pattern, context): 1473 self.view.setFocus() 1474 self.find_bar.Busy() 1475 self.finder.Find(value, direction, pattern, context, self.FindDone) 1476 1477 def FindDone(self, row): 1478 self.find_bar.Idle() 1479 if row >= 0: 1480 self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex())) 1481 else: 1482 self.find_bar.NotFound() 1483 1484# Line edit data item 1485 1486class LineEditDataItem(object): 1487 1488 def __init__(self, glb, label, placeholder_text, parent, id = ""): 1489 self.glb = glb 1490 self.label = label 1491 self.placeholder_text = placeholder_text 1492 self.parent = parent 1493 self.id = id 1494 1495 self.value = "" 1496 1497 self.widget = QLineEdit() 1498 self.widget.editingFinished.connect(self.Validate) 1499 self.widget.textChanged.connect(self.Invalidate) 1500 self.red = False 1501 self.error = "" 1502 self.validated = True 1503 1504 if placeholder_text: 1505 self.widget.setPlaceholderText(placeholder_text) 1506 1507 def TurnTextRed(self): 1508 if not self.red: 1509 palette = QPalette() 1510 palette.setColor(QPalette.Text,Qt.red) 1511 self.widget.setPalette(palette) 1512 self.red = True 1513 1514 def TurnTextNormal(self): 1515 if self.red: 1516 palette = QPalette() 1517 self.widget.setPalette(palette) 1518 self.red = False 1519 1520 def InvalidValue(self, value): 1521 self.value = "" 1522 self.TurnTextRed() 1523 self.error = self.label + " invalid value '" + value + "'" 1524 self.parent.ShowMessage(self.error) 1525 1526 def Invalidate(self): 1527 self.validated = False 1528 1529 def DoValidate(self, input_string): 1530 self.value = input_string.strip() 1531 1532 def Validate(self): 1533 self.validated = True 1534 self.error = "" 1535 self.TurnTextNormal() 1536 self.parent.ClearMessage() 1537 input_string = self.widget.text() 1538 if not len(input_string.strip()): 1539 self.value = "" 1540 return 1541 self.DoValidate(input_string) 1542 1543 def IsValid(self): 1544 if not self.validated: 1545 self.Validate() 1546 if len(self.error): 1547 self.parent.ShowMessage(self.error) 1548 return False 1549 return True 1550 1551 def IsNumber(self, value): 1552 try: 1553 x = int(value) 1554 except: 1555 x = 0 1556 return str(x) == value 1557 1558# Non-negative integer ranges dialog data item 1559 1560class NonNegativeIntegerRangesDataItem(LineEditDataItem): 1561 1562 def __init__(self, glb, label, placeholder_text, column_name, parent): 1563 super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent) 1564 1565 self.column_name = column_name 1566 1567 def DoValidate(self, input_string): 1568 singles = [] 1569 ranges = [] 1570 for value in [x.strip() for x in input_string.split(",")]: 1571 if "-" in value: 1572 vrange = value.split("-") 1573 if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]): 1574 return self.InvalidValue(value) 1575 ranges.append(vrange) 1576 else: 1577 if not self.IsNumber(value): 1578 return self.InvalidValue(value) 1579 singles.append(value) 1580 ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges] 1581 if len(singles): 1582 ranges.append(self.column_name + " IN (" + ",".join(singles) + ")") 1583 self.value = " OR ".join(ranges) 1584 1585# Dialog data item converted and validated using a SQL table 1586 1587class SQLTableDataItem(LineEditDataItem): 1588 1589 def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_name2, parent): 1590 super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent) 1591 1592 self.table_name = table_name 1593 self.match_column = match_column 1594 self.column_name1 = column_name1 1595 self.column_name2 = column_name2 1596 1597 def ValueToIds(self, value): 1598 ids = [] 1599 query = QSqlQuery(self.glb.db) 1600 stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'" 1601 ret = query.exec_(stmt) 1602 if ret: 1603 while query.next(): 1604 ids.append(str(query.value(0))) 1605 return ids 1606 1607 def DoValidate(self, input_string): 1608 all_ids = [] 1609 for value in [x.strip() for x in input_string.split(",")]: 1610 ids = self.ValueToIds(value) 1611 if len(ids): 1612 all_ids.extend(ids) 1613 else: 1614 return self.InvalidValue(value) 1615 self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")" 1616 if self.column_name2: 1617 self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )" 1618 1619# Sample time ranges dialog data item converted and validated using 'samples' SQL table 1620 1621class SampleTimeRangesDataItem(LineEditDataItem): 1622 1623 def __init__(self, glb, label, placeholder_text, column_name, parent): 1624 self.column_name = column_name 1625 1626 self.last_id = 0 1627 self.first_time = 0 1628 self.last_time = 2 ** 64 1629 1630 query = QSqlQuery(glb.db) 1631 QueryExec(query, "SELECT id, time FROM samples ORDER BY id DESC LIMIT 1") 1632 if query.next(): 1633 self.last_id = int(query.value(0)) 1634 self.last_time = int(query.value(1)) 1635 QueryExec(query, "SELECT time FROM samples WHERE time != 0 ORDER BY id LIMIT 1") 1636 if query.next(): 1637 self.first_time = int(query.value(0)) 1638 if placeholder_text: 1639 placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time) 1640 1641 super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent) 1642 1643 def IdBetween(self, query, lower_id, higher_id, order): 1644 QueryExec(query, "SELECT id FROM samples WHERE id > " + str(lower_id) + " AND id < " + str(higher_id) + " ORDER BY id " + order + " LIMIT 1") 1645 if query.next(): 1646 return True, int(query.value(0)) 1647 else: 1648 return False, 0 1649 1650 def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor): 1651 query = QSqlQuery(self.glb.db) 1652 while True: 1653 next_id = int((lower_id + higher_id) / 2) 1654 QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id)) 1655 if not query.next(): 1656 ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC") 1657 if not ok: 1658 ok, dbid = self.IdBetween(query, next_id, higher_id, "") 1659 if not ok: 1660 return str(higher_id) 1661 next_id = dbid 1662 QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id)) 1663 next_time = int(query.value(0)) 1664 if get_floor: 1665 if target_time > next_time: 1666 lower_id = next_id 1667 else: 1668 higher_id = next_id 1669 if higher_id <= lower_id + 1: 1670 return str(higher_id) 1671 else: 1672 if target_time >= next_time: 1673 lower_id = next_id 1674 else: 1675 higher_id = next_id 1676 if higher_id <= lower_id + 1: 1677 return str(lower_id) 1678 1679 def ConvertRelativeTime(self, val): 1680 mult = 1 1681 suffix = val[-2:] 1682 if suffix == "ms": 1683 mult = 1000000 1684 elif suffix == "us": 1685 mult = 1000 1686 elif suffix == "ns": 1687 mult = 1 1688 else: 1689 return val 1690 val = val[:-2].strip() 1691 if not self.IsNumber(val): 1692 return val 1693 val = int(val) * mult 1694 if val >= 0: 1695 val += self.first_time 1696 else: 1697 val += self.last_time 1698 return str(val) 1699 1700 def ConvertTimeRange(self, vrange): 1701 if vrange[0] == "": 1702 vrange[0] = str(self.first_time) 1703 if vrange[1] == "": 1704 vrange[1] = str(self.last_time) 1705 vrange[0] = self.ConvertRelativeTime(vrange[0]) 1706 vrange[1] = self.ConvertRelativeTime(vrange[1]) 1707 if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]): 1708 return False 1709 beg_range = max(int(vrange[0]), self.first_time) 1710 end_range = min(int(vrange[1]), self.last_time) 1711 if beg_range > self.last_time or end_range < self.first_time: 1712 return False 1713 vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True) 1714 vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False) 1715 return True 1716 1717 def AddTimeRange(self, value, ranges): 1718 n = value.count("-") 1719 if n == 1: 1720 pass 1721 elif n == 2: 1722 if value.split("-")[1].strip() == "": 1723 n = 1 1724 elif n == 3: 1725 n = 2 1726 else: 1727 return False 1728 pos = findnth(value, "-", n) 1729 vrange = [value[:pos].strip() ,value[pos+1:].strip()] 1730 if self.ConvertTimeRange(vrange): 1731 ranges.append(vrange) 1732 return True 1733 return False 1734 1735 def DoValidate(self, input_string): 1736 ranges = [] 1737 for value in [x.strip() for x in input_string.split(",")]: 1738 if not self.AddTimeRange(value, ranges): 1739 return self.InvalidValue(value) 1740 ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges] 1741 self.value = " OR ".join(ranges) 1742 1743# Report Dialog Base 1744 1745class ReportDialogBase(QDialog): 1746 1747 def __init__(self, glb, title, items, partial, parent=None): 1748 super(ReportDialogBase, self).__init__(parent) 1749 1750 self.glb = glb 1751 1752 self.report_vars = ReportVars() 1753 1754 self.setWindowTitle(title) 1755 self.setMinimumWidth(600) 1756 1757 self.data_items = [x(glb, self) for x in items] 1758 1759 self.partial = partial 1760 1761 self.grid = QGridLayout() 1762 1763 for row in xrange(len(self.data_items)): 1764 self.grid.addWidget(QLabel(self.data_items[row].label), row, 0) 1765 self.grid.addWidget(self.data_items[row].widget, row, 1) 1766 1767 self.status = QLabel() 1768 1769 self.ok_button = QPushButton("Ok", self) 1770 self.ok_button.setDefault(True) 1771 self.ok_button.released.connect(self.Ok) 1772 self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 1773 1774 self.cancel_button = QPushButton("Cancel", self) 1775 self.cancel_button.released.connect(self.reject) 1776 self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 1777 1778 self.hbox = QHBoxLayout() 1779 #self.hbox.addStretch() 1780 self.hbox.addWidget(self.status) 1781 self.hbox.addWidget(self.ok_button) 1782 self.hbox.addWidget(self.cancel_button) 1783 1784 self.vbox = QVBoxLayout() 1785 self.vbox.addLayout(self.grid) 1786 self.vbox.addLayout(self.hbox) 1787 1788 self.setLayout(self.vbox); 1789 1790 def Ok(self): 1791 vars = self.report_vars 1792 for d in self.data_items: 1793 if d.id == "REPORTNAME": 1794 vars.name = d.value 1795 if not vars.name: 1796 self.ShowMessage("Report name is required") 1797 return 1798 for d in self.data_items: 1799 if not d.IsValid(): 1800 return 1801 for d in self.data_items[1:]: 1802 if len(d.value): 1803 if len(vars.where_clause): 1804 vars.where_clause += " AND " 1805 vars.where_clause += d.value 1806 if len(vars.where_clause): 1807 if self.partial: 1808 vars.where_clause = " AND ( " + vars.where_clause + " ) " 1809 else: 1810 vars.where_clause = " WHERE " + vars.where_clause + " " 1811 else: 1812 self.ShowMessage("No selection") 1813 return 1814 self.accept() 1815 1816 def ShowMessage(self, msg): 1817 self.status.setText("<font color=#FF0000>" + msg) 1818 1819 def ClearMessage(self): 1820 self.status.setText("") 1821 1822# Selected branch report creation dialog 1823 1824class SelectedBranchDialog(ReportDialogBase): 1825 1826 def __init__(self, glb, parent=None): 1827 title = "Selected Branches" 1828 items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"), 1829 lambda g, p: SampleTimeRangesDataItem(g, "Time ranges:", "Enter time ranges", "samples.id", p), 1830 lambda g, p: NonNegativeIntegerRangesDataItem(g, "CPUs:", "Enter CPUs or ranges e.g. 0,5-6", "cpu", p), 1831 lambda g, p: SQLTableDataItem(g, "Commands:", "Only branches with these commands will be included", "comms", "comm", "comm_id", "", p), 1832 lambda g, p: SQLTableDataItem(g, "PIDs:", "Only branches with these process IDs will be included", "threads", "pid", "thread_id", "", p), 1833 lambda g, p: SQLTableDataItem(g, "TIDs:", "Only branches with these thread IDs will be included", "threads", "tid", "thread_id", "", p), 1834 lambda g, p: SQLTableDataItem(g, "DSOs:", "Only branches with these DSOs will be included", "dsos", "short_name", "samples.dso_id", "to_dso_id", p), 1835 lambda g, p: SQLTableDataItem(g, "Symbols:", "Only branches with these symbols will be included", "symbols", "name", "symbol_id", "to_symbol_id", p), 1836 lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p)) 1837 super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent) 1838 1839# Event list 1840 1841def GetEventList(db): 1842 events = [] 1843 query = QSqlQuery(db) 1844 QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id") 1845 while query.next(): 1846 events.append(query.value(0)) 1847 return events 1848 1849# Is a table selectable 1850 1851def IsSelectable(db, table): 1852 query = QSqlQuery(db) 1853 try: 1854 QueryExec(query, "SELECT * FROM " + table + " LIMIT 1") 1855 except: 1856 return False 1857 return True 1858 1859# SQL data preparation 1860 1861def SQLTableDataPrep(query, count): 1862 data = [] 1863 for i in xrange(count): 1864 data.append(query.value(i)) 1865 return data 1866 1867# SQL table data model item 1868 1869class SQLTableItem(): 1870 1871 def __init__(self, row, data): 1872 self.row = row 1873 self.data = data 1874 1875 def getData(self, column): 1876 return self.data[column] 1877 1878# SQL table data model 1879 1880class SQLTableModel(TableModel): 1881 1882 progress = Signal(object) 1883 1884 def __init__(self, glb, sql, column_headers, parent=None): 1885 super(SQLTableModel, self).__init__(parent) 1886 self.glb = glb 1887 self.more = True 1888 self.populated = 0 1889 self.column_headers = column_headers 1890 self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): SQLTableDataPrep(x, y), self.AddSample) 1891 self.fetcher.done.connect(self.Update) 1892 self.fetcher.Fetch(glb_chunk_sz) 1893 1894 def DisplayData(self, item, index): 1895 self.FetchIfNeeded(item.row) 1896 return item.getData(index.column()) 1897 1898 def AddSample(self, data): 1899 child = SQLTableItem(self.populated, data) 1900 self.child_items.append(child) 1901 self.populated += 1 1902 1903 def Update(self, fetched): 1904 if not fetched: 1905 self.more = False 1906 self.progress.emit(0) 1907 child_count = self.child_count 1908 count = self.populated - child_count 1909 if count > 0: 1910 parent = QModelIndex() 1911 self.beginInsertRows(parent, child_count, child_count + count - 1) 1912 self.insertRows(child_count, count, parent) 1913 self.child_count += count 1914 self.endInsertRows() 1915 self.progress.emit(self.child_count) 1916 1917 def FetchMoreRecords(self, count): 1918 current = self.child_count 1919 if self.more: 1920 self.fetcher.Fetch(count) 1921 else: 1922 self.progress.emit(0) 1923 return current 1924 1925 def HasMoreRecords(self): 1926 return self.more 1927 1928 def columnCount(self, parent=None): 1929 return len(self.column_headers) 1930 1931 def columnHeader(self, column): 1932 return self.column_headers[column] 1933 1934# SQL automatic table data model 1935 1936class SQLAutoTableModel(SQLTableModel): 1937 1938 def __init__(self, glb, table_name, parent=None): 1939 sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz) 1940 if table_name == "comm_threads_view": 1941 # For now, comm_threads_view has no id column 1942 sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz) 1943 column_headers = [] 1944 query = QSqlQuery(glb.db) 1945 if glb.dbref.is_sqlite3: 1946 QueryExec(query, "PRAGMA table_info(" + table_name + ")") 1947 while query.next(): 1948 column_headers.append(query.value(1)) 1949 if table_name == "sqlite_master": 1950 sql = "SELECT * FROM " + table_name 1951 else: 1952 if table_name[:19] == "information_schema.": 1953 sql = "SELECT * FROM " + table_name 1954 select_table_name = table_name[19:] 1955 schema = "information_schema" 1956 else: 1957 select_table_name = table_name 1958 schema = "public" 1959 QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'") 1960 while query.next(): 1961 column_headers.append(query.value(0)) 1962 super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent) 1963 1964# Base class for custom ResizeColumnsToContents 1965 1966class ResizeColumnsToContentsBase(QObject): 1967 1968 def __init__(self, parent=None): 1969 super(ResizeColumnsToContentsBase, self).__init__(parent) 1970 1971 def ResizeColumnToContents(self, column, n): 1972 # Using the view's resizeColumnToContents() here is extrememly slow 1973 # so implement a crude alternative 1974 font = self.view.font() 1975 metrics = QFontMetrics(font) 1976 max = 0 1977 for row in xrange(n): 1978 val = self.data_model.child_items[row].data[column] 1979 len = metrics.width(str(val) + "MM") 1980 max = len if len > max else max 1981 val = self.data_model.columnHeader(column) 1982 len = metrics.width(str(val) + "MM") 1983 max = len if len > max else max 1984 self.view.setColumnWidth(column, max) 1985 1986 def ResizeColumnsToContents(self): 1987 n = min(self.data_model.child_count, 100) 1988 if n < 1: 1989 # No data yet, so connect a signal to notify when there is 1990 self.data_model.rowsInserted.connect(self.UpdateColumnWidths) 1991 return 1992 columns = self.data_model.columnCount() 1993 for i in xrange(columns): 1994 self.ResizeColumnToContents(i, n) 1995 1996 def UpdateColumnWidths(self, *x): 1997 # This only needs to be done once, so disconnect the signal now 1998 self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths) 1999 self.ResizeColumnsToContents() 2000 2001# Table window 2002 2003class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase): 2004 2005 def __init__(self, glb, table_name, parent=None): 2006 super(TableWindow, self).__init__(parent) 2007 2008 self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name)) 2009 2010 self.model = QSortFilterProxyModel() 2011 self.model.setSourceModel(self.data_model) 2012 2013 self.view = QTableView() 2014 self.view.setModel(self.model) 2015 self.view.setEditTriggers(QAbstractItemView.NoEditTriggers) 2016 self.view.verticalHeader().setVisible(False) 2017 self.view.sortByColumn(-1, Qt.AscendingOrder) 2018 self.view.setSortingEnabled(True) 2019 2020 self.ResizeColumnsToContents() 2021 2022 self.find_bar = FindBar(self, self, True) 2023 2024 self.finder = ChildDataItemFinder(self.data_model) 2025 2026 self.fetch_bar = FetchMoreRecordsBar(self.data_model, self) 2027 2028 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget()) 2029 2030 self.setWidget(self.vbox.Widget()) 2031 2032 AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table") 2033 2034 def Find(self, value, direction, pattern, context): 2035 self.view.setFocus() 2036 self.find_bar.Busy() 2037 self.finder.Find(value, direction, pattern, context, self.FindDone) 2038 2039 def FindDone(self, row): 2040 self.find_bar.Idle() 2041 if row >= 0: 2042 self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex()))) 2043 else: 2044 self.find_bar.NotFound() 2045 2046# Table list 2047 2048def GetTableList(glb): 2049 tables = [] 2050 query = QSqlQuery(glb.db) 2051 if glb.dbref.is_sqlite3: 2052 QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name") 2053 else: 2054 QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name") 2055 while query.next(): 2056 tables.append(query.value(0)) 2057 if glb.dbref.is_sqlite3: 2058 tables.append("sqlite_master") 2059 else: 2060 tables.append("information_schema.tables") 2061 tables.append("information_schema.views") 2062 tables.append("information_schema.columns") 2063 return tables 2064 2065# Action Definition 2066 2067def CreateAction(label, tip, callback, parent=None, shortcut=None): 2068 action = QAction(label, parent) 2069 if shortcut != None: 2070 action.setShortcuts(shortcut) 2071 action.setStatusTip(tip) 2072 action.triggered.connect(callback) 2073 return action 2074 2075# Typical application actions 2076 2077def CreateExitAction(app, parent=None): 2078 return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit) 2079 2080# Typical MDI actions 2081 2082def CreateCloseActiveWindowAction(mdi_area): 2083 return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area) 2084 2085def CreateCloseAllWindowsAction(mdi_area): 2086 return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area) 2087 2088def CreateTileWindowsAction(mdi_area): 2089 return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area) 2090 2091def CreateCascadeWindowsAction(mdi_area): 2092 return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area) 2093 2094def CreateNextWindowAction(mdi_area): 2095 return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild) 2096 2097def CreatePreviousWindowAction(mdi_area): 2098 return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild) 2099 2100# Typical MDI window menu 2101 2102class WindowMenu(): 2103 2104 def __init__(self, mdi_area, menu): 2105 self.mdi_area = mdi_area 2106 self.window_menu = menu.addMenu("&Windows") 2107 self.close_active_window = CreateCloseActiveWindowAction(mdi_area) 2108 self.close_all_windows = CreateCloseAllWindowsAction(mdi_area) 2109 self.tile_windows = CreateTileWindowsAction(mdi_area) 2110 self.cascade_windows = CreateCascadeWindowsAction(mdi_area) 2111 self.next_window = CreateNextWindowAction(mdi_area) 2112 self.previous_window = CreatePreviousWindowAction(mdi_area) 2113 self.window_menu.aboutToShow.connect(self.Update) 2114 2115 def Update(self): 2116 self.window_menu.clear() 2117 sub_window_count = len(self.mdi_area.subWindowList()) 2118 have_sub_windows = sub_window_count != 0 2119 self.close_active_window.setEnabled(have_sub_windows) 2120 self.close_all_windows.setEnabled(have_sub_windows) 2121 self.tile_windows.setEnabled(have_sub_windows) 2122 self.cascade_windows.setEnabled(have_sub_windows) 2123 self.next_window.setEnabled(have_sub_windows) 2124 self.previous_window.setEnabled(have_sub_windows) 2125 self.window_menu.addAction(self.close_active_window) 2126 self.window_menu.addAction(self.close_all_windows) 2127 self.window_menu.addSeparator() 2128 self.window_menu.addAction(self.tile_windows) 2129 self.window_menu.addAction(self.cascade_windows) 2130 self.window_menu.addSeparator() 2131 self.window_menu.addAction(self.next_window) 2132 self.window_menu.addAction(self.previous_window) 2133 if sub_window_count == 0: 2134 return 2135 self.window_menu.addSeparator() 2136 nr = 1 2137 for sub_window in self.mdi_area.subWindowList(): 2138 label = str(nr) + " " + sub_window.name 2139 if nr < 10: 2140 label = "&" + label 2141 action = self.window_menu.addAction(label) 2142 action.setCheckable(True) 2143 action.setChecked(sub_window == self.mdi_area.activeSubWindow()) 2144 action.triggered.connect(lambda x=nr: self.setActiveSubWindow(x)) 2145 self.window_menu.addAction(action) 2146 nr += 1 2147 2148 def setActiveSubWindow(self, nr): 2149 self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1]) 2150 2151# Help text 2152 2153glb_help_text = """ 2154<h1>Contents</h1> 2155<style> 2156p.c1 { 2157 text-indent: 40px; 2158} 2159p.c2 { 2160 text-indent: 80px; 2161} 2162} 2163</style> 2164<p class=c1><a href=#reports>1. Reports</a></p> 2165<p class=c2><a href=#callgraph>1.1 Context-Sensitive Call Graph</a></p> 2166<p class=c2><a href=#allbranches>1.2 All branches</a></p> 2167<p class=c2><a href=#selectedbranches>1.3 Selected branches</a></p> 2168<p class=c1><a href=#tables>2. Tables</a></p> 2169<h1 id=reports>1. Reports</h1> 2170<h2 id=callgraph>1.1 Context-Sensitive Call Graph</h2> 2171The result is a GUI window with a tree representing a context-sensitive 2172call-graph. Expanding a couple of levels of the tree and adjusting column 2173widths to suit will display something like: 2174<pre> 2175 Call Graph: pt_example 2176Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%) 2177v- ls 2178 v- 2638:2638 2179 v- _start ld-2.19.so 1 10074071 100.0 211135 100.0 2180 |- unknown unknown 1 13198 0.1 1 0.0 2181 >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3 2182 >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3 2183 v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4 2184 >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1 2185 >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0 2186 >- __libc_csu_init ls 1 10354 0.1 10 0.0 2187 |- _setjmp libc-2.19.so 1 0 0.0 4 0.0 2188 v- main ls 1 8182043 99.6 180254 99.9 2189</pre> 2190<h3>Points to note:</h3> 2191<ul> 2192<li>The top level is a command name (comm)</li> 2193<li>The next level is a thread (pid:tid)</li> 2194<li>Subsequent levels are functions</li> 2195<li>'Count' is the number of calls</li> 2196<li>'Time' is the elapsed time until the function returns</li> 2197<li>Percentages are relative to the level above</li> 2198<li>'Branch Count' is the total number of branches for that function and all functions that it calls 2199</ul> 2200<h3>Find</h3> 2201Ctrl-F displays a Find bar which finds function names by either an exact match or a pattern match. 2202The pattern matching symbols are ? for any character and * for zero or more characters. 2203<h2 id=allbranches>1.2 All branches</h2> 2204The All branches report displays all branches in chronological order. 2205Not all data is fetched immediately. More records can be fetched using the Fetch bar provided. 2206<h3>Disassembly</h3> 2207Open a branch to display disassembly. This only works if: 2208<ol> 2209<li>The disassembler is available. Currently, only Intel XED is supported - see <a href=#xed>Intel XED Setup</a></li> 2210<li>The object code is available. Currently, only the perf build ID cache is searched for object code. 2211The default directory ~/.debug can be overridden by setting environment variable PERF_BUILDID_DIR. 2212One exception is kcore where the DSO long name is used (refer dsos_view on the Tables menu), 2213or alternatively, set environment variable PERF_KCORE to the kcore file name.</li> 2214</ol> 2215<h4 id=xed>Intel XED Setup</h4> 2216To use Intel XED, libxed.so must be present. To build and install libxed.so: 2217<pre> 2218git clone https://github.com/intelxed/mbuild.git mbuild 2219git clone https://github.com/intelxed/xed 2220cd xed 2221./mfile.py --share 2222sudo ./mfile.py --prefix=/usr/local install 2223sudo ldconfig 2224</pre> 2225<h3>Find</h3> 2226Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match. 2227Refer to Python documentation for the regular expression syntax. 2228All columns are searched, but only currently fetched rows are searched. 2229<h2 id=selectedbranches>1.3 Selected branches</h2> 2230This is the same as the <a href=#allbranches>All branches</a> report but with the data reduced 2231by various selection criteria. A dialog box displays available criteria which are AND'ed together. 2232<h3>1.3.1 Time ranges</h3> 2233The time ranges hint text shows the total time range. Relative time ranges can also be entered in 2234ms, us or ns. Also, negative values are relative to the end of trace. Examples: 2235<pre> 2236 81073085947329-81073085958238 From 81073085947329 to 81073085958238 2237 100us-200us From 100us to 200us 2238 10ms- From 10ms to the end 2239 -100ns The first 100ns 2240 -10ms- The last 10ms 2241</pre> 2242N.B. Due to the granularity of timestamps, there could be no branches in any given time range. 2243<h1 id=tables>2. Tables</h1> 2244The Tables menu shows all tables and views in the database. Most tables have an associated view 2245which displays the information in a more friendly way. Not all data for large tables is fetched 2246immediately. More records can be fetched using the Fetch bar provided. Columns can be sorted, 2247but that can be slow for large tables. 2248<p>There are also tables of database meta-information. 2249For SQLite3 databases, the sqlite_master table is included. 2250For PostgreSQL databases, information_schema.tables/views/columns are included. 2251<h3>Find</h3> 2252Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match. 2253Refer to Python documentation for the regular expression syntax. 2254All columns are searched, but only currently fetched rows are searched. 2255<p>N.B. Results are found in id order, so if the table is re-ordered, find-next and find-previous 2256will go to the next/previous result in id order, instead of display order. 2257""" 2258 2259# Help window 2260 2261class HelpWindow(QMdiSubWindow): 2262 2263 def __init__(self, glb, parent=None): 2264 super(HelpWindow, self).__init__(parent) 2265 2266 self.text = QTextBrowser() 2267 self.text.setHtml(glb_help_text) 2268 self.text.setReadOnly(True) 2269 self.text.setOpenExternalLinks(True) 2270 2271 self.setWidget(self.text) 2272 2273 AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help") 2274 2275# Main window that only displays the help text 2276 2277class HelpOnlyWindow(QMainWindow): 2278 2279 def __init__(self, parent=None): 2280 super(HelpOnlyWindow, self).__init__(parent) 2281 2282 self.setMinimumSize(200, 100) 2283 self.resize(800, 600) 2284 self.setWindowTitle("Exported SQL Viewer Help") 2285 self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation)) 2286 2287 self.text = QTextBrowser() 2288 self.text.setHtml(glb_help_text) 2289 self.text.setReadOnly(True) 2290 self.text.setOpenExternalLinks(True) 2291 2292 self.setCentralWidget(self.text) 2293 2294# Font resize 2295 2296def ResizeFont(widget, diff): 2297 font = widget.font() 2298 sz = font.pointSize() 2299 font.setPointSize(sz + diff) 2300 widget.setFont(font) 2301 2302def ShrinkFont(widget): 2303 ResizeFont(widget, -1) 2304 2305def EnlargeFont(widget): 2306 ResizeFont(widget, 1) 2307 2308# Unique name for sub-windows 2309 2310def NumberedWindowName(name, nr): 2311 if nr > 1: 2312 name += " <" + str(nr) + ">" 2313 return name 2314 2315def UniqueSubWindowName(mdi_area, name): 2316 nr = 1 2317 while True: 2318 unique_name = NumberedWindowName(name, nr) 2319 ok = True 2320 for sub_window in mdi_area.subWindowList(): 2321 if sub_window.name == unique_name: 2322 ok = False 2323 break 2324 if ok: 2325 return unique_name 2326 nr += 1 2327 2328# Add a sub-window 2329 2330def AddSubWindow(mdi_area, sub_window, name): 2331 unique_name = UniqueSubWindowName(mdi_area, name) 2332 sub_window.setMinimumSize(200, 100) 2333 sub_window.resize(800, 600) 2334 sub_window.setWindowTitle(unique_name) 2335 sub_window.setAttribute(Qt.WA_DeleteOnClose) 2336 sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon)) 2337 sub_window.name = unique_name 2338 mdi_area.addSubWindow(sub_window) 2339 sub_window.show() 2340 2341# Main window 2342 2343class MainWindow(QMainWindow): 2344 2345 def __init__(self, glb, parent=None): 2346 super(MainWindow, self).__init__(parent) 2347 2348 self.glb = glb 2349 2350 self.setWindowTitle("Exported SQL Viewer: " + glb.dbname) 2351 self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon)) 2352 self.setMinimumSize(200, 100) 2353 2354 self.mdi_area = QMdiArea() 2355 self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) 2356 self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) 2357 2358 self.setCentralWidget(self.mdi_area) 2359 2360 menu = self.menuBar() 2361 2362 file_menu = menu.addMenu("&File") 2363 file_menu.addAction(CreateExitAction(glb.app, self)) 2364 2365 edit_menu = menu.addMenu("&Edit") 2366 edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find)) 2367 edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)])) 2368 edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")])) 2369 edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")])) 2370 2371 reports_menu = menu.addMenu("&Reports") 2372 if IsSelectable(glb.db, "calls"): 2373 reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self)) 2374 2375 self.EventMenu(GetEventList(glb.db), reports_menu) 2376 2377 self.TableMenu(GetTableList(glb), menu) 2378 2379 self.window_menu = WindowMenu(self.mdi_area, menu) 2380 2381 help_menu = menu.addMenu("&Help") 2382 help_menu.addAction(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence.HelpContents)) 2383 2384 def Find(self): 2385 win = self.mdi_area.activeSubWindow() 2386 if win: 2387 try: 2388 win.find_bar.Activate() 2389 except: 2390 pass 2391 2392 def FetchMoreRecords(self): 2393 win = self.mdi_area.activeSubWindow() 2394 if win: 2395 try: 2396 win.fetch_bar.Activate() 2397 except: 2398 pass 2399 2400 def ShrinkFont(self): 2401 win = self.mdi_area.activeSubWindow() 2402 ShrinkFont(win.view) 2403 2404 def EnlargeFont(self): 2405 win = self.mdi_area.activeSubWindow() 2406 EnlargeFont(win.view) 2407 2408 def EventMenu(self, events, reports_menu): 2409 branches_events = 0 2410 for event in events: 2411 event = event.split(":")[0] 2412 if event == "branches": 2413 branches_events += 1 2414 dbid = 0 2415 for event in events: 2416 dbid += 1 2417 event = event.split(":")[0] 2418 if event == "branches": 2419 label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")" 2420 reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda x=dbid: self.NewBranchView(x), self)) 2421 label = "Selected branches" if branches_events == 1 else "Selected branches " + "(id=" + dbid + ")" 2422 reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda x=dbid: self.NewSelectedBranchView(x), self)) 2423 2424 def TableMenu(self, tables, menu): 2425 table_menu = menu.addMenu("&Tables") 2426 for table in tables: 2427 table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda t=table: self.NewTableView(t), self)) 2428 2429 def NewCallGraph(self): 2430 CallGraphWindow(self.glb, self) 2431 2432 def NewBranchView(self, event_id): 2433 BranchWindow(self.glb, event_id, ReportVars(), self) 2434 2435 def NewSelectedBranchView(self, event_id): 2436 dialog = SelectedBranchDialog(self.glb, self) 2437 ret = dialog.exec_() 2438 if ret: 2439 BranchWindow(self.glb, event_id, dialog.report_vars, self) 2440 2441 def NewTableView(self, table_name): 2442 TableWindow(self.glb, table_name, self) 2443 2444 def Help(self): 2445 HelpWindow(self.glb, self) 2446 2447# XED Disassembler 2448 2449class xed_state_t(Structure): 2450 2451 _fields_ = [ 2452 ("mode", c_int), 2453 ("width", c_int) 2454 ] 2455 2456class XEDInstruction(): 2457 2458 def __init__(self, libxed): 2459 # Current xed_decoded_inst_t structure is 192 bytes. Use 512 to allow for future expansion 2460 xedd_t = c_byte * 512 2461 self.xedd = xedd_t() 2462 self.xedp = addressof(self.xedd) 2463 libxed.xed_decoded_inst_zero(self.xedp) 2464 self.state = xed_state_t() 2465 self.statep = addressof(self.state) 2466 # Buffer for disassembled instruction text 2467 self.buffer = create_string_buffer(256) 2468 self.bufferp = addressof(self.buffer) 2469 2470class LibXED(): 2471 2472 def __init__(self): 2473 try: 2474 self.libxed = CDLL("libxed.so") 2475 except: 2476 self.libxed = None 2477 if not self.libxed: 2478 self.libxed = CDLL("/usr/local/lib/libxed.so") 2479 2480 self.xed_tables_init = self.libxed.xed_tables_init 2481 self.xed_tables_init.restype = None 2482 self.xed_tables_init.argtypes = [] 2483 2484 self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero 2485 self.xed_decoded_inst_zero.restype = None 2486 self.xed_decoded_inst_zero.argtypes = [ c_void_p ] 2487 2488 self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode 2489 self.xed_operand_values_set_mode.restype = None 2490 self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ] 2491 2492 self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode 2493 self.xed_decoded_inst_zero_keep_mode.restype = None 2494 self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ] 2495 2496 self.xed_decode = self.libxed.xed_decode 2497 self.xed_decode.restype = c_int 2498 self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ] 2499 2500 self.xed_format_context = self.libxed.xed_format_context 2501 self.xed_format_context.restype = c_uint 2502 self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_void_p ] 2503 2504 self.xed_tables_init() 2505 2506 def Instruction(self): 2507 return XEDInstruction(self) 2508 2509 def SetMode(self, inst, mode): 2510 if mode: 2511 inst.state.mode = 4 # 32-bit 2512 inst.state.width = 4 # 4 bytes 2513 else: 2514 inst.state.mode = 1 # 64-bit 2515 inst.state.width = 8 # 8 bytes 2516 self.xed_operand_values_set_mode(inst.xedp, inst.statep) 2517 2518 def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip): 2519 self.xed_decoded_inst_zero_keep_mode(inst.xedp) 2520 err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt) 2521 if err: 2522 return 0, "" 2523 # Use AT&T mode (2), alternative is Intel (3) 2524 ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0) 2525 if not ok: 2526 return 0, "" 2527 # Return instruction length and the disassembled instruction text 2528 # For now, assume the length is in byte 166 2529 return inst.xedd[166], inst.buffer.value 2530 2531def TryOpen(file_name): 2532 try: 2533 return open(file_name, "rb") 2534 except: 2535 return None 2536 2537def Is64Bit(f): 2538 result = sizeof(c_void_p) 2539 # ELF support only 2540 pos = f.tell() 2541 f.seek(0) 2542 header = f.read(7) 2543 f.seek(pos) 2544 magic = header[0:4] 2545 eclass = ord(header[4]) 2546 encoding = ord(header[5]) 2547 version = ord(header[6]) 2548 if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1: 2549 result = True if eclass == 2 else False 2550 return result 2551 2552# Global data 2553 2554class Glb(): 2555 2556 def __init__(self, dbref, db, dbname): 2557 self.dbref = dbref 2558 self.db = db 2559 self.dbname = dbname 2560 self.home_dir = os.path.expanduser("~") 2561 self.buildid_dir = os.getenv("PERF_BUILDID_DIR") 2562 if self.buildid_dir: 2563 self.buildid_dir += "/.build-id/" 2564 else: 2565 self.buildid_dir = self.home_dir + "/.debug/.build-id/" 2566 self.app = None 2567 self.mainwindow = None 2568 self.instances_to_shutdown_on_exit = weakref.WeakSet() 2569 try: 2570 self.disassembler = LibXED() 2571 self.have_disassembler = True 2572 except: 2573 self.have_disassembler = False 2574 2575 def FileFromBuildId(self, build_id): 2576 file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf" 2577 return TryOpen(file_name) 2578 2579 def FileFromNamesAndBuildId(self, short_name, long_name, build_id): 2580 # Assume current machine i.e. no support for virtualization 2581 if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore": 2582 file_name = os.getenv("PERF_KCORE") 2583 f = TryOpen(file_name) if file_name else None 2584 if f: 2585 return f 2586 # For now, no special handling if long_name is /proc/kcore 2587 f = TryOpen(long_name) 2588 if f: 2589 return f 2590 f = self.FileFromBuildId(build_id) 2591 if f: 2592 return f 2593 return None 2594 2595 def AddInstanceToShutdownOnExit(self, instance): 2596 self.instances_to_shutdown_on_exit.add(instance) 2597 2598 # Shutdown any background processes or threads 2599 def ShutdownInstances(self): 2600 for x in self.instances_to_shutdown_on_exit: 2601 try: 2602 x.Shutdown() 2603 except: 2604 pass 2605 2606# Database reference 2607 2608class DBRef(): 2609 2610 def __init__(self, is_sqlite3, dbname): 2611 self.is_sqlite3 = is_sqlite3 2612 self.dbname = dbname 2613 2614 def Open(self, connection_name): 2615 dbname = self.dbname 2616 if self.is_sqlite3: 2617 db = QSqlDatabase.addDatabase("QSQLITE", connection_name) 2618 else: 2619 db = QSqlDatabase.addDatabase("QPSQL", connection_name) 2620 opts = dbname.split() 2621 for opt in opts: 2622 if "=" in opt: 2623 opt = opt.split("=") 2624 if opt[0] == "hostname": 2625 db.setHostName(opt[1]) 2626 elif opt[0] == "port": 2627 db.setPort(int(opt[1])) 2628 elif opt[0] == "username": 2629 db.setUserName(opt[1]) 2630 elif opt[0] == "password": 2631 db.setPassword(opt[1]) 2632 elif opt[0] == "dbname": 2633 dbname = opt[1] 2634 else: 2635 dbname = opt 2636 2637 db.setDatabaseName(dbname) 2638 if not db.open(): 2639 raise Exception("Failed to open database " + dbname + " error: " + db.lastError().text()) 2640 return db, dbname 2641 2642# Main 2643 2644def Main(): 2645 if (len(sys.argv) < 2): 2646 print >> sys.stderr, "Usage is: exported-sql-viewer.py {<database name> | --help-only}" 2647 raise Exception("Too few arguments") 2648 2649 dbname = sys.argv[1] 2650 if dbname == "--help-only": 2651 app = QApplication(sys.argv) 2652 mainwindow = HelpOnlyWindow() 2653 mainwindow.show() 2654 err = app.exec_() 2655 sys.exit(err) 2656 2657 is_sqlite3 = False 2658 try: 2659 f = open(dbname) 2660 if f.read(15) == "SQLite format 3": 2661 is_sqlite3 = True 2662 f.close() 2663 except: 2664 pass 2665 2666 dbref = DBRef(is_sqlite3, dbname) 2667 db, dbname = dbref.Open("main") 2668 glb = Glb(dbref, db, dbname) 2669 app = QApplication(sys.argv) 2670 glb.app = app 2671 mainwindow = MainWindow(glb) 2672 glb.mainwindow = mainwindow 2673 mainwindow.show() 2674 err = app.exec_() 2675 glb.ShutdownInstances() 2676 db.close() 2677 sys.exit(err) 2678 2679if __name__ == "__main__": 2680 Main() 2681