Lines Matching refs:self
184 def __init__(self, task, param=None, parent=None): argument
185 super(Thread, self).__init__(parent)
186 self.task = task
187 self.param = param
189 def run(self): argument
191 if self.param is None:
192 done, result = self.task()
194 done, result = self.task(self.param)
195 self.done.emit(result)
203 def __init__(self, glb, params, parent=None): argument
204 super(TreeModel, self).__init__(parent)
205 self.glb = glb
206 self.params = params
207 self.root = self.GetRoot()
208 self.last_row_read = 0
210 def Item(self, parent): argument
214 return self.root
216 def rowCount(self, parent): argument
217 result = self.Item(parent).childCount()
220 self.dataChanged.emit(parent, parent)
223 def hasChildren(self, parent): argument
224 return self.Item(parent).hasChildren()
226 def headerData(self, section, orientation, role): argument
228 return self.columnAlignment(section)
233 return self.columnHeader(section)
235 def parent(self, child): argument
237 if child_item is self.root:
240 return self.createIndex(parent_item.getRow(), 0, parent_item)
242 def index(self, row, column, parent): argument
243 child_item = self.Item(parent).getChildItem(row)
244 return self.createIndex(row, column, child_item)
246 def DisplayData(self, item, index): argument
249 def FetchIfNeeded(self, row): argument
250 if row > self.last_row_read:
251 self.last_row_read = row
252 if row + 10 >= self.root.child_count:
253 self.fetcher.Fetch(glb_chunk_sz)
255 def columnAlignment(self, column): argument
258 def columnFont(self, column): argument
261 def data(self, index, role): argument
263 return self.columnAlignment(index.column())
265 return self.columnFont(index.column())
269 return self.DisplayData(item, index)
275 def __init__(self, parent=None): argument
276 super(TableModel, self).__init__(parent)
277 self.child_count = 0
278 self.child_items = []
279 self.last_row_read = 0
281 def Item(self, parent): argument
285 return self
287 def rowCount(self, parent): argument
288 return self.child_count
290 def headerData(self, section, orientation, role): argument
292 return self.columnAlignment(section)
297 return self.columnHeader(section)
299 def index(self, row, column, parent): argument
300 return self.createIndex(row, column, self.child_items[row])
302 def DisplayData(self, item, index): argument
305 def FetchIfNeeded(self, row): argument
306 if row > self.last_row_read:
307 self.last_row_read = row
308 if row + 10 >= self.child_count:
309 self.fetcher.Fetch(glb_chunk_sz)
311 def columnAlignment(self, column): argument
314 def columnFont(self, column): argument
317 def data(self, index, role): argument
319 return self.columnAlignment(index.column())
321 return self.columnFont(index.column())
325 return self.DisplayData(item, index)
348 def __init__(self, parent, finder, is_reg_expr=False): argument
349 self.finder = finder
350 self.context = []
351 self.last_value = None
352 self.last_pattern = None
357 self.textbox = QComboBox()
358 self.textbox.setEditable(True)
359 self.textbox.currentIndexChanged.connect(self.ValueChanged)
361 self.progress = QProgressBar()
362 self.progress.setRange(0, 0)
363 self.progress.hide()
366 self.pattern = QCheckBox("Regular Expression")
368 self.pattern = QCheckBox("Pattern")
369 self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
371 self.next_button = QToolButton()
372 self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
373 self.next_button.released.connect(lambda: self.NextPrev(1))
375 self.prev_button = QToolButton()
376 self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
377 self.prev_button.released.connect(lambda: self.NextPrev(-1))
379 self.close_button = QToolButton()
380 self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
381 self.close_button.released.connect(self.Deactivate)
383 self.hbox = QHBoxLayout()
384 self.hbox.setContentsMargins(0, 0, 0, 0)
386 self.hbox.addWidget(label)
387 self.hbox.addWidget(self.textbox)
388 self.hbox.addWidget(self.progress)
389 self.hbox.addWidget(self.pattern)
390 self.hbox.addWidget(self.next_button)
391 self.hbox.addWidget(self.prev_button)
392 self.hbox.addWidget(self.close_button)
394 self.bar = QWidget()
395 self.bar.setLayout(self.hbox)
396 self.bar.hide()
398 def Widget(self): argument
399 return self.bar
401 def Activate(self): argument
402 self.bar.show()
403 self.textbox.lineEdit().selectAll()
404 self.textbox.setFocus()
406 def Deactivate(self): argument
407 self.bar.hide()
409 def Busy(self): argument
410 self.textbox.setEnabled(False)
411 self.pattern.hide()
412 self.next_button.hide()
413 self.prev_button.hide()
414 self.progress.show()
416 def Idle(self): argument
417 self.textbox.setEnabled(True)
418 self.progress.hide()
419 self.pattern.show()
420 self.next_button.show()
421 self.prev_button.show()
423 def Find(self, direction): argument
424 value = self.textbox.currentText()
425 pattern = self.pattern.isChecked()
426 self.last_value = value
427 self.last_pattern = pattern
428 self.finder.Find(value, direction, pattern, self.context)
430 def ValueChanged(self): argument
431 value = self.textbox.currentText()
432 pattern = self.pattern.isChecked()
433 index = self.textbox.currentIndex()
434 data = self.textbox.itemData(index)
437 self.textbox.setItemData(index, pattern)
439 self.pattern.setChecked(data)
440 self.Find(0)
442 def NextPrev(self, direction): argument
443 value = self.textbox.currentText()
444 pattern = self.pattern.isChecked()
445 if value != self.last_value:
446 index = self.textbox.findText(value)
449 index = self.textbox.count()
450 self.textbox.addItem(value, pattern)
451 self.textbox.setCurrentIndex(index)
454 self.textbox.setItemData(index, pattern)
455 elif pattern != self.last_pattern:
457 index = self.textbox.currentIndex()
458 self.textbox.setItemData(index, pattern)
459 self.Find(direction)
461 def NotFound(self): argument
462 QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
468 def __init__(self, glb, params, row, parent_item): argument
469 self.glb = glb
470 self.params = params
471 self.row = row
472 self.parent_item = parent_item
473 self.query_done = False
474 self.child_count = 0
475 self.child_items = []
477 self.level = parent_item.level + 1
479 self.level = 0
481 def getChildItem(self, row): argument
482 return self.child_items[row]
484 def getParentItem(self): argument
485 return self.parent_item
487 def getRow(self): argument
488 return self.row
490 def childCount(self): argument
491 if not self.query_done:
492 self.Select()
493 if not self.child_count:
495 return self.child_count
497 def hasChildren(self): argument
498 if not self.query_done:
500 return self.child_count > 0
502 def getData(self, column): argument
503 return self.data[column]
509 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, br… argument
510 super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
511 self.comm_id = comm_id
512 self.thread_id = thread_id
513 self.call_path_id = call_path_id
514 self.insn_cnt = insn_cnt
515 self.cyc_cnt = cyc_cnt
516 self.branch_count = branch_count
517 self.time = time
519 def Select(self): argument
520 self.query_done = True
521 query = QSqlQuery(self.glb.db)
522 if self.params.have_ipc:
531 " WHERE parent_call_path_id = " + str(self.call_path_id) +
532 " AND comm_id = " + str(self.comm_id) +
533 " AND thread_id = " + str(self.thread_id) +
537 if self.params.have_ipc:
545 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
546 self.child_items.append(child_item)
547 self.child_count += 1
553 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, ins… argument
554 …super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, …
556 if self.params.have_ipc:
561 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_c…
563 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch…
564 self.dbid = call_path_id
570 def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item): argument
571 …super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, p…
572 if self.params.have_ipc:
573 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
575 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
576 self.dbid = thread_id
578 def Select(self): argument
579 super(CallGraphLevelTwoItem, self).Select()
580 for child_item in self.child_items:
581 self.time += child_item.time
582 self.insn_cnt += child_item.insn_cnt
583 self.cyc_cnt += child_item.cyc_cnt
584 self.branch_count += child_item.branch_count
585 for child_item in self.child_items:
586 child_item.data[4] = PercentToOneDP(child_item.time, self.time)
587 if self.params.have_ipc:
588 child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
589 child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
590 child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
592 child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
598 def __init__(self, glb, params, row, comm_id, comm, parent_item): argument
599 super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
600 if self.params.have_ipc:
601 self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
603 self.data = [comm, "", "", "", "", "", ""]
604 self.dbid = comm_id
606 def Select(self): argument
607 self.query_done = True
608 query = QSqlQuery(self.glb.db)
612 " WHERE comm_id = " + str(self.dbid))
614 …= CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
615 self.child_items.append(child_item)
616 self.child_count += 1
622 def __init__(self, glb, params): argument
623 super(CallGraphRootItem, self).__init__(glb, params, 0, None)
624 self.dbid = 0
625 self.query_done = True
634 …child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), …
635 self.child_items.append(child_item)
636 self.child_count += 1
642 def __init__(self, glb, parent=None): argument
643 self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
649 def __init__(self, glb, parent=None): argument
650 super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
652 def FindSelect(self, value, pattern, query): argument
659 if not self.glb.dbref.is_sqlite3:
670 self.DoFindSelect(query, match)
672 def Found(self, query, found): argument
674 return self.FindPath(query)
677 def FindValue(self, value, pattern, query, last_value, last_pattern): argument
681 self.FindSelect(value, pattern, query)
683 return self.Found(query, found)
685 def FindNext(self, query): argument
689 return self.Found(query, found)
691 def FindPrev(self, query): argument
695 return self.Found(query, found)
697 def FindThread(self, c): argument
699 ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
701 ids = self.FindNext(c.query)
703 ids = self.FindPrev(c.query)
706 def Find(self, value, direction, pattern, context, callback): argument
708 def __init__(self, *x): argument
709 self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
710 def Update(self, *x): argument
711 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, se…
715 context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
717 thread = Thread(self.FindThread, context[0])
718 …thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnectio…
721 def FindDone(self, thread, callback, ids): argument
728 def __init__(self, glb, parent=None): argument
729 super(CallGraphModel, self).__init__(glb, parent)
731 def GetRoot(self): argument
732 return CallGraphRootItem(self.glb, self.params)
734 def columnCount(self, parent=None): argument
735 if self.params.have_ipc:
740 def columnHeader(self, column): argument
741 if self.params.have_ipc:
747 def columnAlignment(self, column): argument
748 if self.params.have_ipc:
754 def DoFindSelect(self, query, match): argument
763 def FindPath(self, query): argument
770 q2 = QSqlQuery(self.glb.db)
788 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, time, insn_cnt, cyc_cnt, branch… argument
789 super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
790 self.comm_id = comm_id
791 self.thread_id = thread_id
792 self.calls_id = calls_id
793 self.insn_cnt = insn_cnt
794 self.cyc_cnt = cyc_cnt
795 self.branch_count = branch_count
796 self.time = time
798 def Select(self): argument
799 self.query_done = True
800 if self.calls_id == 0:
801 comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
804 if self.params.have_ipc:
808 query = QSqlQuery(self.glb.db)
814 " WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
817 if self.params.have_ipc:
825 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
826 self.child_items.append(child_item)
827 self.child_count += 1
833 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, count, time, insn_cn… argument
834 …super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, time,…
836 if self.params.have_ipc:
841 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_c…
843 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch…
844 self.dbid = calls_id
850 def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item): argument
851 …super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, pa…
852 if self.params.have_ipc:
853 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
855 self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
856 self.dbid = thread_id
858 def Select(self): argument
859 super(CallTreeLevelTwoItem, self).Select()
860 for child_item in self.child_items:
861 self.time += child_item.time
862 self.insn_cnt += child_item.insn_cnt
863 self.cyc_cnt += child_item.cyc_cnt
864 self.branch_count += child_item.branch_count
865 for child_item in self.child_items:
866 child_item.data[4] = PercentToOneDP(child_item.time, self.time)
867 if self.params.have_ipc:
868 child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
869 child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
870 child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
872 child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
878 def __init__(self, glb, params, row, comm_id, comm, parent_item): argument
879 super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
880 if self.params.have_ipc:
881 self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
883 self.data = [comm, "", "", "", "", "", ""]
884 self.dbid = comm_id
886 def Select(self): argument
887 self.query_done = True
888 query = QSqlQuery(self.glb.db)
892 " WHERE comm_id = " + str(self.dbid))
894 … = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
895 self.child_items.append(child_item)
896 self.child_count += 1
902 def __init__(self, glb, params): argument
903 super(CallTreeRootItem, self).__init__(glb, params, 0, None)
904 self.dbid = 0
905 self.query_done = True
914 …child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), s…
915 self.child_items.append(child_item)
916 self.child_count += 1
922 def __init__(self, glb, parent=None): argument
923 super(CallTreeModel, self).__init__(glb, parent)
925 def GetRoot(self): argument
926 return CallTreeRootItem(self.glb, self.params)
928 def columnCount(self, parent=None): argument
929 if self.params.have_ipc:
934 def columnHeader(self, column): argument
935 if self.params.have_ipc:
941 def columnAlignment(self, column): argument
942 if self.params.have_ipc:
948 def DoFindSelect(self, query, match): argument
956 def FindPath(self, query): argument
963 q2 = QSqlQuery(self.glb.db)
978 def __init__(self, w1, w2, w3=None): argument
979 self.vbox = QWidget()
980 self.vbox.setLayout(QVBoxLayout())
982 self.vbox.layout().setContentsMargins(0, 0, 0, 0)
984 self.vbox.layout().addWidget(w1)
985 self.vbox.layout().addWidget(w2)
987 self.vbox.layout().addWidget(w3)
989 def Widget(self): argument
990 return self.vbox
996 def __init__(self, parent=None): argument
997 super(TreeWindowBase, self).__init__(parent)
999 self.model = None
1000 self.find_bar = None
1002 self.view = QTreeView()
1003 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
1004 self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
1006 self.context_menu = TreeContextMenu(self.view)
1008 def DisplayFound(self, ids): argument
1014 n = self.model.rowCount(parent)
1016 child = self.model.index(row, 0, parent)
1019 self.view.setCurrentIndex(child)
1026 def Find(self, value, direction, pattern, context): argument
1027 self.view.setFocus()
1028 self.find_bar.Busy()
1029 self.model.Find(value, direction, pattern, context, self.FindDone)
1031 def FindDone(self, ids): argument
1033 if not self.DisplayFound(ids):
1035 self.find_bar.Idle()
1037 self.find_bar.NotFound()
1044 def __init__(self, glb, parent=None): argument
1045 super(CallGraphWindow, self).__init__(parent)
1047 self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
1049 self.view.setModel(self.model)
1052 self.view.setColumnWidth(c, w)
1054 self.find_bar = FindBar(self, self)
1056 self.vbox = VBox(self.view, self.find_bar.Widget())
1058 self.setWidget(self.vbox.Widget())
1060 AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
1066 def __init__(self, glb, parent=None): argument
1067 super(CallTreeWindow, self).__init__(parent)
1069 self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
1071 self.view.setModel(self.model)
1074 self.view.setColumnWidth(c, w)
1076 self.find_bar = FindBar(self, self)
1078 self.vbox = VBox(self.view, self.find_bar.Widget())
1080 self.setWidget(self.vbox.Widget())
1082 AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
1088 def __init__(self, root): argument
1089 self.root = root
1090 self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
1091 self.rows = []
1092 self.pos = 0
1094 def FindSelect(self): argument
1095 self.rows = []
1096 if self.pattern:
1097 pattern = re.compile(self.value)
1098 for child in self.root.child_items:
1101 self.rows.append(child.row)
1104 for child in self.root.child_items:
1106 if self.value in str(column_data):
1107 self.rows.append(child.row)
1110 def FindValue(self): argument
1111 self.pos = 0
1112 if self.last_value != self.value or self.pattern != self.last_pattern:
1113 self.FindSelect()
1114 if not len(self.rows):
1116 return self.rows[self.pos]
1118 def FindThread(self): argument
1119 if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
1120 row = self.FindValue()
1121 elif len(self.rows):
1122 if self.direction > 0:
1123 self.pos += 1
1124 if self.pos >= len(self.rows):
1125 self.pos = 0
1127 self.pos -= 1
1128 if self.pos < 0:
1129 self.pos = len(self.rows) - 1
1130 row = self.rows[self.pos]
1135 def Find(self, value, direction, pattern, context, callback): argument
1136 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,p…
1138 thread = Thread(self.FindThread)
1139 …thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnectio…
1142 def FindDone(self, thread, callback, row): argument
1153 …def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wai… argument
1156 self.db, dbname = dbref.Open(conn_name)
1157 self.sql = sql
1158 self.buffer = buffer
1159 self.head = head
1160 self.tail = tail
1161 self.fetch_count = fetch_count
1162 self.fetching_done = fetching_done
1163 self.process_target = process_target
1164 self.wait_event = wait_event
1165 self.fetched_event = fetched_event
1166 self.prep = prep
1167 self.query = QSqlQuery(self.db)
1168 self.query_limit = 0 if "$$last_id$$" in sql else 2
1169 self.last_id = -1
1170 self.fetched = 0
1171 self.more = True
1172 self.local_head = self.head.value
1173 self.local_tail = self.tail.value
1175 def Select(self): argument
1176 if self.query_limit:
1177 if self.query_limit == 1:
1179 self.query_limit -= 1
1180 stmt = self.sql.replace("$$last_id$$", str(self.last_id))
1181 QueryExec(self.query, stmt)
1183 def Next(self): argument
1184 if not self.query.next():
1185 self.Select()
1186 if not self.query.next():
1188 self.last_id = self.query.value(0)
1189 return self.prep(self.query)
1191 def WaitForTarget(self): argument
1193 self.wait_event.clear()
1194 target = self.process_target.value
1195 if target > self.fetched or target < 0:
1197 self.wait_event.wait()
1200 def HasSpace(self, sz): argument
1201 if self.local_tail <= self.local_head:
1202 space = len(self.buffer) - self.local_head
1208 self.buffer[self.local_head : self.local_head + len(nd)] = nd
1209 self.local_head = 0
1210 if self.local_tail - self.local_head > sz:
1214 def WaitForSpace(self, sz): argument
1215 if self.HasSpace(sz):
1218 self.wait_event.clear()
1219 self.local_tail = self.tail.value
1220 if self.HasSpace(sz):
1222 self.wait_event.wait()
1224 def AddToBuffer(self, obj): argument
1229 self.WaitForSpace(sz)
1230 pos = self.local_head
1231 self.buffer[pos : pos + len(nd)] = nd
1232 self.buffer[pos + glb_nsz : pos + sz] = d
1233 self.local_head += sz
1235 def FetchBatch(self, batch_size): argument
1238 obj = self.Next()
1240 self.more = False
1242 self.AddToBuffer(obj)
1245 self.fetched += fetched
1246 with self.fetch_count.get_lock():
1247 self.fetch_count.value += fetched
1248 self.head.value = self.local_head
1249 self.fetched_event.set()
1251 def Run(self): argument
1252 while self.more:
1253 target = self.WaitForTarget()
1256 batch_size = min(glb_chunk_sz, target - self.fetched)
1257 self.FetchBatch(batch_size)
1258 self.fetching_done.value = True
1259 self.fetched_event.set()
1271 def __init__(self, glb, sql, prep, process_data, parent=None): argument
1272 super(SQLFetcher, self).__init__(parent)
1273 self.process_data = process_data
1274 self.more = True
1275 self.target = 0
1276 self.last_target = 0
1277 self.fetched = 0
1278 self.buffer_size = 16 * 1024 * 1024
1279 self.buffer = Array(c_char, self.buffer_size, lock=False)
1280 self.head = Value(c_longlong)
1281 self.tail = Value(c_longlong)
1282 self.local_tail = 0
1283 self.fetch_count = Value(c_longlong)
1284 self.fetching_done = Value(c_bool)
1285 self.last_count = 0
1286 self.process_target = Value(c_longlong)
1287 self.wait_event = Event()
1288 self.fetched_event = Event()
1289 glb.AddInstanceToShutdownOnExit(self)
1290 …self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tai…
1291 self.process.start()
1292 self.thread = Thread(self.Thread)
1293 self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
1294 self.thread.start()
1296 def Shutdown(self): argument
1298 self.process_target.value = -1
1299 self.wait_event.set()
1300 self.more = False
1301 self.fetching_done.value = True
1302 self.fetched_event.set()
1304 def Thread(self): argument
1305 if not self.more:
1308 self.fetched_event.clear()
1309 fetch_count = self.fetch_count.value
1310 if fetch_count != self.last_count:
1312 if self.fetching_done.value:
1313 self.more = False
1315 self.fetched_event.wait()
1316 count = fetch_count - self.last_count
1317 self.last_count = fetch_count
1318 self.fetched += count
1321 def Fetch(self, nr): argument
1322 if not self.more:
1325 result = self.fetched
1326 extra = result + nr - self.target
1328 self.target += extra
1330 if self.process_target.value >= 0:
1331 self.process_target.value = self.target
1332 self.wait_event.set()
1335 def RemoveFromBuffer(self): argument
1336 pos = self.local_tail
1337 if len(self.buffer) - pos < glb_nsz:
1339 n = pickle.loads(self.buffer[pos : pos + glb_nsz])
1342 n = pickle.loads(self.buffer[0 : glb_nsz])
1344 obj = pickle.loads(self.buffer[pos : pos + n])
1345 self.local_tail = pos + n
1348 def ProcessData(self, count): argument
1350 obj = self.RemoveFromBuffer()
1351 self.process_data(obj)
1352 self.tail.value = self.local_tail
1353 self.wait_event.set()
1354 self.done.emit(count)
1360 def __init__(self, model, parent): argument
1361 self.model = model
1363 self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
1364 self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
1366 self.fetch_count = QSpinBox()
1367 self.fetch_count.setRange(1, 1000000)
1368 self.fetch_count.setValue(10)
1369 self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
1371 self.fetch = QPushButton("Go!")
1372 self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
1373 self.fetch.released.connect(self.FetchMoreRecords)
1375 self.progress = QProgressBar()
1376 self.progress.setRange(0, 100)
1377 self.progress.hide()
1379 self.done_label = QLabel("All records fetched")
1380 self.done_label.hide()
1382 self.spacer = QLabel("")
1384 self.close_button = QToolButton()
1385 self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
1386 self.close_button.released.connect(self.Deactivate)
1388 self.hbox = QHBoxLayout()
1389 self.hbox.setContentsMargins(0, 0, 0, 0)
1391 self.hbox.addWidget(self.label)
1392 self.hbox.addWidget(self.fetch_count)
1393 self.hbox.addWidget(self.fetch)
1394 self.hbox.addWidget(self.spacer)
1395 self.hbox.addWidget(self.progress)
1396 self.hbox.addWidget(self.done_label)
1397 self.hbox.addWidget(self.close_button)
1399 self.bar = QWidget()
1400 self.bar.setLayout(self.hbox)
1401 self.bar.show()
1403 self.in_progress = False
1404 self.model.progress.connect(self.Progress)
1406 self.done = False
1409 self.Done()
1411 def Widget(self): argument
1412 return self.bar
1414 def Activate(self): argument
1415 self.bar.show()
1416 self.fetch.setFocus()
1418 def Deactivate(self): argument
1419 self.bar.hide()
1421 def Enable(self, enable): argument
1422 self.fetch.setEnabled(enable)
1423 self.fetch_count.setEnabled(enable)
1425 def Busy(self): argument
1426 self.Enable(False)
1427 self.fetch.hide()
1428 self.spacer.hide()
1429 self.progress.show()
1431 def Idle(self): argument
1432 self.in_progress = False
1433 self.Enable(True)
1434 self.progress.hide()
1435 self.fetch.show()
1436 self.spacer.show()
1438 def Target(self): argument
1439 return self.fetch_count.value() * glb_chunk_sz
1441 def Done(self): argument
1442 self.done = True
1443 self.Idle()
1444 self.label.hide()
1445 self.fetch_count.hide()
1446 self.fetch.hide()
1447 self.spacer.hide()
1448 self.done_label.show()
1450 def Progress(self, count): argument
1451 if self.in_progress:
1453 percent = ((count - self.start) * 100) / self.Target()
1455 self.Idle()
1457 self.progress.setValue(percent)
1460 self.Done()
1462 def FetchMoreRecords(self): argument
1463 if self.done:
1465 self.progress.setValue(0)
1466 self.Busy()
1467 self.in_progress = True
1468 self.start = self.model.FetchMoreRecords(self.Target())
1474 def __init__(self, row, col, text, parent_item): argument
1475 self.row = row
1476 self.parent_item = parent_item
1477 self.data = [""] * (col + 1)
1478 self.data[col] = text
1479 self.level = 2
1481 def getParentItem(self): argument
1482 return self.parent_item
1484 def getRow(self): argument
1485 return self.row
1487 def childCount(self): argument
1490 def hasChildren(self): argument
1493 def getData(self, column): argument
1494 return self.data[column]
1500 def __init__(self, glb, row, data, parent_item): argument
1501 self.glb = glb
1502 self.row = row
1503 self.parent_item = parent_item
1504 self.child_count = 0
1505 self.child_items = []
1506 self.data = data[1:]
1507 self.dbid = data[0]
1508 self.level = 1
1509 self.query_done = False
1510 self.br_col = len(self.data) - 1
1512 def getChildItem(self, row): argument
1513 return self.child_items[row]
1515 def getParentItem(self): argument
1516 return self.parent_item
1518 def getRow(self): argument
1519 return self.row
1521 def Select(self): argument
1522 self.query_done = True
1524 if not self.glb.have_disassembler:
1527 query = QSqlQuery(self.glb.db)
1533 " WHERE samples.id = " + str(self.dbid))
1551 " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
1568 inst = self.glb.disassembler.Instruction()
1569 f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
1573 self.glb.disassembler.SetMode(inst, mode)
1582 cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
1591 self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
1592 self.child_count += 1
1600 def childCount(self): argument
1601 if not self.query_done:
1602 self.Select()
1603 if not self.child_count:
1605 return self.child_count
1607 def hasChildren(self): argument
1608 if not self.query_done:
1610 return self.child_count > 0
1612 def getData(self, column): argument
1613 return self.data[column]
1619 def __init__(self): argument
1620 self.child_count = 0
1621 self.child_items = []
1622 self.level = 0
1624 def getChildItem(self, row): argument
1625 return self.child_items[row]
1627 def getParentItem(self): argument
1630 def getRow(self): argument
1633 def childCount(self): argument
1634 return self.child_count
1636 def hasChildren(self): argument
1637 return self.child_count > 0
1639 def getData(self, column): argument
1710 def __init__(self, glb, event_id, where_clause, parent=None): argument
1711 super(BranchModel, self).__init__(glb, None, parent)
1712 self.event_id = event_id
1713 self.more = True
1714 self.populated = 0
1715 self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
1716 if self.have_ipc:
1738 " AND evsel_id = " + str(self.event_id) +
1745 self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
1746 self.fetcher.done.connect(self.Update)
1747 self.fetcher.Fetch(glb_chunk_sz)
1749 def GetRoot(self): argument
1752 def columnCount(self, parent=None): argument
1753 if self.have_ipc:
1758 def columnHeader(self, column): argument
1759 if self.have_ipc:
1764 def columnFont(self, column): argument
1765 if self.have_ipc:
1773 def DisplayData(self, item, index): argument
1775 self.FetchIfNeeded(item.row)
1778 def AddSample(self, data): argument
1779 child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
1780 self.root.child_items.append(child)
1781 self.populated += 1
1783 def Update(self, fetched): argument
1785 self.more = False
1786 self.progress.emit(0)
1787 child_count = self.root.child_count
1788 count = self.populated - child_count
1791 self.beginInsertRows(parent, child_count, child_count + count - 1)
1792 self.insertRows(child_count, count, parent)
1793 self.root.child_count += count
1794 self.endInsertRows()
1795 self.progress.emit(self.root.child_count)
1797 def FetchMoreRecords(self, count): argument
1798 current = self.root.child_count
1799 if self.more:
1800 self.fetcher.Fetch(count)
1802 self.progress.emit(0)
1805 def HasMoreRecords(self): argument
1806 return self.more
1812 def __init__(self, name = "", where_clause = "", limit = ""): argument
1813 self.name = name
1814 self.where_clause = where_clause
1815 self.limit = limit
1817 def UniqueId(self): argument
1818 return str(self.where_clause + ";" + self.limit)
1824 def __init__(self, glb, event_id, report_vars, parent=None): argument
1825 super(BranchWindow, self).__init__(parent)
1829 …self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_cl…
1831 self.view = QTreeView()
1832 self.view.setUniformRowHeights(True)
1833 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
1834 self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
1835 self.view.setModel(self.model)
1837 self.ResizeColumnsToContents()
1839 self.context_menu = TreeContextMenu(self.view)
1841 self.find_bar = FindBar(self, self, True)
1843 self.finder = ChildDataItemFinder(self.model.root)
1845 self.fetch_bar = FetchMoreRecordsBar(self.model, self)
1847 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
1849 self.setWidget(self.vbox.Widget())
1851 AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
1853 def ResizeColumnToContents(self, column, n): argument
1857 font = self.view.font()
1861 val = self.model.root.child_items[row].data[column]
1864 val = self.model.columnHeader(column)
1867 self.view.setColumnWidth(column, max)
1869 def ResizeColumnsToContents(self): argument
1870 n = min(self.model.root.child_count, 100)
1873 self.model.rowsInserted.connect(self.UpdateColumnWidths)
1875 columns = self.model.columnCount()
1877 self.ResizeColumnToContents(i, n)
1879 def UpdateColumnWidths(self, *x): argument
1881 self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
1882 self.ResizeColumnsToContents()
1884 def Find(self, value, direction, pattern, context): argument
1885 self.view.setFocus()
1886 self.find_bar.Busy()
1887 self.finder.Find(value, direction, pattern, context, self.FindDone)
1889 def FindDone(self, row): argument
1890 self.find_bar.Idle()
1892 self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
1894 self.find_bar.NotFound()
1900 def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""): argument
1901 self.glb = glb
1902 self.label = label
1903 self.placeholder_text = placeholder_text
1904 self.parent = parent
1905 self.id = id
1907 self.value = default
1909 self.widget = QLineEdit(default)
1910 self.widget.editingFinished.connect(self.Validate)
1911 self.widget.textChanged.connect(self.Invalidate)
1912 self.red = False
1913 self.error = ""
1914 self.validated = True
1917 self.widget.setPlaceholderText(placeholder_text)
1919 def TurnTextRed(self): argument
1920 if not self.red:
1923 self.widget.setPalette(palette)
1924 self.red = True
1926 def TurnTextNormal(self): argument
1927 if self.red:
1929 self.widget.setPalette(palette)
1930 self.red = False
1932 def InvalidValue(self, value): argument
1933 self.value = ""
1934 self.TurnTextRed()
1935 self.error = self.label + " invalid value '" + value + "'"
1936 self.parent.ShowMessage(self.error)
1938 def Invalidate(self): argument
1939 self.validated = False
1941 def DoValidate(self, input_string): argument
1942 self.value = input_string.strip()
1944 def Validate(self): argument
1945 self.validated = True
1946 self.error = ""
1947 self.TurnTextNormal()
1948 self.parent.ClearMessage()
1949 input_string = self.widget.text()
1951 self.value = ""
1953 self.DoValidate(input_string)
1955 def IsValid(self): argument
1956 if not self.validated:
1957 self.Validate()
1958 if len(self.error):
1959 self.parent.ShowMessage(self.error)
1963 def IsNumber(self, value): argument
1974 def __init__(self, glb, label, placeholder_text, column_name, parent): argument
1975 super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
1977 self.column_name = column_name
1979 def DoValidate(self, input_string): argument
1985 if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
1986 return self.InvalidValue(value)
1989 if not self.IsNumber(value):
1990 return self.InvalidValue(value)
1992 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
1994 ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
1995 self.value = " OR ".join(ranges)
2001 def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""): argument
2002 super(PositiveIntegerDataItem, self).__init__(glb, label, placeholder_text, parent, id, default)
2004 def DoValidate(self, input_string): argument
2005 if not self.IsNumber(input_string.strip()):
2006 return self.InvalidValue(input_string)
2009 return self.InvalidValue(input_string)
2010 self.value = str(value)
2016 …def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_na… argument
2017 super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
2019 self.table_name = table_name
2020 self.match_column = match_column
2021 self.column_name1 = column_name1
2022 self.column_name2 = column_name2
2024 def ValueToIds(self, value): argument
2026 query = QSqlQuery(self.glb.db)
2027 stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
2034 def DoValidate(self, input_string): argument
2037 ids = self.ValueToIds(value)
2041 return self.InvalidValue(value)
2042 self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
2043 if self.column_name2:
2044 self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
2050 def __init__(self, glb, label, placeholder_text, column_name, parent): argument
2051 self.column_name = column_name
2053 self.last_id = 0
2054 self.first_time = 0
2055 self.last_time = 2 ** 64
2060 self.last_id = int(query.value(0))
2061 self.last_time = int(query.value(1))
2064 self.first_time = int(query.value(0))
2066 placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
2068 super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
2070 def IdBetween(self, query, lower_id, higher_id, order): argument
2077 def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor): argument
2078 query = QSqlQuery(self.glb.db)
2083 ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
2085 ok, dbid = self.IdBetween(query, next_id, higher_id, "")
2106 def ConvertRelativeTime(self, val): argument
2118 if not self.IsNumber(val):
2122 val += self.first_time
2124 val += self.last_time
2127 def ConvertTimeRange(self, vrange): argument
2129 vrange[0] = str(self.first_time)
2131 vrange[1] = str(self.last_time)
2132 vrange[0] = self.ConvertRelativeTime(vrange[0])
2133 vrange[1] = self.ConvertRelativeTime(vrange[1])
2134 if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
2136 beg_range = max(int(vrange[0]), self.first_time)
2137 end_range = min(int(vrange[1]), self.last_time)
2138 if beg_range > self.last_time or end_range < self.first_time:
2140 vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
2141 vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
2144 def AddTimeRange(self, value, ranges): argument
2157 if self.ConvertTimeRange(vrange):
2162 def DoValidate(self, input_string): argument
2165 if not self.AddTimeRange(value, ranges):
2166 return self.InvalidValue(value)
2167 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
2168 self.value = " OR ".join(ranges)
2174 def __init__(self, glb, title, items, partial, parent=None): argument
2175 super(ReportDialogBase, self).__init__(parent)
2177 self.glb = glb
2179 self.report_vars = ReportVars()
2181 self.setWindowTitle(title)
2182 self.setMinimumWidth(600)
2184 self.data_items = [x(glb, self) for x in items]
2186 self.partial = partial
2188 self.grid = QGridLayout()
2190 for row in xrange(len(self.data_items)):
2191 self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
2192 self.grid.addWidget(self.data_items[row].widget, row, 1)
2194 self.status = QLabel()
2196 self.ok_button = QPushButton("Ok", self)
2197 self.ok_button.setDefault(True)
2198 self.ok_button.released.connect(self.Ok)
2199 self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2201 self.cancel_button = QPushButton("Cancel", self)
2202 self.cancel_button.released.connect(self.reject)
2203 self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2205 self.hbox = QHBoxLayout()
2207 self.hbox.addWidget(self.status)
2208 self.hbox.addWidget(self.ok_button)
2209 self.hbox.addWidget(self.cancel_button)
2211 self.vbox = QVBoxLayout()
2212 self.vbox.addLayout(self.grid)
2213 self.vbox.addLayout(self.hbox)
2215 self.setLayout(self.vbox)
2217 def Ok(self): argument
2218 vars = self.report_vars
2219 for d in self.data_items:
2223 self.ShowMessage("Report name is required")
2225 for d in self.data_items:
2228 for d in self.data_items[1:]:
2236 if self.partial:
2240 self.accept()
2242 def ShowMessage(self, msg): argument
2243 self.status.setText("<font color=#FF0000>" + msg)
2245 def ClearMessage(self): argument
2246 self.status.setText("")
2252 def __init__(self, glb, parent=None): argument
2263 super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
2289 def __init__(self, row, data): argument
2290 self.row = row
2291 self.data = data
2293 def getData(self, column): argument
2294 return self.data[column]
2302 def __init__(self, glb, sql, column_headers, parent=None): argument
2303 super(SQLTableModel, self).__init__(parent)
2304 self.glb = glb
2305 self.more = True
2306 self.populated = 0
2307 self.column_headers = column_headers
2308 …self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), …
2309 self.fetcher.done.connect(self.Update)
2310 self.fetcher.Fetch(glb_chunk_sz)
2312 def DisplayData(self, item, index): argument
2313 self.FetchIfNeeded(item.row)
2316 def AddSample(self, data): argument
2317 child = SQLTableItem(self.populated, data)
2318 self.child_items.append(child)
2319 self.populated += 1
2321 def Update(self, fetched): argument
2323 self.more = False
2324 self.progress.emit(0)
2325 child_count = self.child_count
2326 count = self.populated - child_count
2329 self.beginInsertRows(parent, child_count, child_count + count - 1)
2330 self.insertRows(child_count, count, parent)
2331 self.child_count += count
2332 self.endInsertRows()
2333 self.progress.emit(self.child_count)
2335 def FetchMoreRecords(self, count): argument
2336 current = self.child_count
2337 if self.more:
2338 self.fetcher.Fetch(count)
2340 self.progress.emit(0)
2343 def HasMoreRecords(self): argument
2344 return self.more
2346 def columnCount(self, parent=None): argument
2347 return len(self.column_headers)
2349 def columnHeader(self, column): argument
2350 return self.column_headers[column]
2352 def SQLTableDataPrep(self, query, count): argument
2362 def __init__(self, glb, table_name, parent=None): argument
2388 self.SQLTableDataPrep = self.samples_view_DataPrep
2390 self.SQLTableDataPrep = self.samples_DataPrep
2391 super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
2393 def samples_view_DataPrep(self, query, count): argument
2402 def samples_DataPrep(self, query, count): argument
2416 def __init__(self, parent=None): argument
2417 super(ResizeColumnsToContentsBase, self).__init__(parent)
2419 def ResizeColumnToContents(self, column, n): argument
2422 font = self.view.font()
2426 val = self.data_model.child_items[row].data[column]
2429 val = self.data_model.columnHeader(column)
2432 self.view.setColumnWidth(column, max)
2434 def ResizeColumnsToContents(self): argument
2435 n = min(self.data_model.child_count, 100)
2438 self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
2440 columns = self.data_model.columnCount()
2442 self.ResizeColumnToContents(i, n)
2444 def UpdateColumnWidths(self, *x): argument
2446 self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
2447 self.ResizeColumnsToContents()
2654 def __init__(self, view): argument
2655 self.view = view
2656 self.view.setContextMenuPolicy(Qt.CustomContextMenu)
2657 self.view.customContextMenuRequested.connect(self.ShowContextMenu)
2659 def ShowContextMenu(self, pos): argument
2660 menu = QMenu(self.view)
2661 self.AddActions(menu)
2662 menu.exec_(self.view.mapToGlobal(pos))
2664 def AddCopy(self, menu): argument
2665 …ion("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
2666 …ction as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
2668 def AddActions(self, menu): argument
2669 self.AddCopy(menu)
2673 def __init__(self, view): argument
2674 super(TreeContextMenu, self).__init__(view)
2676 def AddActions(self, menu): argument
2677 i = self.view.currentIndex()
2680 …y "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
2681 self.AddCopy(menu)
2687 def __init__(self, glb, table_name, parent=None): argument
2688 super(TableWindow, self).__init__(parent)
2690 …self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_na…
2692 self.model = QSortFilterProxyModel()
2693 self.model.setSourceModel(self.data_model)
2695 self.view = QTableView()
2696 self.view.setModel(self.model)
2697 self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
2698 self.view.verticalHeader().setVisible(False)
2699 self.view.sortByColumn(-1, Qt.AscendingOrder)
2700 self.view.setSortingEnabled(True)
2701 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
2702 self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
2704 self.ResizeColumnsToContents()
2706 self.context_menu = ContextMenu(self.view)
2708 self.find_bar = FindBar(self, self, True)
2710 self.finder = ChildDataItemFinder(self.data_model)
2712 self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
2714 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
2716 self.setWidget(self.vbox.Widget())
2718 AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
2720 def Find(self, value, direction, pattern, context): argument
2721 self.view.setFocus()
2722 self.find_bar.Busy()
2723 self.finder.Find(value, direction, pattern, context, self.FindDone)
2725 def FindDone(self, row): argument
2726 self.find_bar.Idle()
2728 self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
2730 self.find_bar.NotFound()
2755 def __init__(self, glb, report_vars, parent=None): argument
2785 …self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLe…
2786 super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
2788 def columnAlignment(self, column): argument
2789 return self.alignment[column]
2795 def __init__(self, glb, parent=None): argument
2805 super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
2811 def __init__(self, glb, report_vars, parent=None): argument
2812 super(TopCallsWindow, self).__init__(parent)
2814 …self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(g…
2815 self.model = self.data_model
2817 self.view = QTableView()
2818 self.view.setModel(self.model)
2819 self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
2820 self.view.verticalHeader().setVisible(False)
2821 self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
2822 self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
2824 self.context_menu = ContextMenu(self.view)
2826 self.ResizeColumnsToContents()
2828 self.find_bar = FindBar(self, self, True)
2830 self.finder = ChildDataItemFinder(self.model)
2832 self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
2834 self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
2836 self.setWidget(self.vbox.Widget())
2838 AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
2840 def Find(self, value, direction, pattern, context): argument
2841 self.view.setFocus()
2842 self.find_bar.Busy()
2843 self.finder.Find(value, direction, pattern, context, self.FindDone)
2845 def FindDone(self, row): argument
2846 self.find_bar.Idle()
2848 self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
2850 self.find_bar.NotFound()
2891 def __init__(self, mdi_area, menu): argument
2892 self.mdi_area = mdi_area
2893 self.window_menu = menu.addMenu("&Windows")
2894 self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
2895 self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
2896 self.tile_windows = CreateTileWindowsAction(mdi_area)
2897 self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
2898 self.next_window = CreateNextWindowAction(mdi_area)
2899 self.previous_window = CreatePreviousWindowAction(mdi_area)
2900 self.window_menu.aboutToShow.connect(self.Update)
2902 def Update(self): argument
2903 self.window_menu.clear()
2904 sub_window_count = len(self.mdi_area.subWindowList())
2906 self.close_active_window.setEnabled(have_sub_windows)
2907 self.close_all_windows.setEnabled(have_sub_windows)
2908 self.tile_windows.setEnabled(have_sub_windows)
2909 self.cascade_windows.setEnabled(have_sub_windows)
2910 self.next_window.setEnabled(have_sub_windows)
2911 self.previous_window.setEnabled(have_sub_windows)
2912 self.window_menu.addAction(self.close_active_window)
2913 self.window_menu.addAction(self.close_all_windows)
2914 self.window_menu.addSeparator()
2915 self.window_menu.addAction(self.tile_windows)
2916 self.window_menu.addAction(self.cascade_windows)
2917 self.window_menu.addSeparator()
2918 self.window_menu.addAction(self.next_window)
2919 self.window_menu.addAction(self.previous_window)
2922 self.window_menu.addSeparator()
2924 for sub_window in self.mdi_area.subWindowList():
2928 action = self.window_menu.addAction(label)
2930 action.setChecked(sub_window == self.mdi_area.activeSubWindow())
2931 action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
2932 self.window_menu.addAction(action)
2935 def setActiveSubWindow(self, nr): argument
2936 self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
3065 def __init__(self, glb, parent=None): argument
3066 super(HelpWindow, self).__init__(parent)
3068 self.text = QTextBrowser()
3069 self.text.setHtml(glb_help_text)
3070 self.text.setReadOnly(True)
3071 self.text.setOpenExternalLinks(True)
3073 self.setWidget(self.text)
3075 AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
3081 def __init__(self, parent=None): argument
3082 super(HelpOnlyWindow, self).__init__(parent)
3084 self.setMinimumSize(200, 100)
3085 self.resize(800, 600)
3086 self.setWindowTitle("Exported SQL Viewer Help")
3087 self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
3089 self.text = QTextBrowser()
3090 self.text.setHtml(glb_help_text)
3091 self.text.setReadOnly(True)
3092 self.text.setOpenExternalLinks(True)
3094 self.setCentralWidget(self.text)
3122 def __init__(self, glb, parent=None): argument
3123 super(AboutDialog, self).__init__(parent)
3125 self.setWindowTitle("About Exported SQL Viewer")
3126 self.setMinimumWidth(300)
3140 self.text = QTextBrowser()
3141 self.text.setHtml(text)
3142 self.text.setReadOnly(True)
3143 self.text.setOpenExternalLinks(True)
3145 self.vbox = QVBoxLayout()
3146 self.vbox.addWidget(self.text)
3148 self.setLayout(self.vbox)
3201 def __init__(self, glb, parent=None): argument
3202 super(MainWindow, self).__init__(parent)
3204 self.glb = glb
3206 self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
3207 self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
3208 self.setMinimumSize(200, 100)
3210 self.mdi_area = QMdiArea()
3211 self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
3212 self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
3214 self.setCentralWidget(self.mdi_area)
3216 menu = self.menuBar()
3219 file_menu.addAction(CreateExitAction(glb.app, self))
3222 …edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySeq…
3223 ….addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
3224 edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
3225 …n(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeyS…
3226 …edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKey…
3227 …edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKe…
3231 …&Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
3234 …n(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
3236 self.EventMenu(GetEventList(glb.db), reports_menu)
3239 …elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
3241 self.TableMenu(GetTableList(glb), menu)
3243 self.window_menu = WindowMenu(self.mdi_area, menu)
3246 …ion(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence…
3247 …u.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
3249 def Try(self, fn): argument
3250 win = self.mdi_area.activeSubWindow()
3257 def CopyToClipboard(self): argument
3258 self.Try(CopyCellsToClipboardHdr)
3260 def CopyToClipboardCSV(self): argument
3261 self.Try(CopyCellsToClipboardCSV)
3263 def Find(self): argument
3264 win = self.mdi_area.activeSubWindow()
3271 def FetchMoreRecords(self): argument
3272 win = self.mdi_area.activeSubWindow()
3279 def ShrinkFont(self): argument
3280 self.Try(ShrinkFont)
3282 def EnlargeFont(self): argument
3283 self.Try(EnlargeFont)
3285 def EventMenu(self, events, reports_menu): argument
3297 …"Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
3299 …a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
3301 def TableMenu(self, tables, menu): argument
3304 … "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
3306 def NewCallGraph(self): argument
3307 CallGraphWindow(self.glb, self)
3309 def NewCallTree(self): argument
3310 CallTreeWindow(self.glb, self)
3312 def NewTopCalls(self): argument
3313 dialog = TopCallsDialog(self.glb, self)
3316 TopCallsWindow(self.glb, dialog.report_vars, self)
3318 def NewBranchView(self, event_id): argument
3319 BranchWindow(self.glb, event_id, ReportVars(), self)
3321 def NewSelectedBranchView(self, event_id): argument
3322 dialog = SelectedBranchDialog(self.glb, self)
3325 BranchWindow(self.glb, event_id, dialog.report_vars, self)
3327 def NewTableView(self, table_name): argument
3328 TableWindow(self.glb, table_name, self)
3330 def Help(self): argument
3331 HelpWindow(self.glb, self)
3333 def About(self): argument
3334 dialog = AboutDialog(self.glb, self)
3348 def __init__(self, libxed): argument
3351 self.xedd = xedd_t()
3352 self.xedp = addressof(self.xedd)
3353 libxed.xed_decoded_inst_zero(self.xedp)
3354 self.state = xed_state_t()
3355 self.statep = addressof(self.state)
3357 self.buffer = create_string_buffer(256)
3358 self.bufferp = addressof(self.buffer)
3362 def __init__(self): argument
3364 self.libxed = CDLL("libxed.so")
3366 self.libxed = None
3367 if not self.libxed:
3368 self.libxed = CDLL("/usr/local/lib/libxed.so")
3370 self.xed_tables_init = self.libxed.xed_tables_init
3371 self.xed_tables_init.restype = None
3372 self.xed_tables_init.argtypes = []
3374 self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero
3375 self.xed_decoded_inst_zero.restype = None
3376 self.xed_decoded_inst_zero.argtypes = [ c_void_p ]
3378 self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode
3379 self.xed_operand_values_set_mode.restype = None
3380 self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ]
3382 self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode
3383 self.xed_decoded_inst_zero_keep_mode.restype = None
3384 self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ]
3386 self.xed_decode = self.libxed.xed_decode
3387 self.xed_decode.restype = c_int
3388 self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ]
3390 self.xed_format_context = self.libxed.xed_format_context
3391 self.xed_format_context.restype = c_uint
3392 …self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_vo…
3394 self.xed_tables_init()
3396 def Instruction(self): argument
3397 return XEDInstruction(self)
3399 def SetMode(self, inst, mode): argument
3406 self.xed_operand_values_set_mode(inst.xedp, inst.statep)
3408 def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip): argument
3409 self.xed_decoded_inst_zero_keep_mode(inst.xedp)
3410 err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt)
3414 ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0)
3455 def __init__(self, dbref, db, dbname): argument
3456 self.dbref = dbref
3457 self.db = db
3458 self.dbname = dbname
3459 self.home_dir = os.path.expanduser("~")
3460 self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
3461 if self.buildid_dir:
3462 self.buildid_dir += "/.build-id/"
3464 self.buildid_dir = self.home_dir + "/.debug/.build-id/"
3465 self.app = None
3466 self.mainwindow = None
3467 self.instances_to_shutdown_on_exit = weakref.WeakSet()
3469 self.disassembler = LibXED()
3470 self.have_disassembler = True
3472 self.have_disassembler = False
3474 def FileFromBuildId(self, build_id): argument
3475 file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
3478 def FileFromNamesAndBuildId(self, short_name, long_name, build_id): argument
3489 f = self.FileFromBuildId(build_id)
3494 def AddInstanceToShutdownOnExit(self, instance): argument
3495 self.instances_to_shutdown_on_exit.add(instance)
3498 def ShutdownInstances(self): argument
3499 for x in self.instances_to_shutdown_on_exit:
3509 def __init__(self, is_sqlite3, dbname): argument
3510 self.is_sqlite3 = is_sqlite3
3511 self.dbname = dbname
3512 self.TRUE = "TRUE"
3513 self.FALSE = "FALSE"
3515 if self.is_sqlite3:
3516 self.TRUE = "1"
3517 self.FALSE = "0"
3519 def Open(self, connection_name): argument
3520 dbname = self.dbname
3521 if self.is_sqlite3: