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