diff --git a/bundles/org.eclipse.test.performance.ui/icons/compare_view.gif b/bundles/org.eclipse.test.performance.ui/icons/compare_view.gif
new file mode 100644
index 0000000..dc549bc
--- /dev/null
+++ b/bundles/org.eclipse.test.performance.ui/icons/compare_view.gif
Binary files differ
diff --git a/bundles/org.eclipse.test.performance.ui/performanceui.jar b/bundles/org.eclipse.test.performance.ui/performanceui.jar
index 82efe4f..bb3394a 100644
--- a/bundles/org.eclipse.test.performance.ui/performanceui.jar
+++ b/bundles/org.eclipse.test.performance.ui/performanceui.jar
Binary files differ
diff --git a/bundles/org.eclipse.test.performance.ui/plugin.xml b/bundles/org.eclipse.test.performance.ui/plugin.xml
index 491cb79..04d80d3 100644
--- a/bundles/org.eclipse.test.performance.ui/plugin.xml
+++ b/bundles/org.eclipse.test.performance.ui/plugin.xml
@@ -49,6 +49,14 @@
             name="Component Results"
             restorable="true">
       </view>
+      <view
+            category="Performances"
+            class="org.eclipse.test.internal.performance.results.ui.BuildsComparisonView"
+            icon="icons/compare_view.gif"
+            id="org.eclipse.test.internal.performance.results.ui.BuildsComparisonView"
+            name="Builds comparison"
+            restorable="true">
+      </view>
    </extension>
    <extension
          point="org.eclipse.core.runtime.preferences">
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/model/PerformanceResultsElement.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/model/PerformanceResultsElement.java
index e8bb640..d4c108c 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/model/PerformanceResultsElement.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/model/PerformanceResultsElement.java
@@ -20,7 +20,7 @@
 import java.util.Arrays;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.test.internal.performance.results.db.*;
-import org.eclipse.test.internal.performance.results.ui.ScenariosComparisonTable;
+import org.eclipse.test.internal.performance.results.ui.BuildsComparisonTable;
 import org.eclipse.test.internal.performance.results.utils.IPerformancesConstants;
 import org.eclipse.test.internal.performance.results.utils.Util;
 import org.eclipse.test.performance.ui.Utils;
@@ -363,7 +363,7 @@
 		try {
 			int length = this.children.length;
 			for (int i=0; i<length; i++) {
-				ScenariosComparisonTable table = new ScenariosComparisonTable(this.children[i].getName(), stream, build, reference);
+				BuildsComparisonTable table = new BuildsComparisonTable(this.children[i].getName(), stream, build, reference);
 				table.print(getPerformanceResults());
 			}
 		}
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonTab.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonTab.java
new file mode 100644
index 0000000..abcbcb1
--- /dev/null
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonTab.java
@@ -0,0 +1,506 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2009 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.test.internal.performance.results.ui;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.InstanceScope;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.MouseEvent;
+import org.eclipse.swt.events.MouseTrackListener;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontData;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.TableItem;
+import org.eclipse.swt.widgets.ToolTip;
+import org.eclipse.test.internal.performance.results.db.AbstractResults;
+import org.eclipse.test.internal.performance.results.db.BuildResults;
+import org.eclipse.test.internal.performance.results.db.ConfigResults;
+import org.eclipse.test.internal.performance.results.db.PerformanceResults;
+import org.eclipse.test.internal.performance.results.db.ScenarioResults;
+import org.eclipse.test.internal.performance.results.model.BuildResultsElement;
+import org.eclipse.test.internal.performance.results.model.PerformanceResultsElement;
+import org.eclipse.test.internal.performance.results.model.ResultsElement;
+import org.eclipse.test.internal.performance.results.utils.IPerformancesConstants;
+import org.eclipse.test.internal.performance.results.utils.Util;
+
+
+/**
+ * Tab to display all performances results numbers for a configuration (i.e a performance machine).
+ */
+public class BuildsComparisonTab {
+
+	// Colors
+	static final Display DEFAULT_DISPLAY = Display.getDefault();
+	static final Color BLUE= DEFAULT_DISPLAY.getSystemColor(SWT.COLOR_BLUE);
+	static final Color DARK_GREEN= DEFAULT_DISPLAY.getSystemColor(SWT.COLOR_DARK_GREEN);
+	static final Color GRAY = DEFAULT_DISPLAY.getSystemColor(SWT.COLOR_GRAY);
+	static final Color MAGENTA = DEFAULT_DISPLAY.getSystemColor(SWT.COLOR_MAGENTA);
+	static final Color RED = DEFAULT_DISPLAY.getSystemColor(SWT.COLOR_RED);
+
+	// SWT resources
+	Shell shell;
+	Display display;
+	Table table;
+	private GC gc;
+	private Color lightred;
+	private Color lightyellow;
+	private Color darkyellow;
+	private Color blueref;
+	private Font boldFont;
+	private Font italicFont;
+	private Font boldItalicFont;
+	Map toolTips;
+
+	// Information
+	String componentName;
+	double[][] allValues;
+	double[][] allErrors;
+
+	// Cells management
+	Point tableOrigin, tableSize;
+	int columnsCount, rowsCount;
+	List firstLine;
+
+	// Eclipse preferences
+	private IEclipsePreferences preferences;
+
+/*
+ * Default constructor.
+ */
+public BuildsComparisonTab(String name) {
+    this.componentName = name;
+	this.preferences = new InstanceScope().getNode(IPerformancesConstants.PLUGIN_ID);
+}
+
+/**
+ * Creates the tab folder page.
+ *
+ * @param tabFolder org.eclipse.swt.widgets.TabFolder
+ * @param fullSelection Tells whether the table should have a full line selection or not
+ * @return the new page for the tab folder
+ */
+Composite createTabFolderPage (BuildsComparisonView view) {
+	// Cache the shell and display.
+	this.shell = view.tabFolder.getShell();
+	this.display = this.shell.getDisplay();
+
+	// Remove old table if present
+	boolean initResources = this.table == null;
+	if (this.table != null) {
+		disposeTable();
+	}
+
+	// Create the "children" table
+	int style = SWT.MULTI | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION;
+	this.table = new Table(view.tabFolder, style);
+	this.table.setLinesVisible (true);
+	this.table.setHeaderVisible (true);
+	GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true, 3, 1);
+	gridData.heightHint = 150;
+	this.table.setLayoutData (gridData);
+	this.gc = new GC(this.table);
+
+	// Init resources
+	if (initResources) initResources();
+
+	// Add columns to the table
+	TableColumn firstColumn = new TableColumn(this.table, SWT.CENTER);
+	firstColumn.setText("");
+	PerformanceResultsElement results = view.getResults();
+	String [] configDescriptions = results.getConfigDescriptions();
+	int length = configDescriptions.length;
+	for (int i = 0; i < length; i++) {
+		TableColumn column = new TableColumn(this.table, SWT.CENTER);
+		column.setText(configDescriptions[i]);
+	}
+
+	// Add lines to the table
+	this.toolTips = new HashMap();
+	boolean fingerprints = this.preferences.getBoolean(IPerformancesConstants.PRE_FILTER_ADVANCED_SCENARIOS, IPerformancesConstants.DEFAULT_FILTER_ADVANCED_SCENARIOS);
+	fillTable(results, view.currentBuild, view.referenceBuild, fingerprints);
+
+	// Updated columns
+	for (int i=0; i<=length; i++) {
+		TableColumn column = this.table.getColumn(i);
+		column.setWidth(i==0?120:100);
+	}
+
+	// Store table info
+	this.columnsCount = length;
+
+	// Listen to mouse track events to display the table cell corresponding tooltip.
+	MouseTrackListener mouseTrackListener = new MouseTrackListener() {
+		ToolTip currentTooltip;
+		public void mouseHover(MouseEvent e) {
+			if (this.currentTooltip != null) {
+				this.currentTooltip.setVisible(false);
+				this.currentTooltip = null;
+			}
+			Point cellPosition = currentCellPosition(e.x, e.y);
+			if (cellPosition != null) {
+				ToolTip tooltip = (ToolTip) BuildsComparisonTab.this.toolTips.get(cellPosition);
+				if (tooltip != null) {
+					Point location = BuildsComparisonTab.this.table.toDisplay(new Point(e.x, e.y));
+					tooltip.setLocation(location);
+					tooltip.setVisible(true);
+					this.currentTooltip = tooltip;
+				}
+			}
+		}
+		public void mouseEnter(MouseEvent e) {
+		}
+		public void mouseExit(MouseEvent e) {
+		}
+	};
+	this.table.addMouseTrackListener(mouseTrackListener);
+
+	// Select the first line by default (as this is the current build)
+	this.table.select(0);
+
+	// Return the built composite
+	return this.table;
+}
+
+/*
+ * Create and store a tooltip with the given information and at the given position.
+ */
+void createToolTip(String toolTipText, String toolTipMessage, int toolTipStyle, Point position) {
+	ToolTip toolTip = new ToolTip(this.table.getShell(), toolTipStyle);
+	toolTip.setAutoHide(true);
+	toolTip.setText(toolTipText);
+	toolTip.setMessage(/*"("+col+","+row+") "+*/toolTipMessage);
+	this.toolTips.put(position, toolTip);
+}
+
+/*
+ * Get the current cell position (column, row) from a point position.
+ */
+Point currentCellPosition(int x, int y) {
+
+	// Compute the origin of the visible area
+	if (this.tableOrigin == null) {
+		this.tableOrigin = new Point(0, this.table.getHeaderHeight());
+	}
+
+	// Increment width until over current y position
+	int height= this.tableOrigin.y;
+	int row = this.table.getTopIndex();
+	while (row<this.rowsCount && height<y) {
+		height += this.table.getItemHeight();
+		row++;
+	}
+	if (height < y) {
+		// return when position is over the last line
+		return null;
+	}
+	row--;
+
+	// Increment width until being over current x position
+	int col = 0;
+	TableItem tableItem = this.table.getItem(row);
+	Rectangle bounds = tableItem.getBounds(col);
+	while (col<this.columnsCount) {
+		int max = bounds.x + bounds.width + this.table.getGridLineWidth();
+		if (x <= max) break;
+		if (col == this.columnsCount) {
+			// return when position is over the last column
+			return null;
+		}
+		col++;
+		bounds = tableItem.getBounds(col);
+	}
+
+	// Return the found table cell position
+	return new Point(col, row);
+}
+
+/*
+ * Dispose all SWT resources.
+ */
+public void dispose() {
+	if (this.boldFont != null) {
+		this.boldFont.dispose();
+	}
+	if (this.italicFont != null) {
+		this.italicFont.dispose();
+	}
+	if (this.boldItalicFont != null) {
+		this.boldItalicFont.dispose();
+	}
+	if (this.darkyellow != null) {
+		this.darkyellow.dispose();
+	}
+	if (this.lightyellow != null) {
+		this.lightyellow.dispose();
+	}
+	if (this.lightred != null) {
+		this.lightred.dispose();
+	}
+	if (this.blueref != null) {
+		this.blueref.dispose();
+	}
+	disposeTable();
+}
+
+/*
+ * Dispose all SWT controls associated with the table.
+ */
+private void disposeTable() {
+	if (this.toolTips != null) {
+		Iterator cells = this.toolTips.keySet().iterator();
+		while (cells.hasNext()) {
+			ToolTip toolTip = (ToolTip) this.toolTips.get(cells.next());
+			toolTip.dispose();
+		}
+	}
+	this.table.dispose();
+	this.tableOrigin = null;
+	this.firstLine = null;
+}
+
+/*
+ * Fill the lines of the tables.
+ * Get all the information from the model which are returned in a list (lines) of lists (columns).
+ */
+private void fillTable(PerformanceResultsElement results, String currentBuild, String referenceBuild, boolean fingerprints) {
+
+	// Get all the scenario for the component
+	final PerformanceResults performanceResults = results.getPerformanceResults();
+	List scenarios = performanceResults.getComponentScenarios(this.componentName);
+	int size = scenarios.size();
+
+	// Get thresholds
+	int failurePref = this.preferences.getInt(IPerformancesConstants.PRE_COMPARISON_THRESHOLD_FAILURE, IPerformancesConstants.DEFAULT_COMPARISON_THRESHOLD_FAILURE);
+	int errorPref = this.preferences.getInt(IPerformancesConstants.PRE_COMPARISON_THRESHOLD_ERROR, IPerformancesConstants.DEFAULT_COMPARISON_THRESHOLD_ERROR);
+	int improvementPref = this.preferences.getInt(IPerformancesConstants.PRE_COMPARISON_THRESHOLD_IMPROVEMENT, IPerformancesConstants.DEFAULT_COMPARISON_THRESHOLD_IMPROVEMENT);
+	final double failureThreshold = -failurePref / 100.0;
+	final double errorThreshold = errorPref / 100.0;
+	final double improvementThreshold = improvementPref / 100.0;
+
+	// Build the map made of one line per scenario results
+	final String[] configs = performanceResults.getConfigNames(true/*sort*/);
+	for (int i=0; i<size; i++) {
+		ScenarioResults scenarioResults = (ScenarioResults) scenarios.get(i);
+		if (!scenarioResults.isValid()) continue;
+		final boolean fingerprint = scenarioResults.hasSummary();
+		if (!fingerprints || fingerprint) {
+
+			// The first column is the scenario name
+			String scenarioName = scenarioResults.getShortName();
+			TableItem item = new TableItem (this.table, SWT.NONE);
+			item.setText(scenarioName);
+
+			// Bold font and blue ref background color if this is a fingerprint test
+			Font italic;
+			if (fingerprint) {
+				item.setFont(0, this.boldFont);
+				item.setBackground(this.blueref);
+				italic = this.boldItalicFont;
+			} else {
+				italic = this.italicFont;
+			}
+
+			// Fill config columns
+			int length = configs.length;
+			for (int j=0; j<length; j++) {
+
+				// See whether there's available numbers
+				int col = j+1;
+				final ConfigResults configResults = scenarioResults.getConfigResults(configs[j]);
+				if (configResults == null || !configResults.isValid()) {
+					item.setText(col, "Invalid");
+					item.setForeground(col, GRAY);
+					item.setFont(col, italic);
+					continue;
+				}
+				final BuildResults buildResults = configResults.getBuildResults(currentBuild);
+				if (buildResults == null) {
+					item.setText(col, "Missing results");
+					item.setForeground(col, GRAY);
+					item.setFont(col, italic);
+					continue;
+				}
+				final BuildResults referenceResults = configResults.getBuildResults(referenceBuild);
+				if (referenceResults == null) {
+					item.setText(col, "Missing ref");
+					item.setForeground(col, GRAY);
+					item.setFont(col, italic);
+					continue;
+				}
+
+				// Get numbers and infos
+				double[] values = configResults.getNumbers(buildResults, referenceResults);
+
+				// Reset tooltip info
+				String toolTipText = null;
+				String toolTipMessage = null;
+				int toolTipStyle = SWT.BALLOON;
+
+				// Get values array
+				final double buildValue = values[AbstractResults.BUILD_VALUE_INDEX];
+				final double referenceValue = values[AbstractResults.BASELINE_VALUE_INDEX];
+				final double delta = values[AbstractResults.DELTA_VALUE_INDEX];
+				final double error = values[AbstractResults.DELTA_ERROR_INDEX];
+
+				// Set text with delta value
+				item.setText(col, Util.PERCENTAGE_FORMAT.format(delta));
+
+				// Compute the tooltip to display on the cell
+				if (error > errorThreshold) {
+					// error is over the threshold
+					item.setForeground(col, this.darkyellow);
+					toolTipText = "May be not reliable";
+					toolTipMessage = "The error on this result is "+Util.PERCENTAGE_FORMAT.format(error)+", hence it may be not reliable";
+					toolTipStyle |= SWT.ICON_WARNING;
+				}
+				if (delta < -0.1) {
+					// delta < -10%: failure shown by an red-cross icon + text in red
+					item.setImage(col, ResultsElement.ERROR_IMAGE);
+				}
+				if (delta < failureThreshold) {
+					// negative delta over the threshold shown in red
+					item.setForeground(col, RED);
+				} else if (delta > improvementThreshold) {
+					// positive delta over the threshold are shown in green
+					item.setForeground(col, DARK_GREEN);
+				}
+
+				// Moderate the status if the build value or the difference is small
+				if (buildValue < 100 || referenceValue < 100) {
+					if (toolTipText == null) {
+						toolTipText = "";
+					} else {
+						toolTipText += ", ";
+					}
+					toolTipText += "Small value";
+					if (toolTipMessage == null) {
+						toolTipMessage = "";
+					} else {
+						toolTipMessage += ".\n";
+					}
+					toolTipMessage += "This test has a small value ("+buildValue+"ms)";
+					toolTipStyle |= SWT.ICON_WARNING;
+					item.setImage(col, ResultsElement.WARN_IMAGE);
+				}
+
+				// Add information in tooltip when history shows big variation
+				double deviation = configResults.getStatistics(Util.BASELINE_BUILD_PREFIXES)[3];
+				if (deviation > 0.2) {
+					// deviation is over 20% over the entire history
+					if (toolTipText == null) {
+						toolTipText = "";
+					} else {
+						toolTipText += ", ";
+					}
+					toolTipText += "History shows erratic values";
+					if (toolTipMessage == null) {
+						toolTipMessage = "";
+					} else {
+						toolTipMessage += ".\n";
+					}
+					toolTipMessage += "The results history shows that the variation of its delta is over 20% ("+Util.PERCENTAGE_FORMAT.format(deviation)+"), hence its result is surely not reliable";
+					// set the text in italic
+					item.setFont(col, italic);
+					toolTipStyle |= SWT.ICON_INFORMATION;
+				} else if (deviation > 0.1) { // moderate the status when the test
+					// deviation is between 10% and 20% over the entire history
+					if (toolTipText == null) {
+						toolTipText = "";
+					} else {
+						toolTipText += ", ";
+					}
+					toolTipText += "History shows unstable values";
+					if (toolTipMessage == null) {
+						toolTipMessage = "";
+					} else {
+						toolTipMessage += ".\n";
+					}
+					toolTipMessage += "The results history shows that the variation of its delta is between 10% and 20% ("+Util.PERCENTAGE_FORMAT.format(deviation)+"), hence its result may not be really reliable";
+					// set the text in italic
+					item.setFont(col, italic);
+					if (toolTipStyle == SWT.BALLOON && delta >= -0.1) {
+						toolTipStyle |= SWT.ICON_INFORMATION;
+					} else {
+						// reduce icon severity from error to warning
+						toolTipStyle |= SWT.ICON_WARNING;
+					}
+				}
+
+				// Set tooltip
+				if (toolTipText != null) {
+					createToolTip(toolTipText, toolTipMessage, toolTipStyle, new Point(col, i));
+				}
+			}
+		}
+	}
+	this.rowsCount = size;
+}
+
+/*
+ * The tab text is the full machine name.
+ */
+public String getTabText() {
+	return Util.componentDisplayName(this.componentName);
+}
+
+/*
+ * Init the SWT resources
+ */
+private void initResources() {
+	// Fonts
+	String fontDataName = this.gc.getFont().getFontData()[0].toString();
+	FontData fdItalic = new FontData(fontDataName);
+	fdItalic.setStyle(SWT.ITALIC);
+	this.italicFont = new Font(this.display, fdItalic);
+	FontData fdBold = new FontData(fontDataName);
+	fdBold.setStyle(SWT.BOLD);
+	this.boldFont = new Font(this.display, fdBold);
+	FontData fdBoldItalic = new FontData(fontDataName);
+	fdBoldItalic.setStyle(SWT.BOLD | SWT.ITALIC);
+	this.boldItalicFont = new Font(this.display, fdBoldItalic);
+
+	// Colors
+	this.lightred = new Color(DEFAULT_DISPLAY, 220, 50, 50);
+	this.lightyellow = new Color(DEFAULT_DISPLAY, 255, 255, 160);
+	this.darkyellow = new Color(DEFAULT_DISPLAY, 160, 160, 0);
+	this.blueref = new Color(DEFAULT_DISPLAY, 200, 200, 255);
+}
+
+/*
+ * Select the line corresponding to the given build.
+ */
+void select(BuildResultsElement buildResultsElement) {
+	int count = this.table.getItemCount();
+	String buildName = buildResultsElement.getName();
+	TableItem[] items = this.table.getItems();
+	for (int i=0; i<count; i++) {
+		if (items[i].getText().endsWith(buildName)) {
+			this.table.deselect(this.table.getSelectionIndex());
+			this.table.select(i);
+			return;
+		}
+	}
+}
+}
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ScenariosComparisonTable.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonTable.java
similarity index 97%
rename from bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ScenariosComparisonTable.java
rename to bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonTable.java
index fcfb69c..440c052 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ScenariosComparisonTable.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonTable.java
@@ -25,14 +25,14 @@
  * This class is responsible to print html table with the difference between two
  * builds for all the scenarios and the configuration of a specific component.
  */
-public class ScenariosComparisonTable {
+public class BuildsComparisonTable {
 
 	private static final double DEFAULT_FAILURE_THRESHOLD = PerformanceResults.DEFAULT_FAILURE_THRESHOLD / 100.0 / 2;
 	private String component;
 	private PrintStream stream;
 	String buildName, referenceName;
 
-public ScenariosComparisonTable(String name, PrintStream stream, String build, String reference) {
+public BuildsComparisonTable(String name, PrintStream stream, String build, String reference) {
     this.component = name;
     this.stream = stream;
     this.buildName = build;
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonView.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonView.java
new file mode 100644
index 0000000..d27eaca
--- /dev/null
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsComparisonView.java
@@ -0,0 +1,345 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2009 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.test.internal.performance.results.ui;
+
+import org.eclipse.core.runtime.preferences.IEclipsePreferences;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
+import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
+import org.eclipse.core.runtime.preferences.InstanceScope;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.IToolBarManager;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TreeSelection;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.CTabFolder;
+import org.eclipse.swt.custom.CTabItem;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.test.internal.performance.results.model.BuildResultsElement;
+import org.eclipse.test.internal.performance.results.model.PerformanceResultsElement;
+import org.eclipse.test.internal.performance.results.utils.IPerformancesConstants;
+import org.eclipse.test.internal.performance.results.utils.Util;
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IMemento;
+import org.eclipse.ui.IViewSite;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.part.ViewPart;
+
+
+/**
+ * This view shows the difference between two selected builds.
+ * <p>
+ * Each component are shown in a separate tab.
+ * </p><p>
+ * The displayed results can be written in a file, either all component or only
+ * the current one.
+ * </p><p>
+ * It's also possible to filter the scenario to display only the fingerprint ones.
+ * <br>
+ * Note that this filter is synchronized with the one applied in the
+ * {@link ComponentsView Components view}.
+ * </p>
+ *
+ * @see ConfigTab Folder tab containing all the results for a configuration.
+ */
+public class BuildsComparisonView extends ViewPart implements ISelectionChangedListener, IPreferenceChangeListener {
+
+	// SWT resources
+	CTabFolder tabFolder;
+
+	// Model information
+	BuildsComparisonTab[] tabs;
+	PerformanceResultsElement results;
+
+	// Action
+	Action filterAdvancedScenarios;
+
+	// Views
+	BuildsView buildsView;
+	IMemento viewState;
+
+	// Eclipse preferences
+	IEclipsePreferences preferences;
+
+	// Comparison
+	String currentBuild;
+	String referenceBuild;
+
+/*
+ * Default constructor:
+ * 	- create the image descriptor
+ * 	- register the view as a properties listener
+ */
+public BuildsComparisonView() {
+	this.preferences = new InstanceScope().getNode(IPerformancesConstants.PLUGIN_ID);
+	this.preferences.addPreferenceChangeListener(this);
+	// TODO should be done only once!
+	Util.initMilestones(this.preferences);
+}
+
+/*
+ * Contribute the local tools bar and the pull-down menu to the action bars.
+ */
+void contributeToActionBars() {
+	IActionBars bars = getViewSite().getActionBars();
+	fillLocalPullDown(bars.getMenuManager());
+	fillLocalToolBar(bars.getToolBarManager());
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
+ */
+public void createPartControl(Composite parent) {
+
+	// Create the tab folder
+	this.tabFolder = new CTabFolder(parent, SWT.BORDER);
+
+	// Add results view as listener to viewer selection changes
+	Display.getDefault().asyncExec(new Runnable() {
+		public void run() {
+			PerformancesView performancesView = (PerformancesView) PerformancesView.getWorkbenchView("org.eclipse.test.internal.performance.results.ui.ComponentsView");
+			if (performancesView != null) {
+				performancesView.viewer.addSelectionChangedListener(BuildsComparisonView.this);
+			}
+		}
+	});
+
+	// Set actions
+	PlatformUI.getWorkbench().getHelpSystem().setHelp(this.tabFolder, "org.eclipse.test.performance.ui.results");
+	makeActions();
+	contributeToActionBars();
+
+	// Restore state
+	restoreState();
+
+	// Create tabs
+	createTabs();
+
+	// Set selections (tab and line)
+	this.tabFolder.setSimple(false);
+}
+
+/*
+ * Create the tab folder pages. There's one tab per performance machine.
+ * The list of these machines is got from the DB_Results contants.
+ */
+void createTabs() {
+	if (this.currentBuild == null || this.referenceBuild == null) return;
+	PerformanceResultsElement performanceResultsElement = getBuildsView().results;
+	String[] components = performanceResultsElement.getComponents();
+	int length = components.length;
+	this.tabs = new BuildsComparisonTab[length];
+	for (int i=0; i<length; i++) {
+		this.tabs[i] = new BuildsComparisonTab(components[i]);
+	}
+	for (int i=0; i<this.tabs.length; i++) {
+		CTabItem item = new CTabItem (this.tabFolder, SWT.NONE);
+		item.setText (this.tabs[i].getTabText ());
+		item.setControl (this.tabs[i].createTabFolderPage(this));
+		item.setData (this.tabs[i]);
+	}
+	this.tabFolder.setSelection(0);
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.part.WorkbenchPart#dispose()
+ */
+public void dispose() {
+	this.tabFolder.dispose();
+	int length = this.tabs==null ? 0 : this.tabs.length;
+	for (int i=0; i<length; i++) {
+		this.tabs[i].dispose();
+	}
+	super.dispose();
+}
+
+/*
+ * Fill the filters drop-down menu with:
+ * 	- filter nightly builds
+ * 	- filter non-milestone builds
+ *	- filter non-fingerprint scenarios
+ */
+void fillFiltersDropDown(IMenuManager manager) {
+	manager.add(this.filterAdvancedScenarios);
+}
+
+/*
+ * Fill the local pull down menu.
+ */
+void fillLocalPullDown(IMenuManager manager) {
+	MenuManager filtersManager= new MenuManager("Filters");
+	fillFiltersDropDown(filtersManager);
+	manager.add(filtersManager);
+}
+
+/*
+ * Fill the local tool bar with:
+ * 	- change line selection display
+ */
+void fillLocalToolBar(IToolBarManager manager) {
+	//manager.add(this.fullLineSelection);
+}
+
+/*
+ * Return the components results view.
+ */
+PerformanceResultsElement getResults() {
+	if (this.results == null) {
+		this.results = getBuildsView().results;
+	}
+	return this.results;
+}
+
+/*
+ * Return the components results view.
+ */
+BuildsView getBuildsView() {
+	if (this.buildsView == null) {
+		this.buildsView = (BuildsView) PerformancesView.getWorkbenchView("org.eclipse.test.internal.performance.results.ui.BuildsView");
+	}
+	return this.buildsView;
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.part.ViewPart#init(org.eclipse.ui.IViewSite, org.eclipse.ui.IMemento)
+ */
+public void init(IViewSite site, IMemento memento) throws PartInitException {
+	super.init(site, memento);
+	this.viewState = memento;
+}
+
+/*
+ * Make the actions of the view:
+ * 	- change table line selection display
+ * 	- filter nightly builds
+ * 	- filter non-milestone builds
+ *	- filter non-fingerprint scenarios
+ */
+void makeActions() {
+
+	// Filter non-fingerprints action
+	this.filterAdvancedScenarios = new Action("Advanced &Scenarios", IAction.AS_CHECK_BOX) {
+		public void run() {
+			BuildsComparisonView.this.preferences.putBoolean(IPerformancesConstants.PRE_FILTER_ADVANCED_SCENARIOS, isChecked());
+			resetTabFolders(false/*refresh*/);
+        }
+	};
+	this.filterAdvancedScenarios.setChecked(true);
+	this.filterAdvancedScenarios.setToolTipText("Filter advanced scenarios (i.e. not fingerprint ones)");
+}
+
+/* (non-Javadoc)
+ * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
+ */
+public void preferenceChange(PreferenceChangeEvent event) {
+	String propertyName = event.getKey();
+	Object newValue = event.getNewValue();
+
+	// Filter non-fingerprints change
+	if (propertyName.equals(IPerformancesConstants.PRE_FILTER_ADVANCED_SCENARIOS)) {
+		boolean checked = newValue == null ? IPerformancesConstants.DEFAULT_FILTER_ADVANCED_SCENARIOS : "true".equals(newValue);
+		this.filterAdvancedScenarios.setChecked(checked);
+		resetTabFolders(false/*refresh*/);
+	}
+}
+
+/*
+ * Reset the table tab folders by re-create all the pages.
+ * Selections are set onto the first found error if this is the first tab creation (typically on a component change event from the ComponentsView)
+ * or to the previous one if this is just a refresh.
+ */
+void resetTabFolders(boolean init) {
+
+	// Store current indexes
+	int tabIndex = this.tabFolder.getSelectionIndex();
+	int lineIndex = tabIndex<0 ? -1 : this.tabs[tabIndex].table.getSelectionIndex();
+
+	// Create tab folders
+	CTabItem[] tabItems = this.tabFolder.getItems();
+	int length = tabItems.length;
+	if (length == 0) {
+		createTabs();
+	} else {
+		for (int i=0; i<length; i++) {
+			tabItems[i].setControl(this.tabs [i].createTabFolderPage(this));
+		}
+	}
+
+	// Set part name
+	setPartName(this.currentBuild+" vs. "+this.referenceBuild);
+
+	// Set the selection
+	if (tabIndex >= 0 && lineIndex >= 0) {
+		this.tabFolder.setSelection(tabIndex);
+		Table table = this.tabs[tabIndex].table;
+		table.setSelection(lineIndex);
+	}
+}
+
+/*
+ * Restore the view state from the memento information.
+ */
+void restoreState() {
+
+	// Filter non fingerprints action state
+	boolean checked = this.preferences.getBoolean(IPerformancesConstants.PRE_FILTER_ADVANCED_SCENARIOS, IPerformancesConstants.DEFAULT_FILTER_ADVANCED_SCENARIOS);
+	this.filterAdvancedScenarios.setChecked(checked);
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.part.ViewPart#saveState(org.eclipse.ui.IMemento)
+ */
+public void saveState(IMemento memento) {
+	super.saveState(memento);
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.eclipse.jface.viewers.ISelectionChangedListener#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
+ */
+public void selectionChanged(SelectionChangedEvent event) {
+	final Object[] selection = ((TreeSelection) event.getSelection()).toArray();
+	String firstBuildResults = null;
+	String secondBuildResults = null;
+	if (selection.length == 2) {
+		if (selection[0] instanceof BuildResultsElement) {
+			firstBuildResults = ((BuildResultsElement) selection[0]).getName();
+		}
+		if (selection[1] instanceof BuildResultsElement) {
+			secondBuildResults = ((BuildResultsElement) selection[1]).getName();
+		}
+		if (!firstBuildResults.equals(this.currentBuild) || !secondBuildResults.equals(this.referenceBuild)) {
+			this.currentBuild = firstBuildResults;
+			this.referenceBuild = secondBuildResults;
+			resetTabFolders(true);
+		}
+	}
+}
+
+/*
+ * (non-Javadoc)
+ * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
+ */
+public void setFocus() {
+	// do nothing
+}
+
+}
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsView.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsView.java
index d703105..f6b9a99 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsView.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/BuildsView.java
@@ -27,6 +27,7 @@
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
 import org.eclipse.jface.operation.IRunnableWithProgress;
 import org.eclipse.jface.resource.JFaceResources;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.LabelProvider;
 import org.eclipse.jface.viewers.SelectionChangedEvent;
@@ -38,6 +39,7 @@
 import org.eclipse.swt.graphics.Font;
 import org.eclipse.swt.graphics.FontData;
 import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
 import org.eclipse.test.internal.performance.results.db.DB_Results;
 import org.eclipse.test.internal.performance.results.model.BuildResultsElement;
 import org.eclipse.test.internal.performance.results.model.ResultsElement;
@@ -274,6 +276,7 @@
 
 	// Views
 	PerformancesView componentsView;
+	BuildsComparisonView buildsComparisonView = null;
 
 	// Results model
 	BuildResultsElement[] buildsResults;
@@ -382,6 +385,16 @@
 	};
 	this.viewer.setSorter(nameSorter);
 
+	// Add results view as listener to viewer selection changes
+	Display.getDefault().asyncExec(new Runnable() {
+		public void run() {
+			ISelectionChangedListener listener = getComparisonView();
+			if (listener != null) {
+				BuildsView.this.viewer.addSelectionChangedListener(listener);
+			}
+		}
+	});
+
 	// Finalize viewer initialization
 	PlatformUI.getWorkbench().getHelpSystem().setHelp(this.viewer.getControl(), "org.eclipse.test.performance.ui.builds");
 	finalizeViewerCreation();
@@ -440,6 +453,16 @@
 }
 
 /*
+ * Return the components results view.
+ */
+BuildsComparisonView getComparisonView() {
+	if (this.buildsComparisonView == null) {
+		this.buildsComparisonView = (BuildsComparisonView) getWorkbenchView("org.eclipse.test.internal.performance.results.ui.BuildsComparisonView");
+	}
+	return this.buildsComparisonView;
+}
+
+/*
  * Return the components view.
  */
 PerformancesView getSiblingView() {
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ComponentResultsView.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ComponentResultsView.java
index 158361d..d166c3d 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ComponentResultsView.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/ComponentResultsView.java
@@ -10,8 +10,6 @@
  *******************************************************************************/
 package org.eclipse.test.internal.performance.results.ui;
 
-import java.util.StringTokenizer;
-
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
 import org.eclipse.core.runtime.preferences.InstanceScope;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
@@ -81,9 +79,6 @@
  */
 public class ComponentResultsView extends ViewPart implements ISelectionChangedListener, IPreferenceChangeListener {
 
-	// Constants
-	private static final String ORG_ECLIPSE = "org.eclipse.";
-
 	// SWT resources
 	CTabFolder tabFolder;
 
@@ -337,7 +332,7 @@
 
 	// Set the part name when possible
 	if (this.componentResultsElement != null) {
-		setPartName();
+		setPartName(Util.componentDisplayName(this.componentResultsElement.getName()));
 	}
 
 	// If this is the first display then look for the first error to set the selection on it
@@ -486,7 +481,7 @@
  * 	- org.eclipse.jdt.ui -> "JDT/UI"
  * 	- org.eclipse.jdt.core -> "JDT/Core"
  * 	- org.eclipse.pde.api.tools -> "PDE/API Tools"
- */
+ *
 protected void setPartName() {
 	String componentName = this.componentResultsElement.getName();
 	String partName;
@@ -527,5 +522,6 @@
 	buffer.append("' results");
 	setPartName(buffer.toString());
 }
+*/
 
 }
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferenceInitializer.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferenceInitializer.java
index 4f27bfe..d40edc3 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferenceInitializer.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferenceInitializer.java
@@ -43,6 +43,11 @@
 	// Status
 	defaultPreferences.putInt(PRE_WRITE_STATUS, IPerformancesConstants.DEFAULT_WRITE_STATUS);
 
+	// Comparison
+	defaultPreferences.putInt(PRE_COMPARISON_THRESHOLD_FAILURE, IPerformancesConstants.DEFAULT_COMPARISON_THRESHOLD_FAILURE);
+	defaultPreferences.putInt(PRE_COMPARISON_THRESHOLD_ERROR, IPerformancesConstants.DEFAULT_COMPARISON_THRESHOLD_ERROR);
+	defaultPreferences.putInt(PRE_COMPARISON_THRESHOLD_IMPROVEMENT, IPerformancesConstants.DEFAULT_COMPARISON_THRESHOLD_IMPROVEMENT);
+
 	// Config descriptors
 	String[][] configDescriptors = PerformanceTestPlugin.getConfigDescriptors();
 	int cdLength = configDescriptors.length;
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferencePage.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferencePage.java
index d5c4b6b..459d1ed 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferencePage.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/ui/PerformanceResultsPreferencePage.java
@@ -82,6 +82,9 @@
 	private Button statusStatisticErraticRadioButton;
 	private Button statusStatisticUnstableRadioButton;
 	private Text statusBuildsToConfirm;
+	private Text comparisonThresholdFailure;
+	private Text comparisonThresholdError;
+	private Text comparisonThresholdImprovement;
 
 	// TODO See whether config descriptors need to be set as preferences or not...
 	// private Table configDescriptorsTable;
@@ -221,6 +224,21 @@
 		this.statusBuildsToConfirm = createTextField(statusGroup);
 		this.statusBuildsToConfirm.setToolTipText("The number of previous builds to take into account to confirm a regression");
 
+		// Comparison
+		Composite compositeComparison = createComposite(parent, 1, 3);
+		Group comparisonGroup = createGroup(compositeComparison, "Comparison", 1);
+		Group thresholdsGroup = createGroup(comparisonGroup, "Thresholds", 6);
+//		Composite compositeFailureThreshold = createComposite(comparisonGroup, 2, 2);
+		createLabel(thresholdsGroup, "Failure:", false);
+		this.comparisonThresholdFailure = createTextField(thresholdsGroup);
+		this.comparisonThresholdFailure.setToolTipText("The threshold in percentage to report a failure");
+		createLabel(thresholdsGroup, "Error:", false);
+		this.comparisonThresholdError = createTextField(thresholdsGroup);
+		this.comparisonThresholdError.setToolTipText("The threshold in percentage to report an error");
+		createLabel(thresholdsGroup, "Improvement:", false);
+		this.comparisonThresholdImprovement = createTextField(thresholdsGroup);
+		this.comparisonThresholdImprovement.setToolTipText("The threshold in percentage to report an improvement");
+
 		// Milestones
 		Composite compositeMilestones = createComposite(parent, 3, 1);
 		createLabel(compositeMilestones, "Milestones", false);
@@ -526,6 +544,11 @@
 	int writeStatus = store.getDefaultInt(PRE_WRITE_STATUS);
 	initStatusValues(writeStatus);
 
+	// Init comparison thresholds
+	this.comparisonThresholdFailure.setText(String.valueOf(store.getDefaultInt(PRE_COMPARISON_THRESHOLD_FAILURE)));
+	this.comparisonThresholdError.setText(String.valueOf(store.getDefaultInt(PRE_COMPARISON_THRESHOLD_ERROR)));
+	this.comparisonThresholdImprovement.setText(String.valueOf(store.getDefaultInt(PRE_COMPARISON_THRESHOLD_IMPROVEMENT)));
+
 	// Init eclipse version
 	this.mVersionRadioButton.setSelection(false);
 	this.dVersionRadionButton.setSelection(false);
@@ -596,6 +619,11 @@
 	int writeStatus = store.getInt(PRE_WRITE_STATUS);
 	initStatusValues(writeStatus);
 
+	// Init comparison thresholds
+	this.comparisonThresholdFailure.setText(String.valueOf(store.getInt(PRE_COMPARISON_THRESHOLD_FAILURE)));
+	this.comparisonThresholdError.setText(String.valueOf(store.getInt(PRE_COMPARISON_THRESHOLD_ERROR)));
+	this.comparisonThresholdImprovement.setText(String.valueOf(store.getInt(PRE_COMPARISON_THRESHOLD_IMPROVEMENT)));
+
 	// Init eclipse version
 	int version = store.getInt(PRE_ECLIPSE_VERSION);
 	if (version == ECLIPSE_MAINTENANCE_VERSION) {
@@ -1004,6 +1032,11 @@
 	writeStatus += Integer.parseInt(this.statusBuildsToConfirm.getText());
 	store.setValue(PRE_WRITE_STATUS, writeStatus);
 
+	// Init comparison thresholds
+	store.setValue(PRE_COMPARISON_THRESHOLD_FAILURE, Integer.parseInt(this.comparisonThresholdFailure.getText()));
+	store.setValue(PRE_COMPARISON_THRESHOLD_ERROR, Integer.parseInt(this.comparisonThresholdError.getText()));
+	store.setValue(PRE_COMPARISON_THRESHOLD_IMPROVEMENT, Integer.parseInt(this.comparisonThresholdImprovement.getText()));
+
 	// Set milestones
 	String prefix = PRE_MILESTONE_BUILDS + "." + version;
 	count  = this.milestonesCombo.getItemCount();
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/IPerformancesConstants.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/IPerformancesConstants.java
index 0dc421b..b1bd2b1 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/IPerformancesConstants.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/IPerformancesConstants.java
@@ -76,6 +76,14 @@
 	public static final int STATUS_STATISTICS_MASK = 0xC000;
 	public static final int DEFAULT_WRITE_STATUS = STATUS_ERROR_NONE | DEFAULT_BUILDS_NUMBER;
 
+	// Comparison
+    public static final String PRE_COMPARISON_THRESHOLD_FAILURE = PREFIX + "comparison.threshold.failure"; //$NON-NLS-1$
+	public static final int DEFAULT_COMPARISON_THRESHOLD_FAILURE = 10;
+    public static final String PRE_COMPARISON_THRESHOLD_ERROR = PREFIX + "comparison.threshold.error"; //$NON-NLS-1$
+	public static final int DEFAULT_COMPARISON_THRESHOLD_ERROR = 3;
+    public static final String PRE_COMPARISON_THRESHOLD_IMPROVEMENT = PREFIX + "comparison.threshold.imporvement"; //$NON-NLS-1$
+	public static final int DEFAULT_COMPARISON_THRESHOLD_IMPROVEMENT = 10;
+
 	// Default milestones nowadays
 	public static final String[] V37_MILESTONES = new String[] {
 	};
diff --git a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/Util.java b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/Util.java
index 185b4d7..4bddd41 100644
--- a/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/Util.java
+++ b/bundles/org.eclipse.test.performance.ui/src/org/eclipse/test/internal/performance/results/utils/Util.java
@@ -78,6 +78,9 @@
 	private static String[] MILESTONES;
 	public static final BuildDateComparator BUILD_DATE_COMPARATOR = new BuildDateComparator();
 
+	// Components constants
+	public static final String ORG_ECLIPSE = "org.eclipse.";
+
 static class BuildDateComparator implements Comparator {
 	public int compare(Object o1, Object o2) {
 		String s1 = (String) o1;
@@ -120,6 +123,84 @@
 public static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyyMMddHHmm"); //$NON-NLS-1$
 
 /**
+ * Return the name to display for the given component.
+ * <p>
+ * This name is built from the name of the component selected in the Components view.
+ * The rules to build the name are:
+ * <ol>
+ * <li>If the component name does not start with "org.eclipse" then the part name is just
+ * 		"<b>component name</b>"</li>
+ * <li>Otherwise, remove "org.eclipse." form the component name and count
+ * 		the tokens separated by a dot ('.')
+ * 		<ul>
+ * 		<li>If there's only one remaining token, then the part name is "<b>Platform/</b>"
+ * 			followed by:
+ * 			<ul>
+ * 			<li>"<b><i>TOKEN</i></b>" if token is less than 3 characters,</li>
+ * 			<li>"<b><i>Token</i></b>" otherwise</li>
+ * 			</ul>
+ * 		</li>
+ * 		<li>Otherwise then the part name is "<b><i>FIRST_TOKEN</i></b>" followed by:
+ * 			<ul>
+ * 			<li>for each followed additional token:
+ * 				<ul>
+ * 				<li>"<b><i>TOKEN</i></b>" if token is less than 3 characters,</li>
+ * 				<li>"<b><i>Token</i></b>" otherwise</li>
+ * 				</ul>
+ * 			</li>
+ * 			</ul>
+ * 		</li>
+ * 		</ul>
+ * </ol>
+ * E.g.
+ * 	- org.eclipse.ui -> "Platform/UI"
+ * 	- org.eclipse.swt -> "Platform/SWT"
+ * 	- org.eclipse.team -> "Platform/Team"
+ * 	- org.eclipse.jdt.ui -> "JDT/UI"
+ * 	- org.eclipse.jdt.core -> "JDT/Core"
+ * 	- org.eclipse.pde.api.tools -> "PDE/API Tools"
+ */
+public static String componentDisplayName(String componentName) {
+	String partName;
+	StringBuffer buffer = null;
+	if (componentName.startsWith(ORG_ECLIPSE)) {
+		partName = componentName.substring(ORG_ECLIPSE.length());
+		StringTokenizer tokenizer = new StringTokenizer(partName, ".");
+		while (tokenizer.hasMoreTokens()) {
+			String token = tokenizer.nextToken();
+			if (buffer == null) {
+				if (tokenizer.hasMoreTokens()) {
+					buffer = new StringBuffer("'"+token.toUpperCase());
+					buffer.append('/');
+				} else {
+					buffer = new StringBuffer("'Platform/");
+					if (token.length() > 3) {
+						buffer.append(Character.toUpperCase(token.charAt(0)));
+						buffer.append(token.substring(1));
+					} else {
+						buffer.append(token.toUpperCase());
+					}
+				}
+			} else {
+				if (token.length() > 3) {
+					buffer.append(Character.toUpperCase(token.charAt(0)));
+					buffer.append(token.substring(1));
+				} else {
+					buffer.append(token.toUpperCase());
+				}
+				if (tokenizer.hasMoreTokens()) buffer.append(' ');
+			}
+		}
+	} else {
+		buffer = new StringBuffer("'");
+		buffer.append(componentName);
+		buffer.append("'");
+	}
+	buffer.append("' results");
+	return buffer.toString();
+}
+
+/**
  * Compute the student t-test values.
  *
  * @see "http://en.wikipedia.org/wiki/Student's_t-test"