tools/perf/scripts/python/exported-sql-viewer.py

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