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