?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / tools / perf / scripts / python / exported-sql-viewer.py
blob26d7be785288293abf23f33f86776302c56dc0f7
1 #!/usr/bin/env python
2 # SPDX-License-Identifier: GPL-2.0
3 # exported-sql-viewer.py: view data from sql database
4 # Copyright (c) 2014-2018, Intel Corporation.
5
6 # To use this script you will need to have exported data using either the
7 # export-to-sqlite.py or the export-to-postgresql.py script. Refer to those
8 # scripts for details.
9 #
10 # Following on from the example in the export scripts, a
11 # call-graph can be displayed for the pt_example database like this:
12 #
13 # python tools/perf/scripts/python/exported-sql-viewer.py pt_example
14 #
15 # Note that for PostgreSQL, this script supports connecting to remote databases
16 # by setting hostname, port, username, password, and dbname e.g.
17 #
18 # python tools/perf/scripts/python/exported-sql-viewer.py "hostname=myhost username=myuser password=mypassword dbname=pt_example"
19 #
20 # The result is a GUI window with a tree representing a context-sensitive
21 # call-graph. Expanding a couple of levels of the tree and adjusting column
22 # widths to suit will display something like:
23 #
24 # Call Graph: pt_example
25 # Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
26 # v- ls
27 # v- 2638:2638
28 # v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
29 # |- unknown unknown 1 13198 0.1 1 0.0
30 # >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
31 # >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
32 # v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
33 # >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
34 # >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
35 # >- __libc_csu_init ls 1 10354 0.1 10 0.0
36 # |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
37 # v- main ls 1 8182043 99.6 180254 99.9
38 #
39 # Points to note:
40 # The top level is a command name (comm)
41 # The next level is a thread (pid:tid)
42 # Subsequent levels are functions
43 # 'Count' is the number of calls
44 # 'Time' is the elapsed time until the function returns
45 # Percentages are relative to the level above
46 # 'Branch Count' is the total number of branches for that function and all
47 # functions that it calls
48
49 # There is also a "All branches" report, which displays branches and
50 # possibly disassembly. However, presently, the only supported disassembler is
51 # Intel XED, and additionally the object code must be present in perf build ID
52 # cache. To use Intel XED, libxed.so must be present. To build and install
53 # libxed.so:
54 # git clone https://github.com/intelxed/mbuild.git mbuild
55 # git clone https://github.com/intelxed/xed
56 # cd xed
57 # ./mfile.py --share
58 # sudo ./mfile.py --prefix=/usr/local install
59 # sudo ldconfig
60 #
61 # Example report:
62 #
63 # Time CPU Command PID TID Branch Type In Tx Branch
64 # 8107675239590 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
65 # 7fab593ea260 48 89 e7 mov %rsp, %rdi
66 # 8107675239899 2 ls 22011 22011 hardware interrupt No 7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
67 # 8107675241900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
68 # 7fab593ea260 48 89 e7 mov %rsp, %rdi
69 # 7fab593ea263 e8 c8 06 00 00 callq 0x7fab593ea930
70 # 8107675241900 2 ls 22011 22011 call No 7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so)
71 # 7fab593ea930 55 pushq %rbp
72 # 7fab593ea931 48 89 e5 mov %rsp, %rbp
73 # 7fab593ea934 41 57 pushq %r15
74 # 7fab593ea936 41 56 pushq %r14
75 # 7fab593ea938 41 55 pushq %r13
76 # 7fab593ea93a 41 54 pushq %r12
77 # 7fab593ea93c 53 pushq %rbx
78 # 7fab593ea93d 48 89 fb mov %rdi, %rbx
79 # 7fab593ea940 48 83 ec 68 sub $0x68, %rsp
80 # 7fab593ea944 0f 31 rdtsc
81 # 7fab593ea946 48 c1 e2 20 shl $0x20, %rdx
82 # 7fab593ea94a 89 c0 mov %eax, %eax
83 # 7fab593ea94c 48 09 c2 or %rax, %rdx
84 # 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
85 # 8107675242232 2 ls 22011 22011 hardware interrupt No 7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
86 # 8107675242900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so)
87 # 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
88 # 7fab593ea956 48 89 15 3b 13 22 00 movq %rdx, 0x22133b(%rip)
89 # 8107675243232 2 ls 22011 22011 hardware interrupt No 7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
90
91 from __future__ import print_function
92
93 import sys
94 import argparse
95 import weakref
96 import threading
97 import string
98 try:
99 # Python2
100 import cPickle as pickle
101 # size of pickled integer big enough for record size
102 glb_nsz = 8
103 except ImportError:
104 import pickle
105 glb_nsz = 16
106 import re
107 import os
108 import random
109 import copy
110 import math
111
112 pyside_version_1 = True
113 if not "--pyside-version-1" in sys.argv:
114 try:
115 from PySide2.QtCore import *
116 from PySide2.QtGui import *
117 from PySide2.QtSql import *
118 from PySide2.QtWidgets import *
119 pyside_version_1 = False
120 except:
121 pass
122
123 if pyside_version_1:
124 from PySide.QtCore import *
125 from PySide.QtGui import *
126 from PySide.QtSql import *
127
128 from decimal import *
129 from ctypes import *
130 from multiprocessing import Process, Array, Value, Event
131
132 # xrange is range in Python3
133 try:
134 xrange
135 except NameError:
136 xrange = range
137
138 def printerr(*args, **keyword_args):
139 print(*args, file=sys.stderr, **keyword_args)
140
141 # Data formatting helpers
142
143 def tohex(ip):
144 if ip < 0:
145 ip += 1 << 64
146 return "%x" % ip
147
148 def offstr(offset):
149 if offset:
150 return "+0x%x" % offset
151 return ""
152
153 def dsoname(name):
154 if name == "[kernel.kallsyms]":
155 return "[kernel]"
156 return name
157
158 def findnth(s, sub, n, offs=0):
159 pos = s.find(sub)
160 if pos < 0:
161 return pos
162 if n <= 1:
163 return offs + pos
164 return findnth(s[pos + 1:], sub, n - 1, offs + pos + 1)
165
166 # Percent to one decimal place
167
168 def PercentToOneDP(n, d):
169 if not d:
170 return "0.0"
171 x = (n * Decimal(100)) / d
172 return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP))
173
174 # Helper for queries that must not fail
175
176 def QueryExec(query, stmt):
177 ret = query.exec_(stmt)
178 if not ret:
179 raise Exception("Query failed: " + query.lastError().text())
180
181 # Background thread
182
183 class Thread(QThread):
184
185 done = Signal(object)
186
187 def __init__(self, task, param=None, parent=None):
188 super(Thread, self).__init__(parent)
189 self.task = task
190 self.param = param
191
192 def run(self):
193 while True:
194 if self.param is None:
195 done, result = self.task()
196 else:
197 done, result = self.task(self.param)
198 self.done.emit(result)
199 if done:
200 break
201
202 # Tree data model
203
204 class TreeModel(QAbstractItemModel):
205
206 def __init__(self, glb, params, parent=None):
207 super(TreeModel, self).__init__(parent)
208 self.glb = glb
209 self.params = params
210 self.root = self.GetRoot()
211 self.last_row_read = 0
212
213 def Item(self, parent):
214 if parent.isValid():
215 return parent.internalPointer()
216 else:
217 return self.root
218
219 def rowCount(self, parent):
220 result = self.Item(parent).childCount()
221 if result < 0:
222 result = 0
223 self.dataChanged.emit(parent, parent)
224 return result
225
226 def hasChildren(self, parent):
227 return self.Item(parent).hasChildren()
228
229 def headerData(self, section, orientation, role):
230 if role == Qt.TextAlignmentRole:
231 return self.columnAlignment(section)
232 if role != Qt.DisplayRole:
233 return None
234 if orientation != Qt.Horizontal:
235 return None
236 return self.columnHeader(section)
237
238 def parent(self, child):
239 child_item = child.internalPointer()
240 if child_item is self.root:
241 return QModelIndex()
242 parent_item = child_item.getParentItem()
243 return self.createIndex(parent_item.getRow(), 0, parent_item)
244
245 def index(self, row, column, parent):
246 child_item = self.Item(parent).getChildItem(row)
247 return self.createIndex(row, column, child_item)
248
249 def DisplayData(self, item, index):
250 return item.getData(index.column())
251
252 def FetchIfNeeded(self, row):
253 if row > self.last_row_read:
254 self.last_row_read = row
255 if row + 10 >= self.root.child_count:
256 self.fetcher.Fetch(glb_chunk_sz)
257
258 def columnAlignment(self, column):
259 return Qt.AlignLeft
260
261 def columnFont(self, column):
262 return None
263
264 def data(self, index, role):
265 if role == Qt.TextAlignmentRole:
266 return self.columnAlignment(index.column())
267 if role == Qt.FontRole:
268 return self.columnFont(index.column())
269 if role != Qt.DisplayRole:
270 return None
271 item = index.internalPointer()
272 return self.DisplayData(item, index)
273
274 # Table data model
275
276 class TableModel(QAbstractTableModel):
277
278 def __init__(self, parent=None):
279 super(TableModel, self).__init__(parent)
280 self.child_count = 0
281 self.child_items = []
282 self.last_row_read = 0
283
284 def Item(self, parent):
285 if parent.isValid():
286 return parent.internalPointer()
287 else:
288 return self
289
290 def rowCount(self, parent):
291 return self.child_count
292
293 def headerData(self, section, orientation, role):
294 if role == Qt.TextAlignmentRole:
295 return self.columnAlignment(section)
296 if role != Qt.DisplayRole:
297 return None
298 if orientation != Qt.Horizontal:
299 return None
300 return self.columnHeader(section)
301
302 def index(self, row, column, parent):
303 return self.createIndex(row, column, self.child_items[row])
304
305 def DisplayData(self, item, index):
306 return item.getData(index.column())
307
308 def FetchIfNeeded(self, row):
309 if row > self.last_row_read:
310 self.last_row_read = row
311 if row + 10 >= self.child_count:
312 self.fetcher.Fetch(glb_chunk_sz)
313
314 def columnAlignment(self, column):
315 return Qt.AlignLeft
316
317 def columnFont(self, column):
318 return None
319
320 def data(self, index, role):
321 if role == Qt.TextAlignmentRole:
322 return self.columnAlignment(index.column())
323 if role == Qt.FontRole:
324 return self.columnFont(index.column())
325 if role != Qt.DisplayRole:
326 return None
327 item = index.internalPointer()
328 return self.DisplayData(item, index)
329
330 # Model cache
331
332 model_cache = weakref.WeakValueDictionary()
333 model_cache_lock = threading.Lock()
334
335 def LookupCreateModel(model_name, create_fn):
336 model_cache_lock.acquire()
337 try:
338 model = model_cache[model_name]
339 except:
340 model = None
341 if model is None:
342 model = create_fn()
343 model_cache[model_name] = model
344 model_cache_lock.release()
345 return model
346
347 def LookupModel(model_name):
348 model_cache_lock.acquire()
349 try:
350 model = model_cache[model_name]
351 except:
352 model = None
353 model_cache_lock.release()
354 return model
355
356 # Find bar
357
358 class FindBar():
359
360 def __init__(self, parent, finder, is_reg_expr=False):
361 self.finder = finder
362 self.context = []
363 self.last_value = None
364 self.last_pattern = None
365
366 label = QLabel("Find:")
367 label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
368
369 self.textbox = QComboBox()
370 self.textbox.setEditable(True)
371 self.textbox.currentIndexChanged.connect(self.ValueChanged)
372
373 self.progress = QProgressBar()
374 self.progress.setRange(0, 0)
375 self.progress.hide()
376
377 if is_reg_expr:
378 self.pattern = QCheckBox("Regular Expression")
379 else:
380 self.pattern = QCheckBox("Pattern")
381 self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
382
383 self.next_button = QToolButton()
384 self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
385 self.next_button.released.connect(lambda: self.NextPrev(1))
386
387 self.prev_button = QToolButton()
388 self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
389 self.prev_button.released.connect(lambda: self.NextPrev(-1))
390
391 self.close_button = QToolButton()
392 self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
393 self.close_button.released.connect(self.Deactivate)
394
395 self.hbox = QHBoxLayout()
396 self.hbox.setContentsMargins(0, 0, 0, 0)
397
398 self.hbox.addWidget(label)
399 self.hbox.addWidget(self.textbox)
400 self.hbox.addWidget(self.progress)
401 self.hbox.addWidget(self.pattern)
402 self.hbox.addWidget(self.next_button)
403 self.hbox.addWidget(self.prev_button)
404 self.hbox.addWidget(self.close_button)
405
406 self.bar = QWidget()
407 self.bar.setLayout(self.hbox)
408 self.bar.hide()
409
410 def Widget(self):
411 return self.bar
412
413 def Activate(self):
414 self.bar.show()
415 self.textbox.lineEdit().selectAll()
416 self.textbox.setFocus()
417
418 def Deactivate(self):
419 self.bar.hide()
420
421 def Busy(self):
422 self.textbox.setEnabled(False)
423 self.pattern.hide()
424 self.next_button.hide()
425 self.prev_button.hide()
426 self.progress.show()
427
428 def Idle(self):
429 self.textbox.setEnabled(True)
430 self.progress.hide()
431 self.pattern.show()
432 self.next_button.show()
433 self.prev_button.show()
434
435 def Find(self, direction):
436 value = self.textbox.currentText()
437 pattern = self.pattern.isChecked()
438 self.last_value = value
439 self.last_pattern = pattern
440 self.finder.Find(value, direction, pattern, self.context)
441
442 def ValueChanged(self):
443 value = self.textbox.currentText()
444 pattern = self.pattern.isChecked()
445 index = self.textbox.currentIndex()
446 data = self.textbox.itemData(index)
447 # Store the pattern in the combo box to keep it with the text value
448 if data == None:
449 self.textbox.setItemData(index, pattern)
450 else:
451 self.pattern.setChecked(data)
452 self.Find(0)
453
454 def NextPrev(self, direction):
455 value = self.textbox.currentText()
456 pattern = self.pattern.isChecked()
457 if value != self.last_value:
458 index = self.textbox.findText(value)
459 # Allow for a button press before the value has been added to the combo box
460 if index < 0:
461 index = self.textbox.count()
462 self.textbox.addItem(value, pattern)
463 self.textbox.setCurrentIndex(index)
464 return
465 else:
466 self.textbox.setItemData(index, pattern)
467 elif pattern != self.last_pattern:
468 # Keep the pattern recorded in the combo box up to date
469 index = self.textbox.currentIndex()
470 self.textbox.setItemData(index, pattern)
471 self.Find(direction)
472
473 def NotFound(self):
474 QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
475
476 # Context-sensitive call graph data model item base
477
478 class CallGraphLevelItemBase(object):
479
480 def __init__(self, glb, params, row, parent_item):
481 self.glb = glb
482 self.params = params
483 self.row = row
484 self.parent_item = parent_item
485 self.query_done = False
486 self.child_count = 0
487 self.child_items = []
488 if parent_item:
489 self.level = parent_item.level + 1
490 else:
491 self.level = 0
492
493 def getChildItem(self, row):
494 return self.child_items[row]
495
496 def getParentItem(self):
497 return self.parent_item
498
499 def getRow(self):
500 return self.row
501
502 def childCount(self):
503 if not self.query_done:
504 self.Select()
505 if not self.child_count:
506 return -1
507 return self.child_count
508
509 def hasChildren(self):
510 if not self.query_done:
511 return True
512 return self.child_count > 0
513
514 def getData(self, column):
515 return self.data[column]
516
517 # Context-sensitive call graph data model level 2+ item base
518
519 class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase):
520
521 def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item):
522 super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
523 self.comm_id = comm_id
524 self.thread_id = thread_id
525 self.call_path_id = call_path_id
526 self.insn_cnt = insn_cnt
527 self.cyc_cnt = cyc_cnt
528 self.branch_count = branch_count
529 self.time = time
530
531 def Select(self):
532 self.query_done = True
533 query = QSqlQuery(self.glb.db)
534 if self.params.have_ipc:
535 ipc_str = ", SUM(insn_count), SUM(cyc_count)"
536 else:
537 ipc_str = ""
538 QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time)" + ipc_str + ", SUM(branch_count)"
539 " FROM calls"
540 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
541 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
542 " INNER JOIN dsos ON symbols.dso_id = dsos.id"
543 " WHERE parent_call_path_id = " + str(self.call_path_id) +
544 " AND comm_id = " + str(self.comm_id) +
545 " AND thread_id = " + str(self.thread_id) +
546 " GROUP BY call_path_id, name, short_name"
547 " ORDER BY call_path_id")
548 while query.next():
549 if self.params.have_ipc:
550 insn_cnt = int(query.value(5))
551 cyc_cnt = int(query.value(6))
552 branch_count = int(query.value(7))
553 else:
554 insn_cnt = 0
555 cyc_cnt = 0
556 branch_count = int(query.value(5))
557 child_item = CallGraphLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
558 self.child_items.append(child_item)
559 self.child_count += 1
560
561 # Context-sensitive call graph data model level three item
562
563 class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase):
564
565 def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, insn_cnt, cyc_cnt, branch_count, parent_item):
566 super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item)
567 dso = dsoname(dso)
568 if self.params.have_ipc:
569 insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
570 cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
571 br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
572 ipc = CalcIPC(cyc_cnt, insn_cnt)
573 self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
574 else:
575 self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
576 self.dbid = call_path_id
577
578 # Context-sensitive call graph data model level two item
579
580 class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase):
581
582 def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
583 super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, parent_item)
584 if self.params.have_ipc:
585 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
586 else:
587 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
588 self.dbid = thread_id
589
590 def Select(self):
591 super(CallGraphLevelTwoItem, self).Select()
592 for child_item in self.child_items:
593 self.time += child_item.time
594 self.insn_cnt += child_item.insn_cnt
595 self.cyc_cnt += child_item.cyc_cnt
596 self.branch_count += child_item.branch_count
597 for child_item in self.child_items:
598 child_item.data[4] = PercentToOneDP(child_item.time, self.time)
599 if self.params.have_ipc:
600 child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
601 child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
602 child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
603 else:
604 child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
605
606 # Context-sensitive call graph data model level one item
607
608 class CallGraphLevelOneItem(CallGraphLevelItemBase):
609
610 def __init__(self, glb, params, row, comm_id, comm, parent_item):
611 super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
612 if self.params.have_ipc:
613 self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
614 else:
615 self.data = [comm, "", "", "", "", "", ""]
616 self.dbid = comm_id
617
618 def Select(self):
619 self.query_done = True
620 query = QSqlQuery(self.glb.db)
621 QueryExec(query, "SELECT thread_id, pid, tid"
622 " FROM comm_threads"
623 " INNER JOIN threads ON thread_id = threads.id"
624 " WHERE comm_id = " + str(self.dbid))
625 while query.next():
626 child_item = CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
627 self.child_items.append(child_item)
628 self.child_count += 1
629
630 # Context-sensitive call graph data model root item
631
632 class CallGraphRootItem(CallGraphLevelItemBase):
633
634 def __init__(self, glb, params):
635 super(CallGraphRootItem, self).__init__(glb, params, 0, None)
636 self.dbid = 0
637 self.query_done = True
638 if_has_calls = ""
639 if IsSelectable(glb.db, "comms", columns = "has_calls"):
640 if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
641 query = QSqlQuery(glb.db)
642 QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
643 while query.next():
644 if not query.value(0):
645 continue
646 child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
647 self.child_items.append(child_item)
648 self.child_count += 1
649
650 # Call graph model parameters
651
652 class CallGraphModelParams():
653
654 def __init__(self, glb, parent=None):
655 self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
656
657 # Context-sensitive call graph data model base
658
659 class CallGraphModelBase(TreeModel):
660
661 def __init__(self, glb, parent=None):
662 super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
663
664 def FindSelect(self, value, pattern, query):
665 if pattern:
666 # postgresql and sqlite pattern patching differences:
667 # postgresql LIKE is case sensitive but sqlite LIKE is not
668 # postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not
669 # postgresql supports ILIKE which is case insensitive
670 # sqlite supports GLOB (text only) which uses * and ? and is case sensitive
671 if not self.glb.dbref.is_sqlite3:
672 # Escape % and _
673 s = value.replace("%", "\%")
674 s = s.replace("_", "\_")
675 # Translate * and ? into SQL LIKE pattern characters % and _
676 trans = string.maketrans("*?", "%_")
677 match = " LIKE '" + str(s).translate(trans) + "'"
678 else:
679 match = " GLOB '" + str(value) + "'"
680 else:
681 match = " = '" + str(value) + "'"
682 self.DoFindSelect(query, match)
683
684 def Found(self, query, found):
685 if found:
686 return self.FindPath(query)
687 return []
688
689 def FindValue(self, value, pattern, query, last_value, last_pattern):
690 if last_value == value and pattern == last_pattern:
691 found = query.first()
692 else:
693 self.FindSelect(value, pattern, query)
694 found = query.next()
695 return self.Found(query, found)
696
697 def FindNext(self, query):
698 found = query.next()
699 if not found:
700 found = query.first()
701 return self.Found(query, found)
702
703 def FindPrev(self, query):
704 found = query.previous()
705 if not found:
706 found = query.last()
707 return self.Found(query, found)
708
709 def FindThread(self, c):
710 if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern:
711 ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
712 elif c.direction > 0:
713 ids = self.FindNext(c.query)
714 else:
715 ids = self.FindPrev(c.query)
716 return (True, ids)
717
718 def Find(self, value, direction, pattern, context, callback):
719 class Context():
720 def __init__(self, *x):
721 self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
722 def Update(self, *x):
723 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern)
724 if len(context):
725 context[0].Update(value, direction, pattern)
726 else:
727 context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
728 # Use a thread so the UI is not blocked during the SELECT
729 thread = Thread(self.FindThread, context[0])
730 thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection)
731 thread.start()
732
733 def FindDone(self, thread, callback, ids):
734 callback(ids)
735
736 # Context-sensitive call graph data model
737
738 class CallGraphModel(CallGraphModelBase):
739
740 def __init__(self, glb, parent=None):
741 super(CallGraphModel, self).__init__(glb, parent)
742
743 def GetRoot(self):
744 return CallGraphRootItem(self.glb, self.params)
745
746 def columnCount(self, parent=None):
747 if self.params.have_ipc:
748 return 12
749 else:
750 return 7
751
752 def columnHeader(self, column):
753 if self.params.have_ipc:
754 headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
755 else:
756 headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
757 return headers[column]
758
759 def columnAlignment(self, column):
760 if self.params.have_ipc:
761 alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
762 else:
763 alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
764 return alignment[column]
765
766 def DoFindSelect(self, query, match):
767 QueryExec(query, "SELECT call_path_id, comm_id, thread_id"
768 " FROM calls"
769 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
770 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
771 " WHERE symbols.name" + match +
772 " GROUP BY comm_id, thread_id, call_path_id"
773 " ORDER BY comm_id, thread_id, call_path_id")
774
775 def FindPath(self, query):
776 # Turn the query result into a list of ids that the tree view can walk
777 # to open the tree at the right place.
778 ids = []
779 parent_id = query.value(0)
780 while parent_id:
781 ids.insert(0, parent_id)
782 q2 = QSqlQuery(self.glb.db)
783 QueryExec(q2, "SELECT parent_id"
784 " FROM call_paths"
785 " WHERE id = " + str(parent_id))
786 if not q2.next():
787 break
788 parent_id = q2.value(0)
789 # The call path root is not used
790 if ids[0] == 1:
791 del ids[0]
792 ids.insert(0, query.value(2))
793 ids.insert(0, query.value(1))
794 return ids
795
796 # Call tree data model level 2+ item base
797
798 class CallTreeLevelTwoPlusItemBase(CallGraphLevelItemBase):
799
800 def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
801 super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
802 self.comm_id = comm_id
803 self.thread_id = thread_id
804 self.calls_id = calls_id
805 self.call_time = call_time
806 self.time = time
807 self.insn_cnt = insn_cnt
808 self.cyc_cnt = cyc_cnt
809 self.branch_count = branch_count
810
811 def Select(self):
812 self.query_done = True
813 if self.calls_id == 0:
814 comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
815 else:
816 comm_thread = ""
817 if self.params.have_ipc:
818 ipc_str = ", insn_count, cyc_count"
819 else:
820 ipc_str = ""
821 query = QSqlQuery(self.glb.db)
822 QueryExec(query, "SELECT calls.id, name, short_name, call_time, return_time - call_time" + ipc_str + ", branch_count"
823 " FROM calls"
824 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
825 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
826 " INNER JOIN dsos ON symbols.dso_id = dsos.id"
827 " WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
828 " ORDER BY call_time, calls.id")
829 while query.next():
830 if self.params.have_ipc:
831 insn_cnt = int(query.value(5))
832 cyc_cnt = int(query.value(6))
833 branch_count = int(query.value(7))
834 else:
835 insn_cnt = 0
836 cyc_cnt = 0
837 branch_count = int(query.value(5))
838 child_item = CallTreeLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
839 self.child_items.append(child_item)
840 self.child_count += 1
841
842 # Call tree data model level three item
843
844 class CallTreeLevelThreeItem(CallTreeLevelTwoPlusItemBase):
845
846 def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
847 super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item)
848 dso = dsoname(dso)
849 if self.params.have_ipc:
850 insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
851 cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
852 br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
853 ipc = CalcIPC(cyc_cnt, insn_cnt)
854 self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
855 else:
856 self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
857 self.dbid = calls_id
858
859 # Call tree data model level two item
860
861 class CallTreeLevelTwoItem(CallTreeLevelTwoPlusItemBase):
862
863 def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
864 super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0, parent_item)
865 if self.params.have_ipc:
866 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
867 else:
868 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
869 self.dbid = thread_id
870
871 def Select(self):
872 super(CallTreeLevelTwoItem, self).Select()
873 for child_item in self.child_items:
874 self.time += child_item.time
875 self.insn_cnt += child_item.insn_cnt
876 self.cyc_cnt += child_item.cyc_cnt
877 self.branch_count += child_item.branch_count
878 for child_item in self.child_items:
879 child_item.data[4] = PercentToOneDP(child_item.time, self.time)
880 if self.params.have_ipc:
881 child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
882 child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
883 child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
884 else:
885 child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
886
887 # Call tree data model level one item
888
889 class CallTreeLevelOneItem(CallGraphLevelItemBase):
890
891 def __init__(self, glb, params, row, comm_id, comm, parent_item):
892 super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
893 if self.params.have_ipc:
894 self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
895 else:
896 self.data = [comm, "", "", "", "", "", ""]
897 self.dbid = comm_id
898
899 def Select(self):
900 self.query_done = True
901 query = QSqlQuery(self.glb.db)
902 QueryExec(query, "SELECT thread_id, pid, tid"
903 " FROM comm_threads"
904 " INNER JOIN threads ON thread_id = threads.id"
905 " WHERE comm_id = " + str(self.dbid))
906 while query.next():
907 child_item = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
908 self.child_items.append(child_item)
909 self.child_count += 1
910
911 # Call tree data model root item
912
913 class CallTreeRootItem(CallGraphLevelItemBase):
914
915 def __init__(self, glb, params):
916 super(CallTreeRootItem, self).__init__(glb, params, 0, None)
917 self.dbid = 0
918 self.query_done = True
919 if_has_calls = ""
920 if IsSelectable(glb.db, "comms", columns = "has_calls"):
921 if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
922 query = QSqlQuery(glb.db)
923 QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
924 while query.next():
925 if not query.value(0):
926 continue
927 child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
928 self.child_items.append(child_item)
929 self.child_count += 1
930
931 # Call Tree data model
932
933 class CallTreeModel(CallGraphModelBase):
934
935 def __init__(self, glb, parent=None):
936 super(CallTreeModel, self).__init__(glb, parent)
937
938 def GetRoot(self):
939 return CallTreeRootItem(self.glb, self.params)
940
941 def columnCount(self, parent=None):
942 if self.params.have_ipc:
943 return 12
944 else:
945 return 7
946
947 def columnHeader(self, column):
948 if self.params.have_ipc:
949 headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
950 else:
951 headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
952 return headers[column]
953
954 def columnAlignment(self, column):
955 if self.params.have_ipc:
956 alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
957 else:
958 alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
959 return alignment[column]
960
961 def DoFindSelect(self, query, match):
962 QueryExec(query, "SELECT calls.id, comm_id, thread_id"
963 " FROM calls"
964 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
965 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
966 " WHERE symbols.name" + match +
967 " ORDER BY comm_id, thread_id, call_time, calls.id")
968
969 def FindPath(self, query):
970 # Turn the query result into a list of ids that the tree view can walk
971 # to open the tree at the right place.
972 ids = []
973 parent_id = query.value(0)
974 while parent_id:
975 ids.insert(0, parent_id)
976 q2 = QSqlQuery(self.glb.db)
977 QueryExec(q2, "SELECT parent_id"
978 " FROM calls"
979 " WHERE id = " + str(parent_id))
980 if not q2.next():
981 break
982 parent_id = q2.value(0)
983 ids.insert(0, query.value(2))
984 ids.insert(0, query.value(1))
985 return ids
986
987 # Vertical layout
988
989 class HBoxLayout(QHBoxLayout):
990
991 def __init__(self, *children):
992 super(HBoxLayout, self).__init__()
993
994 self.layout().setContentsMargins(0, 0, 0, 0)
995 for child in children:
996 if child.isWidgetType():
997 self.layout().addWidget(child)
998 else:
999 self.layout().addLayout(child)
1000
1001 # Horizontal layout
1002
1003 class VBoxLayout(QVBoxLayout):
1004
1005 def __init__(self, *children):
1006 super(VBoxLayout, self).__init__()
1007
1008 self.layout().setContentsMargins(0, 0, 0, 0)
1009 for child in children:
1010 if child.isWidgetType():
1011 self.layout().addWidget(child)
1012 else:
1013 self.layout().addLayout(child)
1014
1015 # Vertical layout widget
1016
1017 class VBox():
1018
1019 def __init__(self, *children):
1020 self.vbox = QWidget()
1021 self.vbox.setLayout(VBoxLayout(*children))
1022
1023 def Widget(self):
1024 return self.vbox
1025
1026 # Tree window base
1027
1028 class TreeWindowBase(QMdiSubWindow):
1029
1030 def __init__(self, parent=None):
1031 super(TreeWindowBase, self).__init__(parent)
1032
1033 self.model = None
1034 self.find_bar = None
1035
1036 self.view = QTreeView()
1037 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
1038 self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
1039
1040 self.context_menu = TreeContextMenu(self.view)
1041
1042 def DisplayFound(self, ids):
1043 if not len(ids):
1044 return False
1045 parent = QModelIndex()
1046 for dbid in ids:
1047 found = False
1048 n = self.model.rowCount(parent)
1049 for row in xrange(n):
1050 child = self.model.index(row, 0, parent)
1051 if child.internalPointer().dbid == dbid:
1052 found = True
1053 self.view.setCurrentIndex(child)
1054 parent = child
1055 break
1056 if not found:
1057 break
1058 return found
1059
1060 def Find(self, value, direction, pattern, context):
1061 self.view.setFocus()
1062 self.find_bar.Busy()
1063 self.model.Find(value, direction, pattern, context, self.FindDone)
1064
1065 def FindDone(self, ids):
1066 found = True
1067 if not self.DisplayFound(ids):
1068 found = False
1069 self.find_bar.Idle()
1070 if not found:
1071 self.find_bar.NotFound()
1072
1073
1074 # Context-sensitive call graph window
1075
1076 class CallGraphWindow(TreeWindowBase):
1077
1078 def __init__(self, glb, parent=None):
1079 super(CallGraphWindow, self).__init__(parent)
1080
1081 self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
1082
1083 self.view.setModel(self.model)
1084
1085 for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)):
1086 self.view.setColumnWidth(c, w)
1087
1088 self.find_bar = FindBar(self, self)
1089
1090 self.vbox = VBox(self.view, self.find_bar.Widget())
1091
1092 self.setWidget(self.vbox.Widget())
1093
1094 AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
1095
1096 # Call tree window
1097
1098 class CallTreeWindow(TreeWindowBase):
1099
1100 def __init__(self, glb, parent=None, thread_at_time=None):
1101 super(CallTreeWindow, self).__init__(parent)
1102
1103 self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
1104
1105 self.view.setModel(self.model)
1106
1107 for c, w in ((0, 230), (1, 100), (2, 100), (3, 70), (4, 70), (5, 100)):
1108 self.view.setColumnWidth(c, w)
1109
1110 self.find_bar = FindBar(self, self)
1111
1112 self.vbox = VBox(self.view, self.find_bar.Widget())
1113
1114 self.setWidget(self.vbox.Widget())
1115
1116 AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
1117
1118 if thread_at_time:
1119 self.DisplayThreadAtTime(*thread_at_time)
1120
1121 def DisplayThreadAtTime(self, comm_id, thread_id, time):
1122 parent = QModelIndex()
1123 for dbid in (comm_id, thread_id):
1124 found = False
1125 n = self.model.rowCount(parent)
1126 for row in xrange(n):
1127 child = self.model.index(row, 0, parent)
1128 if child.internalPointer().dbid == dbid:
1129 found = True
1130 self.view.setCurrentIndex(child)
1131 parent = child
1132 break
1133 if not found:
1134 return
1135 found = False
1136 while True:
1137 n = self.model.rowCount(parent)
1138 if not n:
1139 return
1140 last_child = None
1141 for row in xrange(n):
1142 child = self.model.index(row, 0, parent)
1143 child_call_time = child.internalPointer().call_time
1144 if child_call_time < time:
1145 last_child = child
1146 elif child_call_time == time:
1147 self.view.setCurrentIndex(child)
1148 return
1149 elif child_call_time > time:
1150 break
1151 if not last_child:
1152 if not found:
1153 child = self.model.index(0, 0, parent)
1154 self.view.setCurrentIndex(child)
1155 return
1156 found = True
1157 self.view.setCurrentIndex(last_child)
1158 parent = last_child
1159
1160 # ExecComm() gets the comm_id of the command string that was set when the process exec'd i.e. the program name
1161
1162 def ExecComm(db, thread_id, time):
1163 query = QSqlQuery(db)
1164 QueryExec(query, "SELECT comm_threads.comm_id, comms.c_time, comms.exec_flag"
1165 " FROM comm_threads"
1166 " INNER JOIN comms ON comms.id = comm_threads.comm_id"
1167 " WHERE comm_threads.thread_id = " + str(thread_id) +
1168 " ORDER BY comms.c_time, comms.id")
1169 first = None
1170 last = None
1171 while query.next():
1172 if first is None:
1173 first = query.value(0)
1174 if query.value(2) and Decimal(query.value(1)) <= Decimal(time):
1175 last = query.value(0)
1176 if not(last is None):
1177 return last
1178 return first
1179
1180 # Container for (x, y) data
1181
1182 class XY():
1183 def __init__(self, x=0, y=0):
1184 self.x = x
1185 self.y = y
1186
1187 def __str__(self):
1188 return "XY({}, {})".format(str(self.x), str(self.y))
1189
1190 # Container for sub-range data
1191
1192 class Subrange():
1193 def __init__(self, lo=0, hi=0):
1194 self.lo = lo
1195 self.hi = hi
1196
1197 def __str__(self):
1198 return "Subrange({}, {})".format(str(self.lo), str(self.hi))
1199
1200 # Graph data region base class
1201
1202 class GraphDataRegion(object):
1203
1204 def __init__(self, key, title = "", ordinal = ""):
1205 self.key = key
1206 self.title = title
1207 self.ordinal = ordinal
1208
1209 # Function to sort GraphDataRegion
1210
1211 def GraphDataRegionOrdinal(data_region):
1212 return data_region.ordinal
1213
1214 # Attributes for a graph region
1215
1216 class GraphRegionAttribute():
1217
1218 def __init__(self, colour):
1219 self.colour = colour
1220
1221 # Switch graph data region represents a task
1222
1223 class SwitchGraphDataRegion(GraphDataRegion):
1224
1225 def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):
1226 super(SwitchGraphDataRegion, self).__init__(key)
1227
1228 self.title = str(pid) + " / " + str(tid) + " " + comm
1229 # Order graph legend within exec comm by pid / tid / time
1230 self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
1231 self.exec_comm_id = exec_comm_id
1232 self.pid = pid
1233 self.tid = tid
1234 self.comm = comm
1235 self.thread_id = thread_id
1236 self.comm_id = comm_id
1237
1238 # Graph data point
1239
1240 class GraphDataPoint():
1241
1242 def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):
1243 self.data = data
1244 self.index = index
1245 self.x = x
1246 self.y = y
1247 self.altx = altx
1248 self.alty = alty
1249 self.hregion = hregion
1250 self.vregion = vregion
1251
1252 # Graph data (single graph) base class
1253
1254 class GraphData(object):
1255
1256 def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):
1257 self.collection = collection
1258 self.points = []
1259 self.xbase = xbase
1260 self.ybase = ybase
1261 self.title = ""
1262
1263 def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):
1264 index = len(self.points)
1265
1266 x = float(Decimal(x) - self.xbase)
1267 y = float(Decimal(y) - self.ybase)
1268
1269 self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))
1270
1271 def XToData(self, x):
1272 return Decimal(x) + self.xbase
1273
1274 def YToData(self, y):
1275 return Decimal(y) + self.ybase
1276
1277 # Switch graph data (for one CPU)
1278
1279 class SwitchGraphData(GraphData):
1280
1281 def __init__(self, db, collection, cpu, xbase):
1282 super(SwitchGraphData, self).__init__(collection, xbase)
1283
1284 self.cpu = cpu
1285 self.title = "CPU " + str(cpu)
1286 self.SelectSwitches(db)
1287
1288 def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):
1289 query = QSqlQuery(db)
1290 QueryExec(query, "SELECT id, c_time"
1291 " FROM comms"
1292 " WHERE c_thread_id = " + str(thread_id) +
1293 " AND exec_flag = " + self.collection.glb.dbref.TRUE +
1294 " AND c_time >= " + str(start_time) +
1295 " AND c_time <= " + str(end_time) +
1296 " ORDER BY c_time, id")
1297 while query.next():
1298 comm_id = query.value(0)
1299 if comm_id == last_comm_id:
1300 continue
1301 time = query.value(1)
1302 hregion = self.HRegion(db, thread_id, comm_id, time)
1303 self.AddPoint(time, 1000, None, None, hregion)
1304
1305 def SelectSwitches(self, db):
1306 last_time = None
1307 last_comm_id = None
1308 last_thread_id = None
1309 query = QSqlQuery(db)
1310 QueryExec(query, "SELECT time, thread_out_id, thread_in_id, comm_out_id, comm_in_id, flags"
1311 " FROM context_switches"
1312 " WHERE machine_id = " + str(self.collection.machine_id) +
1313 " AND cpu = " + str(self.cpu) +
1314 " ORDER BY time, id")
1315 while query.next():
1316 flags = int(query.value(5))
1317 if flags & 1:
1318 # Schedule-out: detect and add exec's
1319 if last_thread_id == query.value(1) and last_comm_id is not None and last_comm_id != query.value(3):
1320 self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
1321 continue
1322 # Schedule-in: add data point
1323 if len(self.points) == 0:
1324 start_time = self.collection.glb.StartTime(self.collection.machine_id)
1325 hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
1326 self.AddPoint(start_time, 1000, None, None, hregion)
1327 time = query.value(0)
1328 comm_id = query.value(4)
1329 thread_id = query.value(2)
1330 hregion = self.HRegion(db, thread_id, comm_id, time)
1331 self.AddPoint(time, 1000, None, None, hregion)
1332 last_time = time
1333 last_comm_id = comm_id
1334 last_thread_id = thread_id
1335
1336 def NewHRegion(self, db, key, thread_id, comm_id, time):
1337 exec_comm_id = ExecComm(db, thread_id, time)
1338 query = QSqlQuery(db)
1339 QueryExec(query, "SELECT pid, tid FROM threads WHERE id = " + str(thread_id))
1340 if query.next():
1341 pid = query.value(0)
1342 tid = query.value(1)
1343 else:
1344 pid = -1
1345 tid = -1
1346 query = QSqlQuery(db)
1347 QueryExec(query, "SELECT comm FROM comms WHERE id = " + str(comm_id))
1348 if query.next():
1349 comm = query.value(0)
1350 else:
1351 comm = ""
1352 return SwitchGraphDataRegion(key, exec_comm_id, pid, tid, comm, thread_id, comm_id)
1353
1354 def HRegion(self, db, thread_id, comm_id, time):
1355 key = str(thread_id) + ":" + str(comm_id)
1356 hregion = self.collection.LookupHRegion(key)
1357 if hregion is None:
1358 hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
1359 self.collection.AddHRegion(key, hregion)
1360 return hregion
1361
1362 # Graph data collection (multiple related graphs) base class
1363
1364 class GraphDataCollection(object):
1365
1366 def __init__(self, glb):
1367 self.glb = glb
1368 self.data = []
1369 self.hregions = {}
1370 self.xrangelo = None
1371 self.xrangehi = None
1372 self.yrangelo = None
1373 self.yrangehi = None
1374 self.dp = XY(0, 0)
1375
1376 def AddGraphData(self, data):
1377 self.data.append(data)
1378
1379 def LookupHRegion(self, key):
1380 if key in self.hregions:
1381 return self.hregions[key]
1382 return None
1383
1384 def AddHRegion(self, key, hregion):
1385 self.hregions[key] = hregion
1386
1387 # Switch graph data collection (SwitchGraphData for each CPU)
1388
1389 class SwitchGraphDataCollection(GraphDataCollection):
1390
1391 def __init__(self, glb, db, machine_id):
1392 super(SwitchGraphDataCollection, self).__init__(glb)
1393
1394 self.machine_id = machine_id
1395 self.cpus = self.SelectCPUs(db)
1396
1397 self.xrangelo = glb.StartTime(machine_id)
1398 self.xrangehi = glb.FinishTime(machine_id)
1399
1400 self.yrangelo = Decimal(0)
1401 self.yrangehi = Decimal(1000)
1402
1403 for cpu in self.cpus:
1404 self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))
1405
1406 def SelectCPUs(self, db):
1407 cpus = []
1408 query = QSqlQuery(db)
1409 QueryExec(query, "SELECT DISTINCT cpu"
1410 " FROM context_switches"
1411 " WHERE machine_id = " + str(self.machine_id))
1412 while query.next():
1413 cpus.append(int(query.value(0)))
1414 return sorted(cpus)
1415
1416 # Switch graph data graphics item displays the graphed data
1417
1418 class SwitchGraphDataGraphicsItem(QGraphicsItem):
1419
1420 def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):
1421 super(SwitchGraphDataGraphicsItem, self).__init__(parent)
1422
1423 self.data = data
1424 self.graph_width = graph_width
1425 self.graph_height = graph_height
1426 self.attrs = attrs
1427 self.event_handler = event_handler
1428 self.setAcceptHoverEvents(True)
1429
1430 def boundingRect(self):
1431 return QRectF(0, 0, self.graph_width, self.graph_height)
1432
1433 def PaintPoint(self, painter, last, x):
1434 if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
1435 if last.x < self.attrs.subrange.x.lo:
1436 x0 = self.attrs.subrange.x.lo
1437 else:
1438 x0 = last.x
1439 if x > self.attrs.subrange.x.hi:
1440 x1 = self.attrs.subrange.x.hi
1441 else:
1442 x1 = x - 1
1443 x0 = self.attrs.XToPixel(x0)
1444 x1 = self.attrs.XToPixel(x1)
1445
1446 y0 = self.attrs.YToPixel(last.y)
1447
1448 colour = self.attrs.region_attributes[last.hregion.key].colour
1449
1450 width = x1 - x0 + 1
1451 if width < 2:
1452 painter.setPen(colour)
1453 painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
1454 else:
1455 painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)
1456
1457 def paint(self, painter, option, widget):
1458 last = None
1459 for point in self.data.points:
1460 self.PaintPoint(painter, last, point.x)
1461 if point.x > self.attrs.subrange.x.hi:
1462 break;
1463 last = point
1464 self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)
1465
1466 def BinarySearchPoint(self, target):
1467 lower_pos = 0
1468 higher_pos = len(self.data.points)
1469 while True:
1470 pos = int((lower_pos + higher_pos) / 2)
1471 val = self.data.points[pos].x
1472 if target >= val:
1473 lower_pos = pos
1474 else:
1475 higher_pos = pos
1476 if higher_pos <= lower_pos + 1:
1477 return lower_pos
1478
1479 def XPixelToData(self, x):
1480 x = self.attrs.PixelToX(x)
1481 if x < self.data.points[0].x:
1482 x = 0
1483 pos = 0
1484 low = True
1485 else:
1486 pos = self.BinarySearchPoint(x)
1487 low = False
1488 return (low, pos, self.data.XToData(x))
1489
1490 def EventToData(self, event):
1491 no_data = (None,) * 4
1492 if len(self.data.points) < 1:
1493 return no_data
1494 x = event.pos().x()
1495 if x < 0:
1496 return no_data
1497 low0, pos0, time_from = self.XPixelToData(x)
1498 low1, pos1, time_to = self.XPixelToData(x + 1)
1499 hregions = set()
1500 hregion_times = []
1501 if not low1:
1502 for i in xrange(pos0, pos1 + 1):
1503 hregion = self.data.points[i].hregion
1504 hregions.add(hregion)
1505 if i == pos0:
1506 time = time_from
1507 else:
1508 time = self.data.XToData(self.data.points[i].x)
1509 hregion_times.append((hregion, time))
1510 return (time_from, time_to, hregions, hregion_times)
1511
1512 def hoverMoveEvent(self, event):
1513 time_from, time_to, hregions, hregion_times = self.EventToData(event)
1514 if time_from is not None:
1515 self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)
1516
1517 def hoverLeaveEvent(self, event):
1518 self.event_handler.NoPointEvent()
1519
1520 def mousePressEvent(self, event):
1521 if event.button() != Qt.RightButton:
1522 super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
1523 return
1524 time_from, time_to, hregions, hregion_times = self.EventToData(event)
1525 if hregion_times:
1526 self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())
1527
1528 # X-axis graphics item
1529
1530 class XAxisGraphicsItem(QGraphicsItem):
1531
1532 def __init__(self, width, parent=None):
1533 super(XAxisGraphicsItem, self).__init__(parent)
1534
1535 self.width = width
1536 self.max_mark_sz = 4
1537 self.height = self.max_mark_sz + 1
1538
1539 def boundingRect(self):
1540 return QRectF(0, 0, self.width, self.height)
1541
1542 def Step(self):
1543 attrs = self.parentItem().attrs
1544 subrange = attrs.subrange.x
1545 t = subrange.hi - subrange.lo
1546 s = (3.0 * t) / self.width
1547 n = 1.0
1548 while s > n:
1549 n = n * 10.0
1550 return n
1551
1552 def PaintMarks(self, painter, at_y, lo, hi, step, i):
1553 attrs = self.parentItem().attrs
1554 x = lo
1555 while x <= hi:
1556 xp = attrs.XToPixel(x)
1557 if i % 10:
1558 if i % 5:
1559 sz = 1
1560 else:
1561 sz = 2
1562 else:
1563 sz = self.max_mark_sz
1564 i = 0
1565 painter.drawLine(xp, at_y, xp, at_y + sz)
1566 x += step
1567 i += 1
1568
1569 def paint(self, painter, option, widget):
1570 # Using QPainter::drawLine(int x1, int y1, int x2, int y2) so x2 = width -1
1571 painter.drawLine(0, 0, self.width - 1, 0)
1572 n = self.Step()
1573 attrs = self.parentItem().attrs
1574 subrange = attrs.subrange.x
1575 if subrange.lo:
1576 x_offset = n - (subrange.lo % n)
1577 else:
1578 x_offset = 0.0
1579 x = subrange.lo + x_offset
1580 i = (x / n) % 10
1581 self.PaintMarks(painter, 0, x, subrange.hi, n, i)
1582
1583 def ScaleDimensions(self):
1584 n = self.Step()
1585 attrs = self.parentItem().attrs
1586 lo = attrs.subrange.x.lo
1587 hi = (n * 10.0) + lo
1588 width = attrs.XToPixel(hi)
1589 if width > 500:
1590 width = 0
1591 return (n, lo, hi, width)
1592
1593 def PaintScale(self, painter, at_x, at_y):
1594 n, lo, hi, width = self.ScaleDimensions()
1595 if not width:
1596 return
1597 painter.drawLine(at_x, at_y, at_x + width, at_y)
1598 self.PaintMarks(painter, at_y, lo, hi, n, 0)
1599
1600 def ScaleWidth(self):
1601 n, lo, hi, width = self.ScaleDimensions()
1602 return width
1603
1604 def ScaleHeight(self):
1605 return self.height
1606
1607 def ScaleUnit(self):
1608 return self.Step() * 10
1609
1610 # Scale graphics item base class
1611
1612 class ScaleGraphicsItem(QGraphicsItem):
1613
1614 def __init__(self, axis, parent=None):
1615 super(ScaleGraphicsItem, self).__init__(parent)
1616 self.axis = axis
1617
1618 def boundingRect(self):
1619 scale_width = self.axis.ScaleWidth()
1620 if not scale_width:
1621 return QRectF()
1622 return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())
1623
1624 def paint(self, painter, option, widget):
1625 scale_width = self.axis.ScaleWidth()
1626 if not scale_width:
1627 return
1628 self.axis.PaintScale(painter, 0, 5)
1629 x = scale_width + 4
1630 painter.drawText(QPointF(x, 10), self.Text())
1631
1632 def Unit(self):
1633 return self.axis.ScaleUnit()
1634
1635 def Text(self):
1636 return ""
1637
1638 # Switch graph scale graphics item
1639
1640 class SwitchScaleGraphicsItem(ScaleGraphicsItem):
1641
1642 def __init__(self, axis, parent=None):
1643 super(SwitchScaleGraphicsItem, self).__init__(axis, parent)
1644
1645 def Text(self):
1646 unit = self.Unit()
1647 if unit >= 1000000000:
1648 unit = int(unit / 1000000000)
1649 us = "s"
1650 elif unit >= 1000000:
1651 unit = int(unit / 1000000)
1652 us = "ms"
1653 elif unit >= 1000:
1654 unit = int(unit / 1000)
1655 us = "us"
1656 else:
1657 unit = int(unit)
1658 us = "ns"
1659 return " = " + str(unit) + " " + us
1660
1661 # Switch graph graphics item contains graph title, scale, x/y-axis, and the graphed data
1662
1663 class SwitchGraphGraphicsItem(QGraphicsItem):
1664
1665 def __init__(self, collection, data, attrs, event_handler, first, parent=None):
1666 super(SwitchGraphGraphicsItem, self).__init__(parent)
1667 self.collection = collection
1668 self.data = data
1669 self.attrs = attrs
1670 self.event_handler = event_handler
1671
1672 margin = 20
1673 title_width = 50
1674
1675 self.title_graphics = QGraphicsSimpleTextItem(data.title, self)
1676
1677 self.title_graphics.setPos(margin, margin)
1678 graph_width = attrs.XToPixel(attrs.subrange.x.hi) + 1
1679 graph_height = attrs.YToPixel(attrs.subrange.y.hi) + 1
1680
1681 self.graph_origin_x = margin + title_width + margin
1682 self.graph_origin_y = graph_height + margin
1683
1684 x_axis_size = 1
1685 y_axis_size = 1
1686 self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)
1687
1688 self.x_axis = XAxisGraphicsItem(graph_width, self)
1689 self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)
1690
1691 if first:
1692 self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
1693 self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)
1694
1695 self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)
1696
1697 self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
1698 self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)
1699
1700 self.width = self.graph_origin_x + graph_width + margin
1701 self.height = self.graph_origin_y + margin
1702
1703 self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, self)
1704 self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)
1705
1706 if parent and 'EnableRubberBand' in dir(parent):
1707 parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)
1708
1709 def boundingRect(self):
1710 return QRectF(0, 0, self.width, self.height)
1711
1712 def paint(self, painter, option, widget):
1713 pass
1714
1715 def RBXToPixel(self, x):
1716 return self.attrs.PixelToX(x - self.graph_origin_x)
1717
1718 def RBXRangeToPixel(self, x0, x1):
1719 return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))
1720
1721 def RBPixelToTime(self, x):
1722 if x < self.data.points[0].x:
1723 return self.data.XToData(0)
1724 return self.data.XToData(x)
1725
1726 def RBEventTimes(self, x0, x1):
1727 x0, x1 = self.RBXRangeToPixel(x0, x1)
1728 time_from = self.RBPixelToTime(x0)
1729 time_to = self.RBPixelToTime(x1)
1730 return (time_from, time_to)
1731
1732 def RBEvent(self, x0, x1):
1733 time_from, time_to = self.RBEventTimes(x0, x1)
1734 self.event_handler.RangeEvent(time_from, time_to)
1735
1736 def RBMoveEvent(self, x0, x1):
1737 if x1 < x0:
1738 x0, x1 = x1, x0
1739 self.RBEvent(x0, x1)
1740
1741 def RBReleaseEvent(self, x0, x1, selection_state):
1742 if x1 < x0:
1743 x0, x1 = x1, x0
1744 x0, x1 = self.RBXRangeToPixel(x0, x1)
1745 self.event_handler.SelectEvent(x0, x1, selection_state)
1746
1747 # Graphics item to draw a vertical bracket (used to highlight "forward" sub-range)
1748
1749 class VerticalBracketGraphicsItem(QGraphicsItem):
1750
1751 def __init__(self, parent=None):
1752 super(VerticalBracketGraphicsItem, self).__init__(parent)
1753
1754 self.width = 0
1755 self.height = 0
1756 self.hide()
1757
1758 def SetSize(self, width, height):
1759 self.width = width + 1
1760 self.height = height + 1
1761
1762 def boundingRect(self):
1763 return QRectF(0, 0, self.width, self.height)
1764
1765 def paint(self, painter, option, widget):
1766 colour = QColor(255, 255, 0, 32)
1767 painter.fillRect(0, 0, self.width, self.height, colour)
1768 x1 = self.width - 1
1769 y1 = self.height - 1
1770 painter.drawLine(0, 0, x1, 0)
1771 painter.drawLine(0, 0, 0, 3)
1772 painter.drawLine(x1, 0, x1, 3)
1773 painter.drawLine(0, y1, x1, y1)
1774 painter.drawLine(0, y1, 0, y1 - 3)
1775 painter.drawLine(x1, y1, x1, y1 - 3)
1776
1777 # Graphics item to contain graphs arranged vertically
1778
1779 class VertcalGraphSetGraphicsItem(QGraphicsItem):
1780
1781 def __init__(self, collection, attrs, event_handler, child_class, parent=None):
1782 super(VertcalGraphSetGraphicsItem, self).__init__(parent)
1783
1784 self.collection = collection
1785
1786 self.top = 10
1787
1788 self.width = 0
1789 self.height = self.top
1790
1791 self.rubber_band = None
1792 self.rb_enabled = False
1793
1794 first = True
1795 for data in collection.data:
1796 child = child_class(collection, data, attrs, event_handler, first, self)
1797 child.setPos(0, self.height + 1)
1798 rect = child.boundingRect()
1799 if rect.right() > self.width:
1800 self.width = rect.right()
1801 self.height = self.height + rect.bottom() + 1
1802 first = False
1803
1804 self.bracket = VerticalBracketGraphicsItem(self)
1805
1806 def EnableRubberBand(self, xlo, xhi, rb_event_handler):
1807 if self.rb_enabled:
1808 return
1809 self.rb_enabled = True
1810 self.rb_in_view = False
1811 self.setAcceptedMouseButtons(Qt.LeftButton)
1812 self.rb_xlo = xlo
1813 self.rb_xhi = xhi
1814 self.rb_event_handler = rb_event_handler
1815 self.mousePressEvent = self.MousePressEvent
1816 self.mouseMoveEvent = self.MouseMoveEvent
1817 self.mouseReleaseEvent = self.MouseReleaseEvent
1818
1819 def boundingRect(self):
1820 return QRectF(0, 0, self.width, self.height)
1821
1822 def paint(self, painter, option, widget):
1823 pass
1824
1825 def RubberBandParent(self):
1826 scene = self.scene()
1827 view = scene.views()[0]
1828 viewport = view.viewport()
1829 return viewport
1830
1831 def RubberBandSetGeometry(self, rect):
1832 scene_rectf = self.mapRectToScene(QRectF(rect))
1833 scene = self.scene()
1834 view = scene.views()[0]
1835 poly = view.mapFromScene(scene_rectf)
1836 self.rubber_band.setGeometry(poly.boundingRect())
1837
1838 def SetSelection(self, selection_state):
1839 if self.rubber_band:
1840 if selection_state:
1841 self.RubberBandSetGeometry(selection_state)
1842 self.rubber_band.show()
1843 else:
1844 self.rubber_band.hide()
1845
1846 def SetBracket(self, rect):
1847 if rect:
1848 x, y, width, height = rect.x(), rect.y(), rect.width(), rect.height()
1849 self.bracket.setPos(x, y)
1850 self.bracket.SetSize(width, height)
1851 self.bracket.show()
1852 else:
1853 self.bracket.hide()
1854
1855 def RubberBandX(self, event):
1856 x = event.pos().toPoint().x()
1857 if x < self.rb_xlo:
1858 x = self.rb_xlo
1859 elif x > self.rb_xhi:
1860 x = self.rb_xhi
1861 else:
1862 self.rb_in_view = True
1863 return x
1864
1865 def RubberBandRect(self, x):
1866 if self.rb_origin.x() <= x:
1867 width = x - self.rb_origin.x()
1868 rect = QRect(self.rb_origin, QSize(width, self.height))
1869 else:
1870 width = self.rb_origin.x() - x
1871 top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
1872 rect = QRect(top_left, QSize(width, self.height))
1873 return rect
1874
1875 def MousePressEvent(self, event):
1876 self.rb_in_view = False
1877 x = self.RubberBandX(event)
1878 self.rb_origin = QPoint(x, self.top)
1879 if self.rubber_band is None:
1880 self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
1881 self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
1882 if self.rb_in_view:
1883 self.rubber_band.show()
1884 self.rb_event_handler.RBMoveEvent(x, x)
1885 else:
1886 self.rubber_band.hide()
1887
1888 def MouseMoveEvent(self, event):
1889 x = self.RubberBandX(event)
1890 rect = self.RubberBandRect(x)
1891 self.RubberBandSetGeometry(rect)
1892 if self.rb_in_view:
1893 self.rubber_band.show()
1894 self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)
1895
1896 def MouseReleaseEvent(self, event):
1897 x = self.RubberBandX(event)
1898 if self.rb_in_view:
1899 selection_state = self.RubberBandRect(x)
1900 else:
1901 selection_state = None
1902 self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)
1903
1904 # Switch graph legend data model
1905
1906 class SwitchGraphLegendModel(QAbstractTableModel):
1907
1908 def __init__(self, collection, region_attributes, parent=None):
1909 super(SwitchGraphLegendModel, self).__init__(parent)
1910
1911 self.region_attributes = region_attributes
1912
1913 self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
1914 self.child_count = len(self.child_items)
1915
1916 self.highlight_set = set()
1917
1918 self.column_headers = ("pid", "tid", "comm")
1919
1920 def rowCount(self, parent):
1921 return self.child_count
1922
1923 def headerData(self, section, orientation, role):
1924 if role != Qt.DisplayRole:
1925 return None
1926 if orientation != Qt.Horizontal:
1927 return None
1928 return self.columnHeader(section)
1929
1930 def index(self, row, column, parent):
1931 return self.createIndex(row, column, self.child_items[row])
1932
1933 def columnCount(self, parent=None):
1934 return len(self.column_headers)
1935
1936 def columnHeader(self, column):
1937 return self.column_headers[column]
1938
1939 def data(self, index, role):
1940 if role == Qt.BackgroundRole:
1941 child = self.child_items[index.row()]
1942 if child in self.highlight_set:
1943 return self.region_attributes[child.key].colour
1944 return None
1945 if role == Qt.ForegroundRole:
1946 child = self.child_items[index.row()]
1947 if child in self.highlight_set:
1948 return QColor(255, 255, 255)
1949 return self.region_attributes[child.key].colour
1950 if role != Qt.DisplayRole:
1951 return None
1952 hregion = self.child_items[index.row()]
1953 col = index.column()
1954 if col == 0:
1955 return hregion.pid
1956 if col == 1:
1957 return hregion.tid
1958 if col == 2:
1959 return hregion.comm
1960 return None
1961
1962 def SetHighlight(self, row, set_highlight):
1963 child = self.child_items[row]
1964 top_left = self.createIndex(row, 0, child)
1965 bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
1966 self.dataChanged.emit(top_left, bottom_right)
1967
1968 def Highlight(self, highlight_set):
1969 for row in xrange(self.child_count):
1970 child = self.child_items[row]
1971 if child in self.highlight_set:
1972 if child not in highlight_set:
1973 self.SetHighlight(row, False)
1974 elif child in highlight_set:
1975 self.SetHighlight(row, True)
1976 self.highlight_set = highlight_set
1977
1978 # Switch graph legend is a table
1979
1980 class SwitchGraphLegend(QWidget):
1981
1982 def __init__(self, collection, region_attributes, parent=None):
1983 super(SwitchGraphLegend, self).__init__(parent)
1984
1985 self.data_model = SwitchGraphLegendModel(collection, region_attributes)
1986
1987 self.model = QSortFilterProxyModel()
1988 self.model.setSourceModel(self.data_model)
1989
1990 self.view = QTableView()
1991 self.view.setModel(self.model)
1992 self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
1993 self.view.verticalHeader().setVisible(False)
1994 self.view.sortByColumn(-1, Qt.AscendingOrder)
1995 self.view.setSortingEnabled(True)
1996 self.view.resizeColumnsToContents()
1997 self.view.resizeRowsToContents()
1998
1999 self.vbox = VBoxLayout(self.view)
2000 self.setLayout(self.vbox)
2001
2002 sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
2003 sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
2004 self.saved_size = sz1
2005
2006 def resizeEvent(self, event):
2007 self.saved_size = self.size().width()
2008 super(SwitchGraphLegend, self).resizeEvent(event)
2009
2010 def Highlight(self, highlight_set):
2011 self.data_model.Highlight(highlight_set)
2012 self.update()
2013
2014 def changeEvent(self, event):
2015 if event.type() == QEvent.FontChange:
2016 self.view.resizeRowsToContents()
2017 self.view.resizeColumnsToContents()
2018 # Need to resize rows again after column resize
2019 self.view.resizeRowsToContents()
2020 super(SwitchGraphLegend, self).changeEvent(event)
2021
2022 # Random colour generation
2023
2024 def RGBColourTooLight(r, g, b):
2025 if g > 230:
2026 return True
2027 if g <= 160:
2028 return False
2029 if r <= 180 and g <= 180:
2030 return False
2031 if r < 60:
2032 return False
2033 return True
2034
2035 def GenerateColours(x):
2036 cs = [0]
2037 for i in xrange(1, x):
2038 cs.append(int((255.0 / i) + 0.5))
2039 colours = []
2040 for r in cs:
2041 for g in cs:
2042 for b in cs:
2043 # Exclude black and colours that look too light against a white background
2044 if (r, g, b) == (0, 0, 0) or RGBColourTooLight(r, g, b):
2045 continue
2046 colours.append(QColor(r, g, b))
2047 return colours
2048
2049 def GenerateNColours(n):
2050 for x in xrange(2, n + 2):
2051 colours = GenerateColours(x)
2052 if len(colours) >= n:
2053 return colours
2054 return []
2055
2056 def GenerateNRandomColours(n, seed):
2057 colours = GenerateNColours(n)
2058 random.seed(seed)
2059 random.shuffle(colours)
2060 return colours
2061
2062 # Graph attributes, in particular the scale and subrange that change when zooming
2063
2064 class GraphAttributes():
2065
2066 def __init__(self, scale, subrange, region_attributes, dp):
2067 self.scale = scale
2068 self.subrange = subrange
2069 self.region_attributes = region_attributes
2070 # Rounding avoids errors due to finite floating point precision
2071 self.dp = dp # data decimal places
2072 self.Update()
2073
2074 def XToPixel(self, x):
2075 return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))
2076
2077 def YToPixel(self, y):
2078 return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))
2079
2080 def PixelToXRounded(self, px):
2081 return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo
2082
2083 def PixelToYRounded(self, py):
2084 return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo
2085
2086 def PixelToX(self, px):
2087 x = self.PixelToXRounded(px)
2088 if self.pdp.x == 0:
2089 rt = self.XToPixel(x)
2090 if rt > px:
2091 return x - 1
2092 return x
2093
2094 def PixelToY(self, py):
2095 y = self.PixelToYRounded(py)
2096 if self.pdp.y == 0:
2097 rt = self.YToPixel(y)
2098 if rt > py:
2099 return y - 1
2100 return y
2101
2102 def ToPDP(self, dp, scale):
2103 # Calculate pixel decimal places:
2104 # (10 ** dp) is the minimum delta in the data
2105 # scale it to get the minimum delta in pixels
2106 # log10 gives the number of decimals places negatively
2107 # subtrace 1 to divide by 10
2108 # round to the lower negative number
2109 # change the sign to get the number of decimals positively
2110 x = math.log10((10 ** dp) * scale)
2111 if x < 0:
2112 x -= 1
2113 x = -int(math.floor(x) - 0.1)
2114 else:
2115 x = 0
2116 return x
2117
2118 def Update(self):
2119 x = self.ToPDP(self.dp.x, self.scale.x)
2120 y = self.ToPDP(self.dp.y, self.scale.y)
2121 self.pdp = XY(x, y) # pixel decimal places
2122
2123 # Switch graph splitter which divides the CPU graphs from the legend
2124
2125 class SwitchGraphSplitter(QSplitter):
2126
2127 def __init__(self, parent=None):
2128 super(SwitchGraphSplitter, self).__init__(parent)
2129
2130 self.first_time = False
2131
2132 def resizeEvent(self, ev):
2133 if self.first_time:
2134 self.first_time = False
2135 sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).view.columnWidth(2) + 2
2136 sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
2137 sz0 = self.size().width() - self.handleWidth() - sz1
2138 self.setSizes([sz0, sz1])
2139 elif not(self.widget(1).saved_size is None):
2140 sz1 = self.widget(1).saved_size
2141 sz0 = self.size().width() - self.handleWidth() - sz1
2142 self.setSizes([sz0, sz1])
2143 super(SwitchGraphSplitter, self).resizeEvent(ev)
2144
2145 # Graph widget base class
2146
2147 class GraphWidget(QWidget):
2148
2149 graph_title_changed = Signal(object)
2150
2151 def __init__(self, parent=None):
2152 super(GraphWidget, self).__init__(parent)
2153
2154 def GraphTitleChanged(self, title):
2155 self.graph_title_changed.emit(title)
2156
2157 def Title(self):
2158 return ""
2159
2160 # Display time in s, ms, us or ns
2161
2162 def ToTimeStr(val):
2163 val = Decimal(val)
2164 if val >= 1000000000:
2165 return "{} s".format((val / 1000000000).quantize(Decimal("0.000000001")))
2166 if val >= 1000000:
2167 return "{} ms".format((val / 1000000).quantize(Decimal("0.000001")))
2168 if val >= 1000:
2169 return "{} us".format((val / 1000).quantize(Decimal("0.001")))
2170 return "{} ns".format(val.quantize(Decimal("1")))
2171
2172 # Switch (i.e. context switch i.e. Time Chart by CPU) graph widget which contains the CPU graphs and the legend and control buttons
2173
2174 class SwitchGraphWidget(GraphWidget):
2175
2176 def __init__(self, glb, collection, parent=None):
2177 super(SwitchGraphWidget, self).__init__(parent)
2178
2179 self.glb = glb
2180 self.collection = collection
2181
2182 self.back_state = []
2183 self.forward_state = []
2184 self.selection_state = (None, None)
2185 self.fwd_rect = None
2186 self.start_time = self.glb.StartTime(collection.machine_id)
2187
2188 i = 0
2189 hregions = collection.hregions.values()
2190 colours = GenerateNRandomColours(len(hregions), 1013)
2191 region_attributes = {}
2192 for hregion in hregions:
2193 if hregion.pid == 0 and hregion.tid == 0:
2194 region_attributes[hregion.key] = GraphRegionAttribute(QColor(0, 0, 0))
2195 else:
2196 region_attributes[hregion.key] = GraphRegionAttribute(colours[i])
2197 i = i + 1
2198
2199 # Default to entire range
2200 xsubrange = Subrange(0.0, float(collection.xrangehi - collection.xrangelo) + 1.0)
2201 ysubrange = Subrange(0.0, float(collection.yrangehi - collection.yrangelo) + 1.0)
2202 subrange = XY(xsubrange, ysubrange)
2203
2204 scale = self.GetScaleForRange(subrange)
2205
2206 self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)
2207
2208 self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)
2209
2210 self.scene = QGraphicsScene()
2211 self.scene.addItem(self.item)
2212
2213 self.view = QGraphicsView(self.scene)
2214 self.view.centerOn(0, 0)
2215 self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
2216
2217 self.legend = SwitchGraphLegend(collection, region_attributes)
2218
2219 self.splitter = SwitchGraphSplitter()
2220 self.splitter.addWidget(self.view)
2221 self.splitter.addWidget(self.legend)
2222
2223 self.point_label = QLabel("")
2224 self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
2225
2226 self.back_button = QToolButton()
2227 self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
2228 self.back_button.setDisabled(True)
2229 self.back_button.released.connect(lambda: self.Back())
2230
2231 self.forward_button = QToolButton()
2232 self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
2233 self.forward_button.setDisabled(True)
2234 self.forward_button.released.connect(lambda: self.Forward())
2235
2236 self.zoom_button = QToolButton()
2237 self.zoom_button.setText("Zoom")
2238 self.zoom_button.setDisabled(True)
2239 self.zoom_button.released.connect(lambda: self.Zoom())
2240
2241 self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)
2242
2243 self.vbox = VBoxLayout(self.splitter, self.hbox)
2244
2245 self.setLayout(self.vbox)
2246
2247 def GetScaleForRangeX(self, xsubrange):
2248 # Default graph 1000 pixels wide
2249 dflt = 1000.0
2250 r = xsubrange.hi - xsubrange.lo
2251 return dflt / r
2252
2253 def GetScaleForRangeY(self, ysubrange):
2254 # Default graph 50 pixels high
2255 dflt = 50.0
2256 r = ysubrange.hi - ysubrange.lo
2257 return dflt / r
2258
2259 def GetScaleForRange(self, subrange):
2260 # Default graph 1000 pixels wide, 50 pixels high
2261 xscale = self.GetScaleForRangeX(subrange.x)
2262 yscale = self.GetScaleForRangeY(subrange.y)
2263 return XY(xscale, yscale)
2264
2265 def PointEvent(self, cpu, time_from, time_to, hregions):
2266 text = "CPU: " + str(cpu)
2267 time_from = time_from.quantize(Decimal(1))
2268 rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
2269 text = text + " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ")"
2270 self.point_label.setText(text)
2271 self.legend.Highlight(hregions)
2272
2273 def RightClickEvent(self, cpu, hregion_times, pos):
2274 if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
2275 return
2276 menu = QMenu(self.view)
2277 for hregion, time in hregion_times:
2278 thread_at_time = (hregion.exec_comm_id, hregion.thread_id, time)
2279 menu_text = "Show Call Tree for {} {}:{} at {}".format(hregion.comm, hregion.pid, hregion.tid, time)
2280 menu.addAction(CreateAction(menu_text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view))
2281 menu.exec_(pos)
2282
2283 def RightClickSelect(self, args):
2284 CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)
2285
2286 def NoPointEvent(self):
2287 self.point_label.setText("")
2288 self.legend.Highlight({})
2289
2290 def RangeEvent(self, time_from, time_to):
2291 time_from = time_from.quantize(Decimal(1))
2292 time_to = time_to.quantize(Decimal(1))
2293 if time_to <= time_from:
2294 self.point_label.setText("")
2295 return
2296 rel_time_from = time_from - self.start_time
2297 rel_time_to = time_to - self.start_time
2298 text = " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ") to: " + str(time_to) + " (+" + ToTimeStr(rel_time_to) + ")"
2299 text = text + " duration: " + ToTimeStr(time_to - time_from)
2300 self.point_label.setText(text)
2301
2302 def BackState(self):
2303 return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)
2304
2305 def PushBackState(self):
2306 state = copy.deepcopy(self.BackState())
2307 self.back_state.append(state)
2308 self.back_button.setEnabled(True)
2309
2310 def PopBackState(self):
2311 self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
2312 self.attrs.Update()
2313 if not self.back_state:
2314 self.back_button.setDisabled(True)
2315
2316 def PushForwardState(self):
2317 state = copy.deepcopy(self.BackState())
2318 self.forward_state.append(state)
2319 self.forward_button.setEnabled(True)
2320
2321 def PopForwardState(self):
2322 self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.pop()
2323 self.attrs.Update()
2324 if not self.forward_state:
2325 self.forward_button.setDisabled(True)
2326
2327 def Title(self):
2328 time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
2329 time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
2330 rel_time_from = time_from - self.start_time
2331 rel_time_to = time_to - self.start_time
2332 title = "+" + ToTimeStr(rel_time_from) + " to +" + ToTimeStr(rel_time_to)
2333 title = title + " (" + ToTimeStr(time_to - time_from) + ")"
2334 return title
2335
2336 def Update(self):
2337 selected_subrange, selection_state = self.selection_state
2338 self.item.SetSelection(selection_state)
2339 self.item.SetBracket(self.fwd_rect)
2340 self.zoom_button.setDisabled(selected_subrange is None)
2341 self.GraphTitleChanged(self.Title())
2342 self.item.update(self.item.boundingRect())
2343
2344 def Back(self):
2345 if not self.back_state:
2346 return
2347 self.PushForwardState()
2348 self.PopBackState()
2349 self.Update()
2350
2351 def Forward(self):
2352 if not self.forward_state:
2353 return
2354 self.PushBackState()
2355 self.PopForwardState()
2356 self.Update()
2357
2358 def SelectEvent(self, x0, x1, selection_state):
2359 if selection_state is None:
2360 selected_subrange = None
2361 else:
2362 if x1 - x0 < 1.0:
2363 x1 += 1.0
2364 selected_subrange = Subrange(x0, x1)
2365 self.selection_state = (selected_subrange, selection_state)
2366 self.zoom_button.setDisabled(selected_subrange is None)
2367
2368 def Zoom(self):
2369 selected_subrange, selection_state = self.selection_state
2370 if selected_subrange is None:
2371 return
2372 self.fwd_rect = selection_state
2373 self.item.SetSelection(None)
2374 self.PushBackState()
2375 self.attrs.subrange.x = selected_subrange
2376 self.forward_state = []
2377 self.forward_button.setDisabled(True)
2378 self.selection_state = (None, None)
2379 self.fwd_rect = None
2380 self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
2381 self.attrs.Update()
2382 self.Update()
2383
2384 # Slow initialization - perform non-GUI initialization in a separate thread and put up a modal message box while waiting
2385
2386 class SlowInitClass():
2387
2388 def __init__(self, glb, title, init_fn):
2389 self.init_fn = init_fn
2390 self.done = False
2391 self.result = None
2392
2393 self.msg_box = QMessageBox(glb.mainwindow)
2394 self.msg_box.setText("Initializing " + title + ". Please wait.")
2395 self.msg_box.setWindowTitle("Initializing " + title)
2396 self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))
2397
2398 self.init_thread = Thread(self.ThreadFn, glb)
2399 self.init_thread.done.connect(lambda: self.Done(), Qt.QueuedConnection)
2400
2401 self.init_thread.start()
2402
2403 def Done(self):
2404 self.msg_box.done(0)
2405
2406 def ThreadFn(self, glb):
2407 conn_name = "SlowInitClass" + str(os.getpid())
2408 db, dbname = glb.dbref.Open(conn_name)
2409 self.result = self.init_fn(db)
2410 self.done = True
2411 return (True, 0)
2412
2413 def Result(self):
2414 while not self.done:
2415 self.msg_box.exec_()
2416 self.init_thread.wait()
2417 return self.result
2418
2419 def SlowInit(glb, title, init_fn):
2420 init = SlowInitClass(glb, title, init_fn)
2421 return init.Result()
2422
2423 # Time chart by CPU window
2424
2425 class TimeChartByCPUWindow(QMdiSubWindow):
2426
2427 def __init__(self, glb, parent=None):
2428 super(TimeChartByCPUWindow, self).__init__(parent)
2429
2430 self.glb = glb
2431 self.machine_id = glb.HostMachineId()
2432 self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)
2433
2434 collection = LookupModel(self.collection_name)
2435 if collection is None:
2436 collection = SlowInit(glb, "Time Chart", self.Init)
2437
2438 self.widget = SwitchGraphWidget(glb, collection, self)
2439 self.view = self.widget
2440
2441 self.base_title = "Time Chart by CPU"
2442 self.setWindowTitle(self.base_title + self.widget.Title())
2443 self.widget.graph_title_changed.connect(self.GraphTitleChanged)
2444
2445 self.setWidget(self.widget)
2446
2447 AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())
2448
2449 def Init(self, db):
2450 return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, self.machine_id))
2451
2452 def GraphTitleChanged(self, title):
2453 self.setWindowTitle(self.base_title + " : " + title)
2454
2455 # Child data item finder
2456
2457 class ChildDataItemFinder():
2458
2459 def __init__(self, root):
2460 self.root = root
2461 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
2462 self.rows = []
2463 self.pos = 0
2464
2465 def FindSelect(self):
2466 self.rows = []
2467 if self.pattern:
2468 pattern = re.compile(self.value)
2469 for child in self.root.child_items:
2470 for column_data in child.data:
2471 if re.search(pattern, str(column_data)) is not None:
2472 self.rows.append(child.row)
2473 break
2474 else:
2475 for child in self.root.child_items:
2476 for column_data in child.data:
2477 if self.value in str(column_data):
2478 self.rows.append(child.row)
2479 break
2480
2481 def FindValue(self):
2482 self.pos = 0
2483 if self.last_value != self.value or self.pattern != self.last_pattern:
2484 self.FindSelect()
2485 if not len(self.rows):
2486 return -1
2487 return self.rows[self.pos]
2488
2489 def FindThread(self):
2490 if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
2491 row = self.FindValue()
2492 elif len(self.rows):
2493 if self.direction > 0:
2494 self.pos += 1
2495 if self.pos >= len(self.rows):
2496 self.pos = 0
2497 else:
2498 self.pos -= 1
2499 if self.pos < 0:
2500 self.pos = len(self.rows) - 1
2501 row = self.rows[self.pos]
2502 else:
2503 row = -1
2504 return (True, row)
2505
2506 def Find(self, value, direction, pattern, context, callback):
2507 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern)
2508 # Use a thread so the UI is not blocked
2509 thread = Thread(self.FindThread)
2510 thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection)
2511 thread.start()
2512
2513 def FindDone(self, thread, callback, row):
2514 callback(row)
2515
2516 # Number of database records to fetch in one go
2517
2518 glb_chunk_sz = 10000
2519
2520 # Background process for SQL data fetcher
2521
2522 class SQLFetcherProcess():
2523
2524 def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep):
2525 # Need a unique connection name
2526 conn_name = "SQLFetcher" + str(os.getpid())
2527 self.db, dbname = dbref.Open(conn_name)
2528 self.sql = sql
2529 self.buffer = buffer
2530 self.head = head
2531 self.tail = tail
2532 self.fetch_count = fetch_count
2533 self.fetching_done = fetching_done
2534 self.process_target = process_target
2535 self.wait_event = wait_event
2536 self.fetched_event = fetched_event
2537 self.prep = prep
2538 self.query = QSqlQuery(self.db)
2539 self.query_limit = 0 if "$$last_id$$" in sql else 2
2540 self.last_id = -1
2541 self.fetched = 0
2542 self.more = True
2543 self.local_head = self.head.value
2544 self.local_tail = self.tail.value
2545
2546 def Select(self):
2547 if self.query_limit:
2548 if self.query_limit == 1:
2549 return
2550 self.query_limit -= 1
2551 stmt = self.sql.replace("$$last_id$$", str(self.last_id))
2552 QueryExec(self.query, stmt)
2553
2554 def Next(self):
2555 if not self.query.next():
2556 self.Select()
2557 if not self.query.next():
2558 return None
2559 self.last_id = self.query.value(0)
2560 return self.prep(self.query)
2561
2562 def WaitForTarget(self):
2563 while True:
2564 self.wait_event.clear()
2565 target = self.process_target.value
2566 if target > self.fetched or target < 0:
2567 break
2568 self.wait_event.wait()
2569 return target
2570
2571 def HasSpace(self, sz):
2572 if self.local_tail <= self.local_head:
2573 space = len(self.buffer) - self.local_head
2574 if space > sz:
2575 return True
2576 if space >= glb_nsz:
2577 # Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer
2578 nd = pickle.dumps(0, pickle.HIGHEST_PROTOCOL)
2579 self.buffer[self.local_head : self.local_head + len(nd)] = nd
2580 self.local_head = 0
2581 if self.local_tail - self.local_head > sz:
2582 return True
2583 return False
2584
2585 def WaitForSpace(self, sz):
2586 if self.HasSpace(sz):
2587 return
2588 while True:
2589 self.wait_event.clear()
2590 self.local_tail = self.tail.value
2591 if self.HasSpace(sz):
2592 return
2593 self.wait_event.wait()
2594
2595 def AddToBuffer(self, obj):
2596 d = pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
2597 n = len(d)
2598 nd = pickle.dumps(n, pickle.HIGHEST_PROTOCOL)
2599 sz = n + glb_nsz
2600 self.WaitForSpace(sz)
2601 pos = self.local_head
2602 self.buffer[pos : pos + len(nd)] = nd
2603 self.buffer[pos + glb_nsz : pos + sz] = d
2604 self.local_head += sz
2605
2606 def FetchBatch(self, batch_size):
2607 fetched = 0
2608 while batch_size > fetched:
2609 obj = self.Next()
2610 if obj is None:
2611 self.more = False
2612 break
2613 self.AddToBuffer(obj)
2614 fetched += 1
2615 if fetched:
2616 self.fetched += fetched
2617 with self.fetch_count.get_lock():
2618 self.fetch_count.value += fetched
2619 self.head.value = self.local_head
2620 self.fetched_event.set()
2621
2622 def Run(self):
2623 while self.more:
2624 target = self.WaitForTarget()
2625 if target < 0:
2626 break
2627 batch_size = min(glb_chunk_sz, target - self.fetched)
2628 self.FetchBatch(batch_size)
2629 self.fetching_done.value = True
2630 self.fetched_event.set()
2631
2632 def SQLFetcherFn(*x):
2633 process = SQLFetcherProcess(*x)
2634 process.Run()
2635
2636 # SQL data fetcher
2637
2638 class SQLFetcher(QObject):
2639
2640 done = Signal(object)
2641
2642 def __init__(self, glb, sql, prep, process_data, parent=None):
2643 super(SQLFetcher, self).__init__(parent)
2644 self.process_data = process_data
2645 self.more = True
2646 self.target = 0
2647 self.last_target = 0
2648 self.fetched = 0
2649 self.buffer_size = 16 * 1024 * 1024
2650 self.buffer = Array(c_char, self.buffer_size, lock=False)
2651 self.head = Value(c_longlong)
2652 self.tail = Value(c_longlong)
2653 self.local_tail = 0
2654 self.fetch_count = Value(c_longlong)
2655 self.fetching_done = Value(c_bool)
2656 self.last_count = 0
2657 self.process_target = Value(c_longlong)
2658 self.wait_event = Event()
2659 self.fetched_event = Event()
2660 glb.AddInstanceToShutdownOnExit(self)
2661 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))
2662 self.process.start()
2663 self.thread = Thread(self.Thread)
2664 self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
2665 self.thread.start()
2666
2667 def Shutdown(self):
2668 # Tell the thread and process to exit
2669 self.process_target.value = -1
2670 self.wait_event.set()
2671 self.more = False
2672 self.fetching_done.value = True
2673 self.fetched_event.set()
2674
2675 def Thread(self):
2676 if not self.more:
2677 return True, 0
2678 while True:
2679 self.fetched_event.clear()
2680 fetch_count = self.fetch_count.value
2681 if fetch_count != self.last_count:
2682 break
2683 if self.fetching_done.value:
2684 self.more = False
2685 return True, 0
2686 self.fetched_event.wait()
2687 count = fetch_count - self.last_count
2688 self.last_count = fetch_count
2689 self.fetched += count
2690 return False, count
2691
2692 def Fetch(self, nr):
2693 if not self.more:
2694 # -1 inidcates there are no more
2695 return -1
2696 result = self.fetched
2697 extra = result + nr - self.target
2698 if extra > 0:
2699 self.target += extra
2700 # process_target < 0 indicates shutting down
2701 if self.process_target.value >= 0:
2702 self.process_target.value = self.target
2703 self.wait_event.set()
2704 return result
2705
2706 def RemoveFromBuffer(self):
2707 pos = self.local_tail
2708 if len(self.buffer) - pos < glb_nsz:
2709 pos = 0
2710 n = pickle.loads(self.buffer[pos : pos + glb_nsz])
2711 if n == 0:
2712 pos = 0
2713 n = pickle.loads(self.buffer[0 : glb_nsz])
2714 pos += glb_nsz
2715 obj = pickle.loads(self.buffer[pos : pos + n])
2716 self.local_tail = pos + n
2717 return obj
2718
2719 def ProcessData(self, count):
2720 for i in xrange(count):
2721 obj = self.RemoveFromBuffer()
2722 self.process_data(obj)
2723 self.tail.value = self.local_tail
2724 self.wait_event.set()
2725 self.done.emit(count)
2726
2727 # Fetch more records bar
2728
2729 class FetchMoreRecordsBar():
2730
2731 def __init__(self, model, parent):
2732 self.model = model
2733
2734 self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
2735 self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2736
2737 self.fetch_count = QSpinBox()
2738 self.fetch_count.setRange(1, 1000000)
2739 self.fetch_count.setValue(10)
2740 self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2741
2742 self.fetch = QPushButton("Go!")
2743 self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2744 self.fetch.released.connect(self.FetchMoreRecords)
2745
2746 self.progress = QProgressBar()
2747 self.progress.setRange(0, 100)
2748 self.progress.hide()
2749
2750 self.done_label = QLabel("All records fetched")
2751 self.done_label.hide()
2752
2753 self.spacer = QLabel("")
2754
2755 self.close_button = QToolButton()
2756 self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
2757 self.close_button.released.connect(self.Deactivate)
2758
2759 self.hbox = QHBoxLayout()
2760 self.hbox.setContentsMargins(0, 0, 0, 0)
2761
2762 self.hbox.addWidget(self.label)
2763 self.hbox.addWidget(self.fetch_count)
2764 self.hbox.addWidget(self.fetch)
2765 self.hbox.addWidget(self.spacer)
2766 self.hbox.addWidget(self.progress)
2767 self.hbox.addWidget(self.done_label)
2768 self.hbox.addWidget(self.close_button)
2769
2770 self.bar = QWidget()
2771 self.bar.setLayout(self.hbox)
2772 self.bar.show()
2773
2774 self.in_progress = False
2775 self.model.progress.connect(self.Progress)
2776
2777 self.done = False
2778
2779 if not model.HasMoreRecords():
2780 self.Done()
2781
2782 def Widget(self):
2783 return self.bar
2784
2785 def Activate(self):
2786 self.bar.show()
2787 self.fetch.setFocus()
2788
2789 def Deactivate(self):
2790 self.bar.hide()
2791
2792 def Enable(self, enable):
2793 self.fetch.setEnabled(enable)
2794 self.fetch_count.setEnabled(enable)
2795
2796 def Busy(self):
2797 self.Enable(False)
2798 self.fetch.hide()
2799 self.spacer.hide()
2800 self.progress.show()
2801
2802 def Idle(self):
2803 self.in_progress = False
2804 self.Enable(True)
2805 self.progress.hide()
2806 self.fetch.show()
2807 self.spacer.show()
2808
2809 def Target(self):
2810 return self.fetch_count.value() * glb_chunk_sz
2811
2812 def Done(self):
2813 self.done = True
2814 self.Idle()
2815 self.label.hide()
2816 self.fetch_count.hide()
2817 self.fetch.hide()
2818 self.spacer.hide()
2819 self.done_label.show()
2820
2821 def Progress(self, count):
2822 if self.in_progress:
2823 if count:
2824 percent = ((count - self.start) * 100) / self.Target()
2825 if percent >= 100:
2826 self.Idle()
2827 else:
2828 self.progress.setValue(percent)
2829 if not count:
2830 # Count value of zero means no more records
2831 self.Done()
2832
2833 def FetchMoreRecords(self):
2834 if self.done:
2835 return
2836 self.progress.setValue(0)
2837 self.Busy()
2838 self.in_progress = True
2839 self.start = self.model.FetchMoreRecords(self.Target())
2840
2841 # Brance data model level two item
2842
2843 class BranchLevelTwoItem():
2844
2845 def __init__(self, row, col, text, parent_item):
2846 self.row = row
2847 self.parent_item = parent_item
2848 self.data = [""] * (col + 1)
2849 self.data[col] = text
2850 self.level = 2
2851
2852 def getParentItem(self):
2853 return self.parent_item
2854
2855 def getRow(self):
2856 return self.row
2857
2858 def childCount(self):
2859 return 0
2860
2861 def hasChildren(self):
2862 return False
2863
2864 def getData(self, column):
2865 return self.data[column]
2866
2867 # Brance data model level one item
2868
2869 class BranchLevelOneItem():
2870
2871 def __init__(self, glb, row, data, parent_item):
2872 self.glb = glb
2873 self.row = row
2874 self.parent_item = parent_item
2875 self.child_count = 0
2876 self.child_items = []
2877 self.data = data[1:]
2878 self.dbid = data[0]
2879 self.level = 1
2880 self.query_done = False
2881 self.br_col = len(self.data) - 1
2882
2883 def getChildItem(self, row):
2884 return self.child_items[row]
2885
2886 def getParentItem(self):
2887 return self.parent_item
2888
2889 def getRow(self):
2890 return self.row
2891
2892 def Select(self):
2893 self.query_done = True
2894
2895 if not self.glb.have_disassembler:
2896 return
2897
2898 query = QSqlQuery(self.glb.db)
2899
2900 QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip"
2901 " FROM samples"
2902 " INNER JOIN dsos ON samples.to_dso_id = dsos.id"
2903 " INNER JOIN symbols ON samples.to_symbol_id = symbols.id"
2904 " WHERE samples.id = " + str(self.dbid))
2905 if not query.next():
2906 return
2907 cpu = query.value(0)
2908 dso = query.value(1)
2909 sym = query.value(2)
2910 if dso == 0 or sym == 0:
2911 return
2912 off = query.value(3)
2913 short_name = query.value(4)
2914 long_name = query.value(5)
2915 build_id = query.value(6)
2916 sym_start = query.value(7)
2917 ip = query.value(8)
2918
2919 QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start"
2920 " FROM samples"
2921 " INNER JOIN symbols ON samples.symbol_id = symbols.id"
2922 " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
2923 " ORDER BY samples.id"
2924 " LIMIT 1")
2925 if not query.next():
2926 return
2927 if query.value(0) != dso:
2928 # Cannot disassemble from one dso to another
2929 return
2930 bsym = query.value(1)
2931 boff = query.value(2)
2932 bsym_start = query.value(3)
2933 if bsym == 0:
2934 return
2935 tot = bsym_start + boff + 1 - sym_start - off
2936 if tot <= 0 or tot > 16384:
2937 return
2938
2939 inst = self.glb.disassembler.Instruction()
2940 f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
2941 if not f:
2942 return
2943 mode = 0 if Is64Bit(f) else 1
2944 self.glb.disassembler.SetMode(inst, mode)
2945
2946 buf_sz = tot + 16
2947 buf = create_string_buffer(tot + 16)
2948 f.seek(sym_start + off)
2949 buf.value = f.read(buf_sz)
2950 buf_ptr = addressof(buf)
2951 i = 0
2952 while tot > 0:
2953 cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
2954 if cnt:
2955 byte_str = tohex(ip).rjust(16)
2956 for k in xrange(cnt):
2957 byte_str += " %02x" % ord(buf[i])
2958 i += 1
2959 while k < 15:
2960 byte_str += " "
2961 k += 1
2962 self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
2963 self.child_count += 1
2964 else:
2965 return
2966 buf_ptr += cnt
2967 tot -= cnt
2968 buf_sz -= cnt
2969 ip += cnt
2970
2971 def childCount(self):
2972 if not self.query_done:
2973 self.Select()
2974 if not self.child_count:
2975 return -1
2976 return self.child_count
2977
2978 def hasChildren(self):
2979 if not self.query_done:
2980 return True
2981 return self.child_count > 0
2982
2983 def getData(self, column):
2984 return self.data[column]
2985
2986 # Brance data model root item
2987
2988 class BranchRootItem():
2989
2990 def __init__(self):
2991 self.child_count = 0
2992 self.child_items = []
2993 self.level = 0
2994
2995 def getChildItem(self, row):
2996 return self.child_items[row]
2997
2998 def getParentItem(self):
2999 return None
3000
3001 def getRow(self):
3002 return 0
3003
3004 def childCount(self):
3005 return self.child_count
3006
3007 def hasChildren(self):
3008 return self.child_count > 0
3009
3010 def getData(self, column):
3011 return ""
3012
3013 # Calculate instructions per cycle
3014
3015 def CalcIPC(cyc_cnt, insn_cnt):
3016 if cyc_cnt and insn_cnt:
3017 ipc = Decimal(float(insn_cnt) / cyc_cnt)
3018 ipc = str(ipc.quantize(Decimal(".01"), rounding=ROUND_HALF_UP))
3019 else:
3020 ipc = "0"
3021 return ipc
3022
3023 # Branch data preparation
3024
3025 def BranchDataPrepBr(query, data):
3026 data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) +
3027 " (" + dsoname(query.value(11)) + ")" + " -> " +
3028 tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) +
3029 " (" + dsoname(query.value(15)) + ")")
3030
3031 def BranchDataPrepIPC(query, data):
3032 insn_cnt = query.value(16)
3033 cyc_cnt = query.value(17)
3034 ipc = CalcIPC(cyc_cnt, insn_cnt)
3035 data.append(insn_cnt)
3036 data.append(cyc_cnt)
3037 data.append(ipc)
3038
3039 def BranchDataPrep(query):
3040 data = []
3041 for i in xrange(0, 8):
3042 data.append(query.value(i))
3043 BranchDataPrepBr(query, data)
3044 return data
3045
3046 def BranchDataPrepWA(query):
3047 data = []
3048 data.append(query.value(0))
3049 # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
3050 data.append("{:>19}".format(query.value(1)))
3051 for i in xrange(2, 8):
3052 data.append(query.value(i))
3053 BranchDataPrepBr(query, data)
3054 return data
3055
3056 def BranchDataWithIPCPrep(query):
3057 data = []
3058 for i in xrange(0, 8):
3059 data.append(query.value(i))
3060 BranchDataPrepIPC(query, data)
3061 BranchDataPrepBr(query, data)
3062 return data
3063
3064 def BranchDataWithIPCPrepWA(query):
3065 data = []
3066 data.append(query.value(0))
3067 # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
3068 data.append("{:>19}".format(query.value(1)))
3069 for i in xrange(2, 8):
3070 data.append(query.value(i))
3071 BranchDataPrepIPC(query, data)
3072 BranchDataPrepBr(query, data)
3073 return data
3074
3075 # Branch data model
3076
3077 class BranchModel(TreeModel):
3078
3079 progress = Signal(object)
3080
3081 def __init__(self, glb, event_id, where_clause, parent=None):
3082 super(BranchModel, self).__init__(glb, None, parent)
3083 self.event_id = event_id
3084 self.more = True
3085 self.populated = 0
3086 self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
3087 if self.have_ipc:
3088 select_ipc = ", insn_count, cyc_count"
3089 prep_fn = BranchDataWithIPCPrep
3090 prep_wa_fn = BranchDataWithIPCPrepWA
3091 else:
3092 select_ipc = ""
3093 prep_fn = BranchDataPrep
3094 prep_wa_fn = BranchDataPrepWA
3095 sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name,"
3096 " CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END,"
3097 " ip, symbols.name, sym_offset, dsos.short_name,"
3098 " to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name"
3099 + select_ipc +
3100 " FROM samples"
3101 " INNER JOIN comms ON comm_id = comms.id"
3102 " INNER JOIN threads ON thread_id = threads.id"
3103 " INNER JOIN branch_types ON branch_type = branch_types.id"
3104 " INNER JOIN symbols ON symbol_id = symbols.id"
3105 " INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id"
3106 " INNER JOIN dsos ON samples.dso_id = dsos.id"
3107 " INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id"
3108 " WHERE samples.id > $$last_id$$" + where_clause +
3109 " AND evsel_id = " + str(self.event_id) +
3110 " ORDER BY samples.id"
3111 " LIMIT " + str(glb_chunk_sz))
3112 if pyside_version_1 and sys.version_info[0] == 3:
3113 prep = prep_fn
3114 else:
3115 prep = prep_wa_fn
3116 self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
3117 self.fetcher.done.connect(self.Update)
3118 self.fetcher.Fetch(glb_chunk_sz)
3119
3120 def GetRoot(self):
3121 return BranchRootItem()
3122
3123 def columnCount(self, parent=None):
3124 if self.have_ipc:
3125 return 11
3126 else:
3127 return 8
3128
3129 def columnHeader(self, column):
3130 if self.have_ipc:
3131 return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Insn Cnt", "Cyc Cnt", "IPC", "Branch")[column]
3132 else:
3133 return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column]
3134
3135 def columnFont(self, column):
3136 if self.have_ipc:
3137 br_col = 10
3138 else:
3139 br_col = 7
3140 if column != br_col:
3141 return None
3142 return QFont("Monospace")
3143
3144 def DisplayData(self, item, index):
3145 if item.level == 1:
3146 self.FetchIfNeeded(item.row)
3147 return item.getData(index.column())
3148
3149 def AddSample(self, data):
3150 child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
3151 self.root.child_items.append(child)
3152 self.populated += 1
3153
3154 def Update(self, fetched):
3155 if not fetched:
3156 self.more = False
3157 self.progress.emit(0)
3158 child_count = self.root.child_count
3159 count = self.populated - child_count
3160 if count > 0:
3161 parent = QModelIndex()
3162 self.beginInsertRows(parent, child_count, child_count + count - 1)
3163 self.insertRows(child_count, count, parent)
3164 self.root.child_count += count
3165 self.endInsertRows()
3166 self.progress.emit(self.root.child_count)
3167
3168 def FetchMoreRecords(self, count):
3169 current = self.root.child_count
3170 if self.more:
3171 self.fetcher.Fetch(count)
3172 else:
3173 self.progress.emit(0)
3174 return current
3175
3176 def HasMoreRecords(self):
3177 return self.more
3178
3179 # Report Variables
3180
3181 class ReportVars():
3182
3183 def __init__(self, name = "", where_clause = "", limit = ""):
3184 self.name = name
3185 self.where_clause = where_clause
3186 self.limit = limit
3187
3188 def UniqueId(self):
3189 return str(self.where_clause + ";" + self.limit)
3190
3191 # Branch window
3192
3193 class BranchWindow(QMdiSubWindow):
3194
3195 def __init__(self, glb, event_id, report_vars, parent=None):
3196 super(BranchWindow, self).__init__(parent)
3197
3198 model_name = "Branch Events " + str(event_id) + " " + report_vars.UniqueId()
3199
3200 self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_clause))
3201
3202 self.view = QTreeView()
3203 self.view.setUniformRowHeights(True)
3204 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
3205 self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
3206 self.view.setModel(self.model)
3207
3208 self.ResizeColumnsToContents()
3209
3210 self.context_menu = TreeContextMenu(self.view)
3211
3212 self.find_bar = FindBar(self, self, True)
3213
3214 self.finder = ChildDataItemFinder(self.model.root)
3215
3216 self.fetch_bar = FetchMoreRecordsBar(self.model, self)
3217
3218 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
3219
3220 self.setWidget(self.vbox.Widget())
3221
3222 AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
3223
3224 def ResizeColumnToContents(self, column, n):
3225 # Using the view's resizeColumnToContents() here is extrememly slow
3226 # so implement a crude alternative
3227 mm = "MM" if column else "MMMM"
3228 font = self.view.font()
3229 metrics = QFontMetrics(font)
3230 max = 0
3231 for row in xrange(n):
3232 val = self.model.root.child_items[row].data[column]
3233 len = metrics.width(str(val) + mm)
3234 max = len if len > max else max
3235 val = self.model.columnHeader(column)
3236 len = metrics.width(str(val) + mm)
3237 max = len if len > max else max
3238 self.view.setColumnWidth(column, max)
3239
3240 def ResizeColumnsToContents(self):
3241 n = min(self.model.root.child_count, 100)
3242 if n < 1:
3243 # No data yet, so connect a signal to notify when there is
3244 self.model.rowsInserted.connect(self.UpdateColumnWidths)
3245 return
3246 columns = self.model.columnCount()
3247 for i in xrange(columns):
3248 self.ResizeColumnToContents(i, n)
3249
3250 def UpdateColumnWidths(self, *x):
3251 # This only needs to be done once, so disconnect the signal now
3252 self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
3253 self.ResizeColumnsToContents()
3254
3255 def Find(self, value, direction, pattern, context):
3256 self.view.setFocus()
3257 self.find_bar.Busy()
3258 self.finder.Find(value, direction, pattern, context, self.FindDone)
3259
3260 def FindDone(self, row):
3261 self.find_bar.Idle()
3262 if row >= 0:
3263 self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
3264 else:
3265 self.find_bar.NotFound()
3266
3267 # Line edit data item
3268
3269 class LineEditDataItem(object):
3270
3271 def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):
3272 self.glb = glb
3273 self.label = label
3274 self.placeholder_text = placeholder_text
3275 self.parent = parent
3276 self.id = id
3277
3278 self.value = default
3279
3280 self.widget = QLineEdit(default)
3281 self.widget.editingFinished.connect(self.Validate)
3282 self.widget.textChanged.connect(self.Invalidate)
3283 self.red = False
3284 self.error = ""
3285 self.validated = True
3286
3287 if placeholder_text:
3288 self.widget.setPlaceholderText(placeholder_text)
3289
3290 def TurnTextRed(self):
3291 if not self.red:
3292 palette = QPalette()
3293 palette.setColor(QPalette.Text,Qt.red)
3294 self.widget.setPalette(palette)
3295 self.red = True
3296
3297 def TurnTextNormal(self):
3298 if self.red:
3299 palette = QPalette()
3300 self.widget.setPalette(palette)
3301 self.red = False
3302
3303 def InvalidValue(self, value):
3304 self.value = ""
3305 self.TurnTextRed()
3306 self.error = self.label + " invalid value '" + value + "'"
3307 self.parent.ShowMessage(self.error)
3308
3309 def Invalidate(self):
3310 self.validated = False
3311
3312 def DoValidate(self, input_string):
3313 self.value = input_string.strip()
3314
3315 def Validate(self):
3316 self.validated = True
3317 self.error = ""
3318 self.TurnTextNormal()
3319 self.parent.ClearMessage()
3320 input_string = self.widget.text()
3321 if not len(input_string.strip()):
3322 self.value = ""
3323 return
3324 self.DoValidate(input_string)
3325
3326 def IsValid(self):
3327 if not self.validated:
3328 self.Validate()
3329 if len(self.error):
3330 self.parent.ShowMessage(self.error)
3331 return False
3332 return True
3333
3334 def IsNumber(self, value):
3335 try:
3336 x = int(value)
3337 except:
3338 x = 0
3339 return str(x) == value
3340
3341 # Non-negative integer ranges dialog data item
3342
3343 class NonNegativeIntegerRangesDataItem(LineEditDataItem):
3344
3345 def __init__(self, glb, label, placeholder_text, column_name, parent):
3346 super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3347
3348 self.column_name = column_name
3349
3350 def DoValidate(self, input_string):
3351 singles = []
3352 ranges = []
3353 for value in [x.strip() for x in input_string.split(",")]:
3354 if "-" in value:
3355 vrange = value.split("-")
3356 if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3357 return self.InvalidValue(value)
3358 ranges.append(vrange)
3359 else:
3360 if not self.IsNumber(value):
3361 return self.InvalidValue(value)
3362 singles.append(value)
3363 ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
3364 if len(singles):
3365 ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
3366 self.value = " OR ".join(ranges)
3367
3368 # Positive integer dialog data item
3369
3370 class PositiveIntegerDataItem(LineEditDataItem):
3371
3372 def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):
3373 super(PositiveIntegerDataItem, self).__init__(glb, label, placeholder_text, parent, id, default)
3374
3375 def DoValidate(self, input_string):
3376 if not self.IsNumber(input_string.strip()):
3377 return self.InvalidValue(input_string)
3378 value = int(input_string.strip())
3379 if value <= 0:
3380 return self.InvalidValue(input_string)
3381 self.value = str(value)
3382
3383 # Dialog data item converted and validated using a SQL table
3384
3385 class SQLTableDataItem(LineEditDataItem):
3386
3387 def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_name2, parent):
3388 super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
3389
3390 self.table_name = table_name
3391 self.match_column = match_column
3392 self.column_name1 = column_name1
3393 self.column_name2 = column_name2
3394
3395 def ValueToIds(self, value):
3396 ids = []
3397 query = QSqlQuery(self.glb.db)
3398 stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
3399 ret = query.exec_(stmt)
3400 if ret:
3401 while query.next():
3402 ids.append(str(query.value(0)))
3403 return ids
3404
3405 def DoValidate(self, input_string):
3406 all_ids = []
3407 for value in [x.strip() for x in input_string.split(",")]:
3408 ids = self.ValueToIds(value)
3409 if len(ids):
3410 all_ids.extend(ids)
3411 else:
3412 return self.InvalidValue(value)
3413 self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
3414 if self.column_name2:
3415 self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
3416
3417 # Sample time ranges dialog data item converted and validated using 'samples' SQL table
3418
3419 class SampleTimeRangesDataItem(LineEditDataItem):
3420
3421 def __init__(self, glb, label, placeholder_text, column_name, parent):
3422 self.column_name = column_name
3423
3424 self.last_id = 0
3425 self.first_time = 0
3426 self.last_time = 2 ** 64
3427
3428 query = QSqlQuery(glb.db)
3429 QueryExec(query, "SELECT id, time FROM samples ORDER BY id DESC LIMIT 1")
3430 if query.next():
3431 self.last_id = int(query.value(0))
3432 self.first_time = int(glb.HostStartTime())
3433 self.last_time = int(glb.HostFinishTime())
3434 if placeholder_text:
3435 placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
3436
3437 super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3438
3439 def IdBetween(self, query, lower_id, higher_id, order):
3440 QueryExec(query, "SELECT id FROM samples WHERE id > " + str(lower_id) + " AND id < " + str(higher_id) + " ORDER BY id " + order + " LIMIT 1")
3441 if query.next():
3442 return True, int(query.value(0))
3443 else:
3444 return False, 0
3445
3446 def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):
3447 query = QSqlQuery(self.glb.db)
3448 while True:
3449 next_id = int((lower_id + higher_id) / 2)
3450 QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
3451 if not query.next():
3452 ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
3453 if not ok:
3454 ok, dbid = self.IdBetween(query, next_id, higher_id, "")
3455 if not ok:
3456 return str(higher_id)
3457 next_id = dbid
3458 QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
3459 next_time = int(query.value(0))
3460 if get_floor:
3461 if target_time > next_time:
3462 lower_id = next_id
3463 else:
3464 higher_id = next_id
3465 if higher_id <= lower_id + 1:
3466 return str(higher_id)
3467 else:
3468 if target_time >= next_time:
3469 lower_id = next_id
3470 else:
3471 higher_id = next_id
3472 if higher_id <= lower_id + 1:
3473 return str(lower_id)
3474
3475 def ConvertRelativeTime(self, val):
3476 mult = 1
3477 suffix = val[-2:]
3478 if suffix == "ms":
3479 mult = 1000000
3480 elif suffix == "us":
3481 mult = 1000
3482 elif suffix == "ns":
3483 mult = 1
3484 else:
3485 return val
3486 val = val[:-2].strip()
3487 if not self.IsNumber(val):
3488 return val
3489 val = int(val) * mult
3490 if val >= 0:
3491 val += self.first_time
3492 else:
3493 val += self.last_time
3494 return str(val)
3495
3496 def ConvertTimeRange(self, vrange):
3497 if vrange[0] == "":
3498 vrange[0] = str(self.first_time)
3499 if vrange[1] == "":
3500 vrange[1] = str(self.last_time)
3501 vrange[0] = self.ConvertRelativeTime(vrange[0])
3502 vrange[1] = self.ConvertRelativeTime(vrange[1])
3503 if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3504 return False
3505 beg_range = max(int(vrange[0]), self.first_time)
3506 end_range = min(int(vrange[1]), self.last_time)
3507 if beg_range > self.last_time or end_range < self.first_time:
3508 return False
3509 vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
3510 vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
3511 return True
3512
3513 def AddTimeRange(self, value, ranges):
3514 n = value.count("-")
3515 if n == 1:
3516 pass
3517 elif n == 2:
3518 if value.split("-")[1].strip() == "":
3519 n = 1
3520 elif n == 3:
3521 n = 2
3522 else:
3523 return False
3524 pos = findnth(value, "-", n)
3525 vrange = [value[:pos].strip() ,value[pos+1:].strip()]
3526 if self.ConvertTimeRange(vrange):
3527 ranges.append(vrange)
3528 return True
3529 return False
3530
3531 def DoValidate(self, input_string):
3532 ranges = []
3533 for value in [x.strip() for x in input_string.split(",")]:
3534 if not self.AddTimeRange(value, ranges):
3535 return self.InvalidValue(value)
3536 ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
3537 self.value = " OR ".join(ranges)
3538
3539 # Report Dialog Base
3540
3541 class ReportDialogBase(QDialog):
3542
3543 def __init__(self, glb, title, items, partial, parent=None):
3544 super(ReportDialogBase, self).__init__(parent)
3545
3546 self.glb = glb
3547
3548 self.report_vars = ReportVars()
3549
3550 self.setWindowTitle(title)
3551 self.setMinimumWidth(600)
3552
3553 self.data_items = [x(glb, self) for x in items]
3554
3555 self.partial = partial
3556
3557 self.grid = QGridLayout()
3558
3559 for row in xrange(len(self.data_items)):
3560 self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
3561 self.grid.addWidget(self.data_items[row].widget, row, 1)
3562
3563 self.status = QLabel()
3564
3565 self.ok_button = QPushButton("Ok", self)
3566 self.ok_button.setDefault(True)
3567 self.ok_button.released.connect(self.Ok)
3568 self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3569
3570 self.cancel_button = QPushButton("Cancel", self)
3571 self.cancel_button.released.connect(self.reject)
3572 self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3573
3574 self.hbox = QHBoxLayout()
3575 #self.hbox.addStretch()
3576 self.hbox.addWidget(self.status)
3577 self.hbox.addWidget(self.ok_button)
3578 self.hbox.addWidget(self.cancel_button)
3579
3580 self.vbox = QVBoxLayout()
3581 self.vbox.addLayout(self.grid)
3582 self.vbox.addLayout(self.hbox)
3583
3584 self.setLayout(self.vbox)
3585
3586 def Ok(self):
3587 vars = self.report_vars
3588 for d in self.data_items:
3589 if d.id == "REPORTNAME":
3590 vars.name = d.value
3591 if not vars.name:
3592 self.ShowMessage("Report name is required")
3593 return
3594 for d in self.data_items:
3595 if not d.IsValid():
3596 return
3597 for d in self.data_items[1:]:
3598 if d.id == "LIMIT":
3599 vars.limit = d.value
3600 elif len(d.value):
3601 if len(vars.where_clause):
3602 vars.where_clause += " AND "
3603 vars.where_clause += d.value
3604 if len(vars.where_clause):
3605 if self.partial:
3606 vars.where_clause = " AND ( " + vars.where_clause + " ) "
3607 else:
3608 vars.where_clause = " WHERE " + vars.where_clause + " "
3609 self.accept()
3610
3611 def ShowMessage(self, msg):
3612 self.status.setText("<font color=#FF0000>" + msg)
3613
3614 def ClearMessage(self):
3615 self.status.setText("")
3616
3617 # Selected branch report creation dialog
3618
3619 class SelectedBranchDialog(ReportDialogBase):
3620
3621 def __init__(self, glb, parent=None):
3622 title = "Selected Branches"
3623 items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
3624 lambda g, p: SampleTimeRangesDataItem(g, "Time ranges:", "Enter time ranges", "samples.id", p),
3625 lambda g, p: NonNegativeIntegerRangesDataItem(g, "CPUs:", "Enter CPUs or ranges e.g. 0,5-6", "cpu", p),
3626 lambda g, p: SQLTableDataItem(g, "Commands:", "Only branches with these commands will be included", "comms", "comm", "comm_id", "", p),
3627 lambda g, p: SQLTableDataItem(g, "PIDs:", "Only branches with these process IDs will be included", "threads", "pid", "thread_id", "", p),
3628 lambda g, p: SQLTableDataItem(g, "TIDs:", "Only branches with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
3629 lambda g, p: SQLTableDataItem(g, "DSOs:", "Only branches with these DSOs will be included", "dsos", "short_name", "samples.dso_id", "to_dso_id", p),
3630 lambda g, p: SQLTableDataItem(g, "Symbols:", "Only branches with these symbols will be included", "symbols", "name", "symbol_id", "to_symbol_id", p),
3631 lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p))
3632 super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
3633
3634 # Event list
3635
3636 def GetEventList(db):
3637 events = []
3638 query = QSqlQuery(db)
3639 QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id")
3640 while query.next():
3641 events.append(query.value(0))
3642 return events
3643
3644 # Is a table selectable
3645
3646 def IsSelectable(db, table, sql = "", columns = "*"):
3647 query = QSqlQuery(db)
3648 try:
3649 QueryExec(query, "SELECT " + columns + " FROM " + table + " " + sql + " LIMIT 1")
3650 except:
3651 return False
3652 return True
3653
3654 # SQL table data model item
3655
3656 class SQLTableItem():
3657
3658 def __init__(self, row, data):
3659 self.row = row
3660 self.data = data
3661
3662 def getData(self, column):
3663 return self.data[column]
3664
3665 # SQL table data model
3666
3667 class SQLTableModel(TableModel):
3668
3669 progress = Signal(object)
3670
3671 def __init__(self, glb, sql, column_headers, parent=None):
3672 super(SQLTableModel, self).__init__(parent)
3673 self.glb = glb
3674 self.more = True
3675 self.populated = 0
3676 self.column_headers = column_headers
3677 self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), self.AddSample)
3678 self.fetcher.done.connect(self.Update)
3679 self.fetcher.Fetch(glb_chunk_sz)
3680
3681 def DisplayData(self, item, index):
3682 self.FetchIfNeeded(item.row)
3683 return item.getData(index.column())
3684
3685 def AddSample(self, data):
3686 child = SQLTableItem(self.populated, data)
3687 self.child_items.append(child)
3688 self.populated += 1
3689
3690 def Update(self, fetched):
3691 if not fetched:
3692 self.more = False
3693 self.progress.emit(0)
3694 child_count = self.child_count
3695 count = self.populated - child_count
3696 if count > 0:
3697 parent = QModelIndex()
3698 self.beginInsertRows(parent, child_count, child_count + count - 1)
3699 self.insertRows(child_count, count, parent)
3700 self.child_count += count
3701 self.endInsertRows()
3702 self.progress.emit(self.child_count)
3703
3704 def FetchMoreRecords(self, count):
3705 current = self.child_count
3706 if self.more:
3707 self.fetcher.Fetch(count)
3708 else:
3709 self.progress.emit(0)
3710 return current
3711
3712 def HasMoreRecords(self):
3713 return self.more
3714
3715 def columnCount(self, parent=None):
3716 return len(self.column_headers)
3717
3718 def columnHeader(self, column):
3719 return self.column_headers[column]
3720
3721 def SQLTableDataPrep(self, query, count):
3722 data = []
3723 for i in xrange(count):
3724 data.append(query.value(i))
3725 return data
3726
3727 # SQL automatic table data model
3728
3729 class SQLAutoTableModel(SQLTableModel):
3730
3731 def __init__(self, glb, table_name, parent=None):
3732 sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz)
3733 if table_name == "comm_threads_view":
3734 # For now, comm_threads_view has no id column
3735 sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz)
3736 column_headers = []
3737 query = QSqlQuery(glb.db)
3738 if glb.dbref.is_sqlite3:
3739 QueryExec(query, "PRAGMA table_info(" + table_name + ")")
3740 while query.next():
3741 column_headers.append(query.value(1))
3742 if table_name == "sqlite_master":
3743 sql = "SELECT * FROM " + table_name
3744 else:
3745 if table_name[:19] == "information_schema.":
3746 sql = "SELECT * FROM " + table_name
3747 select_table_name = table_name[19:]
3748 schema = "information_schema"
3749 else:
3750 select_table_name = table_name
3751 schema = "public"
3752 QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'")
3753 while query.next():
3754 column_headers.append(query.value(0))
3755 if pyside_version_1 and sys.version_info[0] == 3:
3756 if table_name == "samples_view":
3757 self.SQLTableDataPrep = self.samples_view_DataPrep
3758 if table_name == "samples":
3759 self.SQLTableDataPrep = self.samples_DataPrep
3760 super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
3761
3762 def samples_view_DataPrep(self, query, count):
3763 data = []
3764 data.append(query.value(0))
3765 # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
3766 data.append("{:>19}".format(query.value(1)))
3767 for i in xrange(2, count):
3768 data.append(query.value(i))
3769 return data
3770
3771 def samples_DataPrep(self, query, count):
3772 data = []
3773 for i in xrange(9):
3774 data.append(query.value(i))
3775 # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
3776 data.append("{:>19}".format(query.value(9)))
3777 for i in xrange(10, count):
3778 data.append(query.value(i))
3779 return data
3780
3781 # Base class for custom ResizeColumnsToContents
3782
3783 class ResizeColumnsToContentsBase(QObject):
3784
3785 def __init__(self, parent=None):
3786 super(ResizeColumnsToContentsBase, self).__init__(parent)
3787
3788 def ResizeColumnToContents(self, column, n):
3789 # Using the view's resizeColumnToContents() here is extrememly slow
3790 # so implement a crude alternative
3791 font = self.view.font()
3792 metrics = QFontMetrics(font)
3793 max = 0
3794 for row in xrange(n):
3795 val = self.data_model.child_items[row].data[column]
3796 len = metrics.width(str(val) + "MM")
3797 max = len if len > max else max
3798 val = self.data_model.columnHeader(column)
3799 len = metrics.width(str(val) + "MM")
3800 max = len if len > max else max
3801 self.view.setColumnWidth(column, max)
3802
3803 def ResizeColumnsToContents(self):
3804 n = min(self.data_model.child_count, 100)
3805 if n < 1:
3806 # No data yet, so connect a signal to notify when there is
3807 self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
3808 return
3809 columns = self.data_model.columnCount()
3810 for i in xrange(columns):
3811 self.ResizeColumnToContents(i, n)
3812
3813 def UpdateColumnWidths(self, *x):
3814 # This only needs to be done once, so disconnect the signal now
3815 self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
3816 self.ResizeColumnsToContents()
3817
3818 # Convert value to CSV
3819
3820 def ToCSValue(val):
3821 if '"' in val:
3822 val = val.replace('"', '""')
3823 if "," in val or '"' in val:
3824 val = '"' + val + '"'
3825 return val
3826
3827 # Key to sort table model indexes by row / column, assuming fewer than 1000 columns
3828
3829 glb_max_cols = 1000
3830
3831 def RowColumnKey(a):
3832 return a.row() * glb_max_cols + a.column()
3833
3834 # Copy selected table cells to clipboard
3835
3836 def CopyTableCellsToClipboard(view, as_csv=False, with_hdr=False):
3837 indexes = sorted(view.selectedIndexes(), key=RowColumnKey)
3838 idx_cnt = len(indexes)
3839 if not idx_cnt:
3840 return
3841 if idx_cnt == 1:
3842 with_hdr=False
3843 min_row = indexes[0].row()
3844 max_row = indexes[0].row()
3845 min_col = indexes[0].column()
3846 max_col = indexes[0].column()
3847 for i in indexes:
3848 min_row = min(min_row, i.row())
3849 max_row = max(max_row, i.row())
3850 min_col = min(min_col, i.column())
3851 max_col = max(max_col, i.column())
3852 if max_col > glb_max_cols:
3853 raise RuntimeError("glb_max_cols is too low")
3854 max_width = [0] * (1 + max_col - min_col)
3855 for i in indexes:
3856 c = i.column() - min_col
3857 max_width[c] = max(max_width[c], len(str(i.data())))
3858 text = ""
3859 pad = ""
3860 sep = ""
3861 if with_hdr:
3862 model = indexes[0].model()
3863 for col in range(min_col, max_col + 1):
3864 val = model.headerData(col, Qt.Horizontal)
3865 if as_csv:
3866 text += sep + ToCSValue(val)
3867 sep = ","
3868 else:
3869 c = col - min_col
3870 max_width[c] = max(max_width[c], len(val))
3871 width = max_width[c]
3872 align = model.headerData(col, Qt.Horizontal, Qt.TextAlignmentRole)
3873 if align & Qt.AlignRight:
3874 val = val.rjust(width)
3875 text += pad + sep + val
3876 pad = " " * (width - len(val))
3877 sep = " "
3878 text += "\n"
3879 pad = ""
3880 sep = ""
3881 last_row = min_row
3882 for i in indexes:
3883 if i.row() > last_row:
3884 last_row = i.row()
3885 text += "\n"
3886 pad = ""
3887 sep = ""
3888 if as_csv:
3889 text += sep + ToCSValue(str(i.data()))
3890 sep = ","
3891 else:
3892 width = max_width[i.column() - min_col]
3893 if i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
3894 val = str(i.data()).rjust(width)
3895 else:
3896 val = str(i.data())
3897 text += pad + sep + val
3898 pad = " " * (width - len(val))
3899 sep = " "
3900 QApplication.clipboard().setText(text)
3901
3902 def CopyTreeCellsToClipboard(view, as_csv=False, with_hdr=False):
3903 indexes = view.selectedIndexes()
3904 if not len(indexes):
3905 return
3906
3907 selection = view.selectionModel()
3908
3909 first = None
3910 for i in indexes:
3911 above = view.indexAbove(i)
3912 if not selection.isSelected(above):
3913 first = i
3914 break
3915
3916 if first is None:
3917 raise RuntimeError("CopyTreeCellsToClipboard internal error")
3918
3919 model = first.model()
3920 row_cnt = 0
3921 col_cnt = model.columnCount(first)
3922 max_width = [0] * col_cnt
3923
3924 indent_sz = 2
3925 indent_str = " " * indent_sz
3926
3927 expanded_mark_sz = 2
3928 if sys.version_info[0] == 3:
3929 expanded_mark = "\u25BC "
3930 not_expanded_mark = "\u25B6 "
3931 else:
3932 expanded_mark = unicode(chr(0xE2) + chr(0x96) + chr(0xBC) + " ", "utf-8")
3933 not_expanded_mark = unicode(chr(0xE2) + chr(0x96) + chr(0xB6) + " ", "utf-8")
3934 leaf_mark = " "
3935
3936 if not as_csv:
3937 pos = first
3938 while True:
3939 row_cnt += 1
3940 row = pos.row()
3941 for c in range(col_cnt):
3942 i = pos.sibling(row, c)
3943 if c:
3944 n = len(str(i.data()))
3945 else:
3946 n = len(str(i.data()).strip())
3947 n += (i.internalPointer().level - 1) * indent_sz
3948 n += expanded_mark_sz
3949 max_width[c] = max(max_width[c], n)
3950 pos = view.indexBelow(pos)
3951 if not selection.isSelected(pos):
3952 break
3953
3954 text = ""
3955 pad = ""
3956 sep = ""
3957 if with_hdr:
3958 for c in range(col_cnt):
3959 val = model.headerData(c, Qt.Horizontal, Qt.DisplayRole).strip()
3960 if as_csv:
3961 text += sep + ToCSValue(val)
3962 sep = ","
3963 else:
3964 max_width[c] = max(max_width[c], len(val))
3965 width = max_width[c]
3966 align = model.headerData(c, Qt.Horizontal, Qt.TextAlignmentRole)
3967 if align & Qt.AlignRight:
3968 val = val.rjust(width)
3969 text += pad + sep + val
3970 pad = " " * (width - len(val))
3971 sep = " "
3972 text += "\n"
3973 pad = ""
3974 sep = ""
3975
3976 pos = first
3977 while True:
3978 row = pos.row()
3979 for c in range(col_cnt):
3980 i = pos.sibling(row, c)
3981 val = str(i.data())
3982 if not c:
3983 if model.hasChildren(i):
3984 if view.isExpanded(i):
3985 mark = expanded_mark
3986 else:
3987 mark = not_expanded_mark
3988 else:
3989 mark = leaf_mark
3990 val = indent_str * (i.internalPointer().level - 1) + mark + val.strip()
3991 if as_csv:
3992 text += sep + ToCSValue(val)
3993 sep = ","
3994 else:
3995 width = max_width[c]
3996 if c and i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
3997 val = val.rjust(width)
3998 text += pad + sep + val
3999 pad = " " * (width - len(val))
4000 sep = " "
4001 pos = view.indexBelow(pos)
4002 if not selection.isSelected(pos):
4003 break
4004 text = text.rstrip() + "\n"
4005 pad = ""
4006 sep = ""
4007
4008 QApplication.clipboard().setText(text)
4009
4010 def CopyCellsToClipboard(view, as_csv=False, with_hdr=False):
4011 view.CopyCellsToClipboard(view, as_csv, with_hdr)
4012
4013 def CopyCellsToClipboardHdr(view):
4014 CopyCellsToClipboard(view, False, True)
4015
4016 def CopyCellsToClipboardCSV(view):
4017 CopyCellsToClipboard(view, True, True)
4018
4019 # Context menu
4020
4021 class ContextMenu(object):
4022
4023 def __init__(self, view):
4024 self.view = view
4025 self.view.setContextMenuPolicy(Qt.CustomContextMenu)
4026 self.view.customContextMenuRequested.connect(self.ShowContextMenu)
4027
4028 def ShowContextMenu(self, pos):
4029 menu = QMenu(self.view)
4030 self.AddActions(menu)
4031 menu.exec_(self.view.mapToGlobal(pos))
4032
4033 def AddCopy(self, menu):
4034 menu.addAction(CreateAction("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
4035 menu.addAction(CreateAction("Copy selection as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
4036
4037 def AddActions(self, menu):
4038 self.AddCopy(menu)
4039
4040 class TreeContextMenu(ContextMenu):
4041
4042 def __init__(self, view):
4043 super(TreeContextMenu, self).__init__(view)
4044
4045 def AddActions(self, menu):
4046 i = self.view.currentIndex()
4047 text = str(i.data()).strip()
4048 if len(text):
4049 menu.addAction(CreateAction('Copy "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
4050 self.AddCopy(menu)
4051
4052 # Table window
4053
4054 class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
4055
4056 def __init__(self, glb, table_name, parent=None):
4057 super(TableWindow, self).__init__(parent)
4058
4059 self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name))
4060
4061 self.model = QSortFilterProxyModel()
4062 self.model.setSourceModel(self.data_model)
4063
4064 self.view = QTableView()
4065 self.view.setModel(self.model)
4066 self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4067 self.view.verticalHeader().setVisible(False)
4068 self.view.sortByColumn(-1, Qt.AscendingOrder)
4069 self.view.setSortingEnabled(True)
4070 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4071 self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4072
4073 self.ResizeColumnsToContents()
4074
4075 self.context_menu = ContextMenu(self.view)
4076
4077 self.find_bar = FindBar(self, self, True)
4078
4079 self.finder = ChildDataItemFinder(self.data_model)
4080
4081 self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4082
4083 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4084
4085 self.setWidget(self.vbox.Widget())
4086
4087 AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
4088
4089 def Find(self, value, direction, pattern, context):
4090 self.view.setFocus()
4091 self.find_bar.Busy()
4092 self.finder.Find(value, direction, pattern, context, self.FindDone)
4093
4094 def FindDone(self, row):
4095 self.find_bar.Idle()
4096 if row >= 0:
4097 self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
4098 else:
4099 self.find_bar.NotFound()
4100
4101 # Table list
4102
4103 def GetTableList(glb):
4104 tables = []
4105 query = QSqlQuery(glb.db)
4106 if glb.dbref.is_sqlite3:
4107 QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name")
4108 else:
4109 QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name")
4110 while query.next():
4111 tables.append(query.value(0))
4112 if glb.dbref.is_sqlite3:
4113 tables.append("sqlite_master")
4114 else:
4115 tables.append("information_schema.tables")
4116 tables.append("information_schema.views")
4117 tables.append("information_schema.columns")
4118 return tables
4119
4120 # Top Calls data model
4121
4122 class TopCallsModel(SQLTableModel):
4123
4124 def __init__(self, glb, report_vars, parent=None):
4125 text = ""
4126 if not glb.dbref.is_sqlite3:
4127 text = "::text"
4128 limit = ""
4129 if len(report_vars.limit):
4130 limit = " LIMIT " + report_vars.limit
4131 sql = ("SELECT comm, pid, tid, name,"
4132 " CASE"
4133 " WHEN (short_name = '[kernel.kallsyms]') THEN '[kernel]'" + text +
4134 " ELSE short_name"
4135 " END AS dso,"
4136 " call_time, return_time, (return_time - call_time) AS elapsed_time, branch_count, "
4137 " CASE"
4138 " WHEN (calls.flags = 1) THEN 'no call'" + text +
4139 " WHEN (calls.flags = 2) THEN 'no return'" + text +
4140 " WHEN (calls.flags = 3) THEN 'no call/return'" + text +
4141 " ELSE ''" + text +
4142 " END AS flags"
4143 " FROM calls"
4144 " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
4145 " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
4146 " INNER JOIN dsos ON symbols.dso_id = dsos.id"
4147 " INNER JOIN comms ON calls.comm_id = comms.id"
4148 " INNER JOIN threads ON calls.thread_id = threads.id" +
4149 report_vars.where_clause +
4150 " ORDER BY elapsed_time DESC" +
4151 limit
4152 )
4153 column_headers = ("Command", "PID", "TID", "Symbol", "Object", "Call Time", "Return Time", "Elapsed Time (ns)", "Branch Count", "Flags")
4154 self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignLeft)
4155 super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
4156
4157 def columnAlignment(self, column):
4158 return self.alignment[column]
4159
4160 # Top Calls report creation dialog
4161
4162 class TopCallsDialog(ReportDialogBase):
4163
4164 def __init__(self, glb, parent=None):
4165 title = "Top Calls by Elapsed Time"
4166 items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
4167 lambda g, p: SQLTableDataItem(g, "Commands:", "Only calls with these commands will be included", "comms", "comm", "comm_id", "", p),
4168 lambda g, p: SQLTableDataItem(g, "PIDs:", "Only calls with these process IDs will be included", "threads", "pid", "thread_id", "", p),
4169 lambda g, p: SQLTableDataItem(g, "TIDs:", "Only calls with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
4170 lambda g, p: SQLTableDataItem(g, "DSOs:", "Only calls with these DSOs will be included", "dsos", "short_name", "dso_id", "", p),
4171 lambda g, p: SQLTableDataItem(g, "Symbols:", "Only calls with these symbols will be included", "symbols", "name", "symbol_id", "", p),
4172 lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p),
4173 lambda g, p: PositiveIntegerDataItem(g, "Record limit:", "Limit selection to this number of records", p, "LIMIT", "100"))
4174 super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
4175
4176 # Top Calls window
4177
4178 class TopCallsWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
4179
4180 def __init__(self, glb, report_vars, parent=None):
4181 super(TopCallsWindow, self).__init__(parent)
4182
4183 self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(glb, report_vars))
4184 self.model = self.data_model
4185
4186 self.view = QTableView()
4187 self.view.setModel(self.model)
4188 self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4189 self.view.verticalHeader().setVisible(False)
4190 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4191 self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4192
4193 self.context_menu = ContextMenu(self.view)
4194
4195 self.ResizeColumnsToContents()
4196
4197 self.find_bar = FindBar(self, self, True)
4198
4199 self.finder = ChildDataItemFinder(self.model)
4200
4201 self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4202
4203 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4204
4205 self.setWidget(self.vbox.Widget())
4206
4207 AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
4208
4209 def Find(self, value, direction, pattern, context):
4210 self.view.setFocus()
4211 self.find_bar.Busy()
4212 self.finder.Find(value, direction, pattern, context, self.FindDone)
4213
4214 def FindDone(self, row):
4215 self.find_bar.Idle()
4216 if row >= 0:
4217 self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
4218 else:
4219 self.find_bar.NotFound()
4220
4221 # Action Definition
4222
4223 def CreateAction(label, tip, callback, parent=None, shortcut=None):
4224 action = QAction(label, parent)
4225 if shortcut != None:
4226 action.setShortcuts(shortcut)
4227 action.setStatusTip(tip)
4228 action.triggered.connect(callback)
4229 return action
4230
4231 # Typical application actions
4232
4233 def CreateExitAction(app, parent=None):
4234 return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit)
4235
4236 # Typical MDI actions
4237
4238 def CreateCloseActiveWindowAction(mdi_area):
4239 return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area)
4240
4241 def CreateCloseAllWindowsAction(mdi_area):
4242 return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area)
4243
4244 def CreateTileWindowsAction(mdi_area):
4245 return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area)
4246
4247 def CreateCascadeWindowsAction(mdi_area):
4248 return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area)
4249
4250 def CreateNextWindowAction(mdi_area):
4251 return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild)
4252
4253 def CreatePreviousWindowAction(mdi_area):
4254 return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild)
4255
4256 # Typical MDI window menu
4257
4258 class WindowMenu():
4259
4260 def __init__(self, mdi_area, menu):
4261 self.mdi_area = mdi_area
4262 self.window_menu = menu.addMenu("&Windows")
4263 self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
4264 self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
4265 self.tile_windows = CreateTileWindowsAction(mdi_area)
4266 self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
4267 self.next_window = CreateNextWindowAction(mdi_area)
4268 self.previous_window = CreatePreviousWindowAction(mdi_area)
4269 self.window_menu.aboutToShow.connect(self.Update)
4270
4271 def Update(self):
4272 self.window_menu.clear()
4273 sub_window_count = len(self.mdi_area.subWindowList())
4274 have_sub_windows = sub_window_count != 0
4275 self.close_active_window.setEnabled(have_sub_windows)
4276 self.close_all_windows.setEnabled(have_sub_windows)
4277 self.tile_windows.setEnabled(have_sub_windows)
4278 self.cascade_windows.setEnabled(have_sub_windows)
4279 self.next_window.setEnabled(have_sub_windows)
4280 self.previous_window.setEnabled(have_sub_windows)
4281 self.window_menu.addAction(self.close_active_window)
4282 self.window_menu.addAction(self.close_all_windows)
4283 self.window_menu.addSeparator()
4284 self.window_menu.addAction(self.tile_windows)
4285 self.window_menu.addAction(self.cascade_windows)
4286 self.window_menu.addSeparator()
4287 self.window_menu.addAction(self.next_window)
4288 self.window_menu.addAction(self.previous_window)
4289 if sub_window_count == 0:
4290 return
4291 self.window_menu.addSeparator()
4292 nr = 1
4293 for sub_window in self.mdi_area.subWindowList():
4294 label = str(nr) + " " + sub_window.name
4295 if nr < 10:
4296 label = "&" + label
4297 action = self.window_menu.addAction(label)
4298 action.setCheckable(True)
4299 action.setChecked(sub_window == self.mdi_area.activeSubWindow())
4300 action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
4301 self.window_menu.addAction(action)
4302 nr += 1
4303
4304 def setActiveSubWindow(self, nr):
4305 self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
4306
4307 # Help text
4308
4309 glb_help_text = """
4310 <h1>Contents</h1>
4311 <style>
4312 p.c1 {
4313 text-indent: 40px;
4314 }
4315 p.c2 {
4316 text-indent: 80px;
4317 }
4318 }
4319 </style>
4320 <p class=c1><a href=#reports>1. Reports</a></p>
4321 <p class=c2><a href=#callgraph>1.1 Context-Sensitive Call Graph</a></p>
4322 <p class=c2><a href=#calltree>1.2 Call Tree</a></p>
4323 <p class=c2><a href=#allbranches>1.3 All branches</a></p>
4324 <p class=c2><a href=#selectedbranches>1.4 Selected branches</a></p>
4325 <p class=c2><a href=#topcallsbyelapsedtime>1.5 Top calls by elapsed time</a></p>
4326 <p class=c1><a href=#charts>2. Charts</a></p>
4327 <p class=c2><a href=#timechartbycpu>2.1 Time chart by CPU</a></p>
4328 <p class=c1><a href=#tables>3. Tables</a></p>
4329 <h1 id=reports>1. Reports</h1>
4330 <h2 id=callgraph>1.1 Context-Sensitive Call Graph</h2>
4331 The result is a GUI window with a tree representing a context-sensitive
4332 call-graph. Expanding a couple of levels of the tree and adjusting column
4333 widths to suit will display something like:
4334 <pre>
4335 Call Graph: pt_example
4336 Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
4337 v- ls
4338 v- 2638:2638
4339 v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
4340 |- unknown unknown 1 13198 0.1 1 0.0
4341 >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
4342 >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
4343 v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
4344 >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
4345 >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
4346 >- __libc_csu_init ls 1 10354 0.1 10 0.0
4347 |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
4348 v- main ls 1 8182043 99.6 180254 99.9
4349 </pre>
4350 <h3>Points to note:</h3>
4351 <ul>
4352 <li>The top level is a command name (comm)</li>
4353 <li>The next level is a thread (pid:tid)</li>
4354 <li>Subsequent levels are functions</li>
4355 <li>'Count' is the number of calls</li>
4356 <li>'Time' is the elapsed time until the function returns</li>
4357 <li>Percentages are relative to the level above</li>
4358 <li>'Branch Count' is the total number of branches for that function and all functions that it calls
4359 </ul>
4360 <h3>Find</h3>
4361 Ctrl-F displays a Find bar which finds function names by either an exact match or a pattern match.
4362 The pattern matching symbols are ? for any character and * for zero or more characters.
4363 <h2 id=calltree>1.2 Call Tree</h2>
4364 The Call Tree report is very similar to the Context-Sensitive Call Graph, but the data is not aggregated.
4365 Also the 'Count' column, which would be always 1, is replaced by the 'Call Time'.
4366 <h2 id=allbranches>1.3 All branches</h2>
4367 The All branches report displays all branches in chronological order.
4368 Not all data is fetched immediately. More records can be fetched using the Fetch bar provided.
4369 <h3>Disassembly</h3>
4370 Open a branch to display disassembly. This only works if:
4371 <ol>
4372 <li>The disassembler is available. Currently, only Intel XED is supported - see <a href=#xed>Intel XED Setup</a></li>
4373 <li>The object code is available. Currently, only the perf build ID cache is searched for object code.
4374 The default directory ~/.debug can be overridden by setting environment variable PERF_BUILDID_DIR.
4375 One exception is kcore where the DSO long name is used (refer dsos_view on the Tables menu),
4376 or alternatively, set environment variable PERF_KCORE to the kcore file name.</li>
4377 </ol>
4378 <h4 id=xed>Intel XED Setup</h4>
4379 To use Intel XED, libxed.so must be present. To build and install libxed.so:
4380 <pre>
4381 git clone https://github.com/intelxed/mbuild.git mbuild
4382 git clone https://github.com/intelxed/xed
4383 cd xed
4384 ./mfile.py --share
4385 sudo ./mfile.py --prefix=/usr/local install
4386 sudo ldconfig
4387 </pre>
4388 <h3>Instructions per Cycle (IPC)</h3>
4389 If available, IPC information is displayed in columns 'insn_cnt', 'cyc_cnt' and 'IPC'.
4390 <p><b>Intel PT note:</b> The information applies to the blocks of code ending with, and including, that branch.
4391 Due to the granularity of timing information, the number of cycles for some code blocks will not be known.
4392 In that case, 'insn_cnt', 'cyc_cnt' and 'IPC' are zero, but when 'IPC' is displayed it covers the period
4393 since the previous displayed 'IPC'.
4394 <h3>Find</h3>
4395 Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
4396 Refer to Python documentation for the regular expression syntax.
4397 All columns are searched, but only currently fetched rows are searched.
4398 <h2 id=selectedbranches>1.4 Selected branches</h2>
4399 This is the same as the <a href=#allbranches>All branches</a> report but with the data reduced
4400 by various selection criteria. A dialog box displays available criteria which are AND'ed together.
4401 <h3>1.4.1 Time ranges</h3>
4402 The time ranges hint text shows the total time range. Relative time ranges can also be entered in
4403 ms, us or ns. Also, negative values are relative to the end of trace. Examples:
4404 <pre>
4405 81073085947329-81073085958238 From 81073085947329 to 81073085958238
4406 100us-200us From 100us to 200us
4407 10ms- From 10ms to the end
4408 -100ns The first 100ns
4409 -10ms- The last 10ms
4410 </pre>
4411 N.B. Due to the granularity of timestamps, there could be no branches in any given time range.
4412 <h2 id=topcallsbyelapsedtime>1.5 Top calls by elapsed time</h2>
4413 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.
4414 The data is reduced by various selection criteria. A dialog box displays available criteria which are AND'ed together.
4415 If not all data is fetched, a Fetch bar is provided. Ctrl-F displays a Find bar.
4416 <h1 id=charts>2. Charts</h1>
4417 <h2 id=timechartbycpu>2.1 Time chart by CPU</h2>
4418 This chart displays context switch information when that data is available. Refer to context_switches_view on the Tables menu.
4419 <h3>Features</h3>
4420 <ol>
4421 <li>Mouse over to highight the task and show the time</li>
4422 <li>Drag the mouse to select a region and zoom by pushing the Zoom button</li>
4423 <li>Go back and forward by pressing the arrow buttons</li>
4424 <li>If call information is available, right-click to show a call tree opened to that task and time.
4425 Note, the call tree may take some time to appear, and there may not be call information for the task or time selected.
4426 </li>
4427 </ol>
4428 <h3>Important</h3>
4429 The graph can be misleading in the following respects:
4430 <ol>
4431 <li>The graph shows the first task on each CPU as running from the beginning of the time range.
4432 Because tracing might start on different CPUs at different times, that is not necessarily the case.
4433 Refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
4434 <li>Similarly, the last task on each CPU can be showing running longer than it really was.
4435 Again, refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
4436 <li>When the mouse is over a task, the highlighted task might not be visible on the legend without scrolling if the legend does not fit fully in the window</li>
4437 </ol>
4438 <h1 id=tables>3. Tables</h1>
4439 The Tables menu shows all tables and views in the database. Most tables have an associated view
4440 which displays the information in a more friendly way. Not all data for large tables is fetched
4441 immediately. More records can be fetched using the Fetch bar provided. Columns can be sorted,
4442 but that can be slow for large tables.
4443 <p>There are also tables of database meta-information.
4444 For SQLite3 databases, the sqlite_master table is included.
4445 For PostgreSQL databases, information_schema.tables/views/columns are included.
4446 <h3>Find</h3>
4447 Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
4448 Refer to Python documentation for the regular expression syntax.
4449 All columns are searched, but only currently fetched rows are searched.
4450 <p>N.B. Results are found in id order, so if the table is re-ordered, find-next and find-previous
4451 will go to the next/previous result in id order, instead of display order.
4452 """
4453
4454 # Help window
4455
4456 class HelpWindow(QMdiSubWindow):
4457
4458 def __init__(self, glb, parent=None):
4459 super(HelpWindow, self).__init__(parent)
4460
4461 self.text = QTextBrowser()
4462 self.text.setHtml(glb_help_text)
4463 self.text.setReadOnly(True)
4464 self.text.setOpenExternalLinks(True)
4465
4466 self.setWidget(self.text)
4467
4468 AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
4469
4470 # Main window that only displays the help text
4471
4472 class HelpOnlyWindow(QMainWindow):
4473
4474 def __init__(self, parent=None):
4475 super(HelpOnlyWindow, self).__init__(parent)
4476
4477 self.setMinimumSize(200, 100)
4478 self.resize(800, 600)
4479 self.setWindowTitle("Exported SQL Viewer Help")
4480 self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
4481
4482 self.text = QTextBrowser()
4483 self.text.setHtml(glb_help_text)
4484 self.text.setReadOnly(True)
4485 self.text.setOpenExternalLinks(True)
4486
4487 self.setCentralWidget(self.text)
4488
4489 # PostqreSQL server version
4490
4491 def PostqreSQLServerVersion(db):
4492 query = QSqlQuery(db)
4493 QueryExec(query, "SELECT VERSION()")
4494 if query.next():
4495 v_str = query.value(0)
4496 v_list = v_str.strip().split(" ")
4497 if v_list[0] == "PostgreSQL" and v_list[2] == "on":
4498 return v_list[1]
4499 return v_str
4500 return "Unknown"
4501
4502 # SQLite version
4503
4504 def SQLiteVersion(db):
4505 query = QSqlQuery(db)
4506 QueryExec(query, "SELECT sqlite_version()")
4507 if query.next():
4508 return query.value(0)
4509 return "Unknown"
4510
4511 # About dialog
4512
4513 class AboutDialog(QDialog):
4514
4515 def __init__(self, glb, parent=None):
4516 super(AboutDialog, self).__init__(parent)
4517
4518 self.setWindowTitle("About Exported SQL Viewer")
4519 self.setMinimumWidth(300)
4520
4521 pyside_version = "1" if pyside_version_1 else "2"
4522
4523 text = "<pre>"
4524 text += "Python version: " + sys.version.split(" ")[0] + "\n"
4525 text += "PySide version: " + pyside_version + "\n"
4526 text += "Qt version: " + qVersion() + "\n"
4527 if glb.dbref.is_sqlite3:
4528 text += "SQLite version: " + SQLiteVersion(glb.db) + "\n"
4529 else:
4530 text += "PostqreSQL version: " + PostqreSQLServerVersion(glb.db) + "\n"
4531 text += "</pre>"
4532
4533 self.text = QTextBrowser()
4534 self.text.setHtml(text)
4535 self.text.setReadOnly(True)
4536 self.text.setOpenExternalLinks(True)
4537
4538 self.vbox = QVBoxLayout()
4539 self.vbox.addWidget(self.text)
4540
4541 self.setLayout(self.vbox)
4542
4543 # Font resize
4544
4545 def ResizeFont(widget, diff):
4546 font = widget.font()
4547 sz = font.pointSize()
4548 font.setPointSize(sz + diff)
4549 widget.setFont(font)
4550
4551 def ShrinkFont(widget):
4552 ResizeFont(widget, -1)
4553
4554 def EnlargeFont(widget):
4555 ResizeFont(widget, 1)
4556
4557 # Unique name for sub-windows
4558
4559 def NumberedWindowName(name, nr):
4560 if nr > 1:
4561 name += " <" + str(nr) + ">"
4562 return name
4563
4564 def UniqueSubWindowName(mdi_area, name):
4565 nr = 1
4566 while True:
4567 unique_name = NumberedWindowName(name, nr)
4568 ok = True
4569 for sub_window in mdi_area.subWindowList():
4570 if sub_window.name == unique_name:
4571 ok = False
4572 break
4573 if ok:
4574 return unique_name
4575 nr += 1
4576
4577 # Add a sub-window
4578
4579 def AddSubWindow(mdi_area, sub_window, name):
4580 unique_name = UniqueSubWindowName(mdi_area, name)
4581 sub_window.setMinimumSize(200, 100)
4582 sub_window.resize(800, 600)
4583 sub_window.setWindowTitle(unique_name)
4584 sub_window.setAttribute(Qt.WA_DeleteOnClose)
4585 sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon))
4586 sub_window.name = unique_name
4587 mdi_area.addSubWindow(sub_window)
4588 sub_window.show()
4589
4590 # Main window
4591
4592 class MainWindow(QMainWindow):
4593
4594 def __init__(self, glb, parent=None):
4595 super(MainWindow, self).__init__(parent)
4596
4597 self.glb = glb
4598
4599 self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
4600 self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
4601 self.setMinimumSize(200, 100)
4602
4603 self.mdi_area = QMdiArea()
4604 self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4605 self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4606
4607 self.setCentralWidget(self.mdi_area)
4608
4609 menu = self.menuBar()
4610
4611 file_menu = menu.addMenu("&File")
4612 file_menu.addAction(CreateExitAction(glb.app, self))
4613
4614 edit_menu = menu.addMenu("&Edit")
4615 edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySequence.Copy))
4616 edit_menu.addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
4617 edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
4618 edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)]))
4619 edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")]))
4620 edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")]))
4621
4622 reports_menu = menu.addMenu("&Reports")
4623 if IsSelectable(glb.db, "calls"):
4624 reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
4625
4626 if IsSelectable(glb.db, "calls", "WHERE parent_id >= 0"):
4627 reports_menu.addAction(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
4628
4629 self.EventMenu(GetEventList(glb.db), reports_menu)
4630
4631 if IsSelectable(glb.db, "calls"):
4632 reports_menu.addAction(CreateAction("&Top calls by elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
4633
4634 if IsSelectable(glb.db, "context_switches"):
4635 charts_menu = menu.addMenu("&Charts")
4636 charts_menu.addAction(CreateAction("&Time chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))
4637
4638 self.TableMenu(GetTableList(glb), menu)
4639
4640 self.window_menu = WindowMenu(self.mdi_area, menu)
4641
4642 help_menu = menu.addMenu("&Help")
4643 help_menu.addAction(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence.HelpContents))
4644 help_menu.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
4645
4646 def Try(self, fn):
4647 win = self.mdi_area.activeSubWindow()
4648 if win:
4649 try:
4650 fn(win.view)
4651 except:
4652 pass
4653
4654 def CopyToClipboard(self):
4655 self.Try(CopyCellsToClipboardHdr)
4656
4657 def CopyToClipboardCSV(self):
4658 self.Try(CopyCellsToClipboardCSV)
4659
4660 def Find(self):
4661 win = self.mdi_area.activeSubWindow()
4662 if win:
4663 try:
4664 win.find_bar.Activate()
4665 except:
4666 pass
4667
4668 def FetchMoreRecords(self):
4669 win = self.mdi_area.activeSubWindow()
4670 if win:
4671 try:
4672 win.fetch_bar.Activate()
4673 except:
4674 pass
4675
4676 def ShrinkFont(self):
4677 self.Try(ShrinkFont)
4678
4679 def EnlargeFont(self):
4680 self.Try(EnlargeFont)
4681
4682 def EventMenu(self, events, reports_menu):
4683 branches_events = 0
4684 for event in events:
4685 event = event.split(":")[0]
4686 if event == "branches":
4687 branches_events += 1
4688 dbid = 0
4689 for event in events:
4690 dbid += 1
4691 event = event.split(":")[0]
4692 if event == "branches":
4693 label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")"
4694 reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
4695 label = "Selected branches" if branches_events == 1 else "Selected branches " + "(id=" + dbid + ")"
4696 reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
4697
4698 def TimeChartByCPU(self):
4699 TimeChartByCPUWindow(self.glb, self)
4700
4701 def TableMenu(self, tables, menu):
4702 table_menu = menu.addMenu("&Tables")
4703 for table in tables:
4704 table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
4705
4706 def NewCallGraph(self):
4707 CallGraphWindow(self.glb, self)
4708
4709 def NewCallTree(self):
4710 CallTreeWindow(self.glb, self)
4711
4712 def NewTopCalls(self):
4713 dialog = TopCallsDialog(self.glb, self)
4714 ret = dialog.exec_()
4715 if ret:
4716 TopCallsWindow(self.glb, dialog.report_vars, self)
4717
4718 def NewBranchView(self, event_id):
4719 BranchWindow(self.glb, event_id, ReportVars(), self)
4720
4721 def NewSelectedBranchView(self, event_id):
4722 dialog = SelectedBranchDialog(self.glb, self)
4723 ret = dialog.exec_()
4724 if ret:
4725 BranchWindow(self.glb, event_id, dialog.report_vars, self)
4726
4727 def NewTableView(self, table_name):
4728 TableWindow(self.glb, table_name, self)
4729
4730 def Help(self):
4731 HelpWindow(self.glb, self)
4732
4733 def About(self):
4734 dialog = AboutDialog(self.glb, self)
4735 dialog.exec_()
4736
4737 # XED Disassembler
4738
4739 class xed_state_t(Structure):
4740
4741 _fields_ = [
4742 ("mode", c_int),
4743 ("width", c_int)
4744 ]
4745
4746 class XEDInstruction():
4747
4748 def __init__(self, libxed):
4749 # Current xed_decoded_inst_t structure is 192 bytes. Use 512 to allow for future expansion
4750 xedd_t = c_byte * 512
4751 self.xedd = xedd_t()
4752 self.xedp = addressof(self.xedd)
4753 libxed.xed_decoded_inst_zero(self.xedp)
4754 self.state = xed_state_t()
4755 self.statep = addressof(self.state)
4756 # Buffer for disassembled instruction text
4757 self.buffer = create_string_buffer(256)
4758 self.bufferp = addressof(self.buffer)
4759
4760 class LibXED():
4761
4762 def __init__(self):
4763 try:
4764 self.libxed = CDLL("libxed.so")
4765 except:
4766 self.libxed = None
4767 if not self.libxed:
4768 self.libxed = CDLL("/usr/local/lib/libxed.so")
4769
4770 self.xed_tables_init = self.libxed.xed_tables_init
4771 self.xed_tables_init.restype = None
4772 self.xed_tables_init.argtypes = []
4773
4774 self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero
4775 self.xed_decoded_inst_zero.restype = None
4776 self.xed_decoded_inst_zero.argtypes = [ c_void_p ]
4777
4778 self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode
4779 self.xed_operand_values_set_mode.restype = None
4780 self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ]
4781
4782 self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode
4783 self.xed_decoded_inst_zero_keep_mode.restype = None
4784 self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ]
4785
4786 self.xed_decode = self.libxed.xed_decode
4787 self.xed_decode.restype = c_int
4788 self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ]
4789
4790 self.xed_format_context = self.libxed.xed_format_context
4791 self.xed_format_context.restype = c_uint
4792 self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_void_p ]
4793
4794 self.xed_tables_init()
4795
4796 def Instruction(self):
4797 return XEDInstruction(self)
4798
4799 def SetMode(self, inst, mode):
4800 if mode:
4801 inst.state.mode = 4 # 32-bit
4802 inst.state.width = 4 # 4 bytes
4803 else:
4804 inst.state.mode = 1 # 64-bit
4805 inst.state.width = 8 # 8 bytes
4806 self.xed_operand_values_set_mode(inst.xedp, inst.statep)
4807
4808 def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip):
4809 self.xed_decoded_inst_zero_keep_mode(inst.xedp)
4810 err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt)
4811 if err:
4812 return 0, ""
4813 # Use AT&T mode (2), alternative is Intel (3)
4814 ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0)
4815 if not ok:
4816 return 0, ""
4817 if sys.version_info[0] == 2:
4818 result = inst.buffer.value
4819 else:
4820 result = inst.buffer.value.decode()
4821 # Return instruction length and the disassembled instruction text
4822 # For now, assume the length is in byte 166
4823 return inst.xedd[166], result
4824
4825 def TryOpen(file_name):
4826 try:
4827 return open(file_name, "rb")
4828 except:
4829 return None
4830
4831 def Is64Bit(f):
4832 result = sizeof(c_void_p)
4833 # ELF support only
4834 pos = f.tell()
4835 f.seek(0)
4836 header = f.read(7)
4837 f.seek(pos)
4838 magic = header[0:4]
4839 if sys.version_info[0] == 2:
4840 eclass = ord(header[4])
4841 encoding = ord(header[5])
4842 version = ord(header[6])
4843 else:
4844 eclass = header[4]
4845 encoding = header[5]
4846 version = header[6]
4847 if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1:
4848 result = True if eclass == 2 else False
4849 return result
4850
4851 # Global data
4852
4853 class Glb():
4854
4855 def __init__(self, dbref, db, dbname):
4856 self.dbref = dbref
4857 self.db = db
4858 self.dbname = dbname
4859 self.home_dir = os.path.expanduser("~")
4860 self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
4861 if self.buildid_dir:
4862 self.buildid_dir += "/.build-id/"
4863 else:
4864 self.buildid_dir = self.home_dir + "/.debug/.build-id/"
4865 self.app = None
4866 self.mainwindow = None
4867 self.instances_to_shutdown_on_exit = weakref.WeakSet()
4868 try:
4869 self.disassembler = LibXED()
4870 self.have_disassembler = True
4871 except:
4872 self.have_disassembler = False
4873 self.host_machine_id = 0
4874 self.host_start_time = 0
4875 self.host_finish_time = 0
4876
4877 def FileFromBuildId(self, build_id):
4878 file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
4879 return TryOpen(file_name)
4880
4881 def FileFromNamesAndBuildId(self, short_name, long_name, build_id):
4882 # Assume current machine i.e. no support for virtualization
4883 if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore":
4884 file_name = os.getenv("PERF_KCORE")
4885 f = TryOpen(file_name) if file_name else None
4886 if f:
4887 return f
4888 # For now, no special handling if long_name is /proc/kcore
4889 f = TryOpen(long_name)
4890 if f:
4891 return f
4892 f = self.FileFromBuildId(build_id)
4893 if f:
4894 return f
4895 return None
4896
4897 def AddInstanceToShutdownOnExit(self, instance):
4898 self.instances_to_shutdown_on_exit.add(instance)
4899
4900 # Shutdown any background processes or threads
4901 def ShutdownInstances(self):
4902 for x in self.instances_to_shutdown_on_exit:
4903 try:
4904 x.Shutdown()
4905 except:
4906 pass
4907
4908 def GetHostMachineId(self):
4909 query = QSqlQuery(self.db)
4910 QueryExec(query, "SELECT id FROM machines WHERE pid = -1")
4911 if query.next():
4912 self.host_machine_id = query.value(0)
4913 else:
4914 self.host_machine_id = 0
4915 return self.host_machine_id
4916
4917 def HostMachineId(self):
4918 if self.host_machine_id:
4919 return self.host_machine_id
4920 return self.GetHostMachineId()
4921
4922 def SelectValue(self, sql):
4923 query = QSqlQuery(self.db)
4924 try:
4925 QueryExec(query, sql)
4926 except:
4927 return None
4928 if query.next():
4929 return Decimal(query.value(0))
4930 return None
4931
4932 def SwitchesMinTime(self, machine_id):
4933 return self.SelectValue("SELECT time"
4934 " FROM context_switches"
4935 " WHERE time != 0 AND machine_id = " + str(machine_id) +
4936 " ORDER BY id LIMIT 1")
4937
4938 def SwitchesMaxTime(self, machine_id):
4939 return self.SelectValue("SELECT time"
4940 " FROM context_switches"
4941 " WHERE time != 0 AND machine_id = " + str(machine_id) +
4942 " ORDER BY id DESC LIMIT 1")
4943
4944 def SamplesMinTime(self, machine_id):
4945 return self.SelectValue("SELECT time"
4946 " FROM samples"
4947 " WHERE time != 0 AND machine_id = " + str(machine_id) +
4948 " ORDER BY id LIMIT 1")
4949
4950 def SamplesMaxTime(self, machine_id):
4951 return self.SelectValue("SELECT time"
4952 " FROM samples"
4953 " WHERE time != 0 AND machine_id = " + str(machine_id) +
4954 " ORDER BY id DESC LIMIT 1")
4955
4956 def CallsMinTime(self, machine_id):
4957 return self.SelectValue("SELECT calls.call_time"
4958 " FROM calls"
4959 " INNER JOIN threads ON threads.thread_id = calls.thread_id"
4960 " WHERE calls.call_time != 0 AND threads.machine_id = " + str(machine_id) +
4961 " ORDER BY calls.id LIMIT 1")
4962
4963 def CallsMaxTime(self, machine_id):
4964 return self.SelectValue("SELECT calls.return_time"
4965 " FROM calls"
4966 " INNER JOIN threads ON threads.thread_id = calls.thread_id"
4967 " WHERE calls.return_time != 0 AND threads.machine_id = " + str(machine_id) +
4968 " ORDER BY calls.return_time DESC LIMIT 1")
4969
4970 def GetStartTime(self, machine_id):
4971 t0 = self.SwitchesMinTime(machine_id)
4972 t1 = self.SamplesMinTime(machine_id)
4973 t2 = self.CallsMinTime(machine_id)
4974 if t0 is None or (not(t1 is None) and t1 < t0):
4975 t0 = t1
4976 if t0 is None or (not(t2 is None) and t2 < t0):
4977 t0 = t2
4978 return t0
4979
4980 def GetFinishTime(self, machine_id):
4981 t0 = self.SwitchesMaxTime(machine_id)
4982 t1 = self.SamplesMaxTime(machine_id)
4983 t2 = self.CallsMaxTime(machine_id)
4984 if t0 is None or (not(t1 is None) and t1 > t0):
4985 t0 = t1
4986 if t0 is None or (not(t2 is None) and t2 > t0):
4987 t0 = t2
4988 return t0
4989
4990 def HostStartTime(self):
4991 if self.host_start_time:
4992 return self.host_start_time
4993 self.host_start_time = self.GetStartTime(self.HostMachineId())
4994 return self.host_start_time
4995
4996 def HostFinishTime(self):
4997 if self.host_finish_time:
4998 return self.host_finish_time
4999 self.host_finish_time = self.GetFinishTime(self.HostMachineId())
5000 return self.host_finish_time
5001
5002 def StartTime(self, machine_id):
5003 if machine_id == self.HostMachineId():
5004 return self.HostStartTime()
5005 return self.GetStartTime(machine_id)
5006
5007 def FinishTime(self, machine_id):
5008 if machine_id == self.HostMachineId():
5009 return self.HostFinishTime()
5010 return self.GetFinishTime(machine_id)
5011
5012 # Database reference
5013
5014 class DBRef():
5015
5016 def __init__(self, is_sqlite3, dbname):
5017 self.is_sqlite3 = is_sqlite3
5018 self.dbname = dbname
5019 self.TRUE = "TRUE"
5020 self.FALSE = "FALSE"
5021 # SQLite prior to version 3.23 does not support TRUE and FALSE
5022 if self.is_sqlite3:
5023 self.TRUE = "1"
5024 self.FALSE = "0"
5025
5026 def Open(self, connection_name):
5027 dbname = self.dbname
5028 if self.is_sqlite3:
5029 db = QSqlDatabase.addDatabase("QSQLITE", connection_name)
5030 else:
5031 db = QSqlDatabase.addDatabase("QPSQL", connection_name)
5032 opts = dbname.split()
5033 for opt in opts:
5034 if "=" in opt:
5035 opt = opt.split("=")
5036 if opt[0] == "hostname":
5037 db.setHostName(opt[1])
5038 elif opt[0] == "port":
5039 db.setPort(int(opt[1]))
5040 elif opt[0] == "username":
5041 db.setUserName(opt[1])
5042 elif opt[0] == "password":
5043 db.setPassword(opt[1])
5044 elif opt[0] == "dbname":
5045 dbname = opt[1]
5046 else:
5047 dbname = opt
5048
5049 db.setDatabaseName(dbname)
5050 if not db.open():
5051 raise Exception("Failed to open database " + dbname + " error: " + db.lastError().text())
5052 return db, dbname
5053
5054 # Main
5055
5056 def Main():
5057 usage_str = "exported-sql-viewer.py [--pyside-version-1] <database name>\n" \
5058 " or: exported-sql-viewer.py --help-only"
5059 ap = argparse.ArgumentParser(usage = usage_str, add_help = False)
5060 ap.add_argument("--pyside-version-1", action='store_true')
5061 ap.add_argument("dbname", nargs="?")
5062 ap.add_argument("--help-only", action='store_true')
5063 args = ap.parse_args()
5064
5065 if args.help_only:
5066 app = QApplication(sys.argv)
5067 mainwindow = HelpOnlyWindow()
5068 mainwindow.show()
5069 err = app.exec_()
5070 sys.exit(err)
5071
5072 dbname = args.dbname
5073 if dbname is None:
5074 ap.print_usage()
5075 print("Too few arguments")
5076 sys.exit(1)
5077
5078 is_sqlite3 = False
5079 try:
5080 f = open(dbname, "rb")
5081 if f.read(15) == b'SQLite format 3':
5082 is_sqlite3 = True
5083 f.close()
5084 except:
5085 pass
5086
5087 dbref = DBRef(is_sqlite3, dbname)
5088 db, dbname = dbref.Open("main")
5089 glb = Glb(dbref, db, dbname)
5090 app = QApplication(sys.argv)
5091 glb.app = app
5092 mainwindow = MainWindow(glb)
5093 glb.mainwindow = mainwindow
5094 mainwindow.show()
5095 err = app.exec_()
5096 glb.ShutdownInstances()
5097 db.close()
5098 sys.exit(err)
5099
5100 if __name__ == "__main__":
5101 Main()
Linux with added FPC-III support