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