--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi.address/src/com/nokia/carbide/cpp/pi/address/AddrFunctionTable.java Thu Feb 11 15:32:31 2010 +0200
@@ -0,0 +1,2390 @@
+/*
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of the License "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+package com.nokia.carbide.cpp.pi.address;
+
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
+import java.awt.event.FocusEvent;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
+import org.eclipse.jface.viewers.CheckStateChangedEvent;
+import org.eclipse.jface.viewers.CheckboxTableViewer;
+import org.eclipse.jface.viewers.ICheckStateListener;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredContentProvider;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.FormAttachment;
+import org.eclipse.swt.layout.FormData;
+import org.eclipse.swt.layout.FormLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Decorations;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.MenuItem;
+import org.eclipse.swt.widgets.Sash;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.TableItem;
+
+import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;
+import com.nokia.carbide.cpp.internal.pi.analyser.ProfileVisualiser;
+import com.nokia.carbide.cpp.internal.pi.model.ProfiledBinary;
+import com.nokia.carbide.cpp.internal.pi.model.ProfiledFunction;
+import com.nokia.carbide.cpp.internal.pi.model.ProfiledGeneric;
+import com.nokia.carbide.cpp.internal.pi.model.ProfiledThread;
+import com.nokia.carbide.cpp.internal.pi.model.ProfiledThreshold;
+import com.nokia.carbide.cpp.internal.pi.visual.Defines;
+import com.nokia.carbide.cpp.internal.pi.visual.PIEvent;
+import com.nokia.carbide.cpp.internal.pi.visual.PIVisualSharedData;
+import com.nokia.carbide.cpp.pi.editors.PIPageEditor;
+import com.nokia.carbide.cpp.pi.util.SourceLookup;
+import com.nokia.carbide.cpp.pi.util.TableColorPalette;
+
+
+public class AddrFunctionTable extends GenericAddrTable
+{
+ // local copy of profiled binaries, which we can sort
+ // without affecting the original
+ Vector<ProfiledGeneric> profiledFunctions = new Vector<ProfiledGeneric>();
+
+ public AddrFunctionTable(GppTraceGraph myGraph, Composite parent)
+ {
+ this.myGraph = myGraph;
+ this.parent = parent;
+ }
+
+ public void createTableViewer(int drawMode)
+ {
+ if (this.parent == null)
+ return;
+
+ // Function table:
+ // checkbox + colored or white background
+ // percent load
+ // function name
+ // function start address
+ // binary containing function
+ // path of binary containing function
+ // sample count
+
+ // Check the drawMode, and use it to decide whether or not to show a color column
+ // or the number of samples
+ switch (drawMode)
+ {
+ case Defines.FUNCTIONS:
+ case Defines.THREADS_BINARIES_FUNCTIONS:
+ case Defines.BINARIES_FUNCTIONS:
+ case Defines.THREADS_FUNCTIONS:
+ case Defines.BINARIES_THREADS_FUNCTIONS:
+ case Defines.THREADS_FUNCTIONS_BINARIES:
+ case Defines.BINARIES_FUNCTIONS_THREADS:
+ case Defines.FUNCTIONS_THREADS:
+ case Defines.FUNCTIONS_THREADS_BINARIES:
+ case Defines.FUNCTIONS_BINARIES:
+ case Defines.FUNCTIONS_BINARIES_THREADS:
+ {
+ break;
+ }
+ default:
+ // no function table in this draw mode
+ return;
+ }
+
+ // create the table viewer
+ this.tableViewer = CheckboxTableViewer.newCheckList(this.parent,
+ SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
+
+ // add the check state handler, label provider and content provider
+ tableViewer.addCheckStateListener(new SharedCheckHandler());
+ tableViewer.setLabelProvider(new shownFunctionsLabelProvider());
+ tableViewer.setContentProvider(new shownFunctionsContentProvider());
+ tableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
+ public void selectionChanged(SelectionChangedEvent arg0) {
+ if (copyAction == null)
+ return;
+
+ // when selection changes, the ability to copy may change
+ copyAction.setEnabled(table.getSelectionCount() > 0);
+ PIPageEditor.getActionBars().updateActionBars();
+ }
+ });
+
+ createDefaultActions();
+
+ // make sure the table viewer has a sorter
+ if (this.sorter == null)
+ this.sorter = new GppTableSorter();
+
+ this.table = tableViewer.getTable();
+ this.table.setRedraw(false);
+
+ // give the table a heading for use in copying and exported
+ this.table.setData(Messages.getString("AddrFunctionTable.functions")); //$NON-NLS-1$
+
+ // create the columns
+ TableColumn column;
+
+ // data associated with the TableViewer will note which columns contain hex values
+ // Keep this in the order in which columns have been created
+ boolean[] isHex = {false, false, false, true, false, false, false};
+ this.table.setData("isHex", isHex); //$NON-NLS-1$
+
+ // select/deselect column
+ column = new TableColumn(table, SWT.CENTER);
+ column.setText(COLUMN_HEAD_SHOW);
+ column.setWidth(COLUMN_WIDTH_SHOW);
+ column.setData(new Integer(COLUMN_ID_SHOW));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // percent load column
+ column = new TableColumn(table, SWT.RIGHT);
+ column.setText(COLUMN_HEAD_PERCENT_LOAD);
+ column.setWidth(COLUMN_WIDTH_PERCENT_LOAD);
+ column.setData(new Integer(COLUMN_ID_PERCENT_LOAD));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // function name column
+ column = new TableColumn(table, SWT.LEFT);
+ column.setText(COLUMN_HEAD_FUNCTION);
+ column.setWidth(COLUMN_WIDTH_FUNCTION_NAME);
+ column.setData(new Integer(COLUMN_ID_FUNCTION));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // function start address column
+ column = new TableColumn(table, SWT.CENTER);
+ column.setText(COLUMN_HEAD_START_ADDR);
+ column.setWidth(COLUMN_WIDTH_START_ADDRESS);
+ column.setData(new Integer(COLUMN_ID_START_ADDR));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // binary containing function column
+ column = new TableColumn(table, SWT.LEFT);
+ column.setText(COLUMN_HEAD_IN_BINARY);
+ column.setWidth(COLUMN_WIDTH_IN_BINARY);
+ column.setData(new Integer(COLUMN_ID_IN_BINARY));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // path to binary containing function column
+ column = new TableColumn(table, SWT.LEFT);
+ column.setText(COLUMN_HEAD_IN_BINARY_PATH);
+ column.setWidth(COLUMN_WIDTH_IN_BINARY_PATH);
+ column.setData(new Integer(COLUMN_ID_IN_BINARY_PATH));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // sample count column
+ column = new TableColumn(table, SWT.CENTER);
+ column.setText(COLUMN_HEAD_SAMPLE_COUNT);
+ column.setWidth(COLUMN_WIDTH_SAMPLE_COUNT);
+ column.setData(new Integer(COLUMN_ID_SAMPLE_COUNT));
+ column.setMoveable(true);
+ column.setResizable(true);
+ column.addSelectionListener(new ColumnSelectionHandler());
+
+ // listen for mouse clicks: to select a row, pop up a menu, etc.
+ table.addMouseListener(new TableMouseListener());
+
+ // listen for key sequences such as Ctrl-A and Ctrl-C
+ table.addKeyListener(new TableKeyListener());
+
+ table.addFocusListener(new AddrTableFocusListener());
+
+ // add form data in case later we add a sash to the right
+ FormData viewerData = new FormData();
+ viewerData.top = new FormAttachment(0);
+ viewerData.bottom = new FormAttachment(100);
+ viewerData.left = new FormAttachment(0);
+ viewerData.right = new FormAttachment(100);
+ table.setLayoutData(viewerData);
+ table.setLayout(new FormLayout());
+
+ table.setHeaderVisible(true);
+ table.setLinesVisible(true);
+ table.setRedraw(true);
+ }
+
+ public void setTableViewer(CheckboxTableViewer tableViewer)
+ {
+ this.tableViewer = tableViewer;
+
+ if (tableViewer == null)
+ this.table = null;
+ }
+
+ public void setTableViewer(int drawMode)
+ {
+ if (this.parent == null)
+ return;
+
+ createTableViewer(drawMode);
+
+ // sort by sample count
+ this.sortColumn = COLUMN_ID_SAMPLE_COUNT;
+ this.sortAscending = false;
+
+ // profiledFunctions and tableItemData contain one entry per table row
+ updateProfiledAndItemData(false);
+ quickSort(sortColumn, profiledFunctions);
+
+ // initially, all rows are selected
+ this.tableViewer.setAllChecked(true);
+ }
+
+ public void refreshTableViewer()
+ {
+ if (this.tableViewer == null)
+ return;
+
+ this.tableViewer.setInput(tableItemData);
+
+ addColor(this.myGraph.getDrawMode());
+ }
+
+ public void addColor(int drawMode)
+ {
+ if (this.tableViewer == null)
+ return;
+
+ // make sure that this table's colors are being shown
+ if ( (drawMode != Defines.FUNCTIONS)
+ && (drawMode != Defines.THREADS_FUNCTIONS)
+ && (drawMode != Defines.THREADS_BINARIES_FUNCTIONS)
+ && (drawMode != Defines.BINARIES_FUNCTIONS)
+ && (drawMode != Defines.BINARIES_THREADS_FUNCTIONS))
+ return;
+
+ ProfiledGeneric pGeneric;
+
+ TableItem[] items = this.table.getItems();
+
+ for (int i = 0; i < items.length; i++) {
+ pGeneric = (ProfiledGeneric) items[i].getData();
+// Color color = ((GppTrace)this.myGraph.getTrace()).getFunctionColorPalette().getColor(pGeneric.getNameString());
+ items[i].setBackground(COLOR_COLUMN_INDEX, pGeneric.getColor());
+ }
+
+ table.redraw();
+ }
+
+ public void removeColor(int drawMode)
+ {
+ if (this.tableViewer == null)
+ return;
+
+ // make sure that this table's colors should not be shown
+ if ( (drawMode == Defines.FUNCTIONS)
+ || (drawMode == Defines.THREADS_FUNCTIONS)
+ || (drawMode == Defines.THREADS_BINARIES_FUNCTIONS)
+ || (drawMode == Defines.BINARIES_FUNCTIONS)
+ || (drawMode == Defines.BINARIES_THREADS_FUNCTIONS))
+ return;
+
+ TableItem[] items = this.table.getItems();
+
+ for (int i = 0; i < items.length; i++) {
+ items[i].setBackground(COLOR_COLUMN_INDEX, this.parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));
+ }
+
+ table.redraw();
+ }
+
+ private static class shownFunctionsContentProvider implements IStructuredContentProvider {
+
+ public shownFunctionsContentProvider() {
+ super();
+ }
+
+ public Object[] getElements(Object inputElement) {
+ return ((Vector) inputElement).toArray();
+ }
+
+ public void dispose() {
+ }
+
+ public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
+ }
+ }
+
+ private class shownFunctionsLabelProvider extends LabelProvider implements ITableLabelProvider {
+
+ public shownFunctionsLabelProvider() {
+ super();
+ }
+
+ public String getColumnText(Object element, int columnIndex) {
+ int columnId = ((Integer) table.getColumn(columnIndex).getData()).intValue();
+
+ if (element instanceof ProfiledThreshold) {
+ ProfiledThreshold pThreshold = (ProfiledThreshold) element;
+ switch (columnId)
+ {
+ case COLUMN_ID_SHOW:
+ {
+ return SHOW_ITEM_VALUE;
+ }
+ case COLUMN_ID_PERCENT_LOAD:
+ {
+ // Percent load string
+ double startTime = PIPageEditor.currentPageEditor().getStartTime();
+ double endTime = PIPageEditor.currentPageEditor().getEndTime();
+ if ( (startTime == -1)
+ || (endTime == -1)
+ || (startTime == endTime)) {
+ pThreshold.setAverageLoadValueString(myGraph.getGraphIndex(), ""); //$NON-NLS-1$
+ } else {
+ float load = (float) (pThreshold.getSampleCount(myGraph.getGraphIndex())/(endTime - startTime)/10.0);
+
+ if (load < 0.005)
+ pThreshold.setAverageLoadValueString(myGraph.getGraphIndex(), Messages.getString("AddrFunctionTable.zeroFormat")); //$NON-NLS-1$
+ else
+ pThreshold.setAverageLoadValueString(myGraph.getGraphIndex(), load);
+ }
+ return pThreshold.getAverageLoadValueString(myGraph.getGraphIndex());
+ }
+ case COLUMN_ID_FUNCTION:
+ {
+ DecimalFormat timeFormat = new DecimalFormat(Messages.getString("AddrFunctionTable.decimalFormat")); //$NON-NLS-1$
+ int count = pThreshold.getItemCount(myGraph.getGraphIndex());
+
+ return count + (count > 1 ? Messages.getString("AddrFunctionTable.threshold1") : Messages.getString("AddrFunctionTable.threshold2")) //$NON-NLS-1$ //$NON-NLS-2$
+ + timeFormat.format((Double)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdLoadThread") * 100.0) + Messages.getString("AddrFunctionTable.threshold3") //$NON-NLS-1$ //$NON-NLS-2$
+ + (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction") + Messages.getString("AddrFunctionTable.threshold4"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+ case COLUMN_ID_SAMPLE_COUNT:
+ {
+ // Sample count
+ return String.valueOf(pThreshold.getSampleCount(myGraph.getGraphIndex()));
+ }
+ default:
+ {
+ return ""; //$NON-NLS-1$
+ }
+ }
+ }
+
+ if (!(element instanceof ProfiledFunction))
+ return ""; //$NON-NLS-1$
+
+ ProfiledFunction profiledItem = (ProfiledFunction) element;
+
+ switch (columnId)
+ {
+ case COLUMN_ID_SHOW:
+ {
+ return SHOW_ITEM_VALUE;
+ }
+ case COLUMN_ID_PERCENT_LOAD:
+ {
+ // Percent load string
+ return profiledItem.getAverageLoadValueString(myGraph.getGraphIndex());
+ }
+ case COLUMN_ID_FUNCTION:
+ {
+ // Function
+ return (profiledItem.getNameString());
+ }
+ case COLUMN_ID_START_ADDR:
+ {
+ // Function start
+ return (Long.toHexString(profiledItem.getFunctionAddress()));
+ }
+ case COLUMN_ID_IN_BINARY:
+ {
+ // Binary
+ String binary = profiledItem.getFunctionBinaryName();
+ int index = binary.lastIndexOf('\\');
+ if (index == -1)
+ return binary;
+ else
+ return binary.substring(index + 1);
+ }
+ case COLUMN_ID_IN_BINARY_PATH:
+ {
+ // Path
+ String binary = profiledItem.getFunctionBinaryName();
+ int index = binary.lastIndexOf('\\');
+ if (index == -1)
+ return ""; //$NON-NLS-1$
+ else
+ return binary.substring(0, index);
+ }
+ case COLUMN_ID_SAMPLE_COUNT:
+ {
+ // Sample count
+ return String.valueOf(profiledItem.getSampleCount(myGraph.getGraphIndex()));
+ }
+ default:
+ {
+ break;
+ }
+ }
+ // should never get here
+ return ""; //$NON-NLS-1$
+ }
+
+ public Image getColumnImage(Object element, int columnIndex) {
+ return null;
+ }
+ }
+
+ public void action(String actionString)
+ {
+ int graphIndex = this.myGraph.getGraphIndex();
+
+ if ( actionString.equals("add") //$NON-NLS-1$
+ || actionString.equals("remove")) //$NON-NLS-1$
+ {
+ actionAddRemove(actionString, graphIndex);
+ return;
+ }
+ else if ( actionString.equals("addall") //$NON-NLS-1$
+ || actionString.equals("removeall")) //$NON-NLS-1$
+ {
+ actionAddRemoveAll(actionString, graphIndex);
+ return;
+ }
+ else if (actionString.equals("recolor")) //$NON-NLS-1$
+ {
+ actionRecolor();
+ return;
+ }
+ else if (actionString.equals("copy")) //$NON-NLS-1$
+ {
+ actionCopyOrSave(true, this.table, CHECKBOX_NO_TEXT, false, "\t", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+ return;
+ }
+ else if (actionString.equals("copyTable")) //$NON-NLS-1$
+ {
+ actionCopyOrSave(true, this.table, CHECKBOX_NO_TEXT, true, "\t", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+ return;
+ }
+ else if (actionString.equals("copyDrilldown")) //$NON-NLS-1$
+ {
+ actionCopyOrSaveDrilldown(true, "\t"); //$NON-NLS-1$
+ return;
+ }
+ else if (actionString.equals("saveTable")) //$NON-NLS-1$
+ {
+ actionCopyOrSave(false, this.table, CHECKBOX_NO_TEXT, true, ",", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+ return;
+ }
+ else if (actionString.equals("saveDrilldown")) //$NON-NLS-1$
+ {
+ actionCopyOrSaveDrilldown(false, ","); //$NON-NLS-1$
+ return;
+ }
+ else if (actionString.equals("saveSamples")) //$NON-NLS-1$
+ {
+ SaveSampleString saveSampleString = new SaveSampleString(graphIndex, myGraph.getDrawMode());
+ actionSaveSamples(saveSampleString); //$NON-NLS-1$
+ return;
+ }
+ else if (actionString.equals("selectAll")) //$NON-NLS-1$
+ {
+ actionSelectAll();
+ return;
+ }
+ else if (actionString.equals("doubleClick")) //$NON-NLS-1$
+ {
+ copyAction.setEnabled(false);
+ PIPageEditor.getActionBars().updateActionBars();
+ return;
+ }
+ else if (actionString.equals("sortinfullpath")) //$NON-NLS-1$
+ {
+ if (this.sortColumn == COLUMN_ID_FULL_IN_PATH)
+ // sort in other order
+ sortAscending = !sortAscending;
+ else
+ // sort in ascending order
+ sortAscending = true;
+ sortColumn = COLUMN_ID_FULL_IN_PATH;
+ quickSort(sortColumn, profiledFunctions);
+ }
+ else if (actionString.equals("function-only")) //$NON-NLS-1$
+ {
+ actionFunction();
+ return;
+ }
+ else if (actionString.equals("function-thread")) //$NON-NLS-1$
+ {
+ actionFunctionThread();
+ return;
+ }
+ else if (actionString.equals("function-thread-binary")) //$NON-NLS-1$
+ {
+ actionFunctionThreadBinary();
+ return;
+ }
+ else if (actionString.equals("function-binary")) //$NON-NLS-1$
+ {
+ actionFunctionBinary();
+ return;
+ }
+ else if (actionString.equals("function-binary-thread")) //$NON-NLS-1$
+ {
+ actionFunctionBinaryThread();
+ return;
+ }
+ else if ( (actionString.equals("thread-only")) //$NON-NLS-1$
+ || (actionString.equals("thread-binary")) //$NON-NLS-1$
+ || (actionString.equals("thread-binary-function")) //$NON-NLS-1$
+ || (actionString.equals("thread-function")) //$NON-NLS-1$
+ || (actionString.equals("thread-function-binary"))) //$NON-NLS-1$
+ {
+ // let the thread page action handler handle it
+ this.myGraph.getThreadTable().action(actionString);
+ return;
+ }
+ else if ( (actionString.equals("binary-only")) //$NON-NLS-1$
+ || (actionString.equals("binary-thread")) //$NON-NLS-1$
+ || (actionString.equals("binary-thread-function")) //$NON-NLS-1$
+ || (actionString.equals("binary-function")) //$NON-NLS-1$
+ || (actionString.equals("binary-function-thread"))) //$NON-NLS-1$
+ {
+ // let the binary page action handler handle it
+ this.myGraph.getBinaryTable().action(actionString);
+ return;
+ }
+ else if (actionString.equals("changeThresholdFunction")) //$NON-NLS-1$
+ {
+ ProfiledThreshold threshold = this.myGraph.getThresholdFunction();
+ boolean enabled = threshold.isEnabled(graphIndex);
+
+ this.tableItemData.clear();
+ this.profiledFunctions.clear();
+ this.myGraph.getSortedFunctions().clear();
+ if (threshold.getItems(graphIndex) != null)
+ threshold.getItems(graphIndex).clear();
+ threshold.initAll();
+
+ // if this appears, it needs to be the first item, so that it is drawn at the bottom
+ myGraph.getSortedFunctions().add(threshold);
+
+ int functionThreshold = (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$
+ for (int i = 0; i < this.myGraph.getGppTrace().getSortedFunctions().size(); i++) {
+ ProfiledGeneric nextElement = (ProfiledGeneric)this.myGraph.getGppTrace().getSortedFunctions().get(i);
+ if (nextElement.getTotalSampleCount() < functionThreshold) {
+ nextElement.setEnabled(graphIndex, enabled);
+ threshold.addItem(graphIndex, nextElement, 0);
+ } else {
+ tableItemData.add(nextElement);
+ profiledFunctions.add(nextElement);
+ myGraph.getSortedFunctions().add(nextElement);
+ }
+ }
+
+ if (threshold.getItemCount(graphIndex) != 0) {
+ tableItemData.add(threshold);
+ profiledFunctions.add(threshold);
+ } else {
+ // remove the threshold item
+ myGraph.getSortedFunctions().remove(0);
+ }
+
+ refreshTableViewer();
+ threshold.setEnabled(graphIndex, enabled);
+
+ // make sure that checkboxes shown reflect the actual enabled values
+ TableItem[] tableItems = this.table.getItems();
+ for (int i = 0; i < tableItems.length; i++) {
+ if (tableItems[i].getData() instanceof ProfiledGeneric) {
+ ProfiledGeneric pGeneric = (ProfiledGeneric) tableItems[i].getData();
+ if (tableItems[i].getChecked() != pGeneric.isEnabled(graphIndex))
+ tableItems[i].setChecked(pGeneric.isEnabled(graphIndex));
+ }
+ }
+
+ this.myGraph.genericRefreshCumulativeThreadTable();
+ }
+ else if (actionString.equals("sourceLookup")) //$NON-NLS-1$
+ {
+ actionSourceLookup();
+ return;
+ }
+ else if (actionString.equals("saveTableTest")) //$NON-NLS-1$
+ {
+ // copy save file contents to the clipboard for easy viewing
+ Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
+ SaveTableString getString = new SaveTableString(this.table, CHECKBOX_NO_TEXT, Messages.getString("AddrFunctionTable.comma"), "\n"); //$NON-NLS-1$ //$NON-NLS-2$
+ String copyString = getString.getData();
+ StringSelection contents = new StringSelection(copyString);
+ cb.setContents(contents, contents);
+ return;
+ }
+ else if (actionString.equals("saveDrilldownTest")) //$NON-NLS-1$
+ {
+ // copy save file contents to the clipboard for easy viewing
+ Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
+ Table[] tables = getDrillDownTables();
+
+ int tableCount = 0;
+ while (tableCount < tables.length && tables[tableCount] != null)
+ tableCount++;
+
+ SaveDrillDownString getString = new SaveDrillDownString(tableCount, tables, Messages.getString("AddrFunctionTable.comma")); //$NON-NLS-1$
+ String copyString = getString.getData();
+ StringSelection contents = new StringSelection(copyString);
+ cb.setContents(contents, contents);
+ return;
+ }
+ }
+
+ private void actionAddRemove(String actionString, int graphIndex)
+ {
+ ProfiledGeneric pGeneric;
+ int totalSamples = 0;
+
+ // true for "add", false for "remove"
+ boolean addIt = actionString.equals("add"); //$NON-NLS-1$
+
+ TableItem[] selectedItems = this.table.getSelection();
+ for (int i = 0; i < selectedItems.length; i++)
+ {
+ selectedItems[i].setChecked(addIt);
+ Object item = ((TableItem)selectedItems[i]).getData();
+ if (item instanceof ProfiledGeneric)
+ {
+ pGeneric = (ProfiledGeneric)item;
+ pGeneric.setEnabled(graphIndex, addIt);
+ totalSamples += pGeneric.getSampleCount(graphIndex);
+
+ if (item instanceof ProfiledThreshold)
+ {
+ ProfiledThreshold pThreshold = (ProfiledThreshold)item;
+ ArrayList<ProfiledGeneric> items = pThreshold.getItems(graphIndex);
+ for (int j = 0; j < items.size(); j++)
+ items.get(j).setEnabled(graphIndex, addIt);
+ }
+ }
+ }
+
+ // this table's set of checkbox-selected rows has changed,
+ // so propagate that information
+ Object[] selectedValues = this.tableViewer.getCheckedElements();
+ String[] nameList = new String[selectedValues.length];
+
+ for (int i = 0; i < selectedValues.length; i++)
+ {
+ if (selectedValues[i] instanceof ProfiledGeneric)
+ {
+ pGeneric = (ProfiledGeneric)selectedValues[i];
+ nameList[i] = pGeneric.getNameString();
+ }
+ }
+
+ PIVisualSharedData shared = myGraph.getSharedDataInstance();
+ shared.GPP_SelectedFunctionNames = nameList;
+
+ if ( (totalSamples != 0)
+ || (myGraph.getDrawMode() == Defines.FUNCTIONS))
+ selectionChangeNotify();
+
+ this.table.deselectAll();
+ }
+
+ private void actionAddRemoveAll(String actionString, int graphIndex)
+ {
+ ProfiledGeneric pGeneric;
+
+ // true for "add", false for "remove"
+ boolean addIt = actionString.equals("addall"); //$NON-NLS-1$
+
+ TableItem[] selectedItems = this.table.getItems();
+ String[] nameList = new String[selectedItems.length];
+ for (int i = 0; i < selectedItems.length; i++)
+ {
+ selectedItems[i].setChecked(addIt);
+ Object item = ((TableItem)selectedItems[i]).getData();
+ if (item instanceof ProfiledGeneric)
+ {
+ pGeneric = (ProfiledGeneric)item;
+ pGeneric.setEnabled(graphIndex, addIt);
+ nameList[i] = pGeneric.getNameString();
+
+ if (item instanceof ProfiledThreshold)
+ {
+ ProfiledThreshold pThreshold = (ProfiledThreshold)item;
+ ArrayList<ProfiledGeneric> items = pThreshold.getItems(graphIndex);
+ for (int j = 0; j < items.size(); j++)
+ items.get(j).setEnabled(graphIndex, addIt);
+ }
+ }
+ }
+
+ // this table's set of checkbox-selected rows has changed,
+ // so propagate that information
+ PIVisualSharedData shared = myGraph.getSharedDataInstance();
+ shared.GPP_SelectedFunctionNames = nameList;
+
+ selectionChangeNotify();
+ this.table.deselectAll();
+ }
+
+ private void actionRecolor()
+ {
+ int uid = this.myGraph.getUid();
+ GppTrace gppTrace = this.myGraph.getGppTrace();
+
+ // recolor selected items
+ boolean didRecolor = false;
+
+ TableItem[] selectedItems = table.getSelection();
+ TableColorPalette palette = ((GppTrace)this.myGraph.getTrace()).getFunctionColorPalette();
+ for (int i = 0; i < selectedItems.length;i++)
+ {
+ if (selectedItems[i].getData() instanceof ProfiledGeneric)
+ {
+ ProfiledGeneric pGeneric = (ProfiledGeneric)selectedItems[i].getData();
+ String nameKey = pGeneric.getNameString();
+ if (palette.recolorEntryDialog(table.getShell(), nameKey))
+ {
+ Color color = palette.getColor(nameKey);
+ Color oldColor = pGeneric.getColor();
+
+ if (color.equals(oldColor))
+ continue;
+
+ didRecolor = true;
+
+ if (!(pGeneric instanceof ProfiledThreshold)){
+ PIPageEditor.currentPageEditor().setDirty();
+ pGeneric.setColor(color);
+ }
+ else {
+ // for the threshold item, we must change every graph's function threshold item
+ gppTrace.getGppGraph(PIPageEditor.THREADS_PAGE, uid).getThresholdFunction().setColor(color);
+ gppTrace.getGppGraph(PIPageEditor.BINARIES_PAGE, uid).getThresholdFunction().setColor(color);
+ gppTrace.getGppGraph(PIPageEditor.FUNCTIONS_PAGE, uid).getThresholdFunction().setColor(color);
+ }
+ }
+
+ // recoloring should only be done in a draw mode that displays this table's colors
+ selectedItems[i].setBackground(COLOR_COLUMN_INDEX, palette.getColor(nameKey));
+ }
+ }
+
+ if (!didRecolor)
+ return;
+
+ table.redraw();
+ this.myGraph.repaint();
+ this.myGraph.setGraphImageChanged(true); // any selection change to drill down will change graph
+
+ // if any other tabs are displaying this type of graph, they need to be scheduled for redrawing
+ for (int i = 0; i < 3; i++) {
+ GppTraceGraph graph = gppTrace.getGppGraph(i, uid);
+
+ if (graph == this.myGraph)
+ continue;
+
+ int drawMode = graph.getDrawMode();
+
+ if ( (drawMode == Defines.FUNCTIONS)
+ || (drawMode == Defines.THREADS_FUNCTIONS)
+ || (drawMode == Defines.THREADS_BINARIES_FUNCTIONS)
+ || (drawMode == Defines.BINARIES_FUNCTIONS)
+ || (drawMode == Defines.BINARIES_THREADS_FUNCTIONS)) {
+ graph.getFunctionTable().addColor(drawMode);
+ graph.setGraphImageChanged(true); // any selection change to drill down will change graph
+ graph.repaint();
+ }
+ }
+ }
+
+ private void actionFunction()
+ {
+ // current drawMode should be FUNCTIONS, FUNCTIONS_THREADS, FUNCTIONS_THREADS_BINARIES,
+ // FUNCTIONS_BINARIES, or FUNCTIONS_BINARIES_THREADS
+ int drawMode = this.myGraph.getDrawMode();
+
+ if ( (drawMode != Defines.FUNCTIONS_THREADS)
+ && (drawMode != Defines.FUNCTIONS_THREADS_BINARIES)
+ && (drawMode != Defines.FUNCTIONS_BINARIES)
+ && (drawMode != Defines.FUNCTIONS_BINARIES_THREADS))
+ {
+ // this case should be drawMode == Defines.FUNCTIONS
+ return;
+ }
+
+ setIsDrilldown(false);
+
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.functionLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(""); //$NON-NLS-1$
+
+ // get rid of any existing tables and sashes
+ if (this.myGraph.getLeftSash() != null) {
+ this.myGraph.getLeftSash().dispose();
+ this.myGraph.setLeftSash(null);
+
+ // detach the table from the sash
+ try {
+ FormData formData = (FormData) this.table.getLayoutData();
+ formData.right = new FormAttachment(100);
+ } catch (ClassCastException e1) {
+ }
+ }
+ if (this.myGraph.getRightSash() != null) {
+ this.myGraph.getRightSash().dispose();
+ this.myGraph.setRightSash(null);
+ }
+ if ( (this.myGraph.getThreadTable() != null)
+ && (this.myGraph.getThreadTable().getTable() != null)) {
+ this.myGraph.getThreadTable().getTableViewer().getTable().dispose();
+ this.myGraph.getThreadTable().setTableViewer(null);
+ }
+ if ( (this.myGraph.getBinaryTable() != null)
+ && (this.myGraph.getBinaryTable().getTable() != null)) {
+ this.myGraph.getBinaryTable().getTableViewer().getTable().dispose();
+ this.myGraph.getBinaryTable().setTableViewer(null);
+ }
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS);
+
+ // add colors to the rightmost table
+ addColor(Defines.FUNCTIONS);
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+ }
+
+ private void actionFunctionBinary()
+ {
+ // current drawMode should be FUNCTIONS, FUNCTIONS_BINARIES, or FUNCTIONS_BINARIES_THREADS
+ int drawMode = this.myGraph.getDrawMode();
+ int graphIndex = this.myGraph.getGraphIndex();
+
+ if ( drawMode != Defines.FUNCTIONS
+ && drawMode != Defines.FUNCTIONS_BINARIES_THREADS) {
+ return;
+ }
+
+ setIsDrilldown(true);
+
+ if (drawMode == Defines.FUNCTIONS) {
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.binaryLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo")); //$NON-NLS-1$
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES);
+
+ // create the binary graph table viewer
+ AddrBinaryTable binaryTable = this.myGraph.getBinaryTable();
+ binaryTable.createTableViewer(Defines.FUNCTIONS_BINARIES);
+ binaryTable.setIsDrilldown(true);
+
+ // create a reduced set of binary entries based on enabled function entries
+ GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
+ Vector<ProfiledGeneric> binaries = gppTrace.setFunctionBinary(graphIndex);
+ this.myGraph.setProfiledBinaries(binaries);
+
+ // put check marks on all rows, and sort by sample count
+ binaryTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledBinaries());
+ binaryTable.updateProfiledAndItemData(true);
+ binaryTable.getTableViewer().setAllChecked(true);
+ binaryTable.getTableViewer().refresh();
+
+ // remove colors where appropriate
+ removeColor(Defines.FUNCTIONS_BINARIES);
+
+ // connect the tables with a sash
+ Sash leftSash = new Sash(this.parent, SWT.VERTICAL);
+
+ final FormData leftSashData = new FormData();
+ leftSashData.top = new FormAttachment(0);
+ leftSashData.bottom = new FormAttachment(100);
+ leftSashData.left = new FormAttachment(50); // middle
+ leftSash.setLayoutData(leftSashData);
+
+ final Composite sashParent = this.parent;
+ leftSash.addListener(SWT.Selection, new Listener() {
+ public void handleEvent(Event event) {
+ if (event.detail != SWT.DRAG) {
+ leftSashData.left = new FormAttachment(0, event.x);
+ sashParent.layout();
+ }
+ }
+ });
+
+ myGraph.setLeftSash(leftSash);
+
+ // attach the binary table to the sash
+ final FormData viewerData = new FormData();
+ viewerData.top = new FormAttachment(0);
+ viewerData.bottom = new FormAttachment(100);
+ viewerData.left = new FormAttachment(leftSash);
+ viewerData.right = new FormAttachment(100);
+ binaryTable.getTable().setLayoutData(viewerData);
+
+ // attach the function table to the sash
+ try {
+ FormData formData = (FormData) this.table.getLayoutData();
+ formData.right = new FormAttachment(leftSash);
+ } catch (ClassCastException e1) {
+ }
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+
+ } else if (drawMode == Defines.FUNCTIONS_BINARIES_THREADS) {
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.binaryLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo")); //$NON-NLS-1$
+
+ // get rid of the thread table and its sash
+ if (this.myGraph.getRightSash() != null) {
+ this.myGraph.getRightSash().dispose();
+ this.myGraph.setRightSash(null);
+ }
+ if ( (this.myGraph.getThreadTable() != null)
+ && (this.myGraph.getThreadTable().getTable() != null)) {
+ this.myGraph.getThreadTable().getTableViewer().getTable().dispose();
+ this.myGraph.getThreadTable().setTableViewer(null);
+ }
+
+ // get rid of the middle table's connection to the sash
+ try {
+ FormData formData = (FormData) this.myGraph.getBinaryTable().getTable().getLayoutData();
+ formData.right = new FormAttachment(100);
+ } catch (ClassCastException e1) {
+ }
+
+ // move the left sash to the middle
+ try {
+ FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();
+ formData.left = new FormAttachment(50); // middle
+ } catch (ClassCastException e1) {
+ }
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES);
+
+ // show colors in the rightmost table
+ this.myGraph.getBinaryTable().addColor(Defines.FUNCTIONS_BINARIES);
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+ }
+
+ // this case should be drawMode == Defines.FUNCTIONS_BINARIES
+ return;
+ }
+
+ private void actionFunctionBinaryThread()
+ {
+ // current drawMode should be FUNCTIONS_BINARIES or FUNCTIONS_BINARIES_THREADS
+ int drawMode = this.myGraph.getDrawMode();
+ int graphIndex = this.myGraph.getGraphIndex();
+
+ if (drawMode != Defines.FUNCTIONS_BINARIES) {
+ // this case should be drawMode == Defines.FUNCTIONS_BINARIES_THREADS
+ return;
+ }
+
+ setIsDrilldown(true);
+
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.threadLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionToBinaryTo")); //$NON-NLS-1$
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS_BINARIES_THREADS);
+
+ // create the thread graph table viewer
+ AddrThreadTable threadTable = this.myGraph.getThreadTable();
+ threadTable.createTableViewer(Defines.FUNCTIONS_BINARIES_THREADS);
+ threadTable.setIsDrilldown(true);
+
+ // create a reduced set of thread entries based on enabled binary and function entries
+ GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
+ Vector<ProfiledGeneric> threads = gppTrace.setFunctionBinaryThread(graphIndex);
+ this.myGraph.setProfiledThreads(threads);
+
+ // put check marks on all rows, and sort by sample count
+ threadTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledThreads());
+ threadTable.updateProfiledAndItemData(true);
+ threadTable.getTableViewer().setAllChecked(true);
+ threadTable.getTableViewer().refresh();
+
+ // remove colors where appropriate
+ this.myGraph.getBinaryTable().removeColor(Defines.FUNCTIONS_BINARIES_THREADS);
+
+ // connect the 2nd and 3rd tables with a sash
+ Sash rightSash = new Sash(this.parent, SWT.VERTICAL);
+
+ final FormData rightSashData = new FormData();
+ rightSashData.top = new FormAttachment(0);
+ rightSashData.bottom = new FormAttachment(100);
+ rightSashData.left = new FormAttachment(67); // two thirds
+ rightSash.setLayoutData(rightSashData);
+
+ final Composite sashParent = this.parent;
+ rightSash.addListener(SWT.Selection, new Listener() {
+ public void handleEvent(Event event) {
+ if (event.detail != SWT.DRAG) {
+ rightSashData.left = new FormAttachment(0, event.x);
+ sashParent.layout();
+ }
+ }
+ });
+
+ myGraph.setRightSash(rightSash);
+
+ // attach the thread table to the sash
+ final FormData viewerData = new FormData();
+ viewerData.top = new FormAttachment(0);
+ viewerData.bottom = new FormAttachment(100);
+ viewerData.left = new FormAttachment(rightSash);
+ viewerData.right = new FormAttachment(100);
+ threadTable.getTable().setLayoutData(viewerData);
+
+ // attach the binary table to the sash
+ try {
+ FormData formData = (FormData) this.myGraph.getBinaryTable().getTable().getLayoutData();
+ formData.right = new FormAttachment(rightSash);
+ } catch (ClassCastException e1) {
+ }
+
+ // move the left sash to 1/3 from the left
+ try {
+ FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();
+ formData.left = new FormAttachment(33); // one third
+ } catch (ClassCastException e1) {
+ }
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+ }
+
+ private void actionFunctionThread()
+ {
+ // current drawMode should be FUNCTIONS, FUNCTIONS_THREADS, or FUNCTIONS_THREADS_BINARIES
+ int drawMode = this.myGraph.getDrawMode();
+ int graphIndex = this.myGraph.getGraphIndex();
+
+ if ( drawMode != Defines.FUNCTIONS
+ && drawMode != Defines.FUNCTIONS_THREADS_BINARIES) {
+ return;
+ }
+
+ setIsDrilldown(true);
+
+ if (drawMode == Defines.FUNCTIONS) {
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.threadLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo")); //$NON-NLS-1$
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS_THREADS);
+
+ // create the thread graph table viewer
+ AddrThreadTable threadTable = this.myGraph.getThreadTable();
+ threadTable.createTableViewer(Defines.FUNCTIONS_THREADS);
+ threadTable.setIsDrilldown(true);
+
+ // create a reduced set of thread entries based on enabled function entries
+ GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
+ Vector<ProfiledGeneric> threads = gppTrace.setFunctionThread(graphIndex);
+ this.myGraph.setProfiledThreads(threads);
+
+ // put check marks on all rows, and sort by sample count
+ threadTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledThreads());
+ threadTable.updateProfiledAndItemData(true);
+ threadTable.getTableViewer().setAllChecked(true);
+ threadTable.getTableViewer().refresh();
+
+ // remove colors where appropriate
+ removeColor(Defines.FUNCTIONS_THREADS);
+
+ // connect the tables with a sash
+ Sash leftSash = new Sash(this.parent, SWT.VERTICAL);
+
+ final FormData leftSashData = new FormData();
+ leftSashData.top = new FormAttachment(0);
+ leftSashData.bottom = new FormAttachment(100);
+ leftSashData.left = new FormAttachment(50); // middle
+ leftSash.setLayoutData(leftSashData);
+
+ final Composite sashParent = this.parent;
+ leftSash.addListener(SWT.Selection, new Listener() {
+ public void handleEvent(Event event) {
+ if (event.detail != SWT.DRAG) {
+ leftSashData.left = new FormAttachment(0, event.x);
+ sashParent.layout();
+ }
+ }
+ });
+
+ myGraph.setLeftSash(leftSash);
+
+ // attach the thread table to the sash
+ final FormData viewerData = new FormData();
+ viewerData.top = new FormAttachment(0);
+ viewerData.bottom = new FormAttachment(100);
+ viewerData.left = new FormAttachment(leftSash);
+ viewerData.right = new FormAttachment(100);
+ threadTable.getTable().setLayoutData(viewerData);
+
+ // attach the function table to the sash
+ try {
+ FormData formData = (FormData) this.table.getLayoutData();
+ formData.right = new FormAttachment(leftSash);
+ } catch (ClassCastException e1) {
+ }
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+
+ } else if (drawMode == Defines.FUNCTIONS_THREADS_BINARIES) {
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.threadLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionTo")); //$NON-NLS-1$
+
+ // get rid of the binary table and its sash
+ if (this.myGraph.getRightSash() != null) {
+ this.myGraph.getRightSash().dispose();
+ this.myGraph.setRightSash(null);
+ }
+ if ( (this.myGraph.getBinaryTable() != null)
+ && (this.myGraph.getBinaryTable().getTable() != null)) {
+ this.myGraph.getBinaryTable().getTableViewer().getTable().dispose();
+ this.myGraph.getBinaryTable().setTableViewer(null);
+ }
+
+ // get rid of the middle table's connection to the sash
+ try {
+ FormData formData = (FormData) this.myGraph.getThreadTable().getTable().getLayoutData();
+ formData.right = new FormAttachment(100);
+ } catch (ClassCastException e1) {
+ }
+
+ // move the left sash to the middle
+ try {
+ FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();
+ formData.left = new FormAttachment(50); // middle
+ } catch (ClassCastException e1) {
+ }
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS_THREADS);
+
+ // show colors in the rightmost table
+ this.myGraph.getThreadTable().addColor(Defines.FUNCTIONS_THREADS);
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+ }
+
+ // this case should be drawMode == Defines.FUNCTIONS_THREADS
+ return;
+ }
+
+ private void actionFunctionThreadBinary()
+ {
+ // current drawMode is FUNCTIONS_THREADS, or FUNCTIONS_THREADS_BINARIES
+ int drawMode = this.myGraph.getDrawMode();
+ int graphIndex = this.myGraph.getGraphIndex();
+
+ if (drawMode != Defines.FUNCTIONS_THREADS) {
+ // this case should be drawMode == Defines.FUNCTIONS_THREADS_BINARIES
+ return;
+ }
+
+ setIsDrilldown(true);
+
+ // set the page's graph title
+ ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(this.myGraph.getUid(), this.myGraph.getGraphIndex());
+ pV.getTitle().setText(Messages.getString("AddrFunctionTable.binaryLoad")); //$NON-NLS-1$
+ pV.getTitle2().setText(Messages.getString("AddrFunctionTable.functionToThreadTo")); //$NON-NLS-1$
+
+ // set the draw mode
+ this.myGraph.setDrawMode(Defines.FUNCTIONS_THREADS_BINARIES);
+
+ // create the binary graph table viewer
+ AddrBinaryTable binaryTable = this.myGraph.getBinaryTable();
+ binaryTable.createTableViewer(Defines.FUNCTIONS_THREADS_BINARIES);
+ binaryTable.setIsDrilldown(true);
+
+ // create a reduced set of binary entries based on enabled thread entries
+ GppTrace gppTrace = (GppTrace) this.myGraph.getTrace();
+ Vector<ProfiledGeneric> binaries = gppTrace.setFunctionThreadBinary(graphIndex);
+ this.myGraph.setProfiledBinaries(binaries);
+
+ // put check marks on all rows, and sort by sample count
+ binaryTable.quickSort(COLUMN_ID_SAMPLE_COUNT, this.myGraph.getProfiledBinaries());
+ binaryTable.updateProfiledAndItemData(true);
+ binaryTable.getTableViewer().setAllChecked(true);
+ binaryTable.getTableViewer().refresh();
+
+ // remove colors where appropriate
+ this.myGraph.getThreadTable().removeColor(Defines.FUNCTIONS_THREADS_BINARIES);
+
+ // connect the 2nd and 3rd tables with a sash
+ Sash rightSash = new Sash(this.parent, SWT.VERTICAL);
+
+ final FormData rightSashData = new FormData();
+ rightSashData.top = new FormAttachment(0);
+ rightSashData.bottom = new FormAttachment(100);
+ rightSashData.left = new FormAttachment(67); // two thirds
+ rightSash.setLayoutData(rightSashData);
+
+ final Composite sashParent = this.parent;
+ rightSash.addListener(SWT.Selection, new Listener() {
+ public void handleEvent(Event event) {
+ if (event.detail != SWT.DRAG) {
+ rightSashData.left = new FormAttachment(0, event.x);
+ sashParent.layout();
+ }
+ }
+ });
+
+ myGraph.setRightSash(rightSash);
+
+ // attach the binary table to the sash
+ final FormData viewerData = new FormData();
+ viewerData.top = new FormAttachment(0);
+ viewerData.bottom = new FormAttachment(100);
+ viewerData.left = new FormAttachment(rightSash);
+ viewerData.right = new FormAttachment(100);
+ binaryTable.getTable().setLayoutData(viewerData);
+
+ // attach the thread table to the sash
+ try {
+ FormData formData = (FormData) this.myGraph.getThreadTable().getTable().getLayoutData();
+ formData.right = new FormAttachment(rightSash);
+ } catch (ClassCastException e1) {
+ }
+
+ // move the left sash to 1/3 from the left
+ try {
+ FormData formData = (FormData) this.myGraph.getLeftSash().getLayoutData();
+ formData.left = new FormAttachment(33); // one third
+ } catch (ClassCastException e1) {
+ }
+
+ this.parent.layout();
+
+ this.myGraph.repaint();
+ }
+
+ private void actionSourceLookup() {
+ // source look up for selected items
+ TableItem selectedItem = table.getSelection()[0];
+ if (selectedItem.getData() instanceof ProfiledGeneric)
+ {
+ ProfiledGeneric pGeneric = (ProfiledGeneric)selectedItem.getData();
+
+ if (pGeneric instanceof ProfiledFunction) {
+ ProfiledFunction pFunc = (ProfiledFunction) pGeneric;
+ SourceLookup.getInstance().lookupAndopenEditorWithHighlight (pFunc.getNameString(), pFunc.getFunctionBinaryName());
+ }
+ }
+ }
+
+ public void focusGained(FocusEvent e) {}
+
+ public void focusLost(FocusEvent e) {}
+
+ public void piEventReceived(PIEvent be)
+ {
+ if (be.getType() == PIEvent.SELECTION_AREA_CHANGED3)
+ {
+ // % loads, % load strings, and/or sample counts have been updated
+ // due to a change in the graph area selected, and all table items
+ // need to be checked
+ updateProfiledAndItemData(true);
+
+ Display.getDefault().syncExec(new Runnable() {
+ public void run() {
+ quickSort(sortColumn, profiledFunctions);
+
+ // initially, all rows are selected
+ tableViewer.setAllChecked(true);
+
+ table.redraw();
+ }
+ });
+ }
+ else if ( (be.getType() == PIEvent.SELECTION_AREA_CHANGED2)
+ || (be.getType() == PIEvent.CHANGED_FUNCTION_TABLE))
+ {
+ int graphIndex = this.myGraph.getGraphIndex();
+
+ // This routine does not change which functions are enabled, but it enables
+ // all entries in the 2nd and 3rd tables.
+ // It assumes that GppTrace.setSelectedArea(), action("add") or action("remove") has set
+ // the % load and sample counts for functions, except for the threshold list.
+ if (be.getType() == PIEvent.SELECTION_AREA_CHANGED2) {
+ int thresholdCount = (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$
+ if (thresholdCount > 0) {
+ Vector<ProfiledGeneric> pGeneric = this.myGraph.getProfiledFunctions();
+ int sampleCount = 0;
+ for (int i = 0; i < pGeneric.size(); i++)
+ if (pGeneric.elementAt(i).getTotalSampleCount() < thresholdCount)
+ sampleCount += pGeneric.elementAt(i).getSampleCount(graphIndex);
+ this.myGraph.getThresholdFunction().setSampleCount(graphIndex, sampleCount);
+ }
+ }
+
+ // redraw this table
+ Display.getDefault().syncExec(new Runnable() {
+ public void run() {
+ if ( (sortColumn == COLUMN_ID_PERCENT_LOAD)
+ || (sortColumn == COLUMN_ID_SAMPLE_COUNT))
+ {
+ quickSort(sortColumn, profiledFunctions);
+ }
+ else
+ refreshTableViewer();
+
+ table.redraw();
+ }
+ });
+
+ int drawMode = this.myGraph.getDrawMode();
+ if (drawMode == Defines.FUNCTIONS)
+ return;
+
+ GppTrace trace = (GppTrace)(this.myGraph.getTrace());
+ Vector<ProfiledGeneric> traceFunctions = trace.getIndexedFunctions();
+
+ int startSampleIndex = trace.getStartSampleIndex();
+ int endSampleIndex = trace.getEndSampleIndex();
+ double percentPerSample;
+ if (startSampleIndex == endSampleIndex)
+ percentPerSample = 0.0;
+ else
+ percentPerSample = 100.0 / ((double)(endSampleIndex - startSampleIndex));
+
+ PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
+
+ switch (drawMode) {
+ case Defines.FUNCTIONS_THREADS:
+ {
+ // get new thread counts and loads
+ Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
+ Vector<ProfiledGeneric> graphThreads = this.myGraph.getProfiledThreads();
+ Hashtable<String,String> foundThreads = new Hashtable<String,String>();
+
+ // previous threads are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enu = graphThreads.elements();
+ while (enu.hasMoreElements()) {
+ ProfiledThread pThread = (ProfiledThread) enu.nextElement();
+ pThread.setEnabled(graphIndex, false);
+ }
+ graphThreads.clear();
+
+ ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
+ if (thresholdThread.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ GppSample[] sortedSamples = trace.getSortedGppSamples();
+
+ // set up in case we find threads below the threshold
+ boolean lowThread;
+ thresholdThread.init(graphIndex);
+
+ int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
+ for (int i = startSampleIndex; i < endSampleIndex; i++) {
+ GppSample sample = sortedSamples[i];
+
+ ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
+ if (pFunction.isEnabled(graphIndex)) {
+ // thread list is based on functions
+ ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
+ String threadName = pThread.getNameString();
+
+ lowThread = pThread.getTotalSampleCount() < threadThreshold;
+
+ if (!foundThreads.containsKey(threadName)) {
+ foundThreads.put(threadName, threadName);
+ if (lowThread) {
+ thresholdThread.addItem(graphIndex, pThread, 1);
+ } else {
+ pThread.setEnabled(graphIndex, true);
+ pThread.setSampleCount(graphIndex, 1);
+ graphThreads.add(pThread);
+ }
+ } else {
+ if (lowThread)
+ thresholdThread.incSampleCount(graphIndex);
+ else
+ pThread.incSampleCount(graphIndex);
+ }
+ }
+ }
+
+ // set the % load
+ for (int i = 0; i < graphThreads.size(); i++) {
+ ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
+ pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdThread.setLoadAndString(graphIndex,
+ (float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
+
+ // update the table items and redraw the table
+ this.myGraph.getThreadTable().piEventReceived(be3);
+ break;
+ }
+ case Defines.FUNCTIONS_THREADS_BINARIES:
+ {
+ // get new thread and binary counts and loads
+ Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
+ Vector<ProfiledGeneric> traceBinaries = trace.getIndexedBinaries();
+ Vector<ProfiledGeneric> graphThreads = this.myGraph.getProfiledThreads();
+ Vector<ProfiledGeneric> graphBinaries = this.myGraph.getProfiledBinaries();
+ Hashtable<String,String> foundThreads = new Hashtable<String,String>();
+ Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
+
+ // previous binaries are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enuBinary = graphBinaries.elements();
+ while (enuBinary.hasMoreElements()) {
+ ProfiledBinary pBinary = (ProfiledBinary) enuBinary.nextElement();
+ pBinary.setEnabled(graphIndex, false);
+ }
+ graphBinaries.clear();
+
+ ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
+
+ if (thresholdBinary.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ // previous threads are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enuThread = graphThreads.elements();
+ while (enuThread.hasMoreElements()) {
+ ProfiledThread pThread = (ProfiledThread) enuThread.nextElement();
+ pThread.setEnabled(graphIndex, false);
+ }
+ graphThreads.clear();
+
+ ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
+
+ if (thresholdThread.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ GppSample[] sortedSamples = trace.getSortedGppSamples();
+
+ // set up in case we find binaries below the threshold
+ boolean lowBinary;
+ thresholdBinary.init(graphIndex);
+
+ // set up in case we find threads below the threshold
+ boolean lowThread;
+ thresholdThread.init(graphIndex);
+
+ int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
+ for (int i = startSampleIndex; i < endSampleIndex; i++) {
+ GppSample sample = sortedSamples[i];
+
+ ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
+ if (pFunction.isEnabled(graphIndex)) {
+ // thread list is based on functions
+ ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
+ String threadName = pThread.getNameString();
+
+ lowThread = pThread.getTotalSampleCount() < threadThreshold;
+
+ if (!foundThreads.containsKey(threadName)) {
+ foundThreads.put(threadName, threadName);
+ if (lowThread) {
+ thresholdThread.addItem(graphIndex, pThread, 1);
+ } else {
+ pThread.setEnabled(graphIndex, true);
+ pThread.setSampleCount(graphIndex, 1);
+ graphThreads.add(pThread);
+ }
+ } else {
+ if (lowThread)
+ thresholdThread.incSampleCount(graphIndex);
+ else
+ pThread.incSampleCount(graphIndex);
+ }
+
+ // binary list is based on functions and threads
+ ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
+ String binaryName = pBinary.getNameString();
+
+ lowBinary = pBinary.getTotalSampleCount() < (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
+
+ if (!foundBinaries.containsKey(binaryName)) {
+ foundBinaries.put(binaryName, binaryName);
+ if (lowBinary) {
+ thresholdBinary.addItem(graphIndex, pBinary, 1);
+ } else {
+ pBinary.setEnabled(graphIndex, true);
+ pBinary.setSampleCount(graphIndex, 1);
+ graphBinaries.add(pBinary);
+ }
+ } else {
+ if (lowBinary)
+ thresholdBinary.incSampleCount(graphIndex);
+ else
+ pBinary.incSampleCount(graphIndex);
+ }
+ }
+ }
+
+ // set the % load
+ for (int i = 0; i < graphThreads.size(); i++) {
+ ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
+ pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdThread.setLoadAndString(graphIndex,
+ (float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
+
+ for (int i = 0; i < graphBinaries.size(); i++) {
+ ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
+ pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdBinary.setLoadAndString(graphIndex,
+ (float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
+
+ // update the table items and redraw the table
+ this.myGraph.getThreadTable().piEventReceived(be3);
+ this.myGraph.getBinaryTable().piEventReceived(be3);
+ break;
+ }
+ case Defines.FUNCTIONS_BINARIES:
+ {
+ // get new counts and loads
+ Vector<ProfiledGeneric> traceBinaries = trace.getIndexedBinaries();
+ Vector<ProfiledGeneric> graphBinaries = this.myGraph.getProfiledBinaries();
+ Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
+
+ // previous binaries are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enu = graphBinaries.elements();
+ while (enu.hasMoreElements()) {
+ ProfiledBinary pBinary = (ProfiledBinary) enu.nextElement();
+ pBinary.setEnabled(graphIndex, false);
+ }
+ graphBinaries.clear();
+
+ ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
+
+ if (thresholdBinary.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ GppSample[] sortedSamples = trace.getSortedGppSamples();
+
+ // set up in case we find binaries below the threshold
+ boolean lowBinary;
+ thresholdBinary.init(graphIndex);
+
+ int binaryThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
+ for (int i = startSampleIndex; i < endSampleIndex; i++) {
+ GppSample sample = sortedSamples[i];
+
+ ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
+ if (pFunction.isEnabled(graphIndex)) {
+ // binary list is based on functions
+ ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
+ String binaryName = pBinary.getNameString();
+
+ lowBinary = pBinary.getTotalSampleCount() < binaryThreshold;
+
+ if (!foundBinaries.containsKey(binaryName)) {
+ foundBinaries.put(binaryName, binaryName);
+ if (lowBinary) {
+ thresholdBinary.addItem(graphIndex, pBinary, 1);
+ } else {
+ pBinary.setEnabled(graphIndex, true);
+ pBinary.setSampleCount(graphIndex, 1);
+ graphBinaries.add(pBinary);
+ }
+ } else {
+ if (lowBinary)
+ thresholdBinary.incSampleCount(graphIndex);
+ else
+ pBinary.incSampleCount(graphIndex);
+ }
+ }
+ }
+
+ // set the % load
+ for (int i = 0; i < graphBinaries.size(); i++) {
+ ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
+ pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdBinary.setLoadAndString(graphIndex,
+ (float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
+
+ // update the table items and redraw the table
+ this.myGraph.getBinaryTable().piEventReceived(be3);
+ break;
+ }
+ case Defines.FUNCTIONS_BINARIES_THREADS:
+ {
+ // get new binary and thread counts and loads
+ Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
+ Vector<ProfiledGeneric> traceBinaries = trace.getIndexedBinaries();
+ Vector<ProfiledGeneric> graphThreads = this.myGraph.getProfiledThreads();
+ Vector<ProfiledGeneric> graphBinaries = this.myGraph.getProfiledBinaries();
+ Hashtable<String,String> foundThreads = new Hashtable<String,String>();
+ Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
+
+ // previous threads are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enuThreads = graphThreads.elements();
+ while (enuThreads.hasMoreElements()) {
+ ProfiledThread pThread = (ProfiledThread) enuThreads.nextElement();
+ pThread.setEnabled(graphIndex, false);
+ }
+ graphThreads.clear();
+
+ ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
+
+ if (thresholdThread.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ // previous binaries are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enuBinary = graphBinaries.elements();
+ while (enuBinary.hasMoreElements()) {
+ ProfiledBinary pBinary = (ProfiledBinary) enuBinary.nextElement();
+ pBinary.setEnabled(graphIndex, false);
+ }
+ graphBinaries.clear();
+
+ ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
+
+ if (thresholdBinary.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ GppSample[] sortedSamples = trace.getSortedGppSamples();
+
+ // set up in case we find threads below the threshold
+ boolean lowThread;
+ thresholdThread.init(graphIndex);
+
+ // set up in case we find binaries below the threshold
+ boolean lowBinary;
+ thresholdBinary.init(graphIndex);
+
+ int binaryThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
+ for (int i = startSampleIndex; i < endSampleIndex; i++) {
+ GppSample sample = sortedSamples[i];
+
+ ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);
+ if (pFunction.isEnabled(graphIndex)) {
+ // binary list is based on
+ ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
+ String binaryName = pBinary.getNameString();
+
+ lowBinary = pBinary.getTotalSampleCount() < binaryThreshold;
+
+ if (!foundBinaries.containsKey(binaryName)) {
+ foundBinaries.put(binaryName, binaryName);
+ if (lowBinary) {
+ thresholdBinary.addItem(graphIndex, pBinary, 1);
+ } else {
+ pBinary.setEnabled(graphIndex, true);
+ pBinary.setSampleCount(graphIndex, 1);
+ graphBinaries.add(pBinary);
+ }
+ } else {
+ if (lowBinary)
+ thresholdBinary.incSampleCount(graphIndex);
+ else
+ pBinary.incSampleCount(graphIndex);
+ }
+
+ // thread list is based on functions and binaries
+ ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
+ String threadName = pThread.getNameString();
+
+ lowThread = pThread.getTotalSampleCount() < (Integer)NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
+
+ if (!foundThreads.containsKey(threadName)) {
+ foundThreads.put(threadName, threadName);
+ if (lowThread) {
+ thresholdThread.addItem(graphIndex, pThread, 1);
+ } else {
+ pThread.setEnabled(graphIndex, true);
+ pThread.setSampleCount(graphIndex, 1);
+ graphThreads.add(pThread);
+ }
+ } else {
+ if (lowThread)
+ thresholdThread.incSampleCount(graphIndex);
+ else
+ pThread.incSampleCount(graphIndex);
+ }
+ }
+ }
+
+ // set the % load
+ for (int i = 0; i < graphThreads.size(); i++) {
+ ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
+ pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdThread.setLoadAndString(graphIndex,
+ (float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
+
+ for (int i = 0; i < graphBinaries.size(); i++) {
+ ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
+ pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdBinary.setLoadAndString(graphIndex,
+ (float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
+
+ // update the table items and redraw the table
+ this.myGraph.getThreadTable().piEventReceived(be3);
+ this.myGraph.getBinaryTable().piEventReceived(be3);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+ else if (be.getType() == PIEvent.CHANGED_THREAD_TABLE)
+ {
+ // This routine enables all entries in the next table
+
+ int drawMode = this.myGraph.getDrawMode();
+ if (drawMode != Defines.FUNCTIONS_THREADS_BINARIES)
+ return;
+
+ // we don't need to redraw the function table, since it has not changed
+
+ GppTrace trace = (GppTrace)(this.myGraph.getTrace());
+ Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
+
+ int graphIndex = this.myGraph.getGraphIndex();
+ int startSampleIndex = trace.getStartSampleIndex();
+ int endSampleIndex = trace.getEndSampleIndex();
+ double percentPerSample;
+ if (startSampleIndex == endSampleIndex)
+ percentPerSample = 0.0;
+ else
+ percentPerSample = 100.0 / ((double)(endSampleIndex - startSampleIndex));
+
+ PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
+
+ // get new binary counts and loads
+ Vector<ProfiledGeneric> traceBinaries = trace.getIndexedBinaries();
+ Vector<ProfiledGeneric> graphBinaries = this.myGraph.getProfiledBinaries();
+ Hashtable<String,String> foundBinaries = new Hashtable<String,String>();
+
+ // previous binaries are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enu = graphBinaries.elements();
+ while (enu.hasMoreElements()) {
+ ProfiledBinary pBinary = (ProfiledBinary) enu.nextElement();
+ pBinary.setEnabled(graphIndex, false);
+ }
+ graphBinaries.clear();
+
+ ProfiledThreshold thresholdBinary = this.myGraph.getThresholdBinary();
+
+ if (thresholdBinary.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdBinary.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ GppSample[] sortedSamples = trace.getSortedGppSamples();
+
+ // set up in case we find binaries below the threshold
+ boolean lowBinary;
+ thresholdBinary.init(graphIndex);
+
+ int binaryThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$
+ for (int i = startSampleIndex; i < endSampleIndex; i++) {
+ GppSample sample = sortedSamples[i];
+
+ ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
+ if (pThread.isEnabled(graphIndex)) {
+ // binary list is based on threads
+ ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
+ String binaryName = pBinary.getNameString();
+
+ lowBinary = pBinary.getTotalSampleCount() < binaryThreshold;
+
+ if (!foundBinaries.containsKey(binaryName)) {
+ foundBinaries.put(binaryName, binaryName);
+ if (lowBinary) {
+ thresholdBinary.addItem(graphIndex, pBinary, 1);
+ } else {
+ pBinary.setEnabled(graphIndex, true);
+ pBinary.setSampleCount(graphIndex, 1);
+ graphBinaries.add(pBinary);
+ }
+ } else {
+ if (lowBinary)
+ thresholdBinary.incSampleCount(graphIndex);
+ else
+ pBinary.incSampleCount(graphIndex);
+ }
+ }
+ }
+
+ // set the % load
+ for (int i = 0; i < graphBinaries.size(); i++) {
+ ProfiledBinary pBinary = (ProfiledBinary) graphBinaries.elementAt(i);
+ pBinary.setLoadAndString(graphIndex, (float)(pBinary.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdBinary.setLoadAndString(graphIndex,
+ (float)(thresholdBinary.getSampleCount(graphIndex)*percentPerSample));
+
+ // update the table items and redraw the table
+ this.myGraph.getBinaryTable().piEventReceived(be3);
+ }
+ else if (be.getType() == PIEvent.CHANGED_BINARY_TABLE)
+ {
+ // This routine enables all entries in the next table
+
+ int drawMode = this.myGraph.getDrawMode();
+ if (drawMode != Defines.FUNCTIONS_BINARIES_THREADS)
+ return;
+
+ // we don't need to redraw the function table, since it has not changed
+
+ GppTrace trace = (GppTrace)(this.myGraph.getTrace());
+ Vector<ProfiledGeneric> traceBinaries = trace.getIndexedBinaries();
+
+ int graphIndex = this.myGraph.getGraphIndex();
+ int startSampleIndex = trace.getStartSampleIndex();
+ int endSampleIndex = trace.getEndSampleIndex();
+ double percentPerSample;
+ if (startSampleIndex == endSampleIndex)
+ percentPerSample = 0.0;
+ else
+ percentPerSample = 100.0 / ((double)(endSampleIndex - startSampleIndex));
+
+ PIEvent be3 = new PIEvent(be.getValueObject(), PIEvent.SELECTION_AREA_CHANGED3);
+
+ // get new thread counts and loads
+ Vector<ProfiledGeneric> traceThreads = trace.getIndexedThreads();
+ Vector<ProfiledGeneric> graphThreads = this.myGraph.getProfiledThreads();
+ Hashtable<String,String> foundThreads = new Hashtable<String,String>();
+
+ // previous threads are not necessarily graphed this time
+ Enumeration<ProfiledGeneric> enu = graphThreads.elements();
+ while (enu.hasMoreElements()) {
+ ProfiledThread pThread = (ProfiledThread) enu.nextElement();
+ pThread.setEnabled(graphIndex, false);
+ }
+ graphThreads.clear();
+
+ ProfiledThreshold thresholdThread = this.myGraph.getThresholdThread();
+
+ if (thresholdThread.isEnabled(graphIndex)) {
+ ArrayList<ProfiledGeneric> items = thresholdThread.getItems(graphIndex);
+ // disable all items below the threshold
+ for (int i = 0; i < items.size(); i++) {
+ items.get(i).setEnabled(graphIndex, false);
+ }
+ }
+
+ GppSample[] sortedSamples = trace.getSortedGppSamples();
+
+ // set up in case we find threads below the threshold
+ boolean lowThread;
+ thresholdThread.init(graphIndex);
+
+ int threadThreshold = (Integer) NpiInstanceRepository.getInstance().activeUidGetPersistState("com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$
+ for (int i = startSampleIndex; i < endSampleIndex; i++) {
+ GppSample sample = sortedSamples[i];
+
+ ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);
+ if (pBinary.isEnabled(graphIndex)) {
+ // thread list is based on binaries
+ ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);
+ String threadName = pThread.getNameString();
+
+ lowThread = pThread.getTotalSampleCount() < threadThreshold;
+
+ if (!foundThreads.containsKey(threadName)) {
+ foundThreads.put(threadName, threadName);
+ if (lowThread) {
+ thresholdThread.addItem(graphIndex, pThread, 1);
+ } else {
+ pThread.setEnabled(graphIndex, true);
+ pThread.setSampleCount(graphIndex, 1);
+ graphThreads.add(pThread);
+ }
+ } else {
+ if (lowThread)
+ thresholdThread.incSampleCount(graphIndex);
+ else
+ pThread.incSampleCount(graphIndex);
+ }
+ }
+ }
+
+ // set the % load
+ for (int i = 0; i < graphThreads.size(); i++) {
+ ProfiledThread pThread = (ProfiledThread) graphThreads.elementAt(i);
+ pThread.setLoadAndString(graphIndex, (float)(pThread.getSampleCount(graphIndex)*percentPerSample));
+ }
+ thresholdThread.setLoadAndString(graphIndex,
+ (float)(thresholdThread.getSampleCount(graphIndex)*percentPerSample));
+
+ // update the table items and redraw the table
+ this.myGraph.getThreadTable().piEventReceived(be3);
+ }
+ }
+
+ public void setSelectedNames()
+ {
+ Object[] selectedValues = this.tableViewer.getCheckedElements();
+ String[] functionNames = new String[selectedValues.length];
+
+ for (int i = 0; i < selectedValues.length; i++)
+ {
+ if (selectedValues[i] instanceof ProfiledFunction)
+ {
+ ProfiledFunction pf = (ProfiledFunction)selectedValues[i];
+ functionNames[i] = pf.getNameString();
+ }
+ }
+
+ PIVisualSharedData shared = myGraph.getSharedDataInstance();
+ shared.GPP_SelectedFunctionNames = functionNames;
+ }
+
+ private class SharedCheckHandler implements ICheckStateListener
+ {
+ public void checkStateChanged(CheckStateChangedEvent event) {
+
+ if (!(event.getElement() instanceof ProfiledGeneric))
+ return;
+
+ // set the stored value to the checkbox value
+ ProfiledGeneric pg = (ProfiledGeneric)event.getElement();
+ pg.setEnabled(myGraph.getGraphIndex(), event.getChecked());
+
+ // this table's set of checkbox-selected rows has changed, so propagate that information
+ setSelectedNames();
+
+ if ( (pg.getSampleCount(myGraph.getGraphIndex()) != 0)
+ || (myGraph.getDrawMode() == Defines.FUNCTIONS))
+ selectionChangeNotify();
+
+ table.deselectAll();
+ }
+ }
+
+ protected void selectionChangeNotify() {
+ PIEvent be = new PIEvent(null, PIEvent.CHANGED_FUNCTION_TABLE);
+ myGraph.piEventReceived(be);
+ }
+
+ public void sortOnColumnSelection(TableColumn tableColumn) {
+ int columnId = ((Integer) tableColumn.getData()).intValue();
+ if (sortColumn == columnId) {
+ // sort in other order
+ sortAscending = !sortAscending;
+ } else {
+ // sort in the default order
+ switch (columnId)
+ {
+ case COLUMN_ID_SHOW:
+ case COLUMN_ID_PERCENT_LOAD:
+ case COLUMN_ID_SAMPLE_COUNT:
+ {
+ // sort in descending order (for checked boxes, this means selected boxes first)
+ sortAscending = false;
+ break;
+ }
+ case COLUMN_ID_FUNCTION:
+ case COLUMN_ID_START_ADDR:
+ case COLUMN_ID_IN_BINARY:
+ case COLUMN_ID_IN_BINARY_PATH:
+ {
+ // sort in ascending order
+ sortAscending = true;
+ break;
+ }
+ default:
+ {
+ return;
+ }
+ }
+ }
+
+ sortColumn = columnId;
+ quickSort(sortColumn, profiledFunctions);
+ }
+
+ private class ColumnSelectionHandler extends SelectionAdapter
+ {
+ public void widgetSelected(SelectionEvent e)
+ {
+ // wait for the previous sort to finish
+ if (sorting || !(e.widget instanceof TableColumn))
+ return;
+
+ sortOnColumnSelection((TableColumn) e.widget);
+ }
+ }
+
+ public void updateProfiledAndItemData(boolean setInput)
+ {
+ tableItemData.clear();
+ profiledFunctions.clear();
+
+ // profiledFunctions and tableItemData contain one entry per table row
+ Enumeration<ProfiledGeneric> enu = myGraph.getProfiledFunctions().elements();
+ while (enu.hasMoreElements())
+ {
+ ProfiledFunction nextElement = (ProfiledFunction)enu.nextElement();
+ tableItemData.add(nextElement);
+ profiledFunctions.add(nextElement);
+ }
+
+ if (myGraph.getThresholdFunction().getItemCount(myGraph.getGraphIndex()) != 0) {
+ tableItemData.add(myGraph.getThresholdFunction());
+ profiledFunctions.add(myGraph.getThresholdFunction());
+ }
+
+ // now sort the items in increasing total sample count, so that they graph correctly
+ Object[] sorted = myGraph.getProfiledFunctions().toArray();
+ Arrays.sort(sorted, new Comparator<Object>() {
+
+ public int compare(Object arg0, Object arg1)
+ {
+ if (arg0 instanceof ProfiledGeneric && arg1 instanceof ProfiledGeneric)
+ return ((ProfiledGeneric)arg0).getTotalSampleCount() -
+ ((ProfiledGeneric)arg1).getTotalSampleCount();
+ else
+ return 0;
+ }
+ });
+
+ // now create the sorted list used to draw the graph
+ myGraph.getSortedFunctions().clear();
+
+ if (myGraph.getThresholdFunction().getItemCount(myGraph.getGraphIndex()) != 0)
+ myGraph.getSortedFunctions().add(myGraph.getThresholdFunction());
+
+ for (int i = 0; i < sorted.length; i++)
+ myGraph.getSortedFunctions().add((ProfiledGeneric) sorted[i]);
+
+ // refresh the table, if needed
+ if (setInput)
+ refreshTableViewer();
+ }
+
+ public void quickSort(int sortBy, Vector<ProfiledGeneric> profiled)
+ {
+ if (profiled.size() == 0)
+ return;
+
+ this.sorting = true;
+
+ ProfiledGeneric pGeneric = profiled.elementAt(profiled.size() - 1);
+
+ if (pGeneric instanceof ProfiledThreshold) {
+ profiled.removeElementAt(profiled.size() - 1);
+ }
+
+ this.sorter.setupSort(sortBy, this.myGraph.getGraphIndex(), sortAscending);
+
+ switch (sortBy) {
+ case COLUMN_ID_SHOW:
+ {
+ this.sorter.quickSortByShow(profiled);
+ break;
+ }
+ case COLUMN_ID_PERCENT_LOAD:
+ {
+ this.sorter.quickSortByAverageLoad(profiled);
+ break;
+ }
+ case COLUMN_ID_THREAD:
+ {
+ this.sorter.quickSortByThread(profiled);
+ break;
+ }
+ case COLUMN_ID_BINARY:
+ {
+ this.sorter.quickSortByBinary(profiled);
+ break;
+ }
+ case COLUMN_ID_FUNCTION:
+ {
+ this.sorter.quickSortByFunction(profiled);
+ break;
+ }
+ case COLUMN_ID_SAMPLE_COUNT:
+ {
+ this.sorter.quickSortBySampleCount(profiled);
+ break;
+ }
+ case COLUMN_ID_START_ADDR:
+ {
+ this.sorter.quickSortByStartAddress(profiled);
+ break;
+ }
+ case COLUMN_ID_IN_BINARY:
+ {
+ this.sorter.quickSortByAssocBinary(profiled);
+ break;
+ }
+ case COLUMN_ID_IN_BINARY_PATH:
+ {
+ this.sorter.quickSortByAssocBinaryPath(profiled);
+ break;
+ }
+ case COLUMN_ID_FULL_IN_PATH:
+ {
+ this.sorter.quickSortByFullAssocBinaryPath(profiled);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ Enumeration<ProfiledGeneric> e = this.sorter.getSortedList().elements();
+ tableItemData = setTableItemData(e);
+ if (pGeneric instanceof ProfiledThreshold) {
+ tableItemData.add(pGeneric);
+ profiled.add(pGeneric);
+ }
+
+ // find the column corresponding to sortBy, and give it a column direction
+ // NOTE: treat sort by binary path then by binary name as sort by path
+ if (sortBy == COLUMN_ID_FULL_PATH)
+ sortBy = COLUMN_ID_PATH;
+ else if (sortBy == COLUMN_ID_FULL_IN_PATH)
+ sortBy = COLUMN_ID_IN_BINARY_PATH;
+
+ TableColumn sortByColumn = null;
+ for (int i = 0; i < this.table.getColumnCount(); i++) {
+ if (this.table.getColumn(i).getData() instanceof Integer) {
+ if (((Integer)this.table.getColumn(i).getData()) == sortBy) {
+ sortByColumn = this.table.getColumn(i);
+ break;
+ }
+ }
+ }
+
+ if (sortByColumn != null) {
+ this.table.setSortColumn(sortByColumn);
+ this.table.setSortDirection(sortAscending ? SWT.UP : SWT.DOWN);
+ }
+
+ refreshTableViewer();
+ this.sorting = false;
+ }
+
+ protected Menu getTableMenu(Decorations parent, int graphIndex, int drawMode) {
+ // get rid of last Menu created so we don't have double menu
+ // in on click
+ if (contextMenu != null) {
+ contextMenu.dispose();
+ }
+
+ contextMenu = new Menu(parent, SWT.POP_UP);
+
+ // Use drawMode to determine the drill down items and
+ // whether to show a color column
+ addDrillDownItems(contextMenu, drawMode);
+
+ // sort by path, then binary
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ getSortInFullPathItem(contextMenu, this.table.getItemCount() > 0);
+
+ // check and uncheck boxes
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ getCheckRows(contextMenu, this.table.getSelectionCount() > 0);
+
+ // select all, copy, and copy all
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ getSelectAllItem(contextMenu, this.table.getItemCount() > 0);
+ getCopyItem(contextMenu, this.table.getSelectionCount() > 0);
+ getCopyTableItem(contextMenu, this.table.getItemCount() > 0);
+
+ // copy drilldown tables, if in drilldown mode
+ switch (drawMode)
+ {
+ case Defines.THREADS:
+ case Defines.BINARIES:
+ case Defines.FUNCTIONS:
+ getCopyDrilldownItem(contextMenu, false);
+ break;
+ default:
+ getCopyDrilldownItem(contextMenu, true);
+ break;
+ }
+
+ // save all and save drilldown tables, if in drilldown mode
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ getSaveTableItem(contextMenu, this.table.getItemCount() > 0);
+
+ switch (drawMode)
+ {
+ case Defines.THREADS:
+ case Defines.BINARIES:
+ case Defines.FUNCTIONS:
+ getSaveDrilldownItem(contextMenu, false);
+ break;
+ default:
+ getSaveDrilldownItem(contextMenu, true);
+ break;
+ }
+
+ // save raw samples
+ boolean haveSamples = false;
+ for (int i = 0; !haveSamples && i < profiledFunctions.size(); i++) {
+ ProfiledGeneric pg = profiledFunctions.get(i);
+ haveSamples = pg.isEnabled(graphIndex) && pg.getSampleCount(graphIndex) > 0;
+ }
+
+ double startTime = PIPageEditor.currentPageEditor().getStartTime();
+ double endTime = PIPageEditor.currentPageEditor().getEndTime();
+ if (!haveSamples || (startTime == -1) || (endTime == -1) || (startTime == endTime))
+ getSaveSamplesItem(contextMenu, Messages.getString("AddrFunctionTable.functions"), false); //$NON-NLS-1$
+ else
+ getSaveSamplesItem(contextMenu, Messages.getString("AddrFunctionTable.functions"), true); //$NON-NLS-1$
+
+ // recolor selected threads
+ switch (drawMode)
+ {
+ case Defines.FUNCTIONS:
+ case Defines.THREADS_BINARIES_FUNCTIONS:
+ case Defines.BINARIES_FUNCTIONS:
+ case Defines.THREADS_FUNCTIONS:
+ case Defines.BINARIES_THREADS_FUNCTIONS:
+ {
+ // recolor selected items
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ getRecolorItem(contextMenu, Messages.getString("AddressPlugin.functions"), //$NON-NLS-1$
+ this.table.getSelectionCount() > 0);
+ break;
+ }
+ case Defines.THREADS_FUNCTIONS_BINARIES:
+ case Defines.BINARIES_FUNCTIONS_THREADS:
+ case Defines.FUNCTIONS_THREADS:
+ case Defines.FUNCTIONS_THREADS_BINARIES:
+ case Defines.FUNCTIONS_BINARIES:
+ case Defines.FUNCTIONS_BINARIES_THREADS:
+ {
+ break;
+ }
+ default:
+ break;
+ }
+
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ getChangeThresholds(contextMenu);
+
+ switch (drawMode) {
+ case Defines.THREADS_FUNCTIONS:
+ case Defines.THREADS_BINARIES_FUNCTIONS:
+ case Defines.BINARIES_FUNCTIONS:
+ case Defines.BINARIES_THREADS_FUNCTIONS:
+ case Defines.FUNCTIONS:
+ new MenuItem(contextMenu, SWT.SEPARATOR);
+ // source look up only when one item is selected
+ if (table.getSelection().length == 1) {
+ getSourceLookUpItem(contextMenu, Messages.getString("AddrFunctionTable.items")); //$NON-NLS-1$
+ } else {
+ getDisabledSourceLookUpItem(contextMenu, Messages.getString("AddrFunctionTable.items")); //$NON-NLS-1$
+ }
+ default:
+ break;
+ }
+
+ contextMenu.setVisible(true);
+
+ return contextMenu;
+ }
+
+ public Vector getTableItemData() {
+ return this.tableItemData;
+ }
+
+}