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