Attachment #77485 for bug #201469




 *******************************************************************************/
package org.eclipse.test.performance.ui;

import java.io.*;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.net.URL;
import java.util.*;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Hashtable;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.test.internal.performance.PerformanceTestPlugin;
import org.eclipse.test.internal.performance.results.AbstractResults;
import org.eclipse.test.internal.performance.results.ConfigResults;
import org.eclipse.test.internal.performance.results.DB_Results;
import org.eclipse.test.internal.performance.results.PerformanceResults;
import org.eclipse.test.internal.performance.results.ScenarioResults;
import org.osgi.framework.Bundle;

/**
 * Main class to generate performance results of all scenarii matching a given pattern
 * in one HTML page per component.
 * 
 * @see #printUsage() method to see a detailed parameters usage
 */
public class Main implements IApplication {

/**
 * Prefix of baseline builds displayed in data graphs.
 * This field is set using <b>-baselinePrefix</b> argument.
 * <p>
 * Example:
 *		<pre>-baseline.prefix 3.2_200606291905</pre>
 *
 * @see #currentBuildPrefixes
 */
private String baselinePrefix = null;

/**
 * Root directory where all files are generated.
 * This field is set using <b>-output</b> argument.
 * <p>
 * Example:
 * 	<pre>-output /releng/results/I20070615-1200/performance</pre>
 */
private File outputDir;

/**
 * Arrays of 2 strings which contains config information: name and description.
 * This field is set using <b>-config</b> and/or <b>-config.properties</b> arguments.
 * <p>
 * Example:
 * <pre>
 * 	-config eclipseperflnx3_R3.3,eclipseperfwin2_R3.3,eclipseperflnx2_R3.3,eclipseperfwin1_R3.3,eclipseperflnx1_R3.3
 * 	-config.properties
 * 		"eclipseperfwin1_R3.3,Win XP Sun 1.4.2_08 (2 GHz 512 MB);
 * 		eclipseperflnx1_R3.3,RHEL 3.0 Sun 1.4.2_08 (2 GHz 512 MB);
 * 		eclipseperfwin2_R3.3,Win XP Sun 1.4.2_08 (3 GHz 2 GB);
 * 		eclipseperflnx2_R3.3,RHEL 3.0 Sun 1.4.2_08 (3 GHz 2 GB);
 * 		eclipseperflnx3_R3.3,RHEL 4.0 Sun 1.4.2_08 (3 GHz 2.5 GB)"
 * </pre>
 * Note that:
 * <ul>
 * <li>if only <b>-config</b> is set, then configuration name is used for description </li>
 * <li>if only <b>-config.properties</b> is set, then all configurations defined with this argument are generated
 * <li>if both arguments are defined, then only configurations defined by <b>-config</b> argument are generated,
 * 		<b>-config.properties</b> argument is only used to set the configuration description.</li>
 * </ul>
 */
private String[][] configDescriptors;

/**
 * Scenario pattern used to generate performance results.
 * This field is set using <b>-scenarioPattern</b> argument.
 * <p>
 * Note that this pattern uses SQL conventions, not RegEx ones,
 * which means that '%' is used to match several consecutive characters
 * and '_' to match a single character.
 * <p>
 * Example:
 * 	<pre>-scenario.pattern org.eclipse.%.test</pre>
 */
private String scenarioPattern;

/**
 * A list of prefixes for builds displayed in data graphs.
 * This field is set using <b>-currentPrefix</b> argument.
 * <p>
 * Example:
 * 	<pre>-current.prefix N, I</pre>
 * 
 * @see #baselinePrefix
 */
private List currentBuildPrefixes;

/**
 * A list of prefixes of builds to highlight in displayed data graphs.
 * This field is set using <b>-highlight</b> and/or <b>-highlight.latest</b> arguments.
 * <p>
 * Example:
 * 	<pre>-higlight 3_2</pre>
 */
private List pointsOfInterest;

/**
 * Tells whether only fingerprints has to be generated.
 * This field is set to <code>true</code> if <b>-fingerprints</b> argument is specified.
 * <p>
 * Default is <code>false</code> which means that scenario data
 * will also be generated.
 * 
 * @see #genData
 * @see #genAll
 */
private boolean genFingerPrints = false;

/**
 * Tells whether only fingerprints has to be generated.
 * This field is set to <code>true</code> if <b>-data</b> argument is specified.
 * <p>
 * Default is <code>false</code> which means that fingerprints
 * will also be generated.
 * 
 * @see #genFingerPrints
 * @see #genAll
 */
private boolean genData = false;

/**
 * Tells whether only fingerprints has to be generated.
 * This field is set to <code>false</code>
 * if <b>-fingerprints</b> or <b>-data</b> argument is specified.
 * <p>
 * Default is <code>true</code> which means that scenario data
 * will also be generated.
 * 
 * @see #genData
 * @see #genFingerPrints
 */
private boolean genAll = true;

/**
 * Tells whether information should be displayed in the console while generating.
 * This field is set to <code>true</code> if <b>-print</b> argument is specified.
 * <p>
 * Default is <code>false</code> which means that nothing is print during the generation.
 */
private boolean print = false;

/*
 * Parse the command arguments and create corresponding performance
 * results object.
 */
private PerformanceResults parse(Object argsObject) {
	StringBuffer buffer = new StringBuffer("Parameters used to generate performance results:\n");
	String[] args = (String[]) argsObject;
	int i = 0;
	if (args.length == 0) {
		printUsage();
	}

	String currentBuildId = null;
	String baseline = null;
	String jvm = null;
	this.configDescriptors = null;

	while (i < args.length) {
		String arg = args[i];
		if (!arg.startsWith("-")) {
			i++;
			continue;
		}
		if (args.length == i + 1 && i != args.length - 1) {
			System.out.println("Missing value for last parameter");
			printUsage();
		}
		if (arg.equals("-baseline")) {
			baseline = args[i + 1];
			if (baseline.startsWith("-")) {
				System.out.println("Missing value for -baseline parameter");
				printUsage();
			}
			buffer.append("	-baseline = "+baseline+'\n');
			i++;
			continue;
		}
		if (arg.equals("-baseline.prefix")) {
			this.baselinePrefix = args[i + 1];
			if (this.baselinePrefix.startsWith("-")) {
				System.out.println("Missing value for -baseline.prefix parameter");
				printUsage();
	private void generate(Utils.ConfigDescriptor cd) {
			//String config=cd.getName();
			String dbloc_property= System.getProperty("eclipse.perf.dbloc");
			if (dbloc_property == null || dbloc_property.equals(""))
				System.out.println("WARNING:  eclipse.perf.dbloc value set to null");
			scenarios = Utils.getScenarios("%", scenarioFilter, cd.name, jvm);
			variations = Utils.getVariations("%", cd.name, jvm);

			//creates and stores fingerprint objects
			if (genFingerPrints || genAll) {
				System.out.print(cd.name + ": generating fingerprints and scenario status tables...");
				
				//global
				FingerPrint global = new FingerPrint(null, cd, baseline, currentBuildId, variations, output);
				
				//store mappings of fingerprints per config for each component
				Hashtable t;
				if (fingerPrints.get("global") != null)
					t = (Hashtable) fingerPrints.get("global");
				else
					t = new Hashtable();

				t.put(cd.name, global);
				fingerPrints.put("global", t);

				//get unique component names from scenario names
				ArrayList components = Utils.getComponentNames(scenarios);
		
				//store fingerprints for config for each component
				for (int i = 0; i < components.size(); i++) {
					String component = components.get(i).toString();
					variations.put("config", cd.name);
					FingerPrint componentFp = new FingerPrint(component, cd, baseline, currentBuildId, variations, output);
					if (fingerPrints.get(component) != null)
						t = (Hashtable) fingerPrints.get(component);
					else
						t = new Hashtable();
					t.put(cd.name, componentFp);
					fingerPrints.put(component, t);
					if (componentFp.scenarioComments!=null)
						scenarioComments.putAll(componentFp.scenarioComments);
				}
				System.out.println("done.");
			}
			buffer.append("	-baselinePrefix = "+this.baselinePrefix+'\n');
			i++;
			continue;
				System.out.print(cd.name
						+ ": generating scenario results...");
				new ScenarioResults(cd,scenarios, baseline,baselinePrefix,currentBuildId,pointsOfInterest,scenarioComments,currentBuildStreamIdPrefixes,rawDataTables,output,variations);
				System.out.println("done.");
			}
		}
	

	private void parse(Object argsObject) {
		String []args=(String[])argsObject;
		int i = 0;
		if (args.length == 0) {
			printUsage();
		}
		if (arg.equals("-current.prefix")) {
			String idPrefixList = args[i + 1];
			if (idPrefixList.startsWith("-")) {
				System.out.println("Missing value for -current.prefix parameter");
				i++;
				continue;
			}
			if (args.length==i+1&&i!=args.length-1){
				System.out.println("Missing value for last parameter");
				printUsage();
			}
			buffer.append("	-current.prefix = ");
			String[] ids = idPrefixList.split(",");
			this.currentBuildPrefixes = new ArrayList();
			for (int j = 0; j < ids.length; j++) {
				this.currentBuildPrefixes.add(ids[j]);
				buffer.append(ids[j]);
				i++;
				continue;
			}
			buffer.append('\n');
			i++;
			continue;
		}
		if (arg.equals("-highlight") || arg.equals("-highlight.latest")) {
			if (args[i + 1].startsWith("-")) {
				System.out.println("Missing value for -highlight parameter");
				printUsage();
			}
			buffer.append("	"+arg+" = ");
			String[] ids = args[i + 1].split(",");
			this.pointsOfInterest = new ArrayList();
			for (int j = 0; j < ids.length; j++) {
				this.pointsOfInterest.add(ids[j]);
				buffer.append(ids[j]);
				String []ids=idPrefixList.split(",");
				currentBuildStreamIdPrefixes=new ArrayList();
				for (int j=0;j<ids.length;j++){
					currentBuildStreamIdPrefixes.add(ids[j]);
				}
				i++;
				continue;
			}
			buffer.append('\n');
			i++;
			continue;
		}
		if (arg.equals("-current")) {
			currentBuildId  = args[i + 1];
			if (currentBuildId.startsWith("-")) {
				System.out.println("Missing value for -current parameter");
				printUsage();
				}
				i++;
				continue;
			}
			buffer.append("	-current = "+currentBuildId+'\n');
			i++;
			continue;
		}
		if (arg.equals("-jvm")) {
			jvm = args[i + 1];
			if (jvm.startsWith("-")) {
				System.out.println("Missing value for -jvm parameter");
				printUsage();
			}
			buffer.append("	-jvm = "+jvm+'\n');
			i++;
			continue;
		}
		if (arg.equals("-output")) {
			String dir = args[++i];
			if (dir.startsWith("-")) {
				System.out.println("Missing value for -output parameter");
				printUsage();
			}
			this.outputDir = new File(dir);
			if (!this.outputDir.exists() && !this.outputDir.mkdirs()) {
				System.err.println("Cannot create directory "+dir+" to write results in!");
				System.exit(2);
					printUsage();
				}
				i++;
				continue;
			}
			buffer.append("	-output = "+dir+'\n');
			continue;
		}
		if (arg.equals("-config")) {
			String configs = args[i + 1];
			if (configs.startsWith("-")) {
				System.out.println("Missing value for -config parameter");
				printUsage();
			}
			String[] names = configs.split(",");
			int length = names.length;
			buffer.append("	-config = ");
			for (int j=0; j<length; j++) {
				if (j>0) buffer.append(',');
				buffer.append(names[j]);
			}
			if (this.configDescriptors == null) {
				this.configDescriptors = new String[length][2];
				for (int j=0; j<length; j++) {
					this.configDescriptors[j][0] = names[j];
					this.configDescriptors[j][1] = names[j];
				}
			} else {
				int confLength = this.configDescriptors[0].length;
				int newLength = confLength;
				mainLoop: for (int j=0; j<confLength; j++) {
					for (int k=0; k<length; k++) {
						if (this.configDescriptors[j][0].equals(names[k])) {
							continue mainLoop;
						}
					}
					this.configDescriptors[j][0] = null;
					this.configDescriptors[j][1] = null;
					newLength--;
				}
				if (newLength < confLength) {
					String[][] newDescriptors = new String[newLength][2];
					for (int j=0, c=0; j<newLength; j++) {
						if (this.configDescriptors[c] != null) {
							newDescriptors[j][0] = this.configDescriptors[c][0];
							newDescriptors[j][1] = this.configDescriptors[c][1];
						} else {
							c++;
						}
					}
					this.configDescriptors = newDescriptors;
				}
				i++;
				continue;
			}
			buffer.append('\n');
			i++;
			continue;
		}
		if (arg.equals("-config.properties")) {
			String configProperties = args[i + 1];
			if (configProperties.startsWith("-")) {
				System.out.println("Missing value for -config.properties parameter");
				printUsage();
			}
			if (this.configDescriptors == null) {
				System.out.println("Missing -config parameter");
				printUsage();
				i++;
				continue;
			}
			int length = this.configDescriptors.length;
			StringTokenizer tokenizer = new StringTokenizer(configProperties, ";");
			buffer.append("	-config.properties = ");
			while (tokenizer.hasMoreTokens()) {
				String labelDescriptor = tokenizer.nextToken();
				String[] elements = labelDescriptor.trim().split(",");
				for (int j=0; j<length; j++) {
					if (elements[0].equals(this.configDescriptors[j][0])) {
						this.configDescriptors[j][1] = elements[1];
						buffer.append("\n\t\t+ ");
						buffer.append(elements[0]);
						buffer.append(" -> ");
						buffer.append(elements[1]);
					}
				}
			}
			buffer.append('\n');
			i++;
			continue;
		}
		if (arg.equals("-scenario.filter") || arg.equals("-scenario.pattern")) {
			this.scenarioPattern= args[i + 1];
			if (this.scenarioPattern.startsWith("-")) {
				System.out.println("Missing value for -baseline parameter");
				printUsage();
			}
			buffer.append("	"+arg+" = "+this.scenarioPattern+'\n');
			i++;
			continue;
		}
		if (arg.equals("-fingerprints")) {
			this.genFingerPrints = true;
			this.genAll = false;
			buffer.append("	-fingerprints\n");
			i++;
			continue;
		}
		if (arg.equals("-data")) {
			this.genData = true;
			this.genAll = false;
			buffer.append("	-data\n");
			i++;
			continue;
		}
		if (arg.equals("-print")) {
			this.print = true;
			buffer.append("	-print\n");
			i++;
			continue;
		}
		i++;
	}
	if (this.print) System.out.println(buffer.toString());
	if (baseline == null || this.outputDir == null || this.configDescriptors == null || jvm == null || currentBuildId == null) {
		printUsage();
	}
	if (this.baselinePrefix == null) {
		// Assume that baseline name format is *always* x.y_yyyyMMddhhmm_yyyyMMddhhmm
		this.baselinePrefix = baseline.substring(0, baseline.lastIndexOf('_'));
	}

	if (this.currentBuildPrefixes == null) {
		this.currentBuildPrefixes = new ArrayList();
		this.currentBuildPrefixes.add("N");
		this.currentBuildPrefixes.add("I");
	}
	return new PerformanceResults(currentBuildId, baseline, this.print);
}

/*
 * Print component PHP file
 */
private void printComponent(PerformanceResults performanceResults, String component) throws FileNotFoundException {
	if (this.print) System.out.print(".");
	File outputFile = new File(this.outputDir, component + ".php");
	PrintStream stream = new PrintStream(new BufferedOutputStream(new FileOutputStream(outputFile)));
	stream.println(Utils.HTML_OPEN);
	stream.println("<link href=\"ToolTip.css\" rel=\"stylesheet\" type=\"text/css\"><script src=\"ToolTip.js\"></script>");
	stream.println(Utils.HTML_DEFAULT_CSS);
	stream.println("<body>");

	String baselineName = performanceResults.getBaselineName();
	String currentName = performanceResults.getName();
	boolean isGlobal = component.equals("global");
	StringBuffer title = new StringBuffer("<h3>Performance of ");
	if (!isGlobal) {
		title.append(component);
		title.append(": ");
	}
	title.append(currentName);
	title.append(" relative to ");
	int index = baselineName.indexOf('_');
	title.append(baselineName.substring(0, index));
	title.append(" (");
	index = baselineName.lastIndexOf('_');
	title.append(baselineName.substring(index+1, baselineName.length()));
	title.append(")</h3>");
	stream.println(title.toString());

	// print the html representation of fingerprint for each config
	if (genFingerPrints || genAll) {
		FingerPrint fingerprint = new FingerPrint(component, stream, this.outputDir);
		try {
			fingerprint.print(performanceResults);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	// print scenario status table
	if (isGlobal) {
		if (!PerformanceTestPlugin.getDBLocation().startsWith("net://")) {
			stream.println("<table border=0 cellpadding=2 cellspacing=5 width=\"100%\">");
			stream.println("<tbody><tr> <td colspan=3 align=\"left\" bgcolor=\"#0080c0\" valign=\"top\"><b><font color=\"#ffffff\" face=\"Arial,Helvetica\">");
			stream.println("Detailed performance data grouped by scenario prefix</font></b></td></tr></tbody></table>");
			stream.println("<a href=\"org.eclipse.ant.php?\">org.eclipse.ant*</a><br>");
			stream.println("<a href=\"org.eclipse.compare.php?\">org.eclipse.compare*</a><br>");
			stream.println("<a href=\"org.eclipse.core.php?\">org.eclipse.core*</a><br>");
			stream.println("<a href=\"org.eclipse.jdt.core.php?\">org.eclipse.jdt.core*</a><br>");
			stream.println("<a href=\"org.eclipse.jdt.debug.php?\">org.eclipse.jdt.debug*</a><br>");
			stream.println("<a href=\"org.eclipse.jdt.text.php?\">org.eclipse.jdt.text*</a><br>");
			stream.println("<a href=\"org.eclipse.jdt.ui.php?\">org.eclipse.jdt.ui*</a><br>");
			stream.println("<a href=\"org.eclipse.jface.php?\">org.eclipse.jface*</a><br>");
			stream.println("<a href=\"org.eclipse.osgi.php?\">org.eclipse.osgi*</a><br>");
			stream.println("<a href=\"org.eclipse.pde.ui.php?\">org.eclipse.pde.ui*</a><br>");
			stream.println("<a href=\"org.eclipse.swt.php?\">org.eclipse.swt*</a><br>");
			stream.println("<a href=\"org.eclipse.team.php?\">org.eclipse.team*</a><br>");
			stream.println("<a href=\"org.eclipse.ua.php?\">org.eclipse.ua*</a><br>");
			stream.println("<a href=\"org.eclipse.ui.php?\">org.eclipse.ui*</a><br><p><br><br>");
		}
	} else if (component.length() > 0) {
		// print the component scenario status table beneath the fingerprint
		ScenarioStatusTable sst = new ScenarioStatusTable(component, stream);
		try {
			sst.print(performanceResults);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	stream.println(Utils.HTML_CLOSE);
	stream.close();
}

/*
 * Print summary of coefficient of variation for each scenario of the given pattern
 * both for baseline and current builds.
 */
private void printSummary(PerformanceResults performanceResults) {
	long start = System.currentTimeMillis();
	if (this.print) System.out.print("Print scenarii variations summary...");
	File outputFile = new File(this.outputDir, "cvsummary.html");
	PrintStream stream = null;
	try {
		stream = new PrintStream(new BufferedOutputStream(new FileOutputStream(outputFile)));
		printSummaryPresentation(stream);
		List scenarioNames = DB_Results.getScenariiNames();
		int size = scenarioNames.size();
		printSummaryColumnsTitle(stream, performanceResults);
		String[] configs = performanceResults.getConfigNames(true/*sorted*/);
		int configsLength = configs.length;
		for (int i=0; i<size; i++) {
			String scenarioName = (String) scenarioNames.get(i);
			if (scenarioName == null) continue;
			ScenarioResults scenarioResults = performanceResults.getScenarioResults(scenarioName);
			if (scenarioResults != null) {
				stream.println("<tr>");
				for (int j=0; j<2; j++) {
					for (int c=0; c<configsLength; c++) {
						printSummaryScenarioLine(j, configs[c], scenarioResults, stream);
					}
				}
				stream.print("<td>");
				stream.print(scenarioName);
				stream.println("</td></tr>");
			}
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		stream.println("</table></body></html>");
		stream.flush();
		stream.close();
	}
	if (this.print) System.out.println("done in "+(System.currentTimeMillis()-start)+"ms");
}

/*
 * Print summary presentation (eg. file start and text presenting the purpose of this file contents)..
 */
private void printSummaryPresentation(PrintStream stream) {
	stream.println(Utils.HTML_OPEN);
	stream.print(Utils.HTML_DEFAULT_CSS);
	stream.println("<title>Summary of Elapsed Process Variation Coefficients</title></head>");
	stream.println("<body><h3>Summary of Elapsed Process Variation Coefficients</h3>\n");
	stream.println("<p> This table provides a bird's eye view of variability in elapsed process times\n");
	stream.print("for baseline and current build stream performance scenarios.");
	stream.print(" This summary is provided to facilitate the identification of scenarios that should be examined due to high variability.");
	stream.println("The variability for each scenario is expressed as a <a href=\"http://en.wikipedia.org/wiki/Coefficient_of_variation\">coefficient\n");
	stream.println("of variation</a> (CV). The CV is calculated by dividing the <b>standard deviation\n");
	stream.println("of the elapse process time over builds</b> by the <b>average elapsed process\n");
	stream.println("time over builds</b> and multiplying by 100.\n");
	stream.println("</p><p>High CV values may be indicative of any of the following:<br></p>\n");
	stream.println("<ol><li> an unstable performance test. </li>\n");
	stream.println("<ul><li>may be evidenced by an erratic elapsed process line graph.<br><br></li></ul>\n");
	stream.println("<li>performance regressions or improvements at some time in the course of builds.</li>\n");
	stream.println("<ul><li>may be evidenced by plateaus in elapsed process line graphs.<br><br></li></ul>\n");
	stream.println("<li>unstable testing hardware.\n");
	stream.print("<ul><li>consistent higher CV values for one test configuration as compared to others across");
	stream.println(" scenarios may be related to hardward problems.</li></ul></li></ol>\n");
	stream.println("<p> Scenarios are listed in alphabetical order in the far right column. A scenario's\n");
	stream.println("variation coefficients (CVs) are in columns to the left for baseline and current\n");
	stream.println("build streams for each test configuration. Scenarios with CVs > 10% are highlighted\n");
	stream.println("in yellow (10%<CV>&lt;CV<20%) and orange(CV>20%). </p>\n");
	stream.println("<p> Each CV value links to the scenario's detailed results to allow viewers to\n");
	stream.println("investigate the variability.</p>\n");
}

/*
 * Print columns titles of the summary table.
 */
private void printSummaryColumnsTitle(PrintStream stream, PerformanceResults performanceResults) {
	String[] configBoxes = performanceResults.getConfigBoxes(true/*sorted*/);
	int length = configBoxes.length;
	stream.print("<table border=\"1\"><tr><td colspan=\"");
	stream.print(length);
	stream.print("\"><b>Baseline CVs</b></td><td colspan=\"");
	stream.print(length);
	stream.println("\"><b>Current Build Stream CVs</b></td><td rowspan=\"2\"><b>Scenario Name</b></td></tr>");
	stream.print("<tr>");
	for (int n=0; n<2; n++) {
		for (int c=0; c<length; c++) {
			stream.print("<td>");
			stream.print(configBoxes[c]);
			stream.print("</td>");
		}
	}
	stream.println("</tr>\n");
}

/*
 * Print a scenario line in the summary table.
 */
private void printSummaryScenarioLine(int i, String config, ScenarioResults scenarioResults, PrintStream stream) {
	ConfigResults configResults = scenarioResults.getConfigResults(config);
	if (configResults == null || !configResults.isValid()) {
		stream.print("<td>n/a</td>");
		return;
	}
	String url = config + "/" + scenarioResults.getFileName()+".html";
	double[] stats = null;
	int dim_id = AbstractResults.SUPPORTED_DIMS[0].getId();
	if (i==0) { // baseline results
		List baselinePrefixes = new ArrayList();
		baselinePrefixes.add(this.baselinePrefix);
		stats = configResults.getStatistics(baselinePrefixes, dim_id);
	} else {
		stats = configResults.getStatistics(this.currentBuildPrefixes, dim_id);
	}
	double variation = stats[3];
	if (variation > 10 && variation < 20) {
		stream.print("<td bgcolor=\"yellow\">");
	} else if (variation >= 20) {
		stream.print("<td bgcolor=\"FF9900\">");
	} else {
		stream.print("<td>");
	}
	stream.print("<a href=\"");
	stream.print(url);
	stream.print("\"/>");
	stream.print(variation);
	stream.print("%</a></td>");
}

/*
 * Print usage in case one of the argument of the line was incorrect.
 * Note that calling this method ends the program run due to final System.exit()
 */
private void printUsage() {
	System.out.println(
		"Usage:\n\n" +
		"-baseline\n" +
		"	Build id against which to compare results.\n" +
		"	Same as value specified for the \"build\" key in the eclipse.perf.config system property.\n\n" +

		"[-baseline.prefix]\n" +
		"	Optional.  Build id prefix used in baseline test builds and reruns.  Used to plot baseline historical data.\n" +
		"	A common prefix used for the value of the \"build\" key in the eclipse.perf.config system property when rerunning baseline tests.\n\n" +

		"-current\n" +
		"	build id for which to generate results.  Compared to build id specified in -baseline parameter above.\n" +
		"	Same as value specified for the \"build\" key in the eclipse.perf.config system property. \n\n" +

		"[-current.prefix]\n" +
		"	Optional.  Comma separated list of build id prefixes used in current build stream.\n" +
		"	Used to plot current build stream historical data.  Defaults to \"N,I\".\n" +
		"	Prefixes for values specified for the \"build\" key in the eclipse.perf.config system property. \n\n" +

		"-jvm\n" +
		"	Value specified in \"jvm\" key in eclipse.perf.config system property for current build.\n\n" +

		"-config\n" +
		"	Comma separated list of config names for which to generate results.\n" +
		"	Same as values specified in \"config\" key in eclipse.perf.config system property.\n\n" +

		"-output\n" +
		"	Path to default output directory.\n\n" +

		"[-config.properties]\n" +
		"	Optional.  Used by scenario status table to provide the following:\n" +
		"		alternate descriptions of config values to use in columns.\n" +
		"	The value should be specified in the following format:\n" +
		"	name1,description1;name2,description2;etc..\n\n" +

		"[-highlight]\n" +
		"	Optional.  Comma-separated list of build Id prefixes used to find most recent matching for each entry.\n" +
		"	Result used to highlight points in line graphs.\n\n" +

		"[-scenario.pattern]\n" +
		"	Optional.  Scenario prefix pattern to query database.  If not specified,\n" +
		"	default of % used in query.\n\n" +

		"[-fingerprints]\n" +
		"	Optional.  Use to generate fingerprints only.\n\n" +

		"[-data]\n" +
		"	Optional.  Generates table of scenario reference and current data with line graphs.\n\n" +

		"[-print]\n" +
		"	Optional.  Display output in the console while generating.\n"
	);

	System.exit(1);
}

/**
 * Generate the performance results for a specified build regarding to a specific reference.
 * This action generates following HTML files:
 * <ul>
 * <li>A summary table to see the variations for all the concerned scenarii</li>
 * <li>A global php file including global scenario fingerprints and links for all concerned components results php files</li>
 * <li>A php file for each component including scenario fingerprints and status table with links to a scenario data file</li>
 * <li>A data HTML file for each co nfig of each scenario included in status table</li>
 * </ul>
 * @see org.eclipse.equinox.app.IApplication#start(org.eclipse.equinox.app.IApplicationContext)
 */
public Object start(IApplicationContext context) throws Exception {

	// Parse arguments and read DB info
	PerformanceResults performanceResults = parse(context.getArguments().get("application.args"));
	performanceResults.read(this.configDescriptors, this.scenarioPattern);

	// Print whole scenarii summary
	printSummary(performanceResults);

	// Copy images and scripts to output dir
	Bundle bundle = UiPlugin.getDefault().getBundle();
	URL images = bundle.getEntry("images");
	URL scripts = bundle.getEntry("scripts");
	if (images != null) {
		images = FileLocator.resolve(images);
		Utils.copyImages(new File(images.getPath()), this.outputDir);
	}
	if (scripts != null) {
		scripts = FileLocator.resolve(scripts);
		Utils.copyScripts(new File(scripts.getPath()), this.outputDir);
	}

	// Print HTML pages and all linked files
	if (this.print) {
		System.out.println("Print performance results HTML pages:");
		System.out.print("	- all components");
	}
	long start = System.currentTimeMillis();
	printComponent(performanceResults, "global");
	Iterator components = performanceResults.getComponents().iterator();
	while (components.hasNext()) {
		printComponent(performanceResults, (String) components.next());
	}
	if (this.print) System.out.println("done in "+(System.currentTimeMillis()-start)+"ms");

	// Print the scenarii data
	if (genData || genAll) {
		start = System.currentTimeMillis();
		if (this.print) System.out.print("	- all scenarii data...");
		ScenarioData data = new ScenarioData(this.baselinePrefix, this.pointsOfInterest, this.currentBuildPrefixes, this.outputDir);
		try {
			data.print(performanceResults);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		if (this.print) System.out.println("done in "+(System.currentTimeMillis()-start)+"ms");
	}
	return null;
}

/* (non-Javadoc)
 * @see org.eclipse.equinox.app.IApplication#stop()
 */
public void stop() {
	// Do nothing
}
}




	private static class BarItem {

		String title;
		double value, error;
		String url;
		String slowdownExpected;
		boolean significant;

		BarItem(String t, double[] stats, String u, String slow, boolean sig) {
			title= t;
			value= -stats[0] * 100;
			error = stats[1] * 100;
			url= u;
			slowdownExpected= slow;
			significant= sig;

		fItems= new ArrayList();
	}

	public void addItem(String name, double[] stats, String url, String slow, boolean significant) {
		fItems.add(new BarItem(name, stats, url, slow, significant));
	}

	public void addItem(String name, double value, String url) {
		fItems.add(new BarItem(name, value, url, null, true));
	}

	public void addItem(String name, double value, String url, String slow, boolean significant) {
		fItems.add(new BarItem(name, value, url, slow, significant));
	}

	public int getHeight() {

		for (int i= 0; i < bars.length; i++) {

			BarItem bar= bars[i];
			double delta = bar.value;
			double error = bar.error;
			double orgDelta= delta;
			
			boolean clamped= false;
			if (NO_SCALE) {
				if (delta > max) {


			int barLength= (int) (delta / max * w2);

			if (delta < 0) {
				if (bar.slowdownExpected != null) {
					gc.setBackground(green);
				else if (bar.slowdownExpected == null)
					gc.setBackground(red);
				else
					gc.setBackground(gray);
				} else if (!bar.significant) {
					gc.setBackground(yellow);
				} else  {
					gc.setBackground(red);
				}
			} else if (!bar.significant) {
				gc.setBackground(yellow);
			} else {
				gc.setBackground(green);
			}

			gc.fillRectangle(center, y + (GAP / 2), barLength, BARHEIGHT);




/*******************************************************************************
 * Copyright (c) 2004, 2006 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

 *******************************************************************************/
package org.eclipse.test.performance.ui;

import java.util.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;

import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.test.internal.performance.data.Dim;

public class TimeLineGraph extends LineGraph{

        Comparator comparator=new TimeLineGraphItem.GraphItemComparator();
 
        while (_enum.hasMoreElements()) {
 			List items = (List) _enum.nextElement();
			Object[] fItemsArray=items.toArray();
			Arrays.sort(fItemsArray,comparator);
			int lastx = 0;
			int lasty = 0;

	}

    public void addItem(String groupName,String name, String description, double value, Color col, boolean display, long timestamp,boolean isSpecial,boolean drawBaseline) {
      	List items = (List) fItemGroups.get(groupName);
  		if (fItemGroups.get(groupName) == null) {
  			items=new ArrayList();
  			fItemGroups.put(groupName, items);
  		}
  		items.add(new TimeLineGraphItem(name, description, value, col, display,
  				timestamp,isSpecial,drawBaseline));
    }
     

    	Enumeration _enum=fItemGroups.elements();
        double maxItem= 0;
    	while (_enum.hasMoreElements()) {
			List items = (List) _enum.nextElement();
			for (int i = 0; i < items.size(); i++) {
				TimeLineGraphItem graphItem = (TimeLineGraphItem) items.get(i);
				if (graphItem.value > maxItem)
					maxItem = graphItem.value;
			}

		double minItem = getMaxItem();

		while (_enum.hasMoreElements()) {
			List items = (List) _enum.nextElement();
			for (int i = 0; i < items.size(); i++) {
				TimeLineGraphItem graphItem = (TimeLineGraphItem) items.get(i);
				if (graphItem.value < minItem)
					minItem = graphItem.value;
			}

		TimeLineGraphItem mostRecentItem = null;

		while (_enum.hasMoreElements()) {
			List items = (List) _enum.nextElement();
			for (int i = 0; i < items.size(); i++) {
				if (items.size() == 1)
					return (TimeLineGraphItem) items.get(i);
				else {
					TimeLineGraphItem graphItem = (TimeLineGraphItem) items.get(i);
					if (graphItem.timestamp > mostRecentTimestamp) {
						mostRecentTimestamp = graphItem.timestamp;
						mostRecentItem = (TimeLineGraphItem) items.get(i);
					}
				}
			}

		int n = mainGroup.size();
		int xIncrement=width/n;
		double max=getMaxItem()*1.2;
//		double min=getMinItem()*0.8;

		for (int i = 0; i < n; i++) {
			TimeLineGraphItem thisItem = (TimeLineGraphItem) fItemsArray[i];




 *******************************************************************************/
package org.eclipse.test.performance.ui;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.StringTokenizer;

import junit.framework.AssertionFailedError;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;
import org.eclipse.test.internal.performance.PerformanceTestPlugin;
import org.eclipse.test.internal.performance.data.Dim;
import org.eclipse.test.internal.performance.db.DB;
import org.eclipse.test.internal.performance.db.Scenario;
import org.eclipse.test.internal.performance.db.SummaryEntry;
import org.eclipse.test.internal.performance.db.TimeSeries;
import org.eclipse.test.internal.performance.db.Variations;
import org.eclipse.test.performance.Dimension;


public class Utils {

	public final static int OK = 0;
	public final static int NAN = 0x1;
	public final static int ERR = 0x2;
	public final static int DEV = 0x4;

	/**
	 * @param dimension
	 * @return A description of the dimension.
	 */
	public static String getDimensionDescription(String dimension) {
		/* Descriptions of dimensions */
		// Windows and Linux
		Hashtable descriptions = new Hashtable();
		descriptions.put("cpu time", "Amount of time the process ran on the CPU.");

		descriptions.put("kernel time", "Amount of time the process ran on the CPU, while the CPU was in kernel mode.");
		descriptions.put("used java heap", "Change in the amount of memory allocated for Java objects.");
		descriptions.put("working set", "Change in the amount of physical memory used by the process (other data resides in swap space).");

		// Linux
		descriptions.put("data size", "Change in the process' data and stack memory size.");
		descriptions.put("hard page faults", "Number of memory pages that were loaded from swap space on disk.");
		descriptions.put("library size", "Change in the process' library memory size.");
		descriptions.put("soft page faults",
				"Number of memory pages that were loaded from memory (i.e., they were not mapped in the process' page table, but already present in memory for some reason).");
		descriptions.put("text size", "Change in the process' code memory size, useful with start-up tests.");

		// Windows
		descriptions.put("committed", "Change in the amount of allocated memory (both, in physical memory and swap space, can be preallocated for future use).");
		descriptions.put("elapsed process", "Amount of wall-clock time.");
		descriptions.put("gdi objects", "Change in the number of GDI (Graphics Device Interface) objects, can be useful for UI tests (particularly start-up tests).");
		descriptions
				.put(
						"page faults",
						"Number of memory pages that were loaded from swap space on disk or from memory (i.e., in the latter case, they were not mapped in the process' page table, but already present in memory for some reason).");
		descriptions.put("system time", "* no longer measured, same as elapsed time, see PerformanceMonitor *");
		descriptions.put("working set peak", "Increase of the maximum working set size, useful with start-up tests.");

		if (descriptions.get(dimension.toLowerCase()) != null)
			return descriptions.get(dimension.toLowerCase()).toString();
		return "";
	}

	/**
	 * @param timeSeriesLabels -
	 *            an array of build ID's with results for a scenario.
	 * @param current -
	 *            the current build ID
	 * @return Build Id's of Nightly builds preceding current.
	 */
	public static ArrayList lastSevenNightlyBuildNames(String[] timeSeriesLabels, String current) {
		int currentIndex = getBuildNameIndex(timeSeriesLabels, current);
		ArrayList labels = new ArrayList();
		int j = 6;

		for (int i = timeSeriesLabels.length - 1; i > -1; i--) {
			if (j == -1)
				break;
			String timeSeriesLabel = timeSeriesLabels[i];
			if (timeSeriesLabel.startsWith("N") && i < currentIndex) {
				labels.add(timeSeriesLabel);
				j--;
			}
		}
		return labels;
	}

	/**
	 * Return &lt;html&gt;&lt;head&gt;&lt;meta http-equiv="Content-Type"

			+ ".indexsub { font-size: xx-small;; font-family: Arial, Helvetica, sans-serif; color: #8080FF}\n" + "</style>";

	/**
	 * An utility object which stores a name, description, url and optional
	 * output directory.
	 */
	public static class ConfigDescriptor {
		String name;
		String description;

		/**
		 *
		 * @param name
		 *            the value specifed for the key config in the
		 *            eclipse.perf.config system.property key value listings.
		 *            ie. relengbuildwin2 (machine name)
		 * @param description
		 *            a meaningful description to further describe the config.
		 *            ie. win32-win32-x86 Sun 1.4.2_06
		 */
		public ConfigDescriptor(String name, String description) {
			this.name = name;
			this.description = description;
		}

		public String getName() {
			return name;
		}

		public boolean descriptionMatches(String descr) {
			return descr.equals(this.description);
		}
	}

	/**
	 * @param configDescriptors
	 *            A semi-colon separated listing of config descriptions.<br>
	 *            Uses the following format: name,description,
	 *            url,outputdir;name2, description2,url2,output2;etc..
	 * @return a mapping of config names to their ConfigDescriptors.
	 */
	public static Hashtable getConfigDescriptors(String configDescriptors) {
		// labelMappings in pairs separated by semi-colon ie.
		// relengbuildwin2,win32-win32-x86;trelenggtk,linux-gtk-x86
		StringTokenizer tokenizer = new StringTokenizer(configDescriptors, ";");
		Hashtable configMap = new Hashtable();

		while (tokenizer.hasMoreTokens()) {
			String labelDescriptor = tokenizer.nextToken();
			String[] elements = labelDescriptor.trim().split(",");
			ConfigDescriptor descriptor = new ConfigDescriptor(elements[0], elements[1]);
			configMap.put(elements[0], descriptor);
		}
		return configMap;
	}

	/**
	 * Queries database with variation composed of buildIdPattern, config and
	 * jvm.
	 *
	 * @return Array of scenarios.
	 */
	public static Scenario[] getScenarios(String buildIdPattern, String scenarioPattern, String config, String jvm) {
		Dim[] qd = null;
		if (scenarioPattern == null)
			scenarioPattern = "";

		Variations variations = getVariations(buildIdPattern, config, jvm);
		return DB.queryScenarios(variations, scenarioPattern + "%", PerformanceTestPlugin.BUILD, qd);
	}

	/**
	 * Creates a Variations object using build id pattern, config and jvm.
	 *
	 * @param buildIdPattern

	}

	/**
	 * @param scenarios
	 * @return list of unique component names derived from prefixes to scenario
	 *         names.
	 */
	public static ArrayList getComponentNames(Scenario[] scenarios) {
		ArrayList componentNames = new ArrayList();

		for (int i = 0; i < scenarios.length; i++) {
			String prefix = null;
			Scenario scenario = scenarios[i];
			String scenarioName = scenario.getScenarioName();

			// use part of scenario name prior to .test to identify component
			if (scenarioName.indexOf(".test") != -1) {
				prefix = scenarioName.substring(0, scenarioName.indexOf(".test"));
				if (!componentNames.contains(prefix))
					componentNames.add(prefix);
			}
		}
		return componentNames;
	}

	/*
	 * @param fp -
	 *            a FingerPrint object
	 * @return - an html representation of the fingerprint.
	 *
	public static String getImageMap(FingerPrint fp) {
		String componentDescription = fp.configDescriptor.description;
		String areas = fp.bar.getAreas();
		if (areas == null)
			areas = "";
		String output = "";
		if (new File(fp.outputDirectory, fp.getOutName() + ".gif").exists()) {
			output = "<h4>" + componentDescription + "</h4>";
			output = output.concat("<img src=\"" + fp.getOutName() + ".gif\" usemap=\"#" + fp.outName + "\">" + "<map name=\"" + fp.getOutName() + "\">" + areas + "</map>\n");
		} else {
			output = output.concat("<br><br>There is no fingerprint for " + componentDescription + "<br><br>\n");
		}
		return output;
	}
	*/

	/**
	 * Utility method to copy a file.
	 *
	 * @param src the source file.

	}

	/**
	 * Returns a LineGraph object representing measurements for a scenario over
	 * builds.
	 *
	 * @param t -
	 *            the scenario object.
	 * @param dimensionName -
	 *            the name of the measurement for which to generate graph.
	 * @param baseline -
	 *            the reference build to label.
	 * @param current -
	 *            the current build to label.
	 * @param pointsOfInterest -
	 *            an array of buildIds. Points for these are highlighted on
	 *            graph.
	 * @return a LineGraph object.
	 */
	public static TimeLineGraph getLineGraph(Scenario t, String dimensionName, String baseline, String baselinePrefix, String current, ArrayList pointsOfInterest,ArrayList currentBuildIdPrefixes) {
		Display display = Display.getDefault();

		Color black = display.getSystemColor(SWT.COLOR_BLACK);
		Color yellow = display.getSystemColor(SWT.COLOR_DARK_YELLOW);
		Color magenta = display.getSystemColor(SWT.COLOR_MAGENTA);

		String scenarioName = t.getScenarioName();
		Dim[] dimensions = t.getDimensions();
		Dim dim = null;
		for (int i = 0; i < dimensions.length; i++) {
			if (dimensions[i].getName().equals(dimensionName))
				dim = dimensions[i];
		}

		TimeLineGraph graph = new TimeLineGraph(scenarioName + ": " + dimensionName, dim);
		TimeSeries ts = null;
		try {
			ts = t.getTimeSeries(dim);
			int n = ts.getLength();

			if (n > 0) {
				boolean currentFound=false;
				for (int j = 0; j < n; j++) {
					String buildID = ts.getLabel(j);
					int underscoreIndex = buildID.indexOf('_');
					String label = (underscoreIndex != -1 && (buildID.equals(baseline) || buildID.equals(current))) ? buildID.substring(0, underscoreIndex) : buildID;

					double value = ts.getValue(j);

					if (buildID.equals(current)) {
						Color color = black;
						if (buildID.startsWith("N"))
							color = yellow;

						graph.addItem("main", label, dim.getDisplayValue(value), value, color, true, getDateFromBuildID(buildID), true);
						continue;
					}
					if (pointsOfInterest.contains(buildID)&&!currentFound) {
						graph.addItem("main", label, dim.getDisplayValue(value), value, black, false, getDateFromBuildID(buildID, false), true);
						continue;
					}
					if (buildID.equals(baseline)) {
						boolean drawBaseline = (baselinePrefix != null) ? false : true;
						graph.addItem("reference", label, dim.getDisplayValue(value), value, magenta, true, getDateFromBuildID(buildID, true), true, drawBaseline);
						continue;
					}
					if (baselinePrefix != null) {
						if (buildID.startsWith(baselinePrefix) && !buildID.equals(baseline) && getDateFromBuildID(buildID, true) <= getDateFromBuildID(baseline, true)) {
							graph.addItem("reference", label, dim.getDisplayValue(value), value, magenta, false, getDateFromBuildID(buildID, true), false);
							continue;
						}
					}
					if (lastSevenNightlyBuildNames(t.getTimeSeriesLabels(), current).contains(buildID)) {
						graph.addItem("main", buildID, dim.getDisplayValue(value), value, yellow, false, getDateFromBuildID(buildID), false);
						continue;
					} else if (buildID.startsWith("N"))
							continue;

					for (int i=0;i<currentBuildIdPrefixes.size();i++){
						if (buildID.startsWith(currentBuildIdPrefixes.get(i).toString())&&!currentFound) {
							graph.addItem("main", buildID, dim.getDisplayValue(value), value, black, false, getDateFromBuildID(buildID), false);
							continue;
						}
					}
				}
			}
		} catch (AssertionFailedError e) {
			// System.err.println("Unable to get result for:
			// "+t.getScenarioName()+" "+ts.toString());
		}
		return graph;
	}

	/**
	 * Prints a LineGraph object as a gif
	 *
	 * @param p -
	 *            the LineGraph object.
	 * @param output -
	 *            the output file path.
	 */
	public static void printLineGraphGif(LineGraph p, String output) {
		File outputFile = new File(output);
		outputFile.getParentFile().mkdir();
		int GRAPH_WIDTH = 600;
		int GRAPH_HEIGHT = 200;
		Image image = new Image(Display.getDefault(), GRAPH_WIDTH, GRAPH_HEIGHT);
		p.paint(image);

		/* Downscale to 8 bit depth palette to save to gif */
		ImageData data = downSample(image);
		ImageLoader il = new ImageLoader();
		il.data = new ImageData[] { data };
		OutputStream out = null;
		try {
			out = new BufferedOutputStream(new FileOutputStream(output));
			il.save(out, SWT.IMAGE_GIF);

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally {
			image.dispose();
			if (out != null) {
				try {
					out.close();
				} catch (IOException e1) {
					// silently ignored
				}
			}
		}
	}

	/**
	 * Utility method which returns HTML code representing an image map for a
	 * LineGraph object.
	 *
	 * @param p -
	 *            the LineGraph object.
	 * @param imageSource -
	 *            the path to insert for the src attribute to <img>.
	 */
	public static String getImageMap(LineGraph p, String imageSource, String rawDataFileLink) {
		String result = "";
		String areas = p.getAreas();

		result = result.concat("<img" + " src=\"" + imageSource + "\" usemap=\"#" + p.fTitle + "\">");
		result = result.concat("<map name=\"" + p.fTitle + "\">");
		result = result.concat(areas);
		result = result.concat("</map>\n");

		return result;
	}

	/**
	 * A utility which returns the index of a given buildId in an array.
	 *
	 * @param timeSeriesLabels -
	 *            array of buildIds
	 * @param buildId -
	 *            the buildId for which to find return value.
	 * @return The index of the buildID in the array.
	 */
	public static int getBuildNameIndex(String[] timeSeriesLabels, String buildId) {
		for (int i = timeSeriesLabels.length - 1; i > -1; i--) {
			String timeSeriesLabel = timeSeriesLabels[i];
			if (timeSeriesLabel.startsWith(buildId))
				return i;
		}
		return -1;
	}

	/**
	 * Downsample Image to 8 bit depth format so that the resulting image data
	 * can be saved to GIF. Note. If the source image contains photo quality
	 * content with more than 256 colours, resulting data will look very poor.


		return -1;
	}
	
	/**
	 * Returns a message corresponding to given statistics.
	 * 
	 * @param resultStats The value with its standard error
	 * @param full
	 * @return The failure message. May be empty if stats are good...
	 */
	}

	public static void printVariabilityTable(Hashtable rawDataTables, String outputFile, Hashtable configDescriptors) {
		String[] scenarios = (String[]) rawDataTables.keySet().toArray(new String[rawDataTables.size()]);
		if (scenarios.length==0)
			return;
		Arrays.sort(scenarios);
		PrintWriter out=null;
		try {
			out = new PrintWriter(new FileWriter(new File(outputFile)));
			out.println(HTML_OPEN + "</head><body>\n");
			out.println("<h3>Summary of Elapsed Process Variation Coefficients</h3>\n"+
		"<p> This table provides a bird's eye view of variability in elapsed process times\n"+
		  "for baseline and current build stream performance scenarios." +
		  " This summary is provided to facilitate the identification of scenarios that should be examined due to high variability." +
		  "The variability for each scenario is expressed as a <a href=\"http://en.wikipedia.org/wiki/Coefficient_of_variation\">coefficient\n"+
		  "of variation</a> (CV). The CV is calculated by dividing the <b>standard deviation\n"+
		  "of the elapse process time over builds</b> by the <b>average elapsed process\n"+
		  "time over builds</b> and multiplying by 100.\n"+
		"</p><p>High CV values may be indicative of any of the following:<br></p>\n"+
		"<ol><li> an unstable performance test. </li>\n"+
		  "<ul><li>may be evidenced by an erratic elapsed process line graph.<br><br></li></ul>\n"+
		  "<li>performance regressions or improvements at some time in the course of builds.</li>\n"+
		  "<ul><li>may be evidenced by plateaus in elapsed process line graphs.<br><br></li></ul>\n"+
		  "<li>unstable testing hardware.\n" +
		  "<ul><li>consistent higher CV values for one test configuration as compared to others across" +
		  " scenarios may be related to hardward problems.</li></ul></li></ol>\n"+
		"<p> Scenarios are listed in alphabetical order in the far right column. A scenario's\n"+
		  "variation coefficients (CVs) are in columns to the left for baseline and current\n"+
		  "build streams for each test configuration. Scenarios with CVs > 10% are highlighted\n"+
		  "in yellow (10%<CV>&lt;CV<20%) and orange(CV>20%). </p>\n"+
		"<p> Each CV value links to the scenario's detailed results to allow viewers to\n"+
		  "investigate the variability.</p>\n");

			Hashtable cvTable = (Hashtable) rawDataTables.get(scenarios[0]);
			String[] configNames = (String[]) cvTable.keySet().toArray(new String[cvTable.size()]);
			Arrays.sort(configNames);


		  	int configColumns=configNames.length/2;
			out.println("<table border=\"1\"><tr>" +
					    "<td colspan=\""+configColumns+"\"><b>Baseline CVs</b></td>"+
					    "<td colspan=\""+configColumns+"\"><b>Current Build Stream CVs</b></td>"+
					    "<td rowspan=\"2\"><b>Scenario Name</b></td>"+
					    "</tr><tr>");


			for (int i = 0; i < configNames.length; i++) {
				//configNames here have prefix cConfig- or bConfig- depending on whether the data comes from
				//current build stream data or baseline data.
				out.print("<td>" + ((ConfigDescriptor)configDescriptors.get(configNames[i].substring(8))).description + "</td>");
			}
			out.println("</tr><tr>\n");

			for (int i = 0; i < scenarios.length; i++) {
				Hashtable aCvTable = (Hashtable) rawDataTables.get(scenarios[i]);
				String scenario = scenarios[i];
				String scenarioFile=scenario.replace('#', '.').replace(':', '_').replace('\\', '_')+".html";

				for (int j = 0; j < configNames.length; j++) {
					String url=configNames[j].substring(8)+"/"+scenarioFile;
					if (aCvTable.get(configNames[j]) == null) {
						out.print("<td>n/a</td>");
						continue;
					}
					String displayValue = aCvTable.get(configNames[j]).toString();
					if (displayValue==null){
						out.print("<td>n/a</td>");
						continue;
					}
					try {
						double value = Double.parseDouble(displayValue.substring(0, displayValue.length() - 1));
						if (value > 10 && value < 20)
							out.print("<td bgcolor=\"yellow\"><a href=\""+url+"\"/>" + displayValue + "</a></td>");
						else if (value >= 20)
							out.print("<td bgcolor=\"FF9900\"><a href=\""+url+"\">" + displayValue + "</a></td>");
						else
							out.print("<td><a href=\""+url+"\">" + displayValue + "</a></td>");
					} catch (NumberFormatException e) {
						e.printStackTrace();
						out.print("<td>n/a</td>");
					}
				}
				out.println("<td>" + scenario + "</td>");
				out.println("</tr>\n");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			out.println("</table></body></html>");
			out.flush();
			out.close();
		}
	}

    public static double[] resultsStatistics(TimeSeries timeSeries) {
    	try {
	    	double valueRef = timeSeries.getValue(0), value = timeSeries.getValue(1);
	    	long countRef = timeSeries.getCount(0), count = timeSeries.getCount(1);
	    	double stddevRef = timeSeries.getStddev(0), stddev = timeSeries.getStddev(1);
	    	double stderr = (countRef == 1 || count == 1)
    			? Double.NaN
				: (Double.isNaN(stddevRef)
					? Math.sqrt((stddev * stddev / count)) / valueRef
					: Math.sqrt((stddevRef * stddevRef / countRef) + (stddev * stddev / count)) / valueRef);
			return new double[] {
				(value - valueRef) / valueRef,
				stderr,
			};
    	}
    	catch (ArrayIndexOutOfBoundsException aioobe) {
    		return null;
    	}
	}

	public static boolean hasConfidentResult(TimeSeries timeSeries) {
	    double[] resultStats = resultsStatistics(timeSeries);
	    return (confidenceLevel(resultStats) & ERR) == 0;
    }
	public static String failureMessage(Variations variations, String scenarioName, String baseline, String config) {
		String current = (String) variations.get(PerformanceTestPlugin.BUILD);
		Dim significanceDimension = (Dim) Dimension.ELAPSED_PROCESS;
		Scenario newScenario= DB.getScenarioSeries(scenarioName, variations, PerformanceTestPlugin.BUILD, baseline, current, new Dim[] { significanceDimension });
        TimeSeries timeSeries = newScenario.getTimeSeries(significanceDimension);
        double[] results = resultsStatistics(timeSeries);
		return failureMessage(results, true);
	}
	public static String failureMessage(double[] resultStats, boolean full) {
		StringBuffer buffer = new StringBuffer();
		int level = confidenceLevel(resultStats);

		}
		return buffer.toString();
	}
	
	/**
	 * Returns the confidence level for given statistics:
	 * <ul>
	 * <li>{@link #NAN}: if the value is infinite or not a number</li>
	 * <li>{@link #ERR}: if the standard error is over the expected threshold ({@link #STANDARD_ERROR_THRESHOLD})</li>
	 * <li>{@link #OK}: in all other cases</li>
	 * </ul>
	 * 
	 * @param resultStats array of 2 doubles, the former is the average value and
	 * 	the latter is the standard error made while computing the average.
	 * @return a value telling caller the level of confidence of the provided value
	 */
	public static int confidenceLevel(double[] resultStats) {
		int level = OK;
 		if (resultStats != null){

 		}
		return level;
	}
	public static boolean matchPattern(String name, String pattern) {
		if (pattern.equals("%")) return true;
		if (pattern.indexOf('%') >= 0 || pattern.indexOf('_') >= 0) {
			StringTokenizer tokenizer = new StringTokenizer(pattern, "%_", true);
			int start = 0;
			String previous = "";
			while (tokenizer.hasMoreTokens()) {
				String token = tokenizer.nextToken();
				if (!token.equals("%") && !token.equals("_")) {
					if (previous.equals("%")) {
						int idx = name.substring(start).indexOf(token);
						if (idx < 0) return false;
						start += idx;
					} else if (previous.equals("_")) {
						if (!name.substring(++start).startsWith(token)) return false;
					}
					start += token.length();
				}
				previous = token;
			}
			if (previous.equals("%")) {
				return true;
			} else if (previous.equals("_")) {
				return name.length() == start;
			}
			return name.endsWith(previous);
		}
		return name.equals(pattern);
	}

	/**
	 * Get an icon image corresponding to a given level of confidence and explanation.
	 * 
	 * @param confidence the confiden level
	 * @param hasExplanation flags indicates whether the confidence may be tempered by an explanation
	 * @return Corresponding image
	 */
	public static String getImage(int confidence, boolean scenarioFailed, boolean hasExplanation) {
	    String image = null;

	    if (scenarioFailed) {

	    return image;
    }

	public static boolean hasSummary(SummaryEntry[] summaries, String scenarioName) {
		int length = summaries == null ? 0 : summaries.length;
		for (int i=0; i<length; i++) {
			SummaryEntry summary = summaries[i];
			if (summary.scenarioName.equals(scenarioName)) {
				return true;
			}
		}
		return false;
	}

	public static String getScenarioShortName(String scenarioName, int max) {

		// Remove class name qualification
		int testSeparator = scenarioName.indexOf('#');
		boolean hasClassName = testSeparator >= 0;
		if (!hasClassName) {
			testSeparator = scenarioName.lastIndexOf('.');
			if (testSeparator <= 0) {
				if (max > 0 && scenarioName.length() > max) {
					return "*"+scenarioName.substring(0, max);
				}
				return scenarioName;
			}
		}
		int classSeparator = scenarioName.substring(0, testSeparator).lastIndexOf('.');
		if (classSeparator < 0) {
			if (max > 0 && scenarioName.length() > max) {
				return "*"+scenarioName.substring(0, max);
			}
			return scenarioName;
		}
		int length = scenarioName.length();
		String shortName = scenarioName.substring(classSeparator+1, length);
		if (!hasClassName && shortName.startsWith("test.")) { // specific case for swt...
			shortName = shortName.substring(5);
		}

		// Remove qualification from test name
		StringTokenizer tokenizer = new StringTokenizer(shortName, " :,", true);
		StringBuffer buffer = new StringBuffer(tokenizer.nextToken());
		while (tokenizer.hasMoreTokens()) {
			String token = tokenizer.nextToken();
			char fc = token.charAt(0);
			while (fc == ' ' || fc == ',' || fc == ':') {
				buffer.append(token); // add the separator
				token = tokenizer.nextToken();
				fc = token.charAt(0);
			}
			int last = token .lastIndexOf('.');
			if (last >= 3) {
				int first = token .indexOf('.');
				if (first == last) {
					buffer.append(token);
				} else {
//					buffer.append(token.substring(0, first));
//					buffer.append("...");
					buffer.append(token.substring(last+1));
				}
			} else {
				buffer.append(token);
			}
		}
		if (max > 0 && buffer.length() > max) {
			return "*"+buffer.substring(0, max);
		}
		return buffer.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2007 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.performance.ui;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;

import junit.framework.AssertionFailedError;

import org.eclipse.test.internal.performance.data.Dim;
import org.eclipse.test.internal.performance.db.Scenario;
import org.eclipse.test.internal.performance.db.TimeSeries;
import org.eclipse.test.internal.performance.db.Variations;
import org.eclipse.test.performance.ui.Utils.ConfigDescriptor;

public class ScenarioResults {
	private Scenario[] scenarios;
	private String baseline;
	private String baselinePrefix = null;
	private String current;
	private ArrayList pointsOfInterest;
	private ArrayList buildIDStreamPatterns;
	private Hashtable scenarioComments;
	private Hashtable variabilityData;
	private ConfigDescriptor configDescriptor;
	private String outputDir;
	private HashMap scenarioMap;
	private Variations variations;
	/**
	 * Summary of results for a scenario for a given build compared to a
	 * reference.
	 * 
	 * @param scenarios -
	 *            the array of Scenario objects for which to generate results.
	 * @param baseline -
	 *            the reference build ID
	 * @param current -
	 *            the current buildID
	 * @param configDescriptor -
	 *            a ConfigDescriptor object.
	 * @param pointsOfInterest -
	 *            an ArrayList of buildId's to highlight on line graphs.
	 */
	public ScenarioResults(Utils.ConfigDescriptor configDescriptor, Scenario[] scenarios, String baseline, String baselinePrefix, String current, 
			ArrayList pointsOfInterest, Hashtable scenarioComments, ArrayList buildIDPatterns, Hashtable variabilityTable, String outputDir,Variations variations) {
		
		this.scenarios = scenarios;
		this.variations=variations;
		scenarioMap=new HashMap();
		for (int i=0;i<scenarios.length;i++){
			scenarioMap.put(scenarios[i].getScenarioName(),scenarios[i]);
		}
		this.baseline = baseline;
		this.baselinePrefix = baselinePrefix;
		this.pointsOfInterest = pointsOfInterest;
		this.scenarioComments = scenarioComments;
		this.configDescriptor=configDescriptor;
		buildIDStreamPatterns=buildIDPatterns;
		this.current = current;
		this.outputDir=outputDir+"/"+configDescriptor.name;
		variabilityData=variabilityTable;

		try {
			printSummary();
			printDetails();
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void printSummary() {
		String outFile = null;
		PrintStream ps = null;

		for (int s = 0; s < scenarios.length; s++) {
			ArrayList pointsOfInterest = new ArrayList();
			Scenario t = scenarios[s];

			// get latest points of interest matching
			if (this.pointsOfInterest != null) {
				Iterator iterator = this.pointsOfInterest.iterator();
				while (iterator.hasNext()) {
					String buildIdPattern = iterator.next().toString();

					if (buildIdPattern.endsWith("*")) {
						pointsOfInterest.addAll(getAllMatchingBuildIds(t, buildIdPattern.substring(0, buildIdPattern.length() - 1)));
					} else {
						String match = getMostRecentMatchingBuildID(t, buildIdPattern);
						if (match != null)
							pointsOfInterest.add(match);
					}
				}
			}

			int[] buildNameIndeces = { -1, -1 };
			buildNameIndeces[0] = Utils.getBuildNameIndex(t.getTimeSeriesLabels(), current);
			buildNameIndeces[1] = Utils.getBuildNameIndex(t.getTimeSeriesLabels(), baseline);
			// don't produce result if none exists for current build
			if (Utils.getBuildNameIndex(t.getTimeSeriesLabels(), current) == -1) {
				continue;
			}

			String scenarioFileName = t.getScenarioName().replace('#', '.').replace(':', '_').replace('\\', '_');
			outFile=outputDir+"/"+ scenarioFileName + ".html";
			String rawDataFile=scenarioFileName+"_raw.html";
			if (outFile != null) {
				try {
					new File(outFile).getParentFile().mkdirs();
					ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(outFile)));
				} catch (FileNotFoundException e) {
					System.err.println("can't create output file" + outFile); //$NON-NLS-1$
				}
			}
			if (ps == null)
				ps = System.out;
			ps.println(Utils.HTML_OPEN);
			ps.println(Utils.HTML_DEFAULT_CSS);
			ps.println("<title>" + t.getScenarioName() + "(" + configDescriptor.description + ")" + "</title></head>"); //$NON-NLS-1$
			ps.println("<h4>Scenario: " + t.getScenarioName() + " (" + configDescriptor.description + ")</h4><br>"); //$NON-NLS-1$ //$NON-NLS-2$
			
			String failureMessage = Utils.failureMessage(variations, t.getScenarioName(),baseline,configDescriptor.name);
     		if (failureMessage != null){
	   			ps.println("<table><tr><td><b>"+failureMessage+"</td></tr></table>\n");
     		}

     		String comment= (String)scenarioComments.get(t.getScenarioName());
			if (comment != null) {
				ps.println("<p><b>Note:</b><br>\n");
				ps.println(comment + "</p>");
			}

			//print link to raw data.
			ps.println("<br><br><b><a href=\""+rawDataFile+"\">Raw data and Stats</a></b><br><br>\n");
			ps.println("<b>Click measurement name to view line graph of measured values over builds.</b><br><br>\n");
			ps.println("<table border=\"1\">"); //$NON-NLS-1$ //$NON-NLS-2$

			Dim[] dimensions = filteredDimensions(t.getDimensions());
			try {
				ps.println("<tr><td>Build Id</td>"); //$NON-NLS-1$
				for (int i = 0; i < dimensions.length; i++) {
					Dim dim = dimensions[i];
					String dimName = dim.getName();
					ps.println("<td><a href=\"#" + configDescriptor.name + "_" + scenarioFileName + "_" + dimName + "\">" + dimName + "</a></td>");
				}
				ps.print("</tr>\n");

				// store current and reference values for diff later
				double[][] diffValues = new double[2][dimensions.length];
				// to determine if diff is possible
				boolean[] refValueExistance = new boolean[dimensions.length];

				for (int j = 0; j < 2; j++) {
					String referenceIndicator = (j == 1) ? "(reference)" : "";

					String buildName = ((buildNameIndeces[j] == -1) ? "n/a" : t.getTimeSeriesLabels()[buildNameIndeces[j]]) + referenceIndicator;
					ps.print("<tr><td>" + buildName + "</td>");

					for (int i = 0; i < dimensions.length; i++) {
						Dim dim = dimensions[i];

						TimeSeries ts = t.getTimeSeries(dim);
						if (j == 1 && buildNameIndeces[j] != -1)
							refValueExistance[i] = true;

						if (buildNameIndeces[j] != -1)
							diffValues[j][i] = ts.getValue(buildNameIndeces[j]);

						String displayValue = (buildNameIndeces[j] == -1) ? "n/a" : dim.getDisplayValue(ts.getValue(buildNameIndeces[j]));
						String stddev = (buildNameIndeces[j] == -1) ? "0" : dim.getDisplayValue(ts.getStddev(buildNameIndeces[j]));

						if (stddev.startsWith("0 ") || stddev.equals("0"))
							ps.println("<td>" + displayValue + "</td>");
						else
							ps.println("<td>" + displayValue + " [" + stddev + "]" + "</td>");
					}
					ps.print("</tr>");
				}
				// get diffs and print results
				ps.println(getDiffs(diffValues, dimensions, refValueExistance));
				ps.println();
				ps.println("</font></table>");
				ps.println("*Delta values in red and green indicate degradation > 10% and improvement > 10%,respectively.<br><br>");
				ps.println("<br><hr>\n\n");

				// print text legend.
				ps.println("Black and yellow points plot values measured in integration and last seven nightly builds.<br>\n" + "Magenta points plot the repeated baseline measurement over time.<br>\n"
						+ "Boxed points represent previous releases, milestone builds, current reference and current build.<br><br>\n" 
						+ "Hover over any point for build id and value.\n");
					
				// print image maps of historical
				for (int i = 0; i < dimensions.length; i++) {
					Dim dim = dimensions[i];
					String dimName = dim.getName();

					TimeLineGraph lg = Utils.getLineGraph(t, dim.getName(), baseline, baselinePrefix, current, pointsOfInterest,buildIDStreamPatterns);

					String lgImg = outputDir + "/graphs/" + scenarioFileName + "_" + dimName + ".gif";
					Utils.printLineGraphGif(lg, lgImg);
					ps.println("<br><a name=\"" + configDescriptor.name + "_" + scenarioFileName + "_" + dimName + "\"></a>");
					ps.println("<br><b>" + dimName + "</b><br>");
					ps.println(Utils.getDimensionDescription(dimName) + "<br><br>\n");
					ps.println(Utils.getImageMap(lg, "graphs/" + scenarioFileName + "_" + dimName + ".gif",scenarioFileName+"_raw.html"));
					}
				ps.println("<br><br></body>");
				ps.println(Utils.HTML_CLOSE); //$NON-NLS-1$
				if (ps != System.out)
					ps.close();

			} catch (AssertionFailedError e) {
				e.printStackTrace();
				continue;
			}
		}
	}

	private void printDetails() {

		String outFile = null;
		PrintStream ps = null;

		for (int s = 0; s < scenarios.length; s++) {
			Scenario t = scenarios[s];
			// don't produce result if none exists for current build
			if (Utils.getBuildNameIndex(t.getTimeSeriesLabels(), current) == -1) {
				continue;
			}
			Dim[] dimensions = filteredDimensions(t.getDimensions());
			//store cv for aggregate data
			Hashtable data=(Hashtable)variabilityData.get(t.getScenarioName());
			if (data==null){
				data=new Hashtable();
				variabilityData.put(t.getScenarioName(),data);
			}
			
			RawDataTable currentResultsTable=new RawDataTable(t,dimensions,buildIDStreamPatterns,current);
			data.put("cConfig-"+configDescriptor.name,currentResultsTable.getCV());
			
			//create table for baseline data
			RawDataTable baselineResultsTable;
			if (baselinePrefix!=null)
				baselineResultsTable=new RawDataTable(t,dimensions,baselinePrefix,baseline);
			else
				baselineResultsTable=new RawDataTable(t,dimensions,baseline,baseline);
			
			data.put("bConfig-"+configDescriptor.name,baselineResultsTable.getCV());
		

			String scenarioFileName = t.getScenarioName().replace('#', '.').replace(':', '_').replace('\\', '_');
			outFile = outputDir + "/" + scenarioFileName + "_raw.html";
			if (outFile != null) {
				try {
					new File(outFile).getParentFile().mkdirs();
					ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(outFile)));
				} catch (FileNotFoundException e) {
					System.err.println("can't create output file" + outFile); //$NON-NLS-1$
				}
			}
			if (ps == null)
				ps = System.out;
			ps.println(Utils.HTML_OPEN);
			ps.println(Utils.HTML_DEFAULT_CSS);
			ps.println("<title>" + t.getScenarioName() + "(" + configDescriptor.description + ")" + " - Details</title></head>"); //$NON-NLS-1$
			ps.println("<h4>Scenario: " + t.getScenarioName() + " (" + configDescriptor.description + ")</h4>"); //$NON-NLS-1$
			ps.println("<a href=\""+scenarioFileName+".html\">VIEW GRAPH</a><br><br>"); //$NON-NLS-1$
			ps.println("<table><td><b>Current Stream Test Runs</b></td><td><b>Baseline Test Runs</b></td></tr>\n");
			ps.println("<tr valign=\"top\">" +
					"<td>"+currentResultsTable.toHtmlString()+"</td>"
					+"<td>"+baselineResultsTable.toHtmlString()+"</td></tr>");
			ps.println("</table>");
			ps.close();
		}
	}

	private String getMostRecentMatchingBuildID(Scenario scenario, String buildIdPrefix) {
		String[] buildIds = scenario.getTimeSeriesLabels();
		for (int i = buildIds.length - 1; i > -1; i--) {
			if (buildIds[i].startsWith(buildIdPrefix))
				return buildIds[i];
		}
		return null;
	}

	private ArrayList getAllMatchingBuildIds(Scenario scenario, String buildIdPrefix) {
		ArrayList result = new ArrayList();
		String[] buildIds = scenario.getTimeSeriesLabels();
		for (int i = buildIds.length - 1; i > -1; i--) {
			if (buildIds[i].startsWith(buildIdPrefix) && !buildIds[i].equals(baseline))
				result.add(buildIds[i]);
		}
		return result;
	}

	private String getDiffs(double[][] values, Dim[] dimensions, boolean[] refValueExistance) {
		String diffRow = "<tr><td>*Delta</td>";
		for (int j = 0; j < dimensions.length; j++) {
			Dim dim = dimensions[j];

			double diffValue = values[0][j] - values[1][j];
			double diffPercentage = 0;
			if (values[1][j] != 0)
				diffPercentage = ((int) (((diffValue / Math.abs(values[1][j])) * 1000))) / 10.0;
			String diffDisplayValue = dim.getDisplayValue(diffValue);
			// green
			String fontColor = "";
			if ((diffPercentage < -10 && !dim.largerIsBetter()) || (diffPercentage > 10 && dim.largerIsBetter()))
				fontColor = "#006600";
			if ((diffPercentage < -10 && dim.largerIsBetter()) || (diffPercentage > 10 && !dim.largerIsBetter()))
				fontColor = "#FF0000";

			diffPercentage = Math.abs(diffPercentage);
			String percentage = (diffPercentage == 0) ? "" : "<br>" + diffPercentage + " %";

			if (diffPercentage > 10 || diffPercentage < -10) {
				diffRow = diffRow.concat("<td><FONT COLOR=\"" + fontColor + "\"><b>" + diffDisplayValue + percentage + "</b></FONT></td>");
			} else if (refValueExistance[j]) {
				diffRow = diffRow.concat("<td>" + diffDisplayValue + percentage + "</td>");
			} else {
				diffRow = diffRow.concat("<td>n/a</td>");
			}
		}
		diffRow = diffRow.concat("</tr>");
		return diffRow;
	}

	private Dim[] filteredDimensions(Dim[] dimensions) {
		ArrayList list = new ArrayList();
		ArrayList filtered = new ArrayList();
		list.add(0, "Elapsed Process");
		list.add(1, "CPU Time");
		list.add(2, "Invocation Count");
		list.add(3, "GDI Objects");
		//list.add(4, "Kernel time");
		//list.add(5, "Data Size");
		//list.add(6, "Library Size");
		//list.add(7, "Text Size");
		// list.add(8,"Used Java Heap");
		// list.add(9,"Committed");
		// list.add(10,"Page Faults");
		// list.add(11,"Hard Page Faults");
		// list.add(12,"Soft Page Faults");

		for (int i = 0; i < dimensions.length; i++) {
			String dimName = dimensions[i].getName();
			if (list.contains(dimName))
				list.set(list.indexOf(dimName), dimensions[i]);
		}
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			Object tmp = iterator.next();
			try {
				if ((Dim) tmp instanceof Dim)
					filtered.add(tmp);
			} catch (ClassCastException e) {
				//silently ignore
			}
		}
		return (Dim[]) filtered.toArray(new Dim[filtered.size()]);
	}

}




package org.eclipse.test.performance.ui;

import java.io.PrintStream;
import java.util.List;
import java.util.Hashtable;
import java.util.StringTokenizer;

import org.eclipse.test.internal.performance.results.BuildResults;
import org.eclipse.test.internal.performance.results.ConfigResults;
import org.eclipse.test.internal.performance.results.PerformanceResults;
import org.eclipse.test.internal.performance.results.ScenarioResults;

/**
 * Class used to print a scenario status table.
 */

public class ScenarioStatusTable {
	
	private Hashtable configMaps=null;
	private Variations variations;
	private String scenarioPattern;
	private ArrayList configNames=new ArrayList();
	private Hashtable scenarioComments;
	private SummaryEntry[] fingerprintEntries;
	private final String baseline;
	
	private class ScenarioStatus{
		Hashtable statusMap;
		String name, shortName;
		Hashtable configStatus;
		Hashtable resultsMap;
		boolean hasSlowDownExplanation=false;
		boolean fingerprint = false;
		boolean hasBaseline = true;
						
		public ScenarioStatus(String scenarioName){
			name = scenarioName;
			statusMap = new Hashtable();
			configStatus = new Hashtable();
			resultsMap = new Hashtable();
		}

	}
	
	/**
	 * Creates an HTML table of red x/green check for a scenario for each
	 * configuration.
	 * 
	 * @param variations
	 * @param scenarioPattern
	 * @param configDescriptors
	 */
	public ScenarioStatusTable(Variations variations,String scenarioPattern,Hashtable configDescriptors,Hashtable scenarioComments, SummaryEntry[] fpSummaries, String baseline){
		configMaps=configDescriptors;
		this.variations=variations;
		this.scenarioPattern=scenarioPattern;
		this.scenarioComments=scenarioComments;
		this.baseline= baseline;
		this.fingerprintEntries = fpSummaries;
	}

	/**
	 * Prints the HTML representation of scenario status table into the given stream.
	 */
	public void print(PrintStream stream, boolean filter) {
		String OS="config";
        Scenario[] scenarios= DB.queryScenarios(variations, scenarioPattern, OS, null);
	
		if (scenarios != null && scenarios.length > 0) {
			ArrayList scenarioStatusList=new ArrayList();

			for (int i= 0; i < scenarios.length; i++) {
				Scenario scenario= scenarios[i];
				String scenarioName=scenario.getScenarioName();
				if (filter && !Utils.matchPattern(scenarioName, scenarioPattern)) continue;
				// returns the config names. Making assumption that indices in
				// the configs array map to the indices of the failure messages.
				String[] configs=scenario.getTimeSeriesLabels();
				String[] failureMessages= scenario.getFailureMessages();
				ScenarioStatus scenarioStatus=new ScenarioStatus(scenarioName);
				scenarioStatus.fingerprint = Utils.hasSummary(this.fingerprintEntries, scenarioName);

	private String component;
	private PrintStream stream;
	private int jsIdCount;

/**
 * Creates an HTML table of red x/green check for a scenario for each
 * configuration.
 */
public ScenarioStatusTable(String  name, PrintStream stream) {
    this.component = name;
    this.stream = stream;
}
//    				double[] resultStats = Utils.resultStats(v, scenarioName, baseline, configs[j]);
					String current = (String) v.get(PerformanceTestPlugin.BUILD);
					Dim significanceDimension = (Dim) Dimension.ELAPSED_PROCESS;
					Scenario newScenario= DB.getScenarioSeries(scenarioName, v, PerformanceTestPlugin.BUILD, baseline, current, new Dim[] { significanceDimension });
			        String[] timeSeriesLabels= newScenario.getTimeSeriesLabels();
			        TimeSeries timeSeries = newScenario.getTimeSeries(significanceDimension);
			        boolean hasBaseline = timeSeriesLabels.length == 2 && timeSeriesLabels[0].equals(baseline);
			        double[] resultStats = Utils.resultsStatistics(timeSeries);
					if (resultStats == null) continue;
					if (resultStats != null && resultStats[1] < 0 && scenarioStatus.hasBaseline) scenarioStatus.hasBaseline = false;
					
					// Store failure message in scenario status
					int confidenceLevel = Utils.confidenceLevel(resultStats);
					boolean hasScenarioFailure = failureMessages[j] != null && failureMessages[j].indexOf(configs[j]) != -1; // ensure correct failure message relates to config
					StringBuffer buffer = new StringBuffer();
					if (hasScenarioFailure) {
						buffer.append(failureMessages[j]);
						if (scenarioStatus.hasSlowDownExplanation) {
							buffer.append(" - Explanation comment: ");
							buffer.append(scenarioComment);
						}
						confidenceLevel |= Utils.DEV;
					}
					scenarioStatus.configStatus.put(configs[j], new Integer(confidenceLevel));
					scenarioStatus.statusMap.put(configs[j], buffer.toString());

					// Store text for numbers in scenario status
					String text = Utils.failureMessage(resultStats, false);
					scenarioStatus.resultsMap.put(configs[j], text);
					
					// Store scenario short name in scenario status (for table column)
					if (scenarioStatus.shortName == null) {
						if (hasBaseline) { // baseline is OK
							scenarioStatus.shortName = Utils.getScenarioShortName(scenarioName, -1);
						} else {
							StringBuffer shortName = new StringBuffer("*");
							shortName.append(Utils.getScenarioShortName(scenarioName, -1));
							shortName.append(" <small>(vs.&nbsp;");
							shortName.append(timeSeriesLabels[0]);
							shortName.append(")</small>");
							scenarioStatus.shortName = shortName.toString();
						}
					}

/**
 * Prints the HTML representation of scenario status table into the given stream.
 */
public void print(PerformanceResults performanceResults) {
	printTitle();
	List scenarii = performanceResults.getComponentScenarii(this.component);
	String baselineName = performanceResults.getBaselineName();
	int size = scenarii.size();
	printColumnsTitle(size, performanceResults);
	this.jsIdCount = 0;
	for (int i=0; i<size; i++) {
		ScenarioResults scenarioResults = (ScenarioResults) scenarii.get(i);
		this.stream.println("<tr>");
		this.stream.print("<td>");
		boolean hasSummary = scenarioResults.hasSummary();
		if (hasSummary) this.stream.print("<b>");
		String scenarioBaseline = scenarioResults.getBaselineBuildName();
		boolean hasBaseline = baselineName.equals(scenarioBaseline);
		if (!hasBaseline) {
			this.stream.print("*");
			this.stream.print(scenarioResults.getShortName());
			this.stream.print(" <small>(vs.&nbsp;");
			this.stream.print(scenarioBaseline);
			this.stream.print(")</small>");
		} else {
			this.stream.print(scenarioResults.getShortName());
		}
		if (hasSummary) this.stream.print("</b>");
		this.stream.println();
		String[] configs = performanceResults.getConfigNames(true/*sort*/);
		int length = configs.length;
		for (int j=0; j<length; j++) {
			printConfigStats(scenarioResults, configs[j]);
		}
	}
	this.stream.println("</table>");
}
			stream.println("<li>\"n/a\": mark a test for with <b>no</b> performance results</li>");
			stream.println("</ul></li>");
			stream.println("<li>the value of the deviation from the baseline as a percentage (ie. formula is: <code>(build_test_time - baseline_test_time) / baseline_test_time</code>)</li>");
			stream.println("<li>the value of the standard error of this deviation as a percentage (ie. formula is: <code>sqrt(build_test_stddev^2 / N + baseline_test_stddev^2 / N) / baseline_test_time</code>)<br>");
			stream.println("When test only has one measure, the standard error cannot be computed and is replaced with a '<font color=\"#CCCC00\">[n/a]</font>'.</li>");
			stream.println("</ul>");
			stream.println("<u>Hints</u>:<ul>");
			stream.println("<li>fly over image of failing tests to see the complete error message</li>");
			stream.println("<li>to look at the complete and detailed test results, click on its image</li>");
			stream.println("</ul>");
			stream.println();
			stream.println("<table border=\"1\">");
			stream.println("<tr>");
			stream.print("<td><h4>All ");
			stream.print(scenarios.length);
			stream.println(" scenarios</h4></td>");

/*
 * Print the table columns title.
 */
private void printColumnsTitle(int size, PerformanceResults performanceResults) {
	this.stream.println("<table border=\"1\">");
	this.stream.println("<tr>");
	this.stream.print("<td><h4>All ");
	this.stream.print(size);
	this.stream.println(" scenarios</h4></td>");
	String[] configNames = performanceResults.getConfigNames(true/*sort*/);
	String[] configBoxes = performanceResults.getConfigBoxes(true/*sort*/);
	int length = configNames.length;
	for (int i=0; i<length; i++) {
		String columnTitle = configNames[i];
		String boxName = configBoxes[i];
		int idx = boxName.indexOf('(');
		if (idx < 0) {
			columnTitle = boxName;
		} else {
			// first line
			StringTokenizer tokenizer = new StringTokenizer(boxName.substring(0, idx).trim(), " ");
			StringBuffer buffer = new StringBuffer(tokenizer.nextToken());
			while (tokenizer.hasMoreTokens()) {
				buffer.append("&nbsp;");
				buffer.append(tokenizer.nextToken());
    						columnTitle = buffer.toString();
						}
					}
				}
				stream.print("<td><h5>");
				stream.print(columnTitle);
				stream.println("</h5>");
			}
			buffer.append(' ');
			// second line
			tokenizer = new StringTokenizer(boxName.substring(idx).trim(), " ");
			buffer.append(tokenizer.nextToken());
			while (tokenizer.hasMoreTokens()) {
				buffer.append("&nbsp;");
				buffer.append(tokenizer.nextToken());
				stream.println("<tr>");
				stream.print("<td>");
				if (status.fingerprint) stream.print("<b>");
				if (!status.hasBaseline) stream.print("*");
//				stream.print(status.name.substring(status.name.indexOf(".",status.name.indexOf(".test")+1)+1));
				stream.print(status.shortName);
				if (!status.hasBaseline) stream.print("</i>");
				if (status.fingerprint) stream.print("</b>");
				stream.println();
				for (int i=0;i<configNames.size();i++){
					String configName=configNames.get(i).toString();
					String aUrl=configName;
					if (status.statusMap.containsKey(configName)){
						String message = (String) status.statusMap.get(configName);
						int confidence = ((Integer) status.configStatus.get(configName)).intValue();
						String image = Utils.getImage(confidence, status.hasSlowDownExplanation);
						stream.print("<td><a ");
						if ((confidence & Utils.DEV) == 0 || (confidence & Utils.NAN) != 0 || message.length() == 0){
							// write deviation with error in table when test pass
							stream.print("href=\"");
							stream.print(aUrl);
							stream.print('/');
							stream.print(status.name.replace('#', '.').replace(':', '_').replace('\\', '_'));
							stream.println(".html\">");
							stream.print("<img hspace=\"10\" border=\"0\" src=\"");
							stream.print(image);
							stream.println("\"/></a>");
						} else {
							// create message with tooltip text including deviation with error plus failure message
							jsIdCount+=1;
							stream.print("class=\"tooltipSource\" onMouseover=\"show_element('toolTip");
							stream.print(jsIdCount);
							stream.print("')\" onMouseout=\"hide_element('toolTip");
							stream.print(jsIdCount);
							stream.print("')\" \nhref=\"");
							stream.print(aUrl);
							stream.print('/');
							stream.print(status.name.replace('#', '.').replace(':', '_').replace('\\', '_'));
							stream.println(".html\">");
							stream.print("<img hspace=\"10\" border=\"0\" src=\"");
							stream.print(image);
							stream.println("\"/>");
							stream.print("<span class=\"hidden_tooltip\" id=\"toolTip");
							stream.print(jsIdCount);
							stream.print("\">");
							stream.print(message);
							stream.println("</span></a>");
						}
						String result = (String) status.resultsMap.get(configName);
						stream.println(result);
					}else{
						stream.println("<td> n/a");
					}
				}
				stream.flush();
			}
			columnTitle = buffer.toString();
		}
		this.stream.print("<td><h5>");
		this.stream.print(columnTitle);
		this.stream.println("</h5>");
	}
}

/*
 * Print the scenario statistics value for the given configuration.
 */
private void printConfigStats(ScenarioResults scenarioResults, String config) {
	ConfigResults configResults = scenarioResults.getConfigResults(config);
	if (configResults == null || !configResults.isValid()) {
		this.stream.print("<td>n/a</td>");
		return;
	}
	BuildResults currentBuildResults = configResults.getCurrentBuildResults();
	String failure = currentBuildResults.getFailure();
	double[] deviation = configResults.getCurrentBuildDeviation();
	int confidence = Utils.confidenceLevel(deviation);
	boolean hasFailure = failure != null;
	String comment = currentBuildResults.getComment();
	String image = Utils.getImage(confidence, hasFailure, comment != null);
	this.stream.print("<td><a ");
	if (!hasFailure|| (confidence & Utils.NAN) != 0 || failure.length() == 0){
		// write deviation with error in table when test pass
		this.stream.print("href=\"");
		this.stream.print(configResults.getName());
		this.stream.print('/');
		this.stream.print(scenarioResults.getFileName());
		this.stream.println(".html\">");
		this.stream.print("<img hspace=\"10\" border=\"0\" src=\"");
		this.stream.print(image);
		this.stream.println("\"/></a>");
	} else {
		// create message with tooltip text including deviation with error plus failure message
		this.jsIdCount+=1;
		this.stream.print("class=\"tooltipSource\" onMouseover=\"show_element('toolTip");
		this.stream.print(jsIdCount);
		this.stream.print("')\" onMouseout=\"hide_element('toolTip");
		this.stream.print(jsIdCount);
		this.stream.print("')\" \nhref=\"");
		this.stream.print(configResults.getName());
		this.stream.print('/');
		this.stream.print(scenarioResults.getFileName());
		this.stream.println(".html\">");
		this.stream.print("<img hspace=\"10\" border=\"0\" src=\"");
		this.stream.print(image);
		this.stream.println("\"/>");
		this.stream.print("<span class=\"hidden_tooltip\" id=\"toolTip");
		this.stream.print(jsIdCount);
		this.stream.print("\">");
		this.stream.print(failure);
		this.stream.println("</span></a>");
	}
	String result = Utils.failureMessage(deviation, false);
	this.stream.println(result);
}

/*
 * Print the status table explanationtitle.
 */
private void printTitle() {
	this.stream.println("<br><h4>Scenario Status</h4>");
	this.stream.println("The following table gives a complete but compact view of performance results for the component.<br>");
	this.stream.println("Each line of the table shows the results for one scenario on all machines.<br><br>");
	this.stream.println("The name of the scenario is in <b>bold</b> when its results are also displayed in the fingerprints<br>");
	this.stream.println("and starts with an '*' when the scenario has no results in the last baseline run.<br><br>");
	this.stream.println("Here are information displayed for each test (ie. in each cell):");
	this.stream.println("<ul>");
	this.stream.println("<li>an icon showing whether the test fails or passes and whether it's reliable or not.<br>");
	this.stream.println("The legend for this icon is:");
	this.stream.println("<ul>");
	this.stream.print("<li>Green (<img src=\"");
	this.stream.print(Utils.OK_IMAGE);
	this.stream.print("\">): mark a <b>successful result</b>, which means this test has neither significant performance regression nor significant standard error</li>");
	this.stream.print("<li>Red (<img src=\"");
	this.stream.print(Utils.FAIL_IMAGE);
	this.stream.println("\">): mark a <b>failing result</b>, which means this test shows a significant performance regression (more than 10%)</li>");
	this.stream.print("<li>Gray (<img src=\"");
	this.stream.print(Utils.FAIL_IMAGE_EXPLAINED);
	this.stream.println("\">): mark a <b>failing result</b> (see above) with a comment explaining this degradation.</li>");
	this.stream.print("<li>Yellow (<img src=\"");
	this.stream.print(Utils.FAIL_IMAGE_WARN);
	this.stream.print("\"> or <img src=\"");
	this.stream.print(Utils.OK_IMAGE_WARN);
	this.stream.print("\">): mark a <b>failing or successful result</b> with a significant standard error (more than ");
	this.stream.print(Utils.STANDARD_ERROR_THRESHOLD_STRING);
	this.stream.println(")</li>");
	this.stream.print("<li>Black (<img src=\"");
	this.stream.print(Utils.UNKNOWN_IMAGE);
	this.stream.print("\">): mark an <b>undefined result</b>, which means that deviation on this test is not a number (<code>NaN</code>) or is infinite (happens when the reference value is equals to 0!)</li>");
	this.stream.println("<li>\"n/a\": mark a test for with <b>no</b> performance results</li>");
	this.stream.println("</ul></li>");
	this.stream.println("<li>the value of the deviation from the baseline as a percentage (ie. formula is: <code>(build_test_time - baseline_test_time) / baseline_test_time</code>)</li>");
	this.stream.println("<li>the value of the standard error of this deviation as a percentage (ie. formula is: <code>sqrt(build_test_stddev^2 / N + baseline_test_stddev^2 / N) / baseline_test_time</code>)<br>");
	this.stream.println("When test only has one measure, the standard error cannot be computed and is replaced with a '<font color=\"#CCCC00\">[n/a]</font>'.</li>");
	this.stream.println("</ul>");
	this.stream.println("<u>Hints</u>:<ul>");
	this.stream.println("<li>fly over image of failing tests to see the complete error message</li>");
	this.stream.println("<li>to look at the complete and detailed test results, click on its image</li>");
	this.stream.println("</ul>");
}
}




import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.widgets.Display;
import org.eclipse.test.internal.performance.results.AbstractResults;
import org.eclipse.test.internal.performance.results.ConfigResults;
import org.eclipse.test.internal.performance.results.PerformanceResults;
import org.eclipse.test.internal.performance.results.ScenarioResults;

/**
 * Class used to create scenario fingerprint.
 */
public class FingerPrint {

private static final int GRAPH_WIDTH = 1000;

	String component;
	PrintStream stream;
	File outputDir;

public FingerPrint(String name, PrintStream ps, File outputDir) {
	if (!name.equals("global")) this.component = name;
	this.stream = ps;
	this.outputDir = outputDir;
}

/**
 * Create and save fingerprints as image and print their reference in the current stream.
 * 
 * @param performanceResults The performance results used to print the fingerprints
 */
public void print(PerformanceResults performanceResults) {
	String baselineBuildName = performanceResults.getBaselineName();
	String buildName = performanceResults.getName();
	
	// Compute fingerprint output file name prefix
	int referenceUnderscoreIndex = baselineBuildName.indexOf('_');
	String baselinePrefix = baselineBuildName;
	if (referenceUnderscoreIndex != -1) {
		baselinePrefix = baselineBuildName.substring(0, referenceUnderscoreIndex);


    public FingerPrint(String component,ConfigDescriptor config, String reference, String current,Variations variations, String outputDir) {
        this.variations=variations;
        this.component=component;
        referenceBuildId= reference;
        currentBuildId= current;
        outputDirectory= outputDir;
        configDescriptor=config;
        variations.put(PerformanceTestPlugin.BUILD, currentBuildId);
        if (component==null){
        	entries= DB.querySummaries(variations,null);
        	this.component="";
        } else {
        	entries=DB.querySummaries(variations,component+'%');
        }
       	run();
    }    
    
    /**
     * Creates the fingerprint gif, image map and scenario status table for the component.
     */
    public void run() {
        new File(outputDirectory).mkdirs();
        String referenceName=referenceBuildId;
        String currentName=currentBuildId;
        int referenceUnderscoreIndex=referenceBuildId.indexOf('_');
        int currentUnderscoreIndex=currentBuildId.indexOf('_');
        
        if (referenceUnderscoreIndex!=-1)
        	referenceName=referenceBuildId.substring(0,referenceUnderscoreIndex);
        if (currentUnderscoreIndex!=-1)
        	currentName=currentBuildId.substring(0,currentUnderscoreIndex);

        title="Performance of " + component +" "+currentName + " relative to " + referenceName;
        bar= new BarGraph(null);
                
        if (entries != null) {
            for (int i= 0; i < entries.length; i++) {
                SummaryEntry summary = entries[i];
                if (summary.comment==null)
                	add(summary.shortName, new Dim[] { summary.dimension }, summary.scenarioName);
                else{
                	setComment(summary.scenarioName, summary.comment);
                	add(summary.shortName, new Dim[] { summary.dimension }, summary.scenarioName, summary.comment);
                }
            }
        }
        
        outName= "FP_" + component+ '_'+referenceName + '_' + currentBuildId+"."+configDescriptor.name;
               
        if (component=="")
        	outName= "FP_"+referenceName + '_' + currentBuildId+"."+configDescriptor.name;
        save(outputDirectory + '/' + outName);
        
        //show(bar);
     
       }

    private void setComment(String scenario, String comment) {
    	if (scenarioComments==null)
    		scenarioComments=new Hashtable();
    	scenarioComments.put(scenario,comment);
    }

    private void add(String name, Dim[] dims, String scenarioName) {
    	add (name,dims,scenarioName,null);
    }

    private void add(String name, Dim[] dims, String scenarioName, String comment) {
         String refData= "";
        Scenario scenario= DB.getScenarioSeries(scenarioName, variations, PerformanceTestPlugin.BUILD, referenceBuildId, currentBuildId, dims);
        String[] timeSeriesLabels= scenario.getTimeSeriesLabels();
        if (timeSeriesLabels.length == 2) {
            // we mark the label with a '*' or '' to indicate that no data was available for the specified builds
            if (!timeSeriesLabels[0].equals(referenceBuildId)) {
                name= '*' + name;
                refData= " (" + timeSeriesLabels[0] + ")";
            } else if (!timeSeriesLabels[1].equals(currentBuildId)) {
                name= '' + name;
                refData= " (" + timeSeriesLabels[1] + ")";
            }
        }
        
        for (int i= 0; i < dims.length; i++) {
            TimeSeries timeSeries= scenario.getTimeSeries(dims[i]);
            int l= timeSeries.getLength();
            if (l >= 1) {
            	double percent= 0.0;
            	boolean hasConfidentResult= true;
            	if (l > 1) {
//            		hasConfidentResult= Utils.hasConfidentResult(variations, scenario.getScenarioName(),referenceBuildId,configDescriptor.name);
            		hasConfidentResult= Utils.hasConfidentResult(timeSeries);
            		/*if (!rejectNullHypothesis) {
            			NumberFormat percentFormatter= NumberFormat.getPercentInstance();
            			String statisticsComment= "There is not enough evidence to reject the null hypothesis at the " + percentFormatter.format(percentile.inside()) + "level";
            			if (comment == null)
            				comment= statisticsComment;
            			else
            				comment+= statisticsComment;
            			setComment(scenarioName, comment);
            		}
            		 */
            		double ref= timeSeries.getValue(0);
            		double val= timeSeries.getValue(1);
            		percent= 100.0 - ((val / ref) * 100.0);
            	}
            	if (Math.abs(percent) < 200) {
            		String n= name + " (" + dims[i].getName() + ")" + refData;
            		bar.addItem(n, percent,configDescriptor.name+"/"+(scenarioName.replace('#','.').replace(':','_').replace('\\','_'))+".html#"+dims[i].getName(),comment, hasConfidentResult); //$NON-NLS-1$ //$NON-NLS-2$
               	}
            }
        }
        //scenario.dump(System.out);
	         
    }

    private void save(String output) {

    	//if (bar.getFItems().size()==0)
    		//return;
    	
        Display display= Display.getDefault();
        
        int height= bar.getHeight();
        Image image= new Image(display, GRAPH_WIDTH, height);
        
        GC gc= new GC(image);
        bar.paint(display, GRAPH_WIDTH, height, gc);
        gc.dispose();

        ImageData data = Utils.downSample(image);
        ImageLoader il= new ImageLoader();
        il.data= new ImageData[] { data };

        OutputStream out= null;
        try {
            out= new BufferedOutputStream(new FileOutputStream(output + ".gif")); //$NON-NLS-1$
            //System.out.println("writing: " + output);
            il.save(out, SWT.IMAGE_GIF);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            image.dispose();
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e1) {
                    // silently ignored
                }
            }
        }
    }
    
    /*
     * Displays bar graph in window
     *
    private void show(final BarGraph bar) {
        Display display= new Display();
        
        Shell shell= new Shell(display);
        shell.setLayout(new FillLayout());
        
        final Canvas canvas= new Canvas(shell, SWT.NO_BACKGROUND);
        canvas.addPaintListener(new PaintListener() {
            public void paintControl(PaintEvent e) {
                Point s= canvas.getSize();
                bar.paint(canvas.getDisplay(), s.x, s.y, e.gc);
            }
        });
        
        shell.open();

        while (!shell.isDisposed())
            if (!display.readAndDispatch())
                display.sleep();
            
        display.dispose();
    }
	public BarGraph getBar() {
		return bar;
	}
	int currentUnderscoreIndex = buildName.indexOf('_');
	if  (currentUnderscoreIndex != -1){
		buildName = buildName.substring(0, currentUnderscoreIndex);
	}
	StringBuffer buffer = new StringBuffer("FP_");
	if (this.component != null) {
		buffer.append(this.component);
		buffer.append('_');
	}
	buffer.append(baselinePrefix);
	buffer.append('_');
	buffer.append(buildName);
	buffer.append('.');
	String filePrefix = buffer.toString();

	// Create each fingerprint and save it
	String[] configNames = performanceResults.getConfigNames(false/* not sorted*/);
	String[] configBoxes = performanceResults.getConfigBoxes(false/* not sorted*/);
	int length = configNames.length;
	for (int c=0; c<length; c++) {
		String configName  = configNames[c];
		List scenarii = performanceResults.getComponentSummaryScenarii(this.component, configName);
		if (scenarii == null) continue;

		// Create BarGraph
//		BarGraph barGraph = new BarGraph(null);
		BarGraph barGraph = null;
		for (int i=0, size=scenarii.size(); i<size; i++) {
			ScenarioResults scenarioResults = (ScenarioResults) scenarii.get(i);
			ConfigResults configResults = scenarioResults.getConfigResults(configName);
			if (configResults == null || !configResults.isValid()) continue;
			double[] results = configResults.getCurrentBuildDeviation();
			double percent = -results[0] * 100.0;
			if (results != null && Math.abs(percent) < 200) {
				String defaultDimensionName = AbstractResults.SUPPORTED_DIMS[0].getName();
				String name = scenarioResults.getLabel() + " (" + defaultDimensionName + ")";
				if (!configResults.getCurrentBuildName().equals(buildName)) {
					continue; // the test didn't run on last build, skip it
				}
				if (!configResults.isBaselined()) {
					name = "*" + name + " (" + configResults.getBaselineBuildName() + ")";
				}
				if (barGraph == null) {
					barGraph = new BarGraph(null);
				}
				barGraph.addItem(name,
				    results,
				    configName + "/" + scenarioResults.getFileName() + ".html#" + defaultDimensionName,
				    configResults.getCurrentBuildResults().getComment(),
				    (Utils.confidenceLevel(results) & Utils.ERR) == 0);
			}
		}
		 if (barGraph == null) continue;

		// Save image file
		String fileName = filePrefix + configName ;
		File outputFile = new File(this.outputDir, fileName+".gif");
		save(barGraph, outputFile);

		// Print image file reference in stream
		String boxName = configBoxes[c];
		if (outputFile.exists()) {
			String areas = barGraph.getAreas();
			if (areas == null) areas = "";
			this.stream.print("<h4>");
			this.stream.print(boxName);
			this.stream.print("</h4>");
			this.stream.print("<img src=\"");
			this.stream.print(fileName);
			this.stream.print(".gif\" usemap=\"#");
			this.stream.print(fileName);
			this.stream.print("\"><map name=\"");
			this.stream.print(fileName);
			this.stream.print("\">");
			this.stream.print(areas);
			this.stream.print("</map>\n");
		} else {
			this.stream.print("<br><br>There is no fingerprint for ");
			this.stream.print(boxName);
			this.stream.print("<br><br>\n");
		}
		return output;
	}
}

/*
 * Save the computed bar graph.
 */
private void save(BarGraph barGraph, File outputFile) {

	// Create and paint image
	Display display = Display.getDefault();
	int height = barGraph.getHeight();
	Image image = new Image(display, GRAPH_WIDTH, height);
	GC gc = new GC(image);
	barGraph.paint(display, GRAPH_WIDTH, height, gc);
	gc.dispose();

	// Save image
	ImageData data = Utils.downSample(image);
	ImageLoader imageLoader = new ImageLoader();
	imageLoader.data = new ImageData[] { data };

	OutputStream out = null;
	try {
		out = new BufferedOutputStream(new FileOutputStream(outputFile));
		imageLoader.save(out, SWT.IMAGE_GIF);
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} finally {
		image.dispose();
		if (out != null) {
			try {
				out.close();
			} catch (IOException e1) {
				// silently ignored
			}
		}
	}
}
}




 *******************************************************************************/
package org.eclipse.test.performance.ui;

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.test.internal.performance.data.Dim;
import org.eclipse.test.internal.performance.results.AbstractResults;
import org.eclipse.test.internal.performance.results.BuildResults;
import org.eclipse.test.internal.performance.results.ConfigResults;

/**
 * Class used to fill details file of scenario builds data.
 * @see ScenarioData
 */
public class RawDataTable {

	private ConfigResults configResults;
	private List buildPrefixes;
	private PrintStream stream;
	private Dim[] dimensions = AbstractResults.SUPPORTED_DIMS;
	private boolean debug = false;

private RawDataTable(ConfigResults results, PrintStream ps) {
	this.configResults = results;
	this.stream = ps;
}
	private ArrayList buildIDPatterns;
		
	
	public RawDataTable(Scenario scenario, Dim[] dimensions, ArrayList buildIDPatterns, String currentBuild) {
		this.scenario = scenario;
		this.dimensions = dimensions;
		this.buildIDPatterns=buildIDPatterns;
		this.currentBuild=currentBuild;
		buildIDTable = new Hashtable();
		derivedValues=new Hashtable();
		fill();
	}
	
	public RawDataTable(Scenario scenario, Dim[] dimensions, String buildIDPrefix,String currentBuild) {
		buildIDPatterns=new ArrayList();
		buildIDPatterns.add(buildIDPrefix);
		this.currentBuild=currentBuild;
		this.scenario = scenario;
		this.dimensions = dimensions;
		buildIDTable = new Hashtable();
		derivedValues=new Hashtable();
		fill();
	}

	private void fill() {

		for (int i = 0; i < dimensions.length; i++) {
			TimeSeries ts = scenario.getTimeSeries(dimensions[i]);
			double total = 0.0;
			int samplesCount=0;
			for (int j = 0; j < ts.getLength(); j++) {
				String buildID = ts.getLabel(j);
				double value = 0.0;
				boolean buildIDmatches=false;
				Iterator iterator=buildIDPatterns.iterator();
				while (iterator.hasNext()){
					Object tmp=iterator.next();
					if (tmp==null)
						continue;
					if (buildID.startsWith(tmp.toString())){
							buildIDmatches=true;
							break;
					}
				}
				if (!buildIDmatches)
					continue;
				
				Hashtable samples=(Hashtable)buildIDTable.get(buildID);
				if (samples==null)
					samples=new Hashtable();
				value = ts.getValue(j);
				
				// store result for build
				samples.put(dimensions[i].getName(),new Double(value));
				buildIDTable.put(buildID,samples);

				//keep count of samples added and total value
				total+=value;
				samplesCount++;
				
				//quit after current build
				if (buildID.equals(currentBuild))
					break;
			}
					
			double mean = total / samplesCount;
			double squaredValues = 0.0;
		
			String[] buildIDs=(String[])buildIDTable.keySet().toArray(new String[buildIDTable.size()]);
			for (int j = 0; j < buildIDs.length; j++) {
				String buildID = buildIDs[j];
				Hashtable storedValues=(Hashtable)buildIDTable.get(buildID);
				double value = ((Double) (storedValues.get(dimensions[i].getName()))).doubleValue();
				double squaredValue = Math.pow(value - mean, 2);
				squaredValues += squaredValue;
			}

public RawDataTable(ConfigResults results, List prefixes, PrintStream ps) {
	this(results, ps);
	this.buildPrefixes = prefixes;
}
public RawDataTable(ConfigResults results, String baselinePrefix, PrintStream ps) {
	this(results, ps);
	this.buildPrefixes = new ArrayList();
	this.buildPrefixes.add(baselinePrefix);
}
			calculatedValuesForDimension.put(SAMPLECOUNT,new Integer(samplesCount));
			calculatedValuesForDimension.put(MEAN, dimensions[i].getDisplayValue(mean));
			calculatedValuesForDimension.put(STDDEV, dimensions[i].getDisplayValue(standardDeviation));
			calculatedValuesForDimension.put(CV, coefficientOfVariation+"%");
			derivedValues.put(dimensions[i].getName(),calculatedValuesForDimension);
			
		}
	}

/**
 * Print all build data to the current stream.
 */
public void print(){
	stream.print("<table border=\"1\">");
	printSummary();
	printDetails();
	stream.println("</table>");
}
			String date=Utils.getDateFromBuildID(buildIDs[i], true)+"";
			if (date.equals("-1"))
				date=buildIDs[i];
			tmp.put(date, buildIDs[i]);
		}
		String[] dates = (String[]) tmp.keySet().toArray(new String[tmp.size()]);
		Arrays.sort(dates);
		for (int i = 0; i < dates.length; i++) {
			result[i] = tmp.get(dates[i]).toString();
		}

/*
 * Print table columns headers.
 */
private void printColumnHeaders() {
	StringBuffer buffer = new StringBuffer();
	int length = this.dimensions.length;
	for (int i=0; i<length; i++) {
		buffer.append("<td><b>");
		buffer.append(this.dimensions[i].getName());
		buffer.append("</b></td>");
	}
	stream.print(buffer.toString());
}

/*
 * Print all build results in the table.
 */
private void printDetails() {
	stream.print("<tr><td><b>Build ID</b></td>");
	printColumnHeaders();
	stream.println("</tr>");

	List builds = this.configResults.getBuildsMatchingPrefixes(this.buildPrefixes);
	Collections.reverse(builds);
	int size = builds.size();
	for (int i=0; i<size; i++) {
		BuildResults buildResults = (BuildResults) builds.get(i);
		stream.print("<tr><td>");
		stream.print(buildResults.getName());
		stream.print("</td>");
		int dimLength = this.dimensions.length;
		for (int d=0; d<dimLength; d++) {
			int dim_id = this.dimensions[d].getId();
			double value = buildResults.getValue(dim_id);
			printDimTitle(this.dimensions[d].getName());
			String displayValue = this.dimensions[d].getDisplayValue(value);
			stream.print(displayValue);
			if (debug) System.out.print("\t"+displayValue);
			stream.print("</td>");
		}
		if (debug) System.out.println();
		stream.println("</tr>");
	}
	if (debug) System.out.println("\n");
}

/*
 * Print summary on top of the table.
 */
private void printSummary() {
	stream.print("<tr><td><b>Stats</b></td>");
	printColumnHeaders();
	stream.println("</tr>");

	int length = this.dimensions.length;
	double[][] dimStats = new double[2][];
	for (int i=0; i<this.dimensions.length; i++) {
		dimStats[i] = this.configResults.getStatistics(this.buildPrefixes, this.dimensions[i].getId());
	}

	stream.print("<tr><td>#BUILDS SAMPLED</td>");
	for (int i=0; i<length; i++) {
		String dimName = this.dimensions[i].getName();
		printDimTitle(dimName);
		stream.print((int)dimStats[i][0]);
		stream.print("</td>");
	}
	stream.println("</tr>");
	stream.print("<tr><td>MEAN</td>");
	printRowDoubles(dimStats, 1);
	stream.println("</tr>");
	stream.print("<tr><td>STD DEV</td>");
	printRowDoubles(dimStats, 2);
	stream.println("</tr>");
	stream.print("<tr><td>COEF. VAR</td>");
	printRowDoubles(dimStats, 3);
	stream.println("</tr>");

	// Blank line
	stream.print("<tr>");
	for (int i=0; i<length+1;	i++){
		stream.print("<td>&nbsp;</td>");
	}
	stream.println("</tr>");
}

/*
 * Print values in table row.
 */
private void printRowDoubles(double[][] stats, int idx) {
	int length = this.dimensions.length;
	for (int i=0; i<length; i++) {
		double value = stats[i][idx];
		String dimName = this.dimensions[i].getName();
		if (idx == 3) {
			if (value>10 && value<20) {
				stream.print("<td bgcolor=\"yellow\" title=\"");
			} else if (value>=20) {
				stream.print("<td bgcolor=\"FF9900\" title=\"");
			} else {
				stream.print("<td title=\"");
			}
			stream.print(dimName);
			stream.print("\">");
			stream.print(value);
			stream.print("%</td>");
		} else {
			printDimTitle(dimName);
			stream.print(this.dimensions[i].getDisplayValue(value));
			stream.print("</td>");
		result = result.concat(htmSummaryRow(CV));

		result = result.concat("</tr><tr>\n");
		for (int i=0;i<dimensions.length+1;i++){
			result=result.concat("<td>&nbsp;</td>");
		}
		result=result.concat("</tr>\n");
		
		return result;
	}

	private String htmSummaryRow(String summaryType) {
		String result="";
		Hashtable tmp;
		for (int j=0;j<dimensions.length;j++){
			String dimensionName=dimensions[j].getName();
			tmp=(Hashtable)(derivedValues.get(dimensionName));
			String displayValue=tmp.get(summaryType).toString();
			if (summaryType.equals(CV)){
				displayValue=displayValue.substring(0,displayValue.length()-1);
				double value=Double.valueOf(displayValue).doubleValue();
				if (value>10&&value<20)
					result = result.concat("<td bgcolor=\"yellow\" title=\""+dimensionName+"\">"+displayValue+"%</td>");
				else if (value>=20)
					result = result.concat("<td bgcolor=\"FF9900\" title=\""+dimensionName+"\">"+displayValue+"%</td>");
				else
					result = result.concat("<td title=\""+dimensionName+"\">"+displayValue+"%</td>");
			} else
				result= result.concat("<td title=\""+dimensionName+"\">"+displayValue+"</td>");
		}
		return result;
	}
}

/*
 * Print dim title inside value reference.
 * TODO (frederic) See if this title is really necessary
 */
private void printDimTitle(String dimName) {
    stream.print("<td title=\"");
    stream.print(dimName);
    stream.print("\">");
}
		
	}
}

Lines 11-17 Link Here

(-)META-INF/MANIFEST.MF (-1 lines)
11	org.eclipse.test.performance,	11	org.eclipse.test.performance,
12	org.eclipse.swt,	12	org.eclipse.swt,
13	org.apache.derby;resolution:=optional,	13	org.apache.derby;resolution:=optional,
14	org.apache.derby.core;resolution:=optional,
15	Cloudscape;resolution:=optional,	14	Cloudscape;resolution:=optional,
16	org.junit	15	org.junit
17	Eclipse-LazyStart: true	16	Eclipse-LazyStart: true




/*******************************************************************************
 * Copyright (c) 2004, 2007 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.performance.ui;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import junit.framework.AssertionFailedError;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.widgets.Display;
import org.eclipse.test.internal.performance.data.Dim;
import org.eclipse.test.internal.performance.data.DimensionMessages;
import org.eclipse.test.internal.performance.results.AbstractResults;
import org.eclipse.test.internal.performance.results.BuildResults;
import org.eclipse.test.internal.performance.results.ComponentResults;
import org.eclipse.test.internal.performance.results.ConfigResults;
import org.eclipse.test.internal.performance.results.PerformanceResults;
import org.eclipse.test.internal.performance.results.ScenarioResults;

/**
 * Class used to print scenario all builds data.
 */
public class ScenarioData {
	private String baselinePrefix = null;
	private List pointsOfInterest;
	private List buildIDStreamPatterns;
	private File rootDir;

/**
 * Summary of results for a scenario for a given build compared to a
 * reference.
 *
 * @param baselinePrefix The prefix of the baseline build names
 * @param pointsOfInterest A list of buildId's to highlight on line graphs
 * @param buildIDPatterns
 * @param outputDir The directory root where the files are generated
 *
*/
public ScenarioData(String baselinePrefix, List pointsOfInterest, List buildIDPatterns, File outputDir) {
	this.baselinePrefix = baselinePrefix;
	this.pointsOfInterest = pointsOfInterest;
	this.buildIDStreamPatterns = buildIDPatterns;
	this.rootDir = outputDir;
}

/**
 * Print the scenario all builds data from the given performance results.
 * 
 * @param performanceResults The needed information to generate scenario data
 */
public void print(PerformanceResults performanceResults) {
	String[] configNames = performanceResults.getConfigNames(false/*not sorted*/);
	String[] configBoxes = performanceResults.getConfigBoxes(false/*not sorted*/);
	int length = configNames.length;
	for (int i=0; i<length; i++) {
		File outputDir = new File(this.rootDir, configNames[i]);
		outputDir.mkdir();
		Iterator components = performanceResults.getResults();
		while (components.hasNext()) {
			ComponentResults componentResults = (ComponentResults) components.next();
			printSummary(configNames[i], configBoxes[i], componentResults, outputDir);
			printDetails(configNames[i], configBoxes[i], componentResults, outputDir);
		}
	}
}

/*
 * Print the summary file of the builds data.
 */
private void printSummary(String configName, String configBox, ComponentResults componentResults, File outputDir) {
	Iterator scenarii = componentResults.getResults();
	while (scenarii.hasNext()) {
		List highlightedPoints = new ArrayList();
		ScenarioResults scenarioResults = (ScenarioResults) scenarii.next();
		ConfigResults configResults = scenarioResults.getConfigResults(configName);
		if (configResults == null || !configResults.isValid()) continue;

		// get latest points of interest matching
		if (this.pointsOfInterest != null) {
			Iterator buildPrefixes = this.pointsOfInterest.iterator();
			while (buildPrefixes.hasNext()) {
				String buildPrefix = (String) buildPrefixes.next();
				List builds = configResults.getBuilds(buildPrefix);
				if (buildPrefix.indexOf('*') <0 && buildPrefix.indexOf('?') < 0) {
					if (builds.size() > 0) {
						highlightedPoints.add(builds.get(builds.size()-1));
					}
				} else {
					highlightedPoints.addAll(builds);
				}
			}
		}

		String scenarioFileName = scenarioResults.getFileName();
		File outFile = new File(outputDir, scenarioFileName + ".html");
		PrintStream stream = null;
		try {
			stream = new PrintStream(new BufferedOutputStream(new FileOutputStream(outFile)));
		} catch (FileNotFoundException e) {
			System.err.println("can't create output file" + outFile); //$NON-NLS-1$
		}
		if (stream == null) {
			stream = System.out;
		}
		stream.println(Utils.HTML_OPEN);
		stream.println(Utils.HTML_DEFAULT_CSS);

		stream.println("<title>" + scenarioResults.getName() + "(" + configBox + ")" + "</title></head>"); //$NON-NLS-1$
		stream.println("<h4>Scenario: " + scenarioResults.getName() + " (" + configBox + ")</h4><br>"); //$NON-NLS-1$ //$NON-NLS-2$

		String failureMessage = Utils.failureMessage(configResults.getCurrentBuildDeviation(), true);
 		if (failureMessage != null){
   			stream.println("<table><tr><td><b>"+failureMessage+"</td></tr></table>\n");
 		}

 		BuildResults currentBuildResults = configResults.getCurrentBuildResults();
 		String comment = currentBuildResults.getComment();
		if (comment != null) {
			stream.println("<p><b>Note:</b><br>\n");
			stream.println(comment + "</p>");
		}

		// Print link to raw data.
		String rawDataFile = scenarioFileName+"_raw.html";
		stream.println("<br><br><b><a href=\""+rawDataFile+"\">Raw data and Stats</a></b><br><br>\n");
		stream.println("<b>Click measurement name to view line graph of measured values over builds.</b><br><br>\n");

		try {
			// Print build result table
			stream.println("<table border=\"1\">"); //$NON-NLS-1$
			stream.print("<tr><td><b>Build Id</b></td>"); //$NON-NLS-1$
			Dim[] dimensions = AbstractResults.SUPPORTED_DIMS;
			int dimLength = dimensions.length;
			for (int d=0; d<dimLength; d++) {
				String dimName = dimensions[d].getName();
				stream.print("<td><a href=\"#" + configName + "_" + scenarioFileName + "_" + dimName + "\"><b>" + dimName + "</b></a></td>");
			}
			stream.println("</tr>\n");

			// Write build lines
			printTableLine(stream, currentBuildResults);
			printTableLine(stream, configResults.getBaselineBuildResults());

			// Write difference line
			printDifferenceLine(stream, configResults);

			// End of table
			stream.println("</table>");
			stream.println("*Delta values in red and green indicate degradation > 10% and improvement > 10%,respectively.<br><br>");
			stream.println("<br><hr>\n\n");

			// print text legend.
			stream.println("Black and yellow points plot values measured in integration and last seven nightly builds.<br>\n" + "Magenta points plot the repeated baseline measurement over time.<br>\n"
					+ "Boxed points represent previous releases, milestone builds, current reference and current build.<br><br>\n"
					+ "Hover over any point for build id and value.\n");

			// print image maps of historical
			for (int d=0; d<dimLength; d++) {
				String dimName = dimensions[d].getName();
				int dim_id = dimensions[d].getId();
				TimeLineGraph lineGraph = getLineGraph(scenarioResults, configResults, dimensions[d], highlightedPoints, this.buildIDStreamPatterns);

				File graphsDir = new File(outputDir, "graphs");
				graphsDir.mkdir();
				File imgFile = new File(graphsDir, scenarioFileName + "_" + dimName + ".gif");
				saveGraph(lineGraph, imgFile);
				stream.println("<br><a name=\"" + configName + "_" + scenarioFileName + "_" + dimName + "\"></a>");
				stream.println("<br><b>" + dimName + "</b><br>");
				stream.println(DimensionMessages.getDescription(dim_id) + "<br><br>\n");
				stream.print("<img src=\"graphs/");
				stream.print(imgFile.getName());
				stream.print("\" usemap=\"#" + lineGraph.fTitle + "\">");
				stream.print("<map name=\"" + lineGraph.fTitle + "\">");
				stream.print(lineGraph.getAreas());
				stream.println("</map>");
			}
			stream.println("<br><br></body>");
			stream.println(Utils.HTML_CLOSE);
			if (stream != System.out)
				stream.close();

		} catch (AssertionFailedError e) {
			e.printStackTrace();
			continue;
		}
	}
}

/*
 * Print the data for a build results.
 */
private void printTableLine(PrintStream stream, BuildResults buildResults) {
	stream.print("<tr><td>");
	stream.print(buildResults.getName());
	if (buildResults.isBaseline()) stream.print(" (reference)");
	stream.print("</td>");
	Dim[] dimensions = AbstractResults.SUPPORTED_DIMS;
	int dimLength = dimensions.length;
	for (int d=0; d<dimLength; d++) {
		int dim_id = dimensions[d].getId();
		double stddev = buildResults.getDeviation(dim_id);
		String displayValue = dimensions[d].getDisplayValue(buildResults.getValue(dim_id));
		stream.print("<td>");
		stream.print(displayValue);
		if (stddev < 0) {
			stream.println(" [n/a]");
		} else if (stddev > 0) {
			stream.print(" [");
			stream.print(dimensions[d].getDisplayValue(stddev));
			stream.print("]");
		}
		stream.print( "</td>");
	}
	stream.println("</tr>");
}

/*
 * Print the line showing the difference between current and baseline builds.
 */
private void printDifferenceLine(PrintStream stream, ConfigResults configResults) {
	stream.print("<tr><td>*Delta</td>");
	Dim[] dimensions = AbstractResults.SUPPORTED_DIMS;
	int dimLength = dimensions.length;
	for (int d=0; d<dimLength; d++) {
		Dim currentDim = dimensions[d];
		int dim_id = currentDim.getId();
		BuildResults currentBuild = configResults.getCurrentBuildResults();
		BuildResults baselineBuild = configResults.getBaselineBuildResults();

		double baselineValue = baselineBuild.getValue(dim_id);
		double diffValue = currentBuild.getValue(dim_id) - baselineValue;
		double diffPercentage =  baselineValue == 0 ? 0 : Math.round(diffValue / baselineValue * 1000) / 10.0;
		String diffDisplayValue = currentDim.getDisplayValue(diffValue);
		// green
		String fontColor = "";
		if ((diffPercentage < -10 && !currentDim.largerIsBetter()) || (diffPercentage > 10 && currentDim.largerIsBetter()))
			fontColor = "#006600";
		if ((diffPercentage < -10 && currentDim.largerIsBetter()) || (diffPercentage > 10 && !currentDim.largerIsBetter()))
			fontColor = "#FF0000";

		diffPercentage = Math.abs(diffPercentage);
		String percentage = (diffPercentage == 0) ? "" : "<br>" + diffPercentage + " %";

		if (diffPercentage > 10 || diffPercentage < -10) {
			stream.print("<td><FONT COLOR=\"" + fontColor + "\"><b>" + diffDisplayValue + percentage + "</b></FONT></td>");
		} else {
			stream.print("<td>" + diffDisplayValue + percentage + "</td>");
		}
	}
	stream.print("</tr></font>");
}

/*
 * Returns a LineGraph object representing measurements for a scenario over builds.
 */
private TimeLineGraph getLineGraph(ScenarioResults scenarioResults, ConfigResults configResults, Dim dim, List highlightedPoints, List currentBuildIdPrefixes) {
	Display display = Display.getDefault();

	Color black = display.getSystemColor(SWT.COLOR_BLACK);
	Color yellow = display.getSystemColor(SWT.COLOR_DARK_YELLOW);
	Color magenta = display.getSystemColor(SWT.COLOR_MAGENTA);

	String scenarioName = scenarioResults.getName();
	TimeLineGraph graph = new TimeLineGraph(scenarioName + ": " + dim.getName(), dim);
	String baseline = configResults.getBaselineBuildName();
	String current = configResults.getCurrentBuildName();

	Iterator builds = configResults.getResults();
	List lastSevenNightlyBuilds = configResults.lastNightlyBuildNames(7);
	buildLoop: while (builds.hasNext()) {
		BuildResults buildResults = (BuildResults) builds.next();
		String buildID = buildResults.getName();
		int underscoreIndex = buildID.indexOf('_');
		String label = (underscoreIndex != -1 && (buildID.equals(baseline) || buildID.equals(current))) ? buildID.substring(0, underscoreIndex) : buildID;

		double value = buildResults.getValue(dim.getId());

		if (buildID.equals(current)) {
			Color color = black;
			if (buildID.startsWith("N"))
				color = yellow;

			graph.addItem("main", label, dim.getDisplayValue(value), value, color, true, Utils.getDateFromBuildID(buildID), true);
			continue;
		}
		if (highlightedPoints.contains(buildID)) {
			graph.addItem("main", label, dim.getDisplayValue(value), value, black, false, Utils.getDateFromBuildID(buildID, false), true);
			continue;
		}
		if (buildID.charAt(0) == 'N') {
			if (lastSevenNightlyBuilds.contains(buildID)) {
				graph.addItem("main", buildID, dim.getDisplayValue(value), value, yellow, false, Utils.getDateFromBuildID(buildID), false);
			}
			continue;
		}
		for (int i=0;i<currentBuildIdPrefixes.size();i++){
			if (buildID.startsWith(currentBuildIdPrefixes.get(i).toString())) {
				graph.addItem("main", buildID, dim.getDisplayValue(value), value, black, false, Utils.getDateFromBuildID(buildID), false);
				continue buildLoop;
			}
		}
		if (buildID.equals(baseline)) {
			boolean drawBaseline = (baselinePrefix != null) ? false : true;
			graph.addItem("reference", label, dim.getDisplayValue(value), value, magenta, true, Utils.getDateFromBuildID(buildID, true), true, drawBaseline);
			continue;
		}
		if (baselinePrefix != null) {
			if (buildID.startsWith(baselinePrefix) && !buildID.equals(baseline) && Utils.getDateFromBuildID(buildID, true) <= Utils.getDateFromBuildID(baseline, true)) {
				graph.addItem("reference", label, dim.getDisplayValue(value), value, magenta, false, Utils.getDateFromBuildID(buildID, true), false);
				continue;
			}
		}
	}
	return graph;
}

/*
 * Print details file of the scenario builds data.
 */
private void printDetails(String configName, String configBox, ComponentResults componentResults, File outputDir) {
	Iterator scenarii = componentResults.getResults();
	while (scenarii.hasNext()) {
		ScenarioResults scenarioResults = (ScenarioResults) scenarii.next();
		ConfigResults configResults = scenarioResults.getConfigResults(configName);
		if (configResults == null || !configResults.isValid()) continue;
		String scenarioName= scenarioResults.getName();
		String scenarioFileName = scenarioResults.getFileName();
		File outFile = new File(outputDir, scenarioFileName + "_raw.html");
		PrintStream stream = null;
		try {
			stream = new PrintStream(new BufferedOutputStream(new FileOutputStream(outFile)));
		} catch (FileNotFoundException e) {
			System.err.println("can't create output file" + outFile); //$NON-NLS-1$
		}
		if (stream == null) stream = System.out;
		RawDataTable currentResultsTable = new RawDataTable(configResults, this.buildIDStreamPatterns, stream);
		RawDataTable baselineResultsTable = new RawDataTable(configResults, this.baselinePrefix, stream);
		stream.println(Utils.HTML_OPEN);
		stream.println(Utils.HTML_DEFAULT_CSS);
		stream.println("<title>" + scenarioName + "(" + configBox + ")" + " - Details</title></head>"); //$NON-NLS-1$
		stream.println("<h4>Scenario: " + scenarioName + " (" + configBox + ")</h4>"); //$NON-NLS-1$
		stream.println("<a href=\""+scenarioFileName+".html\">VIEW GRAPH</a><br><br>"); //$NON-NLS-1$
		stream.println("<table><td><b>Current Stream Test Runs</b></td><td><b>Baseline Test Runs</b></td></tr>\n");
		stream.println("<tr valign=\"top\">");
		stream.print("<td>");
		currentResultsTable.print();
		stream.println("</td>");
		stream.print("<td>");
		baselineResultsTable.print();
		stream.println("</td>");
		stream.println("</tr>");
		stream.println("</table>");
		stream.close();
	}
}

/*
 * Prints a LineGraph object as a gif file.
 */
private void saveGraph(LineGraph p, File outputFile) {
	int GRAPH_WIDTH = 600;
	int GRAPH_HEIGHT = 200;
	Image image = new Image(Display.getDefault(), GRAPH_WIDTH, GRAPH_HEIGHT);
	p.paint(image);

	/* Downscale to 8 bit depth palette to save to gif */
	ImageData data = Utils.downSample(image);
	ImageLoader il = new ImageLoader();
	il.data = new ImageData[] { data };
	OutputStream out = null;
	try {
		out = new BufferedOutputStream(new FileOutputStream(outputFile));
		il.save(out, SWT.IMAGE_GIF);

	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} finally {
		image.dispose();
		if (out != null) {
			try {
				out.close();
			} catch (IOException e1) {
				// silently ignored
			}
		}
	}
}
}

Lines 26-34 Link Here

(-)src/org/eclipse/test/internal/performance/data/DimensionMessages.java (-2 / +6 lines)
26	private DimensionMessages() {	26	private DimensionMessages() {
27	// emtpy	27	// emtpy
28	}	28	}
29		29
30	public static String getString(int id) {	30	public static String getString(int id) {
31	return getString("Dimension." + id); //$NON-NLS-1$	31	return getString("dimension." + id); //$NON-NLS-1$
		32	}
		33
		34	public static String getDescription(int id) {
		35	return getString("dimension.description." + id); //$NON-NLS-1$
32	}	36	}
33		37
34	public static String getString(String key) {	38	public static String getString(String key) {




# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################

# Dimension Name
dimension.2=System Time
dimension.3=Used Java Heap
dimension.4=Working Set
dimension.7=Committed
dimension.8=Working Set Peak
dimension.9=Elapsed Process
dimension.10=User time
dimension.11=Kernel time
dimension.19=Page Faults
dimension.20=CPU Time
dimension.22=Commit Limit
dimension.23=Commit Peak
dimension.24=Physical Memory
dimension.25=Physical Available
dimension.26=System Cache
dimension.27=Kernel Total
dimension.28=Kernel Paged
dimension.29=Kernel Nonpaged
dimension.30=Page Size
dimension.31=Handle Count
dimension.32=Process Count
dimension.33=Thread Count
dimension.34=GDI Objects
dimension.35=USER Objects
dimension.36=Open Handles
dimension.37=Commit Total
dimension.38=Read Count
dimension.39=Write Count
dimension.40=Bytes Read
dimension.41=Bytes Written
dimension.42=Hard Page Faults
dimension.43=Soft Page Faults
dimension.44=Text Size
dimension.45=Data Size
dimension.46=Library Size
dimension.48=Used Memory
dimension.49=Free Memory
dimension.50=Buffers Memory
dimension.51=Free Java Memory
dimension.52=Invocation Count

# Dimension Description
dimension.description.2=* no longer measured, same as elapsed time, see PerformanceMonitor *
dimension.description.3=Change in the amount of memory allocated for Java objects.
dimension.description.4=Change in the amount of physical memory used by the process (other data resides in swap space).
dimension.description.7=Change in the amount of allocated memory (both, in physical memory and swap space, can be preallocated for future use).
dimension.description.8=Increase of the maximum working set size, useful with start-up tests.
dimension.description.9=Amount of wall-clock time.
dimension.description.10=User time
dimension.description.11=Amount of time the process ran on the CPU, while the CPU was in kernel mode.
dimension.description.19=Number of memory pages that were loaded from swap space on disk or from memory (i.e., in the latter case, they were not mapped in the process' page table, but already present in memory for some reason).
dimension.description.20=Amount of time the process ran on the CPU.
dimension.description.22=Commit Limit
dimension.description.23=Commit Peak
dimension.description.24=Physical Memory
dimension.description.25=Physical Available
dimension.description.26=System Cache
dimension.description.27=Kernel Total
dimension.description.28=Kernel Paged
dimension.description.29=Kernel Nonpaged
dimension.description.30=Page Size
dimension.description.31=Handle Count
dimension.description.32=Process Count
dimension.description.33=Thread Count
dimension.description.34=Change in the number of GDI (Graphics Device Interface) objects, can be useful for UI tests (particularly start-up tests).
dimension.description.35=USER Objects
dimension.description.36=Open Handles
dimension.description.37=Commit Total
dimension.description.38=Read Count
dimension.description.39=Write Count
dimension.description.40=Bytes Read
dimension.description.41=Bytes Written
dimension.description.42=Number of memory pages that were loaded from swap space on disk.
dimension.description.43=Number of memory pages that were loaded from memory (i.e., they were not mapped in the process' page table, but already present in memory for some reason).
dimension.description.44=Change in the process' code memory size, useful with start-up tests.
dimension.description.45=Change in the process' data and stack memory size.
dimension.description.46=Change in the process' library memory size.
dimension.description.48=Used Memory
dimension.description.49=Free Memory
dimension.description.50=Buffers Memory
dimension.description.51=Free Java Memory
dimension.description.52=Invocation Count

Lines 69-78 Link Here

(-)src/org/eclipse/test/internal/performance/data/Dim.java (-1 / +5 lines)
69	public boolean largerIsBetter() {	69	public boolean largerIsBetter() {
70	return fLargerIsBetter;	70	return fLargerIsBetter;
71	}	71	}
72		72
73	public String getName() {	73	public String getName() {
74	return DimensionMessages.getString(fId);	74	return DimensionMessages.getString(fId);
75	}	75	}
		76
		77	public String getDescription() {
		78	return DimensionMessages.getString(fId);
		79	}
76		80
77	public String toString() {	81	public String toString() {
78	return "Dimension [name=" + getName() + ", " + fUnit + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	82	return "Dimension [name=" + getName() + ", " + fUnit + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$




#Fri Aug 10 17:30:18 CEST 2007
eclipse.preferences.version=1
org.eclipse.jdt.core.builder.cleanOutputFolder=clean
org.eclipse.jdt.core.builder.duplicateResourceTask=warning
org.eclipse.jdt.core.builder.invalidClasspath=abort
org.eclipse.jdt.core.builder.resourceCopyExclusionFilter=*.launch
org.eclipse.jdt.core.circularClasspath=error
org.eclipse.jdt.core.classpath.exclusionPatterns=enabled
org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.2
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.4
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.doc.comment.support=enabled
org.eclipse.jdt.core.compiler.maxProblemPerUnit=100
org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning
org.eclipse.jdt.core.compiler.problem.deprecation=warning
org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
org.eclipse.jdt.core.compiler.problem.finalParameterBound=ignore
org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=error
org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=error
org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning
org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=private
org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=error
org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=enabled
org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public
org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=enabled
org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=private
org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
org.eclipse.jdt.core.compiler.problem.noEffectAssignment=error
org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=error
org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning
org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=error
org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=error
org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=error
org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=warning
org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=enabled
org.eclipse.jdt.core.compiler.problem.unusedImport=warning
org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
org.eclipse.jdt.core.compiler.source=1.3
org.eclipse.jdt.core.incompatibleJDKLevel=ignore
org.eclipse.jdt.core.incompleteClasspath=error





	private boolean fCompatibility= false;

	protected Connection fConnection;

	private PreparedStatement fInsertVariation, fInsertScenario, fInsertSample, fInsertDataPoint, fInsertScalar;
	private PreparedStatement fQueryComment, fInsertComment, fQueryComment2;

			fQuerySummaryEntries;
	private PreparedStatement fInsertFailure, fQueryFailure;

	protected SQL(Connection con) throws SQLException {
		fConnection= con;

		boolean needsUpgrade= true;

		}
	}

	protected void dispose() throws SQLException {
		if (fInsertVariation != null)
			fInsertVariation.close();
		if (fInsertScenario != null)




 org.eclipse.test.internal.performance.data,
 org.eclipse.test.internal.performance.db,
 org.eclipse.test.internal.performance.eval,
 org.eclipse.test.internal.performance.results,
 org.eclipse.test.internal.performance.tests,
 org.eclipse.test.performance
Require-Bundle: org.eclipse.core.runtime,
 org.junit,
 org.apache.derby;resolution:=optional,
 org.apache.derby.core;resolution:=optional,
 Cloudscape;resolution:=optional
Eclipse-LazyStart: true
Bundle-ClassPath: .




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.util.*;


/**
 * Root class to handle performance results.
 * 
 * Usually performance results are built for a current build vs. a baseline build.
 * 
 * This class allow to read all data from releng performance database for given
 * configurations and scenario pattern.
 * 
 * Then it provides easy and speedy access to all stored results.
 */
public class PerformanceResults extends AbstractResults {

	final String baselineName; // Name of the baseline build used for comparison
	final String baselinePrefix;
	private String scenarioPattern;
	private List components;
	private String[] configNames, sortedConfigNames;
	private String[] configBoxes, sortedConfigBoxes;

public PerformanceResults(String name, String baseline, boolean print) {
	super(null, name);
	this.baselineName = baseline;
	this.baselinePrefix = baseline.substring(0, baseline.lastIndexOf('_'));
	this.print = print;
}

/**
 * Returns the name of the baseline used for extracted results
 * 
 * @return The build name of the baseline of <code>null</code>
 * 	if no specific baseline is used for the extracted results.
 */
public String getBaselineName() {
	return this.baselineName;
}

String getBaselinePrefix() {
	return this.baselinePrefix;
}

/**
 * Return the list of components concerned by performance results.
 * 
 * @return The list of the components
 */
public List getComponents() {
	return components;
}

/**
 * Get the scenarii of a given component.
 *
 * @param componentName The component name. Should not be <code>null</code>
 * @return A list of {@link ScenarioResults scenario results}
 */
public List getComponentScenarii(String componentName) {
	ComponentResults componentResults = (ComponentResults) getResults(componentName);
	if (componentResults == null) return null;
	return Collections.unmodifiableList(componentResults.children);
}

/**
 * Get the scenarii which have a summary for a given component.
 *
 * @param componentName The component name
 * @param config Configuration name
 * @return A list of {@link ScenarioResults scenario results} which have a summary
 */
public List getComponentSummaryScenarii(String componentName, String config) {
	if (componentName == null) {
		int size = size();
		List scenarii = new ArrayList();
		for (int i=0; i< size; i++) {
			ComponentResults componentResults = (ComponentResults) this.children.get(i);
			scenarii.addAll(componentResults.getSummaryScenarii(true, config));
		}
		return scenarii;
	}
	ComponentResults componentResults = (ComponentResults) getResults(componentName);
	return componentResults.getSummaryScenarii(false, config);
}

/**
 * Return the configuration boxes considered for this performance results
 * sorted or not depending on the given flag.
 * 
 * @param sort Indicates whether the list must be sorted or not.
 * 	The order is defined by the configuration names, not by the box names
 * @return The list of configuration boxes sorted by configuration names
 */
public String[] getConfigBoxes(boolean sort) {
	return sort ? this.sortedConfigBoxes : this.configBoxes;
}

/**
 * Return the configuration names considered for this performance results
 * sorted or not depending on the given flag.
 * 
 * @param sort Indicates whether the list must be sorted or not
 * @return The list of configuration names
 */
public String[] getConfigNames(boolean sort) {
	return sort ?this.sortedConfigNames : this.configNames;
}

String getConfigurationsPattern() {
	int length = this.sortedConfigNames == null ? 0 : this.sortedConfigNames.length;
	if (length == 0) return null;
	String configurations = this.sortedConfigNames[0];
	int refLength = configurations.length();
	for (int i=1; i<length; i++) {
		String config = this.sortedConfigNames[i];
		StringBuffer newConfig = null;
		if (refLength != config.length()) return null; // strings have not the same length => cannot find a pattern
		for (int j=0; j<refLength; j++) {
			char c = configurations.charAt(j);
			if (config.charAt(j) != c) {
				if (newConfig == null) {
					newConfig = new StringBuffer(refLength);
					if (j == 0) return null; // first char is already different => cannot find a pattern
					newConfig.append(configurations.substring(0, j));
				}
				newConfig.append('_');
			} else if (newConfig != null) {
				newConfig.append(c);
			}
		}
		if (newConfig != null) {
			configurations = newConfig.toString();
		}
	}
	return configurations;
}

PerformanceResults getPerformance() {
	return this;
}

/**
 * Get the results of a given scenario.
 *
 * @param scenarioName The scenario name
 * @return The {@link ScenarioResults scenario results}
 */
public ScenarioResults getScenarioResults(String scenarioName) {
	ComponentResults componentResults = (ComponentResults) getResults(DB_Results.getComponentNameFromScenario(scenarioName));
	return componentResults == null ? null : (ScenarioResults) componentResults.getResults(scenarioName);
}

/**
 * Read all data from performance database for the given configurations
 * and scenario pattern.
 * 
 * @param configs All configs to extract results. If <code>null</code>,
 * 	then all known configurations ({@link #CONFIGS})  are read.
 * @param pattern The pattern of the concerned scenarii
 */
public void read(String[][] configs, String pattern) {

	this.scenarioPattern = pattern;

	// Print title
	StringBuffer buffer = new StringBuffer("Read performance results until build '"); //$NON-NLS-1$
	buffer.append(this.name);
	if (scenarioPattern == null) {
		buffer.append("':"); //$NON-NLS-1$
	} else {
		buffer.append("' using scenario pattern '"); //$NON-NLS-1$
		buffer.append(scenarioPattern);
		buffer.append("':"); //$NON-NLS-1$
	}
	println(buffer);

	// Store given configs
	if (configs == null) {
		int length=CONFIGS.length;
		this.configNames = new String[length];
		this.sortedConfigNames = new String[length];
		this.configBoxes = new String[length];
		for (int i=0; i<length; i++) {
			this.configNames[i] = this.sortedConfigNames[i] = CONFIGS[i];
			this.configBoxes[i] = BOXES[i];
		}
	} else {
		int length = configs.length;
		this.configNames = new String[length];
		this.sortedConfigNames = new String[length];
		this.configBoxes = new String[length];
		for (int i=0; i<length; i++) {
			this.configNames[i] = this.sortedConfigNames[i] = configs[i][0];
			this.configBoxes[i] = configs[i][1];
		}
	}
	Arrays.sort(this.sortedConfigNames);
	int length = this.sortedConfigNames.length;
	this.sortedConfigBoxes = new String[length];
	for (int i=0; i<length; i++) {
		for (int j=0; j<length; j++) {
			if (this.sortedConfigNames[i] == this.configNames[j]) { // == is intentional!
				this.sortedConfigBoxes[i] = this.configBoxes[j];
				break;
			}
		}
	}

	// Get scenarii from the given pattern
	print("	+ get all scenarii for build: "+this.name); //$NON-NLS-1$
	long start = System.currentTimeMillis();
	Map allScenarii = DB_Results.queryAllScenarii(this.scenarioPattern, this.name);
	println(" -> "+(System.currentTimeMillis()-start)+"ms"); //$NON-NLS-1$ //$NON-NLS-2$

	// Create corresponding children
	List allComponents = DB_Results.getAllComponents();
	int size = allComponents.size();
	this.components = new ArrayList(size);
	for (int i=0; i<size; i++) {
		String componentName = (String) allComponents.get(i);
		List scenarii = (List) allScenarii.get(componentName);
		if (scenarii == null) continue;
		this.components.add(componentName);
		ComponentResults componentResults = new ComponentResults(this, componentName);
		addChild(componentResults, true);
		componentResults.read(scenarii);
	}

	// Print time
	printGlobalTime(start);
}
}




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.test.internal.performance.InternalDimensions;

/**
 * Class to handle results for an Eclipse performance test box
 * (called a <i>configuration</i>).
 * 
 * It gives access to results for each build on which this configuration has been run.
 * 
 * @see BuildResults
 */
public class ConfigResults extends AbstractResults {
	BuildResults baseline, current;
	boolean baselined = false, valid = false;

public ConfigResults(AbstractResults parent, int id) {
	super(parent, id);
	this.name = DB_Results.getConfig(id);
	this.print = parent.print;
}

/**
 * Returns the baseline build name used to compare results with.
 *
 * @return The name of the baseline build
 * @see #getBaselineBuildResults()
 */
public String getBaselineBuildName() {
	return this.baseline.getName();
}

/**
 * Returns the baseline build results.
 * <p>
 * This build is currently the last reference build which has performance
 * 
 * @return The baseline build results.
 * @see BuildResults
 */
public BuildResults getBaselineBuildResults() {
	return this.baseline;
}

/**
 * Returns the build results matching a given pattern.
 *
 * @param buildPattern The pattern of searched builds
 * @return The list of the builds which names match the given pattern.
 * 	The list is ordered by build results date.
 */
public List getBuilds(String buildPattern) {
	List builds = new ArrayList();
	int size = size();
	for (int i=0; i<size; i++) {
		BuildResults buildResults = (BuildResults) this.children.get(i);
		if (buildResults.match(buildPattern)) {
			builds.add(buildResults);
		}
	}
	return builds;
}

/**
 * Returns a list of build results which names starts with one of the given prefixes.
 *
 * @param prefixes List of expected prefixes
 * @return A list of builds which names start with one of the given patterns.
 */
public List getBuildsMatchingPrefixes(List prefixes) {
	List builds = new ArrayList();
	int size = size();
	int length = prefixes.size();
	for (int i=0; i<size; i++) {
		BuildResults buildResults = (BuildResults) this.children.get(i);
		String buildName = buildResults.getName();
		for (int j=0; j<length; j++) {
			if (buildName.startsWith((String)prefixes.get(j))) {
				builds.add(buildResults);
			}
		}
	}
	return builds;
}

/**
 * Return the deviation value and its associated standard error for the default dimension
 * (currently {@link InternalDimensions#ELAPSED_PROCESS}).
 *
 * @return an array of double. First number is the deviation itself and
 * 	the second is the standard error.
 */
public double[] getCurrentBuildDeviation() {
	int dim_id = SUPPORTED_DIMS[0].getId();
	double baselineValue = this.baseline.getValue(dim_id);
	double currentValue = this.current.getValue(dim_id);
	double deviation = (currentValue - baselineValue) / baselineValue;
	if (Double.isNaN(deviation)) {
		return new double[] { Double.NaN, Double.NaN };
	}
	long baselineCount = this.baseline.getCount(dim_id);
	long currentCount = this.current.getCount(dim_id);
	if (baselineCount == 1 || currentCount == 1) {
		return new double[] { deviation, Double.NaN };
	}
	double baselineError = this.baseline.getError(dim_id);
	double currentError = this.current.getError(dim_id);
	double stderr = Double.isNaN(baselineError)
			? currentError / baselineValue
			: Math.sqrt(baselineError*baselineError + currentError*currentError) / baselineValue;
	return new double[] { deviation, stderr };
}

/**
 * Returns the current build name.
 *
 * @return The name of the current build
 * @see #getCurrentBuildResults()
 */
public String getCurrentBuildName() {
	return this.current.getName();
}

/**
 * Returns the current build results.
 * <p>
 * This build is currently the last integration or nightly
 * build which has performance results in the database.
 * It may differ from the {@link PerformanceResults#getName()}.
 * 
 * @return The current build results.
 * @see BuildResults
 */
public BuildResults getCurrentBuildResults() {
	return this.current;
}

/**
 * Get all dimension builds statistics for a given list of build prefixes
 * and a given dimension.
 *
 * @param prefixes List of prefixes to filter builds. If <code>null</code>
 * 	then all the builds are taken to compute statistics.
 * @param dim_id The id of the dimension on which the statistics must be computed
 * @return An array of double built as follows:
 * 	- 0:	numbers of values
 * 	- 1:	mean of values
 * 	- 2:	standard deviation of these values
 * 	- 3:	coefficient of variation of these values
 */
public double[] getStatistics(List prefixes, int dim_id) {
	int size = size();
	int length = prefixes == null ? 0 : prefixes.size();
	int count = 0;
	double mean=0, stddev=0, variation=0;
	double[] values = new double[size];
	count = 0;
	mean = 0.0;
	for (int i=0; i<size; i++) {
		BuildResults buildResults = (BuildResults) children.get(i);
		String buildName = buildResults.getName();
		if (prefixes == null) {
			double value = buildResults.getValue(dim_id);
			values[count] = value;
			mean += value;
			count++;
		} else {
			for (int j=0; j<length; j++) {
				if (buildName.startsWith((String)prefixes.get(j))) {
					double value = buildResults.getValue(dim_id);
					values[count] = value;
					mean += value;
					count++;
				}
			}
		}
	}
	mean /= count;
	for (int i=0; i<count; i++) {
		stddev += Math.pow(values[i] - mean, 2);
	}
	stddev = Math.sqrt((stddev / (count - 1)));
	variation = Math.round(((stddev) / mean) * 100 * 100) / 100;
	return new double[] { count, mean, stddev, variation };
}

/**
 * Returns whether the configuration has results for the performance
 * baseline build or not.
 * 
 * @return <code>true</code> if the configuration has results
 * 	for the performance baseline build, <code>false</code> otherwise.
 */
public boolean isBaselined() {
	return this.baselined;
}

/**
 * Returns whether the configuration has results for the performance
 * current build or not.
 * 
 * @return <code>true</code> if the configuration has results
 * 	for the performance current build, <code>false</code> otherwise.
 */
public boolean isValid() {
	return this.valid;
}

/**
 * Returns the 'n' last nightly build names.
 *
 * @param n Number of last nightly builds to return
 * @return Last n nightly build names preceding current.
 */
public List lastNightlyBuildNames(int n) {
	List labels = new ArrayList();
	for (int i=size()-2; i>=0; i--) {
		BuildResults buildResults = (BuildResults) this.children.get(i);
		String buildName = buildResults.getName();
		if (buildName.startsWith("N")) { //$NON-NLS-1$
			labels.add(buildName);
			if (labels.size() >= n) break;
		}
	}
	return labels;
}

/*
 * Read scenario results information available in three maps.
 */
void read() {

	// Get performance results builds name
	PerformanceResults perfResults = getPerformance();
	String baselineBuildName = perfResults.getBaselineName();
	String currentBuildName = perfResults.getName();

	// Set baseline and current builds
	int size = size();
	for (int i=0; i<size; i++) {
		BuildResults buildResults = (BuildResults) this.children.get(i);
		if (buildResults.values != null) {
			buildResults.cleanValues();
		}
		if (buildResults.getName().equals(baselineBuildName)) {
			this.baseline = buildResults;
			this.baselined = true;
		} else if (buildResults.getName().equals(currentBuildName)) {
			this.current = buildResults;
			this.valid = true;
		}
	}
	if (this.baseline == null) {
		this.baseline = (BuildResults) this.children.get(0);
	}
	if (this.current == null) {
		this.current = (BuildResults) this.children.get(size()-1);
	}

	// Get current and baseline builds failures and summaries
	ScenarioResults scenarioResults = (ScenarioResults) this.parent;
	DB_Results.queryScenarioFailures(scenarioResults, this.name, this.current, this.baseline);
	DB_Results.queryScenarioSummaries(scenarioResults, this.name, this.current, this.baseline);
}

/*
 * Set the configuration value from database information
 */
void setValue(int build_id, int dim_id, int step, long value) {
	BuildResults buildResults = (BuildResults) getResults(build_id);
	if (buildResults == null) {
		buildResults = new BuildResults(this, build_id);
		addChild(buildResults, true);
	}
	buildResults.setValue(dim_id, step, value);
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.util.StringTokenizer;


/**
 * Class to handle performance results of a component's scenario
 * (for example 'org.eclipse.jdt.core.FullSourceWorkspaceSearchTest#searchAllTypeNames()').
 * 
 * It gives access to results for each configuration run on this scenario.
 * 
 * @see ConfigResults
 */
public class ScenarioResults extends AbstractResults {
	String fileName;
	String label;
	String shortName;

public ScenarioResults(int id, String name, String shortName) {
	super(null, id);
	this.name = name;
	this.label = shortName;
}

/**
 * Returns the first configuration baseline build name.
 *
 * @return The name of the baseline build
 * @see ConfigResults#getBaselineBuildName()
 */
public String getBaselineBuildName() {
	int size = size();
	StringBuffer buffer = new StringBuffer();
	for (int i=0; i<size; i++) {
		ConfigResults configResults = (ConfigResults) this.children.get(i);
		if (configResults.isValid()) {
			return configResults.getBaselineBuildName();
			/* TODO (frederic) decide what return when baseline is not the same on all configs...
			String baselineName = configResults.getBaselineBuildName();
			if (buffer.indexOf(baselineName) < 0) {
				if (buffer.length() > 0) buffer.append('|');
				buffer.append(baselineName);
			}
			*/
		}
	}
	return buffer.toString();
}

/**
 * Return the results of the given configuration.
 * 
 * @param config The configuration name
 * @return The {@link ConfigResults results} for the given configuration
 * 	or <code>null</code> if none was found.
 */
public ConfigResults getConfigResults(String config) {
	return (ConfigResults) getResults(config);
}

/**
 * Return a name which can be used as a file name to store information
 * related to this scenario. This name does not contain the extension.
 * 
 * @return The file name
 */
public String getFileName() {
	if (this.fileName == null) {
		this.fileName = this.name.replace('#', '.').replace(':', '_').replace('\\', '_');
	}
	return this.fileName;
}

/**
 * Returns the scenario label. If no label exist as there's no associated summary,
 * then the short name is returned
 *
 * @return The label of the scenario or it's short name if no summary exists
 */
public String getLabel() {
	return this.label;
}

/**
 * Returns the short name of the scenario. Short name is the name scenario
 * from which package declaration has been removed.
 * 
 * @return The scenario short name
 */
public String getShortName() {
	if (this.shortName == null) {
		// Remove class name qualification
		int testSeparator = this.name.indexOf('#');
		boolean hasClassName = testSeparator >= 0;
		if (!hasClassName) {
			testSeparator = this.name.lastIndexOf('.');
			if (testSeparator <= 0) {
				return this.shortName = this.name;
			}
		}
		int classSeparator = this.name.substring(0, testSeparator).lastIndexOf('.');
		if (classSeparator < 0) {
			return this.shortName = this.name;
		}
		int length = this.name.length();
		String testName = this.name.substring(classSeparator+1, length);
		if (!hasClassName && testName.startsWith("test.")) { // specific case for swt... //$NON-NLS-1$
			testName = testName.substring(5);
		}
	
		// Remove qualification from test name
		StringTokenizer tokenizer = new StringTokenizer(testName, " :,", true); //$NON-NLS-1$
		StringBuffer buffer = new StringBuffer(tokenizer.nextToken());
		while (tokenizer.hasMoreTokens()) {
			String token = tokenizer.nextToken();
			char fc = token.charAt(0);
			while (fc == ' ' || fc == ',' || fc == ':') {
				buffer.append(token); // add the separator
				token = tokenizer.nextToken();
				fc = token.charAt(0);
			}
			int last = token.lastIndexOf('.');
			if (last >= 3) {
				int first = token .indexOf('.');
				if (first == last) {
					buffer.append(token);
				} else {
					buffer.append(token.substring(last+1));
				}
			} else {
				buffer.append(token);
			}
		}
		this.shortName = buffer.toString();
	}
	return this.shortName;
}

/**
 * Returns whether one of the scenario's config has a summary or not.
 * 
 * @return <code>true</code> if one of the scenario's config has a summary
 * 	<code>false</code> otherwise.
 */
public boolean hasSummary() {
	int size = size();
	for (int i=0; i<size; i++) {
		ConfigResults configResults = (ConfigResults) this.children.get(i);
		if (configResults.getCurrentBuildResults().hasSummary()) return true;
	}
	return false;
}

/* (non-Javadoc)
 * @see org.eclipse.test.internal.performance.results.AbstractResults#hashCode()
 */
public int hashCode() {
	return this.id;
}

/**
 * Returns whether the current build of the given config has valid results or not.
 * 
 * @param config The name of the configuration
 * @return <code>true</code> if the build has valid results
 * 	<code>false</code> otherwise.
 */
public boolean isValid(String config) {
	return getResults(config) != null;
}

/*
 * Read scenario results information from database.
 */
void read() {
	
	// Get values
	print("+ scenario '"+getShortName()+"': "); //$NON-NLS-1$ //$NON-NLS-2$
	long start = System.currentTimeMillis();
	String configPattern = getPerformance().getConfigurationsPattern();
	DB_Results.queryScenarioValues(this, configPattern);
	print(" values for "+size()+" configs ("+(System.currentTimeMillis()-start)+"ms), "); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	// Set baseline and current builds
	start = System.currentTimeMillis();
	int size = size();
	for (int i=0; i<size; i++) {
		ConfigResults configResults = (ConfigResults) this.children.get(i);
		configResults.read();
	}
	println("failures and summaries ("+(System.currentTimeMillis()-start)+"ms)."); //$NON-NLS-1$ //$NON-NLS-2$
}

/*
 * Set value from database information.
 */
void setValue(int build_id, int dim_id, int config_id, int step, long value) {
	ConfigResults configResults = (ConfigResults) getResults(config_id);
	if (configResults == null) {
		configResults = new ConfigResults(this, config_id);
		addChild(configResults, true);
	}
	configResults.setValue(build_id, dim_id, step, value);
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.eclipse.test.internal.performance.PerformanceTestPlugin;

/**
 * Specific and private implementation of {@link org.eclipse.test.internal.performance.db.DB} class
 * to get massive results from performance results database.
 */
public class DB_Results {
    
    static final boolean DEBUG = true;
    
    // the two supported DB types
    private static final String DERBY= "derby"; //$NON-NLS-1$
    private static final String CLOUDSCAPE= "cloudscape"; //$NON-NLS-1$
        
    private static DB_Results fgDefault;
    
    private Connection fConnection;
    private SQL_Results fSQL;
    private boolean fIsEmbedded;
    private String fDBType;	// either "derby" or "cloudscape"

    // Store results of global request
    final static StringWriter STRING_WRITER = DEBUG ? new StringWriter() : null;
    final static PrintWriter LOG_WRITER = DEBUG ? new PrintWriter(STRING_WRITER) : null;
    
	// Data storage from queries
	private static String[] CONFIGS, COMPONENTS, BUILDS;
	private static int BUILDS_LENGTH;
	private static String[] SCENARII;
	private static String[] COMMENTS;

	// Static data
	private final static int MAX_CONFIGS = 5;
	private final static String[] SUPPORTED_VMS =  { // Consider only supported VMs a static data
		"sun" //$NON-NLS-1$
	};
	private final static String[] SUPPORTED_COMPONENTS = {
		"org.eclipse.ant", //$NON-NLS-1$
		"org.eclipse.compare", //$NON-NLS-1$
		"org.eclipse.core", //$NON-NLS-1$
		"org.eclipse.help", //$NON-NLS-1$
		"org.eclipse.jdt.core", //$NON-NLS-1$
		"org.eclipse.jdt.debug", //$NON-NLS-1$
		"org.eclipse.jdt.text", //$NON-NLS-1$
		"org.eclipse.jdt.ui", //$NON-NLS-1$
		"org.eclipse.jface", //$NON-NLS-1$
		"org.eclipse.osgi", //$NON-NLS-1$
		"org.eclipse.pde.ui", //$NON-NLS-1$
		"org.eclipse.swt", //$NON-NLS-1$
		"org.eclipse.team", //$NON-NLS-1$
		"org.eclipse.ua", //$NON-NLS-1$
		"org.eclipse.ui" //$NON-NLS-1$
	};
    
    //---- private implementation
    
	/**
     * Private constructor to block instance creation.
     */
    private DB_Results() {
    	// empty implementation
    }

    synchronized static DB_Results getDefault() {
        if (fgDefault == null) {
            fgDefault= new DB_Results();
            fgDefault.connect();
            if (PerformanceTestPlugin.getDefault() == null) {
            	// not started as plugin
	            Runtime.getRuntime().addShutdownHook(
	                new Thread() {
	                    public void run() {
	                    	shutdown();
	                    }
	                }
	            );
            }
        }
        return fgDefault;
    }
    
    public static void shutdown() {
        if (fgDefault != null) {
            fgDefault.disconnect();
            fgDefault= null;
        }
        if (DEBUG) {
        	LOG_WRITER.println("DB.shutdown"); //$NON-NLS-1$
        	System.out.println(STRING_WRITER.toString());
        }
    }

/**
 * Get all components read from database.
 *
 * @return A list of component names matching the given pattern
 */
static List getAllComponents() {
	return Arrays.asList(COMPONENTS);
}

/**
 * Return the build name from a given id.
 * 
 * @param id The build id
 * @return The name of the build (eg. I20070615-1200)
 */
static String getBuildName(int id) {
	return BUILDS[id];
}

/**
 * Get component name from a scenario.
 * 
 * @param scenarioName The name of the scenario
 * @return The component name
 */
static String getComponentNameFromScenario(String scenarioName) {
	int length = SUPPORTED_COMPONENTS.length;
	for (int i=0; i<length; i++) {
		if (scenarioName.startsWith(SUPPORTED_COMPONENTS[i])) {
			return SUPPORTED_COMPONENTS[i];
		}
	}
	return null;
}

/**
 * Return the name of the configuration from the given id.
 * 
 * @param id The index of the configuration in the stored list.
 * @return The name of the configuration (eg. eclipseperflnx1_R3.3)
 */
static String getConfig(int id) {
	return CONFIGS[id];
}

/**
 * Returns all the scenarii names stored in the dynamic list.
 * 
 * @return The list of all scenarii matching the pattern for a given build.
 * @see #internalQueryBuildScenarii(String, String)
 */
public static List getScenariiNames() {
	return Arrays.asList(SCENARII);
}

/**
 * Get all scenarii read from database matching a given pattern.
 * Note that all scenarii are returned if the pattern is <code>null</code>.
 *
 * @param scenarioPattern The pattern of the requested scenarii
 * @param buildName TODO
 * @return A list of scenario names matching the given pattern
 */
static Map queryAllScenarii(String scenarioPattern, String buildName) {
	return getDefault().internalQueryBuildScenarii(scenarioPattern, buildName);
}

/**
 * Get all the failures from DB for a given scenario, configuration
 * pattern and builds.
 * 
 * @param scenarioResults The scenario results where to store data
 * @param configPattern The configuration pattern concerned by the query
 * @param currentBuild The current build to narrow the query
 * @param baselineBuild The baseline build to narrow the query 
 */
static void queryScenarioFailures(ScenarioResults scenarioResults, String configPattern, BuildResults currentBuild, BuildResults baselineBuild) {
	getDefault().internalQueryScenarioFailures(scenarioResults, configPattern, currentBuild, baselineBuild);
}

/**
 * Get all summaries from DB for a given scenario, configuration
 * pattern and builds.
 *
 * @param scenarioResults The scenario results where to store data
 * @param configPattern The configuration pattern concerned by the query
 * @param currentBuild The current build to narrow the query
 * @param baselineBuild The baseline build to narrow the query 
 */
static void queryScenarioSummaries(ScenarioResults scenarioResults, String configPattern, BuildResults currentBuild, BuildResults baselineBuild) {
	getDefault().internalQueryScenarioSummaries(scenarioResults, configPattern, currentBuild, baselineBuild);
}

/**
 * Query and store all values for given scenario results
 *
 * @param scenarioResults The scenario results where the values has to be put
 * @param configPattern The pattern of the configuration concerned by the query 
 *
public static void queryScenarioValues(int id, ScenarioResults scenarioResults, String[] configNames) {
	getDefault().internalQueryScenarioValues(id, scenarioResults, configNames);
}
*/
static void queryScenarioValues(ScenarioResults scenarioResults, String configPattern) {
	getDefault().internalQueryScenarioValues(scenarioResults, configPattern);
}

/**
 * dbloc=						embed in home directory
 * dbloc=/tmp/performance			embed given location
 * dbloc=net://localhost			connect to local server
 * dbloc=net://www.eclipse.org	connect to remove server
 */
private void connect() {

	if (fConnection != null)
		return;

	String dbloc = PerformanceTestPlugin.getDBLocation();
	if (dbloc == null)
		return;

	String dbname = PerformanceTestPlugin.getDBName();
	String url = null;
	java.util.Properties info = new java.util.Properties();

	if (DEBUG) {
		LOG_WRITER.println();
		LOG_WRITER.println("==========================================================="); //$NON-NLS-1$
		LOG_WRITER.println("Database information logged during processing"); //$NON-NLS-1$
	}

	fDBType = DERBY; // assume we are using Derby
	try {
		if (dbloc.startsWith("net://")) { //$NON-NLS-1$
			// remote
			fIsEmbedded = false;
			// connect over network
			if (DEBUG)
				LOG_WRITER.println("Trying to connect over network..."); //$NON-NLS-1$
			Class.forName("com.ibm.db2.jcc.DB2Driver"); //$NON-NLS-1$
			info.put("user", PerformanceTestPlugin.getDBUser()); //$NON-NLS-1$
			info.put("password", PerformanceTestPlugin.getDBPassword()); //$NON-NLS-1$
			info.put("retrieveMessagesFromServerOnGetMessage", "true"); //$NON-NLS-1$ //$NON-NLS-2$
			info.put("create", "true"); //$NON-NLS-1$ //$NON-NLS-2$
			url = dbloc + '/' + dbname;
		} else if (dbloc.startsWith("//")) { //$NON-NLS-1$
			// remote
			fIsEmbedded = false;
			// connect over network
			if (DEBUG)
				LOG_WRITER.println("Trying to connect over network..."); //$NON-NLS-1$
			Class.forName("org.apache.derby.jdbc.ClientDriver"); //$NON-NLS-1$
			info.put("user", PerformanceTestPlugin.getDBUser()); //$NON-NLS-1$
			info.put("password", PerformanceTestPlugin.getDBPassword()); //$NON-NLS-1$
			info.put("create", "true"); //$NON-NLS-1$ //$NON-NLS-2$
			url = dbloc + '/' + dbname;
		} else {
			// workaround for Derby issue:
			// http://nagoya.apache.org/jira/browse/DERBY-1
			if ("Mac OS X".equals(System.getProperty("os.name"))) //$NON-NLS-1$//$NON-NLS-2$
				System.setProperty("derby.storage.fileSyncTransactionLog", "true"); //$NON-NLS-1$ //$NON-NLS-2$

			// embedded
			fIsEmbedded = true;
			try {
				Class.forName("org.apache.derby.jdbc.EmbeddedDriver"); //$NON-NLS-1$
			} catch (ClassNotFoundException e) {
				Class.forName("com.ihost.cs.jdbc.CloudscapeDriver"); //$NON-NLS-1$
				fDBType = CLOUDSCAPE;
			}
			if (DEBUG)
				LOG_WRITER.println("Loaded embedded " + fDBType); //$NON-NLS-1$
			File f;
			if (dbloc.length() == 0) {
				String user_home = System.getProperty("user.home"); //$NON-NLS-1$
				if (user_home == null)
					return;
				f = new File(user_home, fDBType);
			} else
				f = new File(dbloc);
			url = new File(f, dbname).getAbsolutePath();
			info.put("user", PerformanceTestPlugin.getDBUser()); //$NON-NLS-1$
			info.put("password", PerformanceTestPlugin.getDBPassword()); //$NON-NLS-1$
			info.put("create", "true"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		try {
			fConnection = DriverManager.getConnection("jdbc:" + fDBType + ":" + url, info); //$NON-NLS-1$ //$NON-NLS-2$
		} catch (SQLException e) {
			if ("08001".equals(e.getSQLState()) && DERBY.equals(fDBType)) { //$NON-NLS-1$
				if (DEBUG)
					LOG_WRITER.println("DriverManager.getConnection failed; retrying for cloudscape"); //$NON-NLS-1$
				// try Cloudscape
				fDBType = CLOUDSCAPE;
				fConnection = DriverManager.getConnection("jdbc:" + fDBType + ":" + url, info); //$NON-NLS-1$ //$NON-NLS-2$
			} else
				throw e;
		}
		if (DEBUG)
			LOG_WRITER.println("connect succeeded!"); //$NON-NLS-1$

		fConnection.setAutoCommit(false);
		fSQL = new SQL_Results(fConnection);
		fConnection.commit();

	} catch (SQLException ex) {
		PerformanceTestPlugin.logError(ex.getMessage());

	} catch (ClassNotFoundException e) {
		PerformanceTestPlugin.log(e);
	}
}

private void disconnect() {
	if (DEBUG)
		LOG_WRITER.println("disconnecting from DB"); //$NON-NLS-1$
	if (fSQL != null) {
		try {
			fSQL.dispose();
		} catch (SQLException e1) {
			PerformanceTestPlugin.log(e1);
		}
		fSQL = null;
	}
	if (fConnection != null) {
		try {
			fConnection.commit();
		} catch (SQLException e) {
			PerformanceTestPlugin.log(e);
		}
		try {
			fConnection.close();
		} catch (SQLException e) {
			PerformanceTestPlugin.log(e);
		}
		fConnection = null;
	}

	if (fIsEmbedded) {
		try {
			DriverManager.getConnection("jdbc:" + fDBType + ":;shutdown=true"); //$NON-NLS-1$ //$NON-NLS-2$
		} catch (SQLException e) {
			String message = e.getMessage();
			if (message.indexOf("system shutdown.") < 0) //$NON-NLS-1$
				e.printStackTrace();
		}
	}
}

/*
 * Return the index of the build in the list.
 */
private int getBuildId(String build) {
	if (BUILDS == null) return -1;
	return Arrays.binarySearch(BUILDS, build);
}

/*
 * Return the index of the given configuration in the stored list.
 */
private int getConfigId(String config) {
	if (CONFIGS == null) return -1;
	return Arrays.binarySearch(CONFIGS, config);
}

SQL_Results getSQL() {
    return fSQL;
}

/*
 * Query all comments from database
 */
private void internalQueryAllComments() {
	if (fSQL == null) return;
	if (COMMENTS != null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("		[DB query all comments..."); //$NON-NLS-1$
	ResultSet result = null;
	try {
		String[] comments = null;
		result = fSQL.queryAllComments();
		while (result.next()) {
			int commentID = result.getInt(1);
			// Ignore kind as there's only one
			// int commentKind = result.getInt(2); 
			String comment = result.getString(3);
			if (comments == null) {
				comments = new String[commentID+10];
			} else if (commentID >= comments.length) {
				int length = comments.length;
				System.arraycopy(comments, 0, comments = new String[commentID+10], 0, length);
			}
			comments[commentID] = comment;
		}
		COMMENTS = comments;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
}

/*
 * Query all variations. This method stores all config and build names.
 */
private void internalQueryAllVariations(String configPattern) {
	if (fSQL == null) return;
	if (BUILDS != null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) {
		LOG_WRITER.print("	- DB query all variations for configuration pattern: "+configPattern); //$NON-NLS-1$
		LOG_WRITER.print("..."); //$NON-NLS-1$
	}
	ResultSet result = null;
	try {
		CONFIGS = new String[MAX_CONFIGS];
		BUILDS = null;
		BUILDS_LENGTH = 0;
		result = fSQL.queryAllVariations(configPattern);
		while (result.next()) {
			String variation = result.getString(1); //  something like "||build=I20070615-1200||config=eclipseperfwin2_R3.3||jvm=sun|"
			StringTokenizer tokenizer = new StringTokenizer(variation, "=|"); //$NON-NLS-1$
			tokenizer.nextToken(); 												// 'build'
			String buildName = tokenizer.nextToken();				// 'I20070615-1200'
			tokenizer.nextToken();												// 'config'
			storeConfig(tokenizer.nextToken()); 	// 'eclipseperfwin2_R3.3'
			tokenizer.nextToken();												// 'jvm'
			String vmName = tokenizer.nextToken();					// 'sun'
			if (!vmName.equals(SUPPORTED_VMS[0])) {
				throw new RuntimeException("Unexpected vm name: "+vmName); //$NON-NLS-1$
			}
			storeBuildName(buildName);
		}
		System.arraycopy(BUILDS, 0, BUILDS = new String[BUILDS_LENGTH], 0, BUILDS_LENGTH);
		for (int i=0; i<MAX_CONFIGS; i++) {
			if (CONFIGS[i] == null) {
				System.arraycopy(CONFIGS, 0, CONFIGS = new String[i], 0, i);
				break;
			}
		}
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
}
/*
private void internalQueryAllScenarii(String scenarioPattern) {
	if (fSQL == null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) {
		LOG_WRITER.print("	- DB query all scenarii from DB..."); //$NON-NLS-1$
	}
	ResultSet result = null;
	SCENARII = null;
	COMPONENTS = null;
	try {
		result = fSQL.queryAllScenarii();
		for (int i = 0; result.next(); i++) {
			int id = result.getInt(1);
			String name = result.getString(2);
			String label = result.getString(3);
			if (scenarioPattern == null || matchPattern(name, scenarioPattern)) {
				storeComponent(getComponentNameFromScenario(name));
			}
			if (SCENARII == null) {
				// as scenario ar order by id descendent order, the first id gives the size of the array
				SCENARII = new String[id];
				SCENARII_LABEL = new String[id];
			}
			SCENARII[id-1] = name;
			SCENARII_LABEL[id-1] = label;
		}

	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);

	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) { // ignored
			}
		}
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
}
*/
/*
public static class Scenario {
	int id, component_id;
	String name;
	String label;
	Scenario(int id, int component_id, String name, String label) {
	    this.id = id;
	    this.name = name;
	    this.label = label;
	    this.component_id = component_id;
    }
	
}
*/
private Map internalQueryBuildScenarii(String scenarioPattern, String buildName) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) {
		LOG_WRITER.print("	- DB query all scenarii"); //$NON-NLS-1$
		if (scenarioPattern != null) LOG_WRITER.print(" with pattern "+scenarioPattern); //$NON-NLS-1$
		LOG_WRITER.print(" for build: "+buildName); //$NON-NLS-1$
	}
	ResultSet result = null;
	Map allScenarii = new HashMap();
	try {
		result = fSQL.queryBuildScenarii(scenarioPattern, buildName);
		int previousId = -1;
		List scenarii = null;
		List scenariiNames = new ArrayList();
		for (int i = 0; result.next(); i++) {
			int id = result.getInt(1);
			String name = result.getString(2);
			scenariiNames.add(name);
			String shortName = result.getString(3);
			int component_id = storeComponent(getComponentNameFromScenario(name));
			if (component_id != previousId) {
				allScenarii.put(COMPONENTS[component_id], scenarii = new ArrayList());
				previousId = component_id;
			}
			scenarii.add(new ScenarioResults(id, name, shortName));
		}
		SCENARII = new String[scenariiNames.size()];
		scenariiNames.toArray(SCENARII);
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) { // ignored
			}
		}
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return allScenarii;
}
/*
private int[] internalQueryScenarioSummaries(int scenarioID, String[] configNames) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	- DB query all summaries from DB for scenario ID: "+scenarioID+"..."); //$NON-NLS-1$ //$NON-NLS-2$
	internalQueryAllComments();
	ResultSet result = null;
	try {
		int[] summaries = null;
		int confLength = configNames.length;
		for (int config_id=0; config_id<confLength; config_id++) {
			result = fSQL.queryScenarioSummaries(configNames[config_id], scenarioID);
			while (result.next()) {
				int variation_id = result.getInt(1);
				int global = result.getShort(2);
				int comment_id = result.getInt(3);
				if (summaries == null) {
					summaries = new int[variation_id+10];
				} else if (variation_id >= summaries.length) {
					int length = summaries.length;
					System.arraycopy(summaries, 0, summaries = new int[variation_id+10], 0, length);
				}
				summaries[variation_id-1] = global == 1 ? comment_id: -comment_id;
			}
		}
		return summaries;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/
/*
private String[] internalQueryScenarioFailures(int scenarioID, String[] configNames) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	[DB query all failures from DB for scenario ID: "+scenarioID+"..."); //$NON-NLS-1$ //$NON-NLS-2$
	ResultSet result = null;
	try {
		String[] failures = null;
		int confLength = configNames.length;
		for (int config_id=0; config_id<confLength; config_id++) {
			result = fSQL.queryScenarioFailures(configNames[config_id], scenarioID);
			while (result.next()) {
				int variation_id = result.getInt(1);
				String message = result.getString(2);
				if (failures == null) {
					failures = new String[variation_id+10];
				} else if (variation_id >= failures.length) {
					int length = failures.length;
					System.arraycopy(failures, 0, failures = new String[variation_id+10], 0, length);
				}
				failures[variation_id-1] = message;
			}
		}
		return failures;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);

	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
		if (DEBUG) LOG_WRITER.println("	-> done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/
/*
private Map internalQueryScenariiBuilds(String config) {
	if (fSQL == null) return null;
	Map scenariiBuilds = (Map) this.allScenariiBuilds.get(config);
	if (scenariiBuilds != null) return scenariiBuilds;
	long start = System.currentTimeMillis();
	if (DEBUG) this.logWriter.print("	- query all build names from DB for config '"+config+"'..."); //$NON-NLS-1$ //$NON-NLS-2$
	ResultSet result = null;
	try {
		result = fSQL.queryScenariiBuilds(config);
//		this.logWriter.print("(sql="+(System.currentTimeMillis()-start)); //$NON-NLS-1$
//		start = System.currentTimeMillis();
		scenariiBuilds = new HashMap();
		for (int i = 0; result.next(); i++) {
			int scenario_id = result.getInt(1);
			Integer scenarioID = new Integer(scenario_id);
			StringTokenizer variation = new StringTokenizer(result.getString(2), "|="); //$NON-NLS-1$
			variation.nextToken(); // skip first token
			List buildNames = (List) scenariiBuilds.get(scenarioID);
			if (buildNames == null) {
				scenariiBuilds.put(scenarioID, buildNames = new ArrayList());
			}
			buildNames.add(variation.nextToken());
		}
		this.allScenariiBuilds.put(config, scenariiBuilds);
		return scenariiBuilds;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
		if (DEBUG) this.logWriter.println("done in " + (System.currentTimeMillis() - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/

/*
private Map internalQueryScenarioDimValues(String config, int scenarioID, int dimID) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) {
		this.logWriter.println("	- query all data points from DB:"); //$NON-NLS-1$
		this.logWriter.println("		+ config = " + config); //$NON-NLS-1$
		this.logWriter.println("		+ scenario id = " + scenarioID); //$NON-NLS-1$
	}
	ResultSet result = null;
	try {
		result = fSQL.queryScenarioDimValues(config, scenarioID, dimID);
		this.logWriter.print("(sql="+(System.currentTimeMillis()-start)); //$NON-NLS-1$
		start = System.currentTimeMillis();
		if (DEBUG) {
			long time = System.currentTimeMillis();
			this.logWriter.println("done in " + (time - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
			start = time;
		}
		Map dimValues = new HashMap();
		long[] values = null;
		String currentBuild = null;
		String buildName = null;
		while (result.next()) {
			int dp_id = result.getInt(1);
			int step = result.getInt(2);
//			long value = result.getBigDecimal(2).longValue();
			StringTokenizer variation = new StringTokenizer(result.getString(3), "|="); //$NON-NLS-1$
			variation.nextToken(); // skip first token
			buildName = variation.nextToken();
			ResultSet rs2 = fSQL.queryScalars(dp_id, dimID);
			rs2.next();
			long value = rs2.getBigDecimal(1).longValue();
			rs2.close();
			int idx = InternalPerformanceMeter.AVERAGE - step;
			if (!buildName.equals(currentBuild)) {
				if (currentBuild != null) dimValues.put(buildName, values);
				values = new long[3];
				currentBuild = buildName;
			}
			values[idx] = value;
		}
		dimValues.put(buildName, values);
		if (DEBUG) this.logWriter.println("		-> " + dimValues.size() + " datapoints created in " + (System.currentTimeMillis() - start) + "ms");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		return dimValues;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/
/*
private Map internalQueryScenarioValues(String config, int scenarioID, Dim[] dims) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) {
		this.logWriter.println("	- query all data points from DB:"); //$NON-NLS-1$
		this.logWriter.println("		+ config = " + config); //$NON-NLS-1$
		this.logWriter.println("		+ scenario id = " + scenarioID); //$NON-NLS-1$
	}
	ResultSet result = null;
	try {
		result = fSQL.queryScenarioDataPoints(config, scenarioID);
//		this.logWriter.print("(sql="+(System.currentTimeMillis()-start)); //$NON-NLS-1$
//		start = System.currentTimeMillis();
		if (DEBUG) {
			long time = System.currentTimeMillis();
			this.logWriter.println("done in " + (time - start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
			start = time;
		}
		Map buildsValues = new HashMap();
		String buildName = null;
		int count = 0;
		int length = dims.length;
		while (result.next()) {
			int dp_id = result.getInt(1);
			int step = result.getInt(2);
//			long value = result.getBigDecimal(3).longValue();
			StringTokenizer variation = new StringTokenizer(result.getString(3), "|="); //$NON-NLS-1$
			variation.nextToken(); // skip first token
			buildName = variation.nextToken();
			Map dimsValues = (Map) buildsValues.get(buildName);
			if (dimsValues == null) {
				buildsValues.put(buildName, dimsValues = new HashMap());
			}
			int idx = InternalPerformanceMeter.AVERAGE - step;
			ResultSet rs2 = fSQL.queryScalars(dp_id);
			while (rs2.next()) {
				Dim dim = Dim.getDimension(rs2.getInt(1));
				for (int i=0; i<length; i++) {
					if (dim == dims[i]) {
						long value = rs2.getBigDecimal(2).longValue();
						long[][] values = (long[][]) dimsValues.get(dim);
						int valuesLength = values == null ? 0 : values.length;
						if (values == null) {
							values = new long[1][3];
							values[0][idx] = value;
							dimsValues.put(dim, values);
						} else if (values[valuesLength-1][idx] == 0) {
							values[valuesLength-1][idx] = value;
						} else {
							System.arraycopy(values, 0, values = new long[valuesLength+1][3], 0, valuesLength);
							for (int j=0; j<3; j++) values[valuesLength][j] = 0;
							values[valuesLength][idx] = value;
							dimsValues.put(dim, values);
						}
					}
				}
			}
			count++;
		}
		if (DEBUG) this.logWriter.println("		-> " + count + " values read in " + (System.currentTimeMillis() - start) + "ms");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		return buildsValues;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/
/*
private void internalQueryScenarioValues(int scenarioId, ScenarioResults scenarioResults, String[] configNames) {
	if (fSQL == null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.println("	- DB query all data points from DB for scenario: " + scenarioResults.getName()); //$NON-NLS-1$
	internalQueryAllVariations(configNames); // need to read all variations to have all build names
	ResultSet result = null;
	try {
		int length = configNames.length;
		int count = 0;
		for (int config_id=0; config_id<length; config_id++) {
			result = fSQL.queryScenarioDataPoints(configNames[config_id], scenarioId);
			while (result.next()) {
				int dp_id = result.getInt(1);
				int step = result.getInt(2);
				StringTokenizer variation = new StringTokenizer(result.getString(3), "|="); //$NON-NLS-1$
				variation.nextToken(); // skip first token
				String buildName = variation.nextToken();
				int build_id = getBuildId(config_id, buildName);
				ResultSet rs2 = fSQL.queryDimScalars(dp_id);
				while (rs2.next()) {
					int dim_id = rs2.getInt(1);
					long value = rs2.getBigDecimal(2).longValue();
					scenarioResults.setValue(build_id, dim_id, config_id, step, value);
					count++;
				}
			}
		}
		if (DEBUG) LOG_WRITER.println("		-> " + count + " values read in " + (System.currentTimeMillis() - start) + "ms]");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
	}
}
*/
/*
private String[] internalQueryScenarioFailures(int scenarioID) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	- DB query all failures from DB for scenario ID: "+scenarioID+"..."); //$NON-NLS-1$ //$NON-NLS-2$
	ResultSet result = null;
	try {
		result = fSQL.queryScenarioFailures(scenarioID);
//		this.logWriter.print("(sql="+(System.currentTimeMillis()-start)); //$NON-NLS-1$
//		start = System.currentTimeMillis();
		String[] failures = null;
		while (result.next()) {
			int variationID = result.getInt(1);
			String message = result.getString(2);
			if (failures == null) {
				failures = new String[variationID+10];
			} else if (variationID >= failures.length) {
				int length = failures.length;
				System.arraycopy(failures, 0, failures = new String[variationID+10], 0, length);
			}
			failures[variationID] = message;
		}
		return failures;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);

	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
		if (DEBUG) LOG_WRITER.println("	-> done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/
/*
private int[] internalQueryScenarioSummaries(int scenarioID) {
	if (fSQL == null) return null;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	- DB query all summaries from DB for scenario ID: "+scenarioID+"..."); //$NON-NLS-1$ //$NON-NLS-2$
	internalQueryAllComments();
	ResultSet result = null;
	try {
		int[] summaries = null;
		result = fSQL.queryScenarioSummaries(scenarioID);
//		this.logWriter.print("(sql="+(System.currentTimeMillis()-start)); //$NON-NLS-1$
//		start = System.currentTimeMillis();
		while (result.next()) {
			int variationID = result.getInt(1);
			int global = result.getShort(2);
			int comment_id = result.getInt(3);
			if (summaries == null) {
				summaries = new int[variationID+10];
			} else if (variationID >= summaries.length) {
				int length = summaries.length;
				System.arraycopy(summaries, 0, summaries = new int[variationID+10], 0, length);
			}
			summaries[variationID] = global == 1 ? comment_id: -comment_id;
		}
		return summaries;
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return null;
}
*/
private void internalQueryScenarioValues(ScenarioResults scenarioResults, String configPattern) {
	if (fSQL == null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	- DB query all data points for config pattern: "+configPattern+" for scenario: " + scenarioResults.getShortName()); //$NON-NLS-1$ //$NON-NLS-2$
	internalQueryAllVariations(configPattern); // need to read all variations to have all build names
	ResultSet result = null;
	try {
		int count = 0;
		result = fSQL.queryScenarioDataPoints(configPattern, scenarioResults.getId());
		while (result.next()) {
			int dp_id = result.getInt(1);
			int step = result.getInt(2);
			String variation = result.getString(3); //  something like "||build=I20070615-1200||config=eclipseperfwin2_R3.3||jvm=sun|"
			StringTokenizer tokenizer = new StringTokenizer(variation, "=|"); //$NON-NLS-1$
			tokenizer.nextToken(); 									// 'build'
			String buildName = tokenizer.nextToken();	// 'I20070615-1200'
			tokenizer.nextToken();									// 'config'
			int config_id = getConfigId(tokenizer.nextToken()); 			// 'eclipseperfwin2_R3.3'
			int build_id = getBuildId(buildName);
			ResultSet rs2 = fSQL.queryDimScalars(dp_id);
			while (rs2.next()) {
				int dim_id = rs2.getInt(1);
				long value = rs2.getBigDecimal(2).longValue();
				scenarioResults.setValue(build_id, dim_id, config_id, step, value);
				count++;
			}
		}
		if (DEBUG) LOG_WRITER.println("		-> " + count + " values read in " + (System.currentTimeMillis() - start) + "ms]");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
	}
}
private void internalQueryScenarioFailures(ScenarioResults scenarioResults, String config, BuildResults currentBuild, BuildResults baselineBuild) {
	if (fSQL == null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	- DB query all failures for config pattern: "+config+" for scenario : "+scenarioResults.getShortName()+"..."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	ResultSet result = null;
	try {
		String currentBuildName = currentBuild.getName();
		String baselineBuildName = baselineBuild.getName();
		result = fSQL.queryScenarioFailures(scenarioResults.getId(), config, currentBuildName, baselineBuildName);
		while (result.next()) {
			String variation = result.getString(1);
			String failure = result.getString(2);
			StringTokenizer tokenizer = new StringTokenizer(variation, "=|"); //$NON-NLS-1$
			tokenizer.nextToken(); 									// 'build'
			String buildName = tokenizer.nextToken();	// 'I20070615-1200'
//			tokenizer.nextToken();									// 'config'
//			String configName = tokenizer.nextToken();	// 'eclipseperfwin2_R3.3'
//			int config_id = getConfigId(configName);
			if (buildName.equals(currentBuildName)) {
				currentBuild.setFailure(failure);
			} else if (buildName.equals(baselineBuildName)) {
				baselineBuild.setFailure(failure);
			}
		}
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);

	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
//		this.logWriter.print(", db="+(System.currentTimeMillis()-start)+") "); //$NON-NLS-1$ //$NON-NLS-2$
		if (DEBUG) LOG_WRITER.println("	-> done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
}

private void internalQueryScenarioSummaries(ScenarioResults scenarioResults, String config, BuildResults currentBuild, BuildResults baselineBuild) {
	if (fSQL == null) return;
	long start = System.currentTimeMillis();
	if (DEBUG) LOG_WRITER.print("	- DB query all summaries for config: "+config+" for scenario: "+scenarioResults.getShortName()+"..."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	internalQueryAllComments();
	ResultSet result = null;
	try {
		String currentBuildName = currentBuild.getName();
		String baselineBuildName = baselineBuild.getName();
		result = fSQL.queryScenarioSummaries(scenarioResults.getId(), config, currentBuild.getName(), baselineBuild.getName());
		while (result.next()) {
			String variation = result.getString(1);
			int summaryKind = result.getShort(2);
			int comment_id = result.getInt(3);
			StringTokenizer tokenizer = new StringTokenizer(variation, "=|"); //$NON-NLS-1$
			tokenizer.nextToken(); 									// 'build'
			String buildName = tokenizer.nextToken();	// 'I20070615-1200'
//			tokenizer.nextToken();									// 'config'
//			String configName = tokenizer.nextToken();	// 'eclipseperfwin2_R3.3'
//			int config_id = getConfigId(configName);
			BuildResults buildResults = null;
			if (buildName.equals(currentBuildName)) {
				buildResults = currentBuild;
			} else if (buildName.equals(baselineBuildName)) {
				buildResults = baselineBuild;
			}
			buildResults.setSummary(summaryKind, COMMENTS[comment_id]);
		}
	} catch (SQLException e) {
		PerformanceTestPlugin.log(e);
	} finally {
		if (result != null) {
			try {
				result.close();
			} catch (SQLException e1) {
				// ignored
			}
		}
		if (DEBUG) LOG_WRITER.println("done in " + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	}
}

/*
 * Store a component in the dynamic list. The list is sorted alphabetically.
 */
private int storeComponent(String component) {
	if (COMPONENTS == null) {
		COMPONENTS = new String[SUPPORTED_COMPONENTS.length];
	}
	int idx = Arrays.binarySearch(SUPPORTED_COMPONENTS, component);
	if (idx < 0) {
		throw new RuntimeException("Unexpected component name: "+component); //$NON-NLS-1$
	}
	if (COMPONENTS[idx] == null) {
		COMPONENTS[idx] = SUPPORTED_COMPONENTS[idx];
	}
	return idx;
}

/*
 * Store a build name in the dynamic list.
 * The list is sorted alphabetically.
 */
private int storeBuildName(String build) {
	if (BUILDS == null) {
		BUILDS = new String[1];
		BUILDS[BUILDS_LENGTH++] = build;
		return 0;
	}
	int idx = Arrays.binarySearch(BUILDS, build);
	if (idx >= 0) return idx;
	int index = -idx-1;
	int length = BUILDS.length;
	if (BUILDS_LENGTH == length) {
		String[] array = new String[length+1];
		if (index > 0) System.arraycopy(BUILDS, 0, array, 0, index);
		array[index] = build;
		if (index < length) System.arraycopy(BUILDS, index+1, array, 0, length-index);
		BUILDS = array;
	} else if (index < length) {
		System.arraycopy(BUILDS, index, BUILDS, index+1, length-index);
		BUILDS[index] = build;
	}
	BUILDS_LENGTH++;
	return index;
}

/*
 * Store a configuration in the dynamic list.
 * The list is sorted alphabetically.
 */
private int storeConfig(String config) {
	for (int i=0; i<MAX_CONFIGS; i++) {
		if (CONFIGS[i] == null) {
			CONFIGS[i] = config;
			return i;
		}
		if (config.equals(CONFIGS[i])) {
			return i;
		}
	}
	return -1;
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.test.internal.performance.InternalDimensions;
import org.eclipse.test.internal.performance.data.Dim;

/**
 * Abstract class to store performance results.
 * 
 * Each results gives access to specific children depending on model.
 */
public abstract class AbstractResults implements Comparable {

	/**
	 * The lis of supported dimensions.
	 * <p>
	 * Currently only {@link InternalDimensions#ELAPSED_PROCESS}
	 * and {@link InternalDimensions#CPU_TIME}.
	 */
	public final static Dim[] SUPPORTED_DIMS = {
		InternalDimensions.ELAPSED_PROCESS,
		InternalDimensions.CPU_TIME
	};

	/**
	 * The list of possible configurations.
	 * <p>
	 * Only used if no specific configurations are specified
	 * (see {@link PerformanceResults#read(String[][], String)}.
	 */
	public final static String[] CONFIGS = {
		"eclipseperflnx3_R3.3", //$NON-NLS-1$
		"eclipseperfwin2_R3.3", //$NON-NLS-1$
		"eclipseperflnx2_R3.3", //$NON-NLS-1$
		"eclipseperfwin1_R3.3", //$NON-NLS-1$
		"eclipseperflnx1_R3.3", //$NON-NLS-1$
	};

	/**
	 * The list of possible test boxes.
	 * <p>
	 * Only used if no specific configurations are specified
	 * (see {@link PerformanceResults#read(String[][], String)}.
	 */
	public final static String[] BOXES = {
		"RHEL 4.0 Sun 1.4.2_10 (3 GHz 2.5 GB)", //$NON-NLS-1$
		"Win XP Sun 1.4.2_10 (3 GHz 2 GB)", //$NON-NLS-1$
		"RHEL 3.0 Sun 1.4.2_10 (3 GHz 2 GB)", //$NON-NLS-1$
		"Win XP Sun 1.4.2_10 (2 GHz 512 MB)", //$NON-NLS-1$
		"RHEL 3.0 Sun 1.4.2_10 (2 GHz 512 MB)", //$NON-NLS-1$
	};


	AbstractResults parent;
	int id = -1;
	String name;
	List children;
	private boolean newLine = true;
	boolean print = false;

static Dim getDimension(int id) {
	int length = SUPPORTED_DIMS.length;
	for (int i=0; i<length; i++) {
		if (SUPPORTED_DIMS[i].getId() == id) {
			return SUPPORTED_DIMS[i];
		}
	}
	return null;
}

AbstractResults(AbstractResults parent, String name) {
	this.parent = parent;
	this.children = new ArrayList();
	this.name = name;
}

AbstractResults(AbstractResults parent, int id) {
	this.parent = parent;
	this.children = new ArrayList();
	this.id = id;
}

/*
 * Add a child to current results, using specific sort
 * order if specified.
 */
void addChild(Comparable child, boolean sort) {
	if (sort) {
		int size = this.children.size();
		for (int i=0; i<size; i++) {
			Object results = this.children.get(i);
			if (child.compareTo(results) < 0) {
				this.children.add(i, child);
				return;
			}
		}
	}
	this.children.add(child);
}

/**
 * Compare the results to the given one using the name.
 * 
 * @see java.lang.Comparable#compareTo(java.lang.Object)
 */
public int compareTo(Object obj) {
	if (obj instanceof AbstractResults) {
		AbstractResults res = (AbstractResults) obj;
		return getName().compareTo(res.getName());
	}
	return -1;
}

/**
 * Returns whether two results are equals using the name
 * to compare them.
 * 
 * @param obj  The results to compare with
 * @return <code>true</code> if the name are equals,
 * 	<code>false</code> otherwise
 * @see java.lang.Comparable#compareTo(java.lang.Object)
 */
public boolean equals(Object obj) {
	if (obj instanceof AbstractResults) {
		return this.name.equals(((AbstractResults)obj).getName());
	}
	return super.equals(obj);
}

int getId() {
	return this.id;
}

/**
 * Returns the name of the results object.
 * 
 * @return The name of the results
 */
public String getName() {
	return this.name;
}

PerformanceResults getPerformance() {
	if (this.parent != null) {
		return this.parent.getPerformance();
	}
	return null;
}

String getPath() {
	String path = this.parent==null || this.parent.parent==null ? "" : this.parent.getPath() + ">"; //$NON-NLS-1$ //$NON-NLS-2$
	return path+this.name;
}

/**
 * Return the children list of the current results.
 * 
 * @return An iterator on the children list
 */
public Iterator getResults() {
	return this.children.iterator();
}

AbstractResults getResults(String resultName) {
	int size = this.children.size();
	for (int i=0; i<size; i++) {
		AbstractResults searchedResults = (AbstractResults) this.children.get(i);
		if (searchedResults.getName().equals(resultName)) {
			return searchedResults;
		}
	}
	return null;
}

AbstractResults getResults(int searchedId) {
	int size = this.children.size();
	for (int i=0; i<size; i++) {
		AbstractResults searchedResults = (AbstractResults) this.children.get(i);
		if (searchedResults.id == searchedId) {
			return searchedResults;
		}
	}
	return null;
}

public int hashCode() {
	return this.name.hashCode();
}

void printTab() {
	if (this.parent != null) {
		if (this.print) System.out.print("\t"); //$NON-NLS-1$
		this.parent.printTab();
	}
}
void print(String text) {
	if (this.print) {
		if (this.newLine) printTab();
		System.out.print(text);
		this.newLine = false;
	}
}

void printGlobalTime(long start) {
	printGlobalTime(start, null);
}

void printGlobalTime(long start, String end) {
	StringBuffer buffer = new StringBuffer("=> time spent in '"); //$NON-NLS-1$
	buffer.append(this.name);
	buffer.append("' was "); //$NON-NLS-1$
	buffer.append((System.currentTimeMillis()-start)/1000.0);
	if (end == null) {
		buffer.append('s');
	} else {
		buffer.append("s. "); //$NON-NLS-1$
		buffer.append(end.trim());
	}
	println(buffer);
}

void println(String text) {
	if (this.print) {
		if (this.newLine) printTab();
		System.out.println(text);
		this.newLine = true;
	}
}

void println(StringBuffer buffer) {
	println(buffer.toString());
}

public int size() {
	return this.children == null ? 0 : this.children.size();
}

public String toString() {
	return getPath();
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.util.ArrayList;
import java.util.List;

/**
 * Class to handle performance results of an eclipse component
 * (for example 'org.eclipse.jdt.core').
 * 
 * It gives access to results for each scenario run for this component.
 * 
 * @see ScenarioResults
 */
public class ComponentResults extends AbstractResults {

public ComponentResults(AbstractResults parent, String name) {
	super(parent, name);
	this.print = parent.print;
}

ComponentResults getComponent() {
	return this;
}

/**
 * Returns a list of scenario results which have a summary
 * 
 * @param global Indicates whether the summary must be global or not.
 * @param config Configuration name
 * @return A list of {@link ScenarioResults scenario results} which have a summary
 */
public List getSummaryScenarii(boolean global, String config) {
	int size= size();
	List scenarii = new ArrayList(size);
	for (int i=0; i<size; i++) {
		ScenarioResults scenarioResults = (ScenarioResults) this.children.get(i);
		ConfigResults configResults = scenarioResults.getConfigResults(config);
		if (configResults != null) {
			BuildResults buildResults = configResults.getCurrentBuildResults();
			if ((global && buildResults.summaryKind == 1) || (!global && buildResults.summaryKind >= 0)) {
				scenarii.add(scenarioResults);
			}
		}
	}
	return scenarii;
}

/*
 * Read performance results information available in three maps.
 */
void read(List scenarii) {
	println("Component '"+this.name+"':"); //$NON-NLS-1$ //$NON-NLS-2$
	long start = System.currentTimeMillis();
	int size = scenarii.size();
	for (int i=0; i<size; i++) {
		ScenarioResults scenarioResults= (ScenarioResults) scenarii.get(i);
		scenarioResults.parent = this;
		scenarioResults.print = this.print;
		scenarioResults.read();
		addChild(scenarioResults, true);
	}
	printGlobalTime(start);
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2005 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;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.eclipse.test.internal.performance.InternalDimensions;
import org.eclipse.test.internal.performance.db.SQL;

/**
 * Specific implementation for massive database requests.
 */
public class SQL_Results extends SQL {

	private PreparedStatement queryBuildScenarii, queryScenarioFailures, queryScenarioSummaries, queryAllComments, queryScenariiBuilds, queryScenarioDataPoints, queryDimScalars, queryAllVariations;


SQL_Results(Connection con) throws SQLException {
	    super(con);
	    // TODO Auto-generated constructor stub
    }

protected void dispose() throws SQLException {
	super.dispose();
	if (this.queryBuildScenarii != null)
		this.queryBuildScenarii.close();
	if (this.queryScenarioFailures != null)
		this.queryScenarioFailures.close();
	if (this.queryScenarioSummaries != null)
		this.queryScenarioSummaries.close();
	if (this.queryAllComments != null)
		this.queryAllComments.close();
	if (this.queryScenariiBuilds != null)
		this.queryScenariiBuilds.close();
	if (this.queryScenarioDataPoints != null)
		this.queryScenarioDataPoints.close();
	if (this.queryDimScalars != null)
		this.queryDimScalars.close();
	if (this.queryAllVariations != null)
		this.queryAllVariations.close();
}

/**
 * Get all comments from database
 *
 * @return A set of the query result
 * @throws SQLException
 */
ResultSet queryAllComments() throws SQLException {
	if (this.queryAllComments == null)
		this.queryAllComments = fConnection.prepareStatement("select ID, KIND, TEXT from COMMENT"); //$NON-NLS-1$
	return this.queryAllComments.executeQuery();
}

/**
 * Get all variations from database.
 *
 * @param configPattern The pattern for all the concerned configurations
 * @return A set of the query result
 * @throws SQLException
 */
ResultSet queryAllVariations(String configPattern) throws SQLException {
	long start = System.currentTimeMillis();
	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print("[SQL query (config pattern="+configPattern); //$NON-NLS-1$
	if (this.queryAllVariations == null) {
		this.queryAllVariations = fConnection.prepareStatement("select KEYVALPAIRS from VARIATION where KEYVALPAIRS like ? order by KEYVALPAIRS"); //$NON-NLS-1$
	}
	this.queryAllVariations.setString(1, "%"+configPattern+"%"); //$NON-NLS-1$ //$NON-NLS-2$
	ResultSet resultSet =  this.queryAllVariations.executeQuery();
	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print(")=" + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	return resultSet;
}

/**
 * Query all scenarii corresponding to a given scenario pattern
 * and for a specific build name.
 *
 * @param scenarioPattern The pattern for all the concerned scenarii
 * @param buildName The name of the concerned build
 * @return Set of the query result
 * @throws SQLException
 */
ResultSet queryBuildScenarii(String scenarioPattern, String buildName) throws SQLException {
	if (this.queryBuildScenarii == null) {
		String statement = "select distinct SCENARIO.ID, SCENARIO.NAME , SCENARIO.SHORT_NAME from SCENARIO, SAMPLE, VARIATION where " + //$NON-NLS-1$
			"SAMPLE.VARIATION_ID = VARIATION.ID and VARIATION.KEYVALPAIRS LIKE ? and " + //$NON-NLS-1$
			"SAMPLE.SCENARIO_ID = SCENARIO.ID and SCENARIO.NAME LIKE ? " + //$NON-NLS-1$
			"order by SCENARIO.NAME"; //$NON-NLS-1$
		this.queryBuildScenarii = fConnection.prepareStatement(statement);
	}
	this.queryBuildScenarii.setString(1, "|build=" + buildName + '%'); //$NON-NLS-1$
	this.queryBuildScenarii.setString(2, scenarioPattern);
	return this.queryBuildScenarii.executeQuery();
}

/**
 * Query all scalars for a given data point.
 * 
 * @param datapointId The id of the data point
 * @return Set of the query result
 * @throws SQLException
 */
ResultSet queryDimScalars(int datapointId) throws SQLException {
	if (this.queryDimScalars == null) {
		this.queryDimScalars = fConnection.prepareStatement("select DIM_ID, VALUE from SCALAR where " + //$NON-NLS-1$
			"DATAPOINT_ID = ? and " + //$NON-NLS-1$
			"(DIM_ID = "+InternalDimensions.CPU_TIME.getId()+" or DIM_ID = "+InternalDimensions.ELAPSED_PROCESS.getId()+") " +   //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			"order by DIM_ID");  //$NON-NLS-1$
	}
	this.queryDimScalars.setInt(1, datapointId);
	return this.queryDimScalars.executeQuery();
}

/**
 * Get all data points for a given scenario and configuration.
 *
 * @param config The name of the concerned configuration
 * @param scenarioID The id of the scenario
 * @return A set of the query result
 * @throws SQLException
 */
ResultSet queryScenarioDataPoints(String config, int scenarioID) throws SQLException {
	long start = System.currentTimeMillis();
	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print("[SQL query (config="+config+", scenario ID="+scenarioID); //$NON-NLS-1$ //$NON-NLS-2$
	if (this.queryScenarioDataPoints== null) {
		String statement = "select DATAPOINT.ID, DATAPOINT.STEP, VARIATION.KEYVALPAIRS from VARIATION, SAMPLE, DATAPOINT where " + //$NON-NLS-1$
			"VARIATION.KEYVALPAIRS like ? and SAMPLE.VARIATION_ID = VARIATION.ID and " + //$NON-NLS-1$
			"SAMPLE.SCENARIO_ID = ? and " + //$NON-NLS-1$
			"DATAPOINT.SAMPLE_ID = SAMPLE.ID " + //$NON-NLS-1$
			"ORDER BY DATAPOINT.ID, DATAPOINT.STEP"; //$NON-NLS-1$
		this.queryScenarioDataPoints = fConnection.prepareStatement(statement);
	}
	this.queryScenarioDataPoints.setString(1, "%"+config+"%"); //$NON-NLS-1$ //$NON-NLS-2$
	this.queryScenarioDataPoints.setInt(2, scenarioID);
	ResultSet resultSet =  this.queryScenarioDataPoints.executeQuery();
	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print(")=" + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
	return resultSet;
}

/**
 * Query all failures from database for a given scenario,
 * configuration and builds.
 *
 * @param config The name of the concerned configuration
 * @param scenarioID The id of the scenario
 * @param currentBuildName The name of the current build
 * @param baselineBuildName The name of the baseline build
 * @return A set of the query result
 * @throws SQLException
 */
ResultSet queryScenarioFailures(int scenarioID, String config, String currentBuildName, String baselineBuildName) throws SQLException {
	if (this.queryScenarioFailures == null) {
		this.queryScenarioFailures = fConnection.prepareStatement("select KEYVALPAIRS, MESSAGE from VARIATION, FAILURE where " + //$NON-NLS-1$
			"(KEYVALPAIRS like ? or KEYVALPAIRS like ?) and " + //$NON-NLS-1$
			"VARIATION_ID = VARIATION.ID and " + //$NON-NLS-1$
			"SCENARIO_ID = ? " + //$NON-NLS-1$
			"ORDER BY VARIATION_ID"); //$NON-NLS-1$
	}
	this.queryScenarioFailures.setString(1, "|build=" + currentBuildName+ "||config="+ config + "||jvm=sun|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	this.queryScenarioFailures.setString(2, "|build=" + baselineBuildName+ "||config="+ config + "||jvm=sun|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	this.queryScenarioFailures.setInt(3, scenarioID);
	return this.queryScenarioFailures.executeQuery();
}

/**
 * Query all summaries from database for a given scenario,
 * configuration and builds.
 *
 * @param config The name of the concerned configuration
 * @param scenarioID The id of the scenario
 * @param currentBuildName The name of the current build
 * @param baselineBuildName The name of the baseline build
 * @return Set of the query result
 * @throws SQLException
 */
ResultSet queryScenarioSummaries(int scenarioID, String config, String currentBuildName, String baselineBuildName) throws SQLException {
	if (this.queryScenarioSummaries == null) {
		this.queryScenarioSummaries= fConnection.prepareStatement("select KEYVALPAIRS, IS_GLOBAL, COMMENT_ID from VARIATION, SUMMARYENTRY where " + //$NON-NLS-1$
			"(KEYVALPAIRS like ? or KEYVALPAIRS like ?) and " + //$NON-NLS-1$
			"VARIATION_ID = VARIATION.ID and " + //$NON-NLS-1$
			"SCENARIO_ID = ? and " + //$NON-NLS-1$
			"DIM_ID = " + InternalDimensions.ELAPSED_PROCESS.getId() + //$NON-NLS-1$
			" order by VARIATION_ID"); //$NON-NLS-1$
	}
	this.queryScenarioSummaries.setString(1, "|build=" + currentBuildName+ "||config="+ config + "||jvm=sun|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	this.queryScenarioSummaries.setString(2, "|build=" + baselineBuildName+ "||config="+ config + "||jvm=sun|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	this.queryScenarioSummaries.setInt(3, scenarioID);
	return this.queryScenarioSummaries.executeQuery();
}

}




/*******************************************************************************
 * Copyright (c) 2000, 2006 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;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.StringTokenizer;

import org.eclipse.test.internal.performance.InternalPerformanceMeter;
import org.eclipse.test.internal.performance.data.Dim;

/**
 * Class providing numbers of a scenario running on a specific configuration
 * at a specific time (for example 'I20070615-1200').
 */
public class BuildResults extends AbstractResults {

	// Build information
	String date;
	boolean baseline;
	String failure;
	String comment;
	int summaryKind = -1;

	// Dimensions informations
	Dim[] dimensions;
	double[] average, stddev;
	long[] count;
	double[][] values;

BuildResults(AbstractResults parent, int id) {
	super(parent, id);
	this.name = DB_Results.getBuildName(id);
	this.baseline = this.name.startsWith(parent.getPerformance().getBaselinePrefix());
}

/*
 * Clean values when several measures has been done for the same build.
 */
void cleanValues() {
	int length = values.length;
	for (int dim_id=0; dim_id<length; dim_id++) {
		int vLength = values[dim_id].length;
		/* Log clean operation
		if (dim_id == 0) {
			IStatus status = new Status(IStatus.WARNING, PerformanceTestPlugin.PLUGIN_ID, "Clean "+vLength+" values for "+this.parent+">"+this.name+" ("+this.count[dim_id]+" measures)...");    //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$//$NON-NLS-4$ //$NON-NLS-5$
			PerformanceTestPlugin.log(status);
		}
		*/
		for (int i=0; i<vLength; i++) {
			this.average[dim_id] += values[dim_id][i];
		}
		this.average[dim_id] /= vLength;
		double squaredDeviations= 0;
		for (int i=0; i<vLength; i++) {
		    double deviation= this.average[dim_id] - values[dim_id][i];
		    squaredDeviations += deviation * deviation;
		}
		this.stddev[dim_id] = Math.sqrt(squaredDeviations / (this.count[dim_id] - 1)); // unbiased sample stdev
		this.values[dim_id] = null;
	}
	for (int i=0; i<length; i++) {
		if (this.values[i] != null) {
			return;
		}
	}
	this.values = null;
}

/**
 * Compare build results using the date of the build.
 * 
 * @see Comparable#compareTo(Object)
 */
public int compareTo(Object obj) {
	if (obj instanceof BuildResults) {
		BuildResults res = (BuildResults) obj;
		return getDate().compareTo(res.getDate());
	}
	return -1;
}

/**
 * Returns the comment associated with the scenario for the current build.
 *
 * @return The comment associated with the scenario for the current build
 * 	or <code>null</code> if no comment was stored for it.
 */
public String getComment() {
	if (this.comment == null) {
		return null;
	}
	return this.comment;
}

/*
 * Return the number of stored values for the given dimension
 *  (see {@link Dim#getId()})
 */
long getCount(int dim_id) {
	return this.count[getDimIndex(dim_id)];
}

/**
 * Returns the date of the build which is a part of its name.
 *
 * @return The date of the build as YYYYMMDD
 */
public String getDate() {
	if (this.date == null) {
		if (this.baseline) {
			int length = this.name.length();
			this.date = this.name.substring(length-12, length);
		} else {
			char first = this.name.charAt(0);
			if (first == 'N' || first == 'I' || first == 'M') { // TODO (frederic) should be buildIdPrefixes...
				this.date = this.name.substring(1, 9)+this.name.substring(10, 14);
			} else {
				SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmm"); //$NON-NLS-1$
				int length = this.name.length() - 12 /* length of date */;
				for (int i=0; i<=length; i++) {
					try {
						String substring = i == 0 ? this.name : this.name.substring(i);
						format.parse(substring);
						this.date = substring; // if no exception is raised then the substring has a correct date format => store it
						break;
					} catch(ParseException ex) {
						// skip
					}
				}
			}
		}
	}
	return this.date;
}

/**
 * Returns the standard deviation of the given dimension computed
 * while running the scenario for the current build.
 * 
 * @param dim_id The id of the dimension (see {@link Dim#getId()})
 * @return The value of the standard deviation
 */
public double getDeviation(int dim_id) {
	return this.stddev[getDimIndex(dim_id)];
}

/*
 * Return the index of the dimension corresponding to the given
 * dimension id (see {@link Dim#getId()})
 */
int getDimIndex(int dim_id) {
	if (this.dimensions == null) return -1;
	int length = this.dimensions.length;
	for (int i=0; i<length; i++) {
		if (this.dimensions[i] == null) break;
		if (this.dimensions[i].getId() == dim_id) {
			return i;
		}
	}
	return -1;
}

/*
 * Return the error computed while storing values for the given dimension
 *  (see {@link Dim#getId()})
 */
double getError(int dim_id) {
	long n = getCount(dim_id);
	if (n == 1) return Double.NaN;
	return getDeviation(dim_id) / Math.sqrt(n);
}

/**
 * Return the failure message which may happened on this scenario
 * while running the current build
 *
 * @return The failure message or <code>null</null> if the scenario passed.
 */
public String getFailure() {
	if (this.failure == null) {
		return null;
	}
	return this.failure;
}

/**
 * Return the value of the performance result stored
 * for the given dimension of the current build.
 * 
 * @param dim_id The id of the dimension (see {@link Dim#getId()})
 * @return The value of the performance result
 */
public double getValue(int dim_id) {
	return this.average[getDimIndex(dim_id)];
}

/**
 * Returns whether the build is a baseline build or not.
 * 
 * @return <code>true</code> if the build name starts with the baseline prefix
 * 	(see {@link PerformanceResults#getBaselinePrefix()} or <code>false</code>
 * 	otherwise.
 */
public boolean isBaseline() {
	return baseline;
}

/**
 * Returns whether the build has a summary or not. Note that the summary
 * may be global or not.
 * 
 * @return <code>true</code> if the summary kind is equals to 0 or 1
 * 	<code>false</code> otherwise.
 */
public boolean hasSummary() {
	return this.summaryKind >= 0;
}
/**
 * Returns whether the build has a global summary or not.
 * 
 * @return <code>true</code> if the summary kind is equals to 1
 * 	<code>false</code> otherwise.
 */
public boolean hasGlobalSummary() {
	return this.summaryKind == 1;
}

/*
 * Returns a given pattern match the build name or not.
 */
boolean match(String pattern) {
	if (pattern.equals("*")) return true; //$NON-NLS-1$
	if (pattern.indexOf('*') < 0 && pattern.indexOf('?') < 0) {
		pattern += "*"; //$NON-NLS-1$
	}
	StringTokenizer tokenizer = new StringTokenizer(pattern, "*?", true); //$NON-NLS-1$
	int start = 0;
	String previous = ""; //$NON-NLS-1$
	while (tokenizer.hasMoreTokens()) {
		String token = tokenizer.nextToken();
		if (!token.equals("*") && !token.equals("?")) { //$NON-NLS-1$ //$NON-NLS-2$
			if (previous.equals("*")) { //$NON-NLS-1$
				int idx = this.name.substring(start).indexOf(token);
				if (idx < 0) return false;
				start += idx;
			} else {
				if (previous.equals("?")) start++; //$NON-NLS-1$
				if (!name.substring(start).startsWith(token)) return false;
			}
			start += token.length();
		}
		previous = token;
	}
	if (previous.equals("*")) { //$NON-NLS-1$
		return true;
	} else if (previous.equals("?")) { //$NON-NLS-1$
		return this.name.length() == start;
	}
	return this.name.endsWith(previous);
}

/*
 * Set the build summary and its associated comment.
 */
void setSummary(int kind, String comment) {
	this.comment = comment;
	this.summaryKind = kind;
}

/*
 * Set the build failure.
 */
void setFailure(String failure) {
	this.failure = failure;
}

/*
 * Set the build value from database information.
 */
void setValue(int dim_id, int step, long value) {
	int length = SUPPORTED_DIMS.length;
	Dim dimension = getDimension(dim_id);
	int idx = 0;
	if (this.dimensions == null){
		this.dimensions = new Dim[length];
		this.average = new double[length];
		this.stddev = new double[length];
		this.count = new long[length];
		this.dimensions[0] = dimension;
	} else {
		length = this.dimensions.length;
		for (int i=0; i<length; i++) {
			if (this.dimensions[i] == null) {
				this.dimensions[i] = dimension;
				idx = i;
				break;
			}
			if (this.dimensions[i].getId() == dim_id) {
				idx = i;
				break;
			}
		}
	}
	switch (step) {
		case InternalPerformanceMeter.AVERAGE:
			if (this.average[idx] != 0) {
				if (values == null) {
					values = new double[length][];
					values[idx] = new double[2];
					values[idx][0] = this.average[idx];
					values[idx][1] = value;
					this.average[idx] = 0;
				} else if (this.values[idx] == null) {
					values[idx] = new double[2];
					values[idx][0] = this.average[idx];
					values[idx][1] = value;
					this.average[idx] = 0;
				}
			} else if (this.values != null && this.values[idx] != null) {
				int vLength = values[idx].length;
				System.arraycopy(values[idx], 0, values[idx] = new double[vLength+1], 0, vLength);
				values[idx][vLength] = value;
			} else {
				this.average[idx] = value;
			}
			break;
		case InternalPerformanceMeter.STDEV:
			this.stddev[idx] += Double.longBitsToDouble(value);
			break;
		case InternalPerformanceMeter.SIZE:
			this.count[idx] += value;
			break;
	}
}

/* (non-Javadoc)
 * @see org.eclipse.test.internal.performance.results.AbstractResults#toString()
 */
public String toString() {
	StringBuffer buffer = new StringBuffer(this.name);
	buffer.append(": "); //$NON-NLS-1$
	int length = this.dimensions.length;
	for (int i=0; i<length; i++) {
		if (i>0)	buffer.append(", "); //$NON-NLS-1$
		buffer.append('[');
		buffer.append(dimensions[i].getId());
		buffer.append("]="); //$NON-NLS-1$
		buffer.append(average[i]);
		buffer.append('/');
		buffer.append(count[i]);
		buffer.append('/');
		buffer.append(Math.round(stddev[i]*1000)/1000.0);
	}
	return buffer.toString();
}

}

Return to bug 201469

Lines 40-53 Link Here

(-)src/org/eclipse/test/performance/ui/BarGraph.java (-22 / +19 lines)
40	private static class BarItem {	40	private static class BarItem {
41		41
42	String title;	42	String title;
43	double value;	43	double value, error;
44	String url;	44	String url;
45	String slowdownExpected;	45	String slowdownExpected;
46	boolean significant;	46	boolean significant;
47		47
48	BarItem(String t, double v, String u, String slow, boolean sig) {	48	BarItem(String t, double[] stats, String u, String slow, boolean sig) {
49	title= t;	49	title= t;
50	value= v;	50	value= -stats[0] * 100;
		51	error = stats[1] * 100;
51	url= u;	52	url= u;
52	slowdownExpected= slow;	53	slowdownExpected= slow;
53	significant= sig;	54	significant= sig;
Lines 62-77 Link Here
62	fItems= new ArrayList();	63	fItems= new ArrayList();
63	}	64	}
64		65
65	public void addItem(String name, double value) {	66	public void addItem(String name, double[] stats, String url, String slow, boolean significant) {
66	fItems.add(new BarItem(name, value, null, null, true));	67	fItems.add(new BarItem(name, stats, url, slow, significant));
67	}
68
69	public void addItem(String name, double value, String url) {
70	fItems.add(new BarItem(name, value, url, null, true));
71	}
72
73	public void addItem(String name, double value, String url, String slow, boolean significant) {
74	fItems.add(new BarItem(name, value, url, slow, significant));
75	}	68	}
76		69
77	public int getHeight() {	70	public int getHeight() {
Lines 195-203 Link Here
195	for (int i= 0; i < bars.length; i++) {	188	for (int i= 0; i < bars.length; i++) {
196		189
197	BarItem bar= bars[i];	190	BarItem bar= bars[i];
198	double delta= bar.value;	191	double delta = bar.value;
		192	double error = bar.error;
199	double orgDelta= delta;	193	double orgDelta= delta;
200		194
201	boolean clamped= false;	195	boolean clamped= false;
202	if (NO_SCALE) {	196	if (NO_SCALE) {
203	if (delta > max) {	197	if (delta > max) {
Lines 211-225 Link Here
211		205
212	int barLength= (int) (delta / max * w2);	206	int barLength= (int) (delta / max * w2);
213		207
214	if (bar.significant) {	208	if (delta < 0) {
215	if (delta > 0.0)	209	if (bar.slowdownExpected != null) {
216	gc.setBackground(green);
217	else if (bar.slowdownExpected == null)
218	gc.setBackground(red);
219	else
220	gc.setBackground(gray);	210	gc.setBackground(gray);
221	} else {	211	} else if (!bar.significant) {
		212	gc.setBackground(yellow);
		213	} else {
		214	gc.setBackground(red);
		215	}
		216	} else if (!bar.significant) {
222	gc.setBackground(yellow);	217	gc.setBackground(yellow);
		218	} else {
		219	gc.setBackground(green);
223	}	220	}
224		221
225	gc.fillRectangle(center, y + (GAP / 2), barLength, BARHEIGHT);	222	gc.fillRectangle(center, y + (GAP / 2), barLength, BARHEIGHT);

Lines 1-5 Link Here

(-)src/org/eclipse/test/performance/ui/TimeLineGraph.java (-26 / +21 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 IBM Corporation and others.	2	* Copyright (c) 2004, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 10-28 Link Here
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.test.performance.ui;	11	package org.eclipse.test.performance.ui;
12		12
13	import java.util.ArrayList;	13	import java.util.*;
14	import java.util.Arrays;
15	import java.util.Comparator;
16	import java.util.Enumeration;
17	import java.util.Hashtable;
18	import java.util.List;
19		14
20	import org.eclipse.swt.graphics.Color;	15	import org.eclipse.swt.graphics.Color;
21	import org.eclipse.swt.graphics.GC;	16	import org.eclipse.swt.graphics.GC;
22	import org.eclipse.swt.graphics.Image;	17	import org.eclipse.swt.graphics.Image;
23	import org.eclipse.swt.graphics.Point;	18	import org.eclipse.swt.graphics.Point;
24	import org.eclipse.swt.graphics.Rectangle;	19	import org.eclipse.swt.graphics.Rectangle;
25
26	import org.eclipse.test.internal.performance.data.Dim;	20	import org.eclipse.test.internal.performance.data.Dim;
27		21
28	public class TimeLineGraph extends LineGraph{	22	public class TimeLineGraph extends LineGraph{
Lines 85-92 Link Here
85	Comparator comparator=new TimeLineGraphItem.GraphItemComparator();	79	Comparator comparator=new TimeLineGraphItem.GraphItemComparator();
86		80
87	while (_enum.hasMoreElements()) {	81	while (_enum.hasMoreElements()) {
88	List fItems = (List) _enum.nextElement();	82	List items = (List) _enum.nextElement();
89	Object[] fItemsArray=fItems.toArray();	83	Object[] fItemsArray=items.toArray();
90	Arrays.sort(fItemsArray,comparator);	84	Arrays.sort(fItemsArray,comparator);
91	int lastx = 0;	85	int lastx = 0;
92	int lasty = 0;	86	int lasty = 0;
Lines 161-172 Link Here
161	}	155	}
162		156
163	public void addItem(String groupName,String name, String description, double value, Color col, boolean display, long timestamp,boolean isSpecial,boolean drawBaseline) {	157	public void addItem(String groupName,String name, String description, double value, Color col, boolean display, long timestamp,boolean isSpecial,boolean drawBaseline) {
164	List fItems = (List) fItemGroups.get(groupName);	158	List items = (List) fItemGroups.get(groupName);
165	if (fItemGroups.get(groupName) == null) {	159	if (fItemGroups.get(groupName) == null) {
166	fItems=new ArrayList();	160	items=new ArrayList();
167	fItemGroups.put(groupName, fItems);	161	fItemGroups.put(groupName, items);
168	}	162	}
169	fItems.add(new TimeLineGraphItem(name, description, value, col, display,	163	items.add(new TimeLineGraphItem(name, description, value, col, display,
170	timestamp,isSpecial,drawBaseline));	164	timestamp,isSpecial,drawBaseline));
171	}	165	}
172		166
Lines 174-182 Link Here
174	Enumeration _enum=fItemGroups.elements();	168	Enumeration _enum=fItemGroups.elements();
175	double maxItem= 0;	169	double maxItem= 0;
176	while (_enum.hasMoreElements()) {	170	while (_enum.hasMoreElements()) {
177	List fItems = (List) _enum.nextElement();	171	List items = (List) _enum.nextElement();
178	for (int i = 0; i < fItems.size(); i++) {	172	for (int i = 0; i < items.size(); i++) {
179	TimeLineGraphItem graphItem = (TimeLineGraphItem) fItems.get(i);	173	TimeLineGraphItem graphItem = (TimeLineGraphItem) items.get(i);
180	if (graphItem.value > maxItem)	174	if (graphItem.value > maxItem)
181	maxItem = graphItem.value;	175	maxItem = graphItem.value;
182	}	176	}
Lines 191-199 Link Here
191	double minItem = getMaxItem();	185	double minItem = getMaxItem();
192		186
193	while (_enum.hasMoreElements()) {	187	while (_enum.hasMoreElements()) {
194	List fItems = (List) _enum.nextElement();	188	List items = (List) _enum.nextElement();
195	for (int i = 0; i < fItems.size(); i++) {	189	for (int i = 0; i < items.size(); i++) {
196	TimeLineGraphItem graphItem = (TimeLineGraphItem) fItems.get(i);	190	TimeLineGraphItem graphItem = (TimeLineGraphItem) items.get(i);
197	if (graphItem.value < minItem)	191	if (graphItem.value < minItem)
198	minItem = graphItem.value;	192	minItem = graphItem.value;
199	}	193	}
Lines 209-223 Link Here
209	TimeLineGraphItem mostRecentItem = null;	203	TimeLineGraphItem mostRecentItem = null;
210		204
211	while (_enum.hasMoreElements()) {	205	while (_enum.hasMoreElements()) {
212	List fItems = (List) _enum.nextElement();	206	List items = (List) _enum.nextElement();
213	for (int i = 0; i < fItems.size(); i++) {	207	for (int i = 0; i < items.size(); i++) {
214	if (fItems.size() == 1)	208	if (items.size() == 1)
215	return (TimeLineGraphItem) fItems.get(i);	209	return (TimeLineGraphItem) items.get(i);
216	else {	210	else {
217	TimeLineGraphItem graphItem = (TimeLineGraphItem) fItems.get(i);	211	TimeLineGraphItem graphItem = (TimeLineGraphItem) items.get(i);
218	if (graphItem.timestamp > mostRecentTimestamp) {	212	if (graphItem.timestamp > mostRecentTimestamp) {
219	mostRecentTimestamp = graphItem.timestamp;	213	mostRecentTimestamp = graphItem.timestamp;
220	mostRecentItem = (TimeLineGraphItem) fItems.get(i);	214	mostRecentItem = (TimeLineGraphItem) items.get(i);
221	}	215	}
222	}	216	}
223	}	217	}
Lines 238-243 Link Here
238	int n = mainGroup.size();	232	int n = mainGroup.size();
239	int xIncrement=width/n;	233	int xIncrement=width/n;
240	double max=getMaxItem()*1.2;	234	double max=getMaxItem()*1.2;
		235	// double min=getMinItem()*0.8;
241		236
242	for (int i = 0; i < n; i++) {	237	for (int i = 0; i < n; i++) {
243	TimeLineGraphItem thisItem = (TimeLineGraphItem) fItemsArray[i];	238	TimeLineGraphItem thisItem = (TimeLineGraphItem) fItemsArray[i];

Removed Link Here

(-)src/org/eclipse/test/performance/ui/ScenarioResults.java (-376 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.test.performance.ui;
12
13	import java.io.BufferedOutputStream;
14	import java.io.File;
15	import java.io.FileNotFoundException;
16	import java.io.FileOutputStream;
17	import java.io.PrintStream;
18	import java.util.ArrayList;
19	import java.util.HashMap;
20	import java.util.Hashtable;
21	import java.util.Iterator;
22
23	import junit.framework.AssertionFailedError;
24
25	import org.eclipse.test.internal.performance.data.Dim;
26	import org.eclipse.test.internal.performance.db.Scenario;
27	import org.eclipse.test.internal.performance.db.TimeSeries;
28	import org.eclipse.test.internal.performance.db.Variations;
29	import org.eclipse.test.performance.ui.Utils.ConfigDescriptor;
30
31	public class ScenarioResults {
32	private Scenario[] scenarios;
33	private String baseline;
34	private String baselinePrefix = null;
35	private String current;
36	private ArrayList pointsOfInterest;
37	private ArrayList buildIDStreamPatterns;
38	private Hashtable scenarioComments;
39	private Hashtable variabilityData;
40	private ConfigDescriptor configDescriptor;
41	private String outputDir;
42	private HashMap scenarioMap;
43	private Variations variations;
44	/**
45	* Summary of results for a scenario for a given build compared to a
46	* reference.
47	*
48	* @param scenarios -
49	* the array of Scenario objects for which to generate results.
50	* @param baseline -
51	* the reference build ID
52	* @param current -
53	* the current buildID
54	* @param configDescriptor -
55	* a ConfigDescriptor object.
56	* @param pointsOfInterest -
57	* an ArrayList of buildId's to highlight on line graphs.
58	*/
59	public ScenarioResults(Utils.ConfigDescriptor configDescriptor, Scenario[] scenarios, String baseline, String baselinePrefix, String current,
60	ArrayList pointsOfInterest, Hashtable scenarioComments, ArrayList buildIDPatterns, Hashtable variabilityTable, String outputDir,Variations variations) {
61
62	this.scenarios = scenarios;
63	this.variations=variations;
64	scenarioMap=new HashMap();
65	for (int i=0;i<scenarios.length;i++){
66	scenarioMap.put(scenarios[i].getScenarioName(),scenarios[i]);
67	}
68	this.baseline = baseline;
69	this.baselinePrefix = baselinePrefix;
70	this.pointsOfInterest = pointsOfInterest;
71	this.scenarioComments = scenarioComments;
72	this.configDescriptor=configDescriptor;
73	buildIDStreamPatterns=buildIDPatterns;
74	this.current = current;
75	this.outputDir=outputDir+"/"+configDescriptor.name;
76	variabilityData=variabilityTable;
77
78	try {
79	printSummary();
80	printDetails();
81	}
82	catch (Exception e) {
83	e.printStackTrace();
84	}
85	}
86
87	private void printSummary() {
88	String outFile = null;
89	PrintStream ps = null;
90
91	for (int s = 0; s < scenarios.length; s++) {
92	ArrayList pointsOfInterest = new ArrayList();
93	Scenario t = scenarios[s];
94
95	// get latest points of interest matching
96	if (this.pointsOfInterest != null) {
97	Iterator iterator = this.pointsOfInterest.iterator();
98	while (iterator.hasNext()) {
99	String buildIdPattern = iterator.next().toString();
100
101	if (buildIdPattern.endsWith("*")) {
102	pointsOfInterest.addAll(getAllMatchingBuildIds(t, buildIdPattern.substring(0, buildIdPattern.length() - 1)));
103	} else {
104	String match = getMostRecentMatchingBuildID(t, buildIdPattern);
105	if (match != null)
106	pointsOfInterest.add(match);
107	}
108	}
109	}
110
111	int[] buildNameIndeces = { -1, -1 };
112	buildNameIndeces[0] = Utils.getBuildNameIndex(t.getTimeSeriesLabels(), current);
113	buildNameIndeces[1] = Utils.getBuildNameIndex(t.getTimeSeriesLabels(), baseline);
114	// don't produce result if none exists for current build
115	if (Utils.getBuildNameIndex(t.getTimeSeriesLabels(), current) == -1) {
116	continue;
117	}
118
119	String scenarioFileName = t.getScenarioName().replace('#', '.').replace(':', '_').replace('\\', '_');
120	outFile=outputDir+"/"+ scenarioFileName + ".html";
121	String rawDataFile=scenarioFileName+"_raw.html";
122	if (outFile != null) {
123	try {
124	new File(outFile).getParentFile().mkdirs();
125	ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(outFile)));
126	} catch (FileNotFoundException e) {
127	System.err.println("can't create output file" + outFile); //$NON-NLS-1$
128	}
129	}
130	if (ps == null)
131	ps = System.out;
132	ps.println(Utils.HTML_OPEN);
133	ps.println(Utils.HTML_DEFAULT_CSS);
134	ps.println("<title>" + t.getScenarioName() + "(" + configDescriptor.description + ")" + "</title></head>"); //$NON-NLS-1$
135	ps.println("<h4>Scenario: " + t.getScenarioName() + " (" + configDescriptor.description + ")</h4><br>"); //$NON-NLS-1$ //$NON-NLS-2$
136
137	String failureMessage = Utils.failureMessage(variations, t.getScenarioName(),baseline,configDescriptor.name);
138	if (failureMessage != null){
139	ps.println("<table><tr><td><b>"+failureMessage+"</td></tr></table>\n");
140	}
141
142	String comment= (String)scenarioComments.get(t.getScenarioName());
143	if (comment != null) {
144	ps.println("<p><b>Note:</b><br>\n");
145	ps.println(comment + "</p>");
146	}
147
148	//print link to raw data.
149	ps.println("<br><br><b><a href=\""+rawDataFile+"\">Raw data and Stats</a></b><br><br>\n");
150	ps.println("<b>Click measurement name to view line graph of measured values over builds.</b><br><br>\n");
151	ps.println("<table border=\"1\">"); //$NON-NLS-1$ //$NON-NLS-2$
152
153	Dim[] dimensions = filteredDimensions(t.getDimensions());
154	try {
155	ps.println("<tr><td>Build Id</td>"); //$NON-NLS-1$
156	for (int i = 0; i < dimensions.length; i++) {
157	Dim dim = dimensions[i];
158	String dimName = dim.getName();
159	ps.println("<td><a href=\"#" + configDescriptor.name + "_" + scenarioFileName + "_" + dimName + "\">" + dimName + "</a></td>");
160	}
161	ps.print("</tr>\n");
162
163	// store current and reference values for diff later
164	double[][] diffValues = new double[2][dimensions.length];
165	// to determine if diff is possible
166	boolean[] refValueExistance = new boolean[dimensions.length];
167
168	for (int j = 0; j < 2; j++) {
169	String referenceIndicator = (j == 1) ? "(reference)" : "";
170
171	String buildName = ((buildNameIndeces[j] == -1) ? "n/a" : t.getTimeSeriesLabels()[buildNameIndeces[j]]) + referenceIndicator;
172	ps.print("<tr><td>" + buildName + "</td>");
173
174	for (int i = 0; i < dimensions.length; i++) {
175	Dim dim = dimensions[i];
176
177	TimeSeries ts = t.getTimeSeries(dim);
178	if (j == 1 && buildNameIndeces[j] != -1)
179	refValueExistance[i] = true;
180
181	if (buildNameIndeces[j] != -1)
182	diffValues[j][i] = ts.getValue(buildNameIndeces[j]);
183
184	String displayValue = (buildNameIndeces[j] == -1) ? "n/a" : dim.getDisplayValue(ts.getValue(buildNameIndeces[j]));
185	String stddev = (buildNameIndeces[j] == -1) ? "0" : dim.getDisplayValue(ts.getStddev(buildNameIndeces[j]));
186
187	if (stddev.startsWith("0 ") \|\| stddev.equals("0"))
188	ps.println("<td>" + displayValue + "</td>");
189	else
190	ps.println("<td>" + displayValue + " [" + stddev + "]" + "</td>");
191	}
192	ps.print("</tr>");
193	}
194	// get diffs and print results
195	ps.println(getDiffs(diffValues, dimensions, refValueExistance));
196	ps.println();
197	ps.println("</font></table>");
198	ps.println("*Delta values in red and green indicate degradation > 10% and improvement > 10%,respectively.<br><br>");
199	ps.println("<br><hr>\n\n");
200
201	// print text legend.
202	ps.println("Black and yellow points plot values measured in integration and last seven nightly builds.<br>\n" + "Magenta points plot the repeated baseline measurement over time.<br>\n"
203	+ "Boxed points represent previous releases, milestone builds, current reference and current build.<br><br>\n"
204	+ "Hover over any point for build id and value.\n");
205
206	// print image maps of historical
207	for (int i = 0; i < dimensions.length; i++) {
208	Dim dim = dimensions[i];
209	String dimName = dim.getName();
210
211	TimeLineGraph lg = Utils.getLineGraph(t, dim.getName(), baseline, baselinePrefix, current, pointsOfInterest,buildIDStreamPatterns);
212
213	String lgImg = outputDir + "/graphs/" + scenarioFileName + "_" + dimName + ".gif";
214	Utils.printLineGraphGif(lg, lgImg);
215	ps.println("<br><a name=\"" + configDescriptor.name + "_" + scenarioFileName + "_" + dimName + "\"></a>");
216	ps.println("<br><b>" + dimName + "</b><br>");
217	ps.println(Utils.getDimensionDescription(dimName) + "<br><br>\n");
218	ps.println(Utils.getImageMap(lg, "graphs/" + scenarioFileName + "_" + dimName + ".gif",scenarioFileName+"_raw.html"));
219	}
220	ps.println("<br><br></body>");
221	ps.println(Utils.HTML_CLOSE); //$NON-NLS-1$
222	if (ps != System.out)
223	ps.close();
224
225	} catch (AssertionFailedError e) {
226	e.printStackTrace();
227	continue;
228	}
229	}
230	}
231
232	private void printDetails() {
233
234	String outFile = null;
235	PrintStream ps = null;
236
237	for (int s = 0; s < scenarios.length; s++) {
238	Scenario t = scenarios[s];
239	// don't produce result if none exists for current build
240	if (Utils.getBuildNameIndex(t.getTimeSeriesLabels(), current) == -1) {
241	continue;
242	}
243	Dim[] dimensions = filteredDimensions(t.getDimensions());
244	//store cv for aggregate data
245	Hashtable data=(Hashtable)variabilityData.get(t.getScenarioName());
246	if (data==null){
247	data=new Hashtable();
248	variabilityData.put(t.getScenarioName(),data);
249	}
250
251	RawDataTable currentResultsTable=new RawDataTable(t,dimensions,buildIDStreamPatterns,current);
252	data.put("cConfig-"+configDescriptor.name,currentResultsTable.getCV());
253
254	//create table for baseline data
255	RawDataTable baselineResultsTable;
256	if (baselinePrefix!=null)
257	baselineResultsTable=new RawDataTable(t,dimensions,baselinePrefix,baseline);
258	else
259	baselineResultsTable=new RawDataTable(t,dimensions,baseline,baseline);
260
261	data.put("bConfig-"+configDescriptor.name,baselineResultsTable.getCV());
262
263
264	String scenarioFileName = t.getScenarioName().replace('#', '.').replace(':', '_').replace('\\', '_');
265	outFile = outputDir + "/" + scenarioFileName + "_raw.html";
266	if (outFile != null) {
267	try {
268	new File(outFile).getParentFile().mkdirs();
269	ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(outFile)));
270	} catch (FileNotFoundException e) {
271	System.err.println("can't create output file" + outFile); //$NON-NLS-1$
272	}
273	}
274	if (ps == null)
275	ps = System.out;
276	ps.println(Utils.HTML_OPEN);
277	ps.println(Utils.HTML_DEFAULT_CSS);
278	ps.println("<title>" + t.getScenarioName() + "(" + configDescriptor.description + ")" + " - Details</title></head>"); //$NON-NLS-1$
279	ps.println("<h4>Scenario: " + t.getScenarioName() + " (" + configDescriptor.description + ")</h4>"); //$NON-NLS-1$
280	ps.println("<a href=\""+scenarioFileName+".html\">VIEW GRAPH</a><br><br>"); //$NON-NLS-1$
281	ps.println("<table><td><b>Current Stream Test Runs</b></td><td><b>Baseline Test Runs</b></td></tr>\n");
282	ps.println("<tr valign=\"top\">" +
283	"<td>"+currentResultsTable.toHtmlString()+"</td>"
284	+"<td>"+baselineResultsTable.toHtmlString()+"</td></tr>");
285	ps.println("</table>");
286	ps.close();
287	}
288	}
289
290	private String getMostRecentMatchingBuildID(Scenario scenario, String buildIdPrefix) {
291	String[] buildIds = scenario.getTimeSeriesLabels();
292	for (int i = buildIds.length - 1; i > -1; i--) {
293	if (buildIds[i].startsWith(buildIdPrefix))
294	return buildIds[i];
295	}
296	return null;
297	}
298
299	private ArrayList getAllMatchingBuildIds(Scenario scenario, String buildIdPrefix) {
300	ArrayList result = new ArrayList();
301	String[] buildIds = scenario.getTimeSeriesLabels();
302	for (int i = buildIds.length - 1; i > -1; i--) {
303	if (buildIds[i].startsWith(buildIdPrefix) && !buildIds[i].equals(baseline))
304	result.add(buildIds[i]);
305	}
306	return result;
307	}
308
309	private String getDiffs(double[][] values, Dim[] dimensions, boolean[] refValueExistance) {
310	String diffRow = "<tr><td>*Delta</td>";
311	for (int j = 0; j < dimensions.length; j++) {
312	Dim dim = dimensions[j];
313
314	double diffValue = values[0][j] - values[1][j];
315	double diffPercentage = 0;
316	if (values[1][j] != 0)
317	diffPercentage = ((int) (((diffValue / Math.abs(values[1][j])) * 1000))) / 10.0;
318	String diffDisplayValue = dim.getDisplayValue(diffValue);
319	// green
320	String fontColor = "";
321	if ((diffPercentage < -10 && !dim.largerIsBetter()) \|\| (diffPercentage > 10 && dim.largerIsBetter()))
322	fontColor = "#006600";
323	if ((diffPercentage < -10 && dim.largerIsBetter()) \|\| (diffPercentage > 10 && !dim.largerIsBetter()))
324	fontColor = "#FF0000";
325
326	diffPercentage = Math.abs(diffPercentage);
327	String percentage = (diffPercentage == 0) ? "" : "<br>" + diffPercentage + " %";
328
329	if (diffPercentage > 10 \|\| diffPercentage < -10) {
330	diffRow = diffRow.concat("<td><FONT COLOR=\"" + fontColor + "\"><b>" + diffDisplayValue + percentage + "</b></FONT></td>");
331	} else if (refValueExistance[j]) {
332	diffRow = diffRow.concat("<td>" + diffDisplayValue + percentage + "</td>");
333	} else {
334	diffRow = diffRow.concat("<td>n/a</td>");
335	}
336	}
337	diffRow = diffRow.concat("</tr>");
338	return diffRow;
339	}
340
341	private Dim[] filteredDimensions(Dim[] dimensions) {
342	ArrayList list = new ArrayList();
343	ArrayList filtered = new ArrayList();
344	list.add(0, "Elapsed Process");
345	list.add(1, "CPU Time");
346	list.add(2, "Invocation Count");
347	list.add(3, "GDI Objects");
348	//list.add(4, "Kernel time");
349	//list.add(5, "Data Size");
350	//list.add(6, "Library Size");
351	//list.add(7, "Text Size");
352	// list.add(8,"Used Java Heap");
353	// list.add(9,"Committed");
354	// list.add(10,"Page Faults");
355	// list.add(11,"Hard Page Faults");
356	// list.add(12,"Soft Page Faults");
357
358	for (int i = 0; i < dimensions.length; i++) {
359	String dimName = dimensions[i].getName();
360	if (list.contains(dimName))
361	list.set(list.indexOf(dimName), dimensions[i]);
362	}
363	Iterator iterator = list.iterator();
364	while (iterator.hasNext()) {
365	Object tmp = iterator.next();
366	try {
367	if ((Dim) tmp instanceof Dim)
368	filtered.add(tmp);
369	} catch (ClassCastException e) {
370	//silently ignore
371	}
372	}
373	return (Dim[]) filtered.toArray(new Dim[filtered.size()]);
374	}
375
376	}

Lines 16-22 Link Here

(-)src/org/eclipse/test/performance/ui/FingerPrint.java (-224 / +149 lines)
16	import java.io.FileOutputStream;	16	import java.io.FileOutputStream;
17	import java.io.IOException;	17	import java.io.IOException;
18	import java.io.OutputStream;	18	import java.io.OutputStream;
19	import java.util.Hashtable;	19	import java.io.PrintStream;
		20	import java.util.List;
20		21
21	import org.eclipse.swt.SWT;	22	import org.eclipse.swt.SWT;
22	import org.eclipse.swt.graphics.GC;	23	import org.eclipse.swt.graphics.GC;
Lines 24-259 Link Here
24	import org.eclipse.swt.graphics.ImageData;	25	import org.eclipse.swt.graphics.ImageData;
25	import org.eclipse.swt.graphics.ImageLoader;	26	import org.eclipse.swt.graphics.ImageLoader;
26	import org.eclipse.swt.widgets.Display;	27	import org.eclipse.swt.widgets.Display;
27	import org.eclipse.test.internal.performance.PerformanceTestPlugin;	28	import org.eclipse.test.internal.performance.results.AbstractResults;
28	import org.eclipse.test.internal.performance.data.Dim;	29	import org.eclipse.test.internal.performance.results.ConfigResults;
29	import org.eclipse.test.internal.performance.db.DB;	30	import org.eclipse.test.internal.performance.results.PerformanceResults;
30	import org.eclipse.test.internal.performance.db.Scenario;	31	import org.eclipse.test.internal.performance.results.ScenarioResults;
31	import org.eclipse.test.internal.performance.db.SummaryEntry;	32
32	import org.eclipse.test.internal.performance.db.TimeSeries;	33	/**
33	import org.eclipse.test.internal.performance.db.Variations;	34	* Class used to create scenario fingerprint.
34	import org.eclipse.test.performance.ui.Utils.ConfigDescriptor;	35	*/
		36	public class FingerPrint {
35		37
		38	private static final int GRAPH_WIDTH = 1000;
36		39
37	public class FingerPrint {	40	String component;
38		41	PrintStream stream;
39	private static final int GRAPH_WIDTH= 1000;	42	File outputDir;
		43
		44	public FingerPrint(String name, PrintStream ps, File outputDir) {
		45	if (!name.equals("global")) this.component = name;
		46	this.stream = ps;
		47	this.outputDir = outputDir;
		48	}
40		49
41	String outputDirectory;	50	/**
42	String referenceBuildId;	51	* Create and save fingerprints as image and print their reference in the current stream.
43	String currentBuildId;	52	*
44	String component;	53	* @param performanceResults The performance results used to print the fingerprints
45	ConfigDescriptor configDescriptor;	54	*/
46	SummaryEntry [] entries;	55	public void print(PerformanceResults performanceResults) {
47	Variations variations;	56	String baselineBuildName = performanceResults.getBaselineName();
48	BarGraph bar;	57	String buildName = performanceResults.getName();
49	String outName;	58
50	String title;	59	// Compute fingerprint output file name prefix
51	Hashtable scenarioComments;	60	int referenceUnderscoreIndex = baselineBuildName.indexOf('_');
52		61	String baselinePrefix = baselineBuildName;
53	public FingerPrint() {	62	if (referenceUnderscoreIndex != -1) {
54	}	63	baselinePrefix = baselineBuildName.substring(0, referenceUnderscoreIndex);
55
56
57	public FingerPrint(String component,ConfigDescriptor config, String reference, String current,Variations variations, String outputDir) {
58	this.variations=variations;
59	this.component=component;
60	referenceBuildId= reference;
61	currentBuildId= current;
62	outputDirectory= outputDir;
63	configDescriptor=config;
64	variations.put(PerformanceTestPlugin.BUILD, currentBuildId);
65	if (component==null){
66	entries= DB.querySummaries(variations,null);
67	this.component="";
68	} else {
69	entries=DB.querySummaries(variations,component+'%');
70	}
71	run();
72	}
73
74	/**
75	* Creates the fingerprint gif, image map and scenario status table for the component.
76	*/
77	public void run() {
78	new File(outputDirectory).mkdirs();
79	String referenceName=referenceBuildId;
80	String currentName=currentBuildId;
81	int referenceUnderscoreIndex=referenceBuildId.indexOf('_');
82	int currentUnderscoreIndex=currentBuildId.indexOf('_');
83
84	if (referenceUnderscoreIndex!=-1)
85	referenceName=referenceBuildId.substring(0,referenceUnderscoreIndex);
86	if (currentUnderscoreIndex!=-1)
87	currentName=currentBuildId.substring(0,currentUnderscoreIndex);
88
89	title="Performance of " + component +" "+currentName + " relative to " + referenceName;
90	bar= new BarGraph(null);
91
92	if (entries != null) {
93	for (int i= 0; i < entries.length; i++) {
94	SummaryEntry summary = entries[i];
95	if (summary.comment==null)
96	add(summary.shortName, new Dim[] { summary.dimension }, summary.scenarioName);
97	else{
98	setComment(summary.scenarioName, summary.comment);
99	add(summary.shortName, new Dim[] { summary.dimension }, summary.scenarioName, summary.comment);
100	}
101	}
102	}
103
104	outName= "FP_" + component+ '_'+referenceName + '_' + currentBuildId+"."+configDescriptor.name;
105
106	if (component=="")
107	outName= "FP_"+referenceName + '_' + currentBuildId+"."+configDescriptor.name;
108	save(outputDirectory + '/' + outName);
109
110	//show(bar);
111
112	}
113
114	private void setComment(String scenario, String comment) {
115	if (scenarioComments==null)
116	scenarioComments=new Hashtable();
117	scenarioComments.put(scenario,comment);
118	}
119
120	private void add(String name, Dim[] dims, String scenarioName) {
121	add (name,dims,scenarioName,null);
122	}
123
124	private void add(String name, Dim[] dims, String scenarioName, String comment) {
125	String refData= "";
126	Scenario scenario= DB.getScenarioSeries(scenarioName, variations, PerformanceTestPlugin.BUILD, referenceBuildId, currentBuildId, dims);
127	String[] timeSeriesLabels= scenario.getTimeSeriesLabels();
128	if (timeSeriesLabels.length == 2) {
129	// we mark the label with a '*' or '' to indicate that no data was available for the specified builds
130	if (!timeSeriesLabels[0].equals(referenceBuildId)) {
131	name= '*' + name;
132	refData= " (" + timeSeriesLabels[0] + ")";
133	} else if (!timeSeriesLabels[1].equals(currentBuildId)) {
134	name= '' + name;
135	refData= " (" + timeSeriesLabels[1] + ")";
136	}
137	}
138
139	for (int i= 0; i < dims.length; i++) {
140	TimeSeries timeSeries= scenario.getTimeSeries(dims[i]);
141	int l= timeSeries.getLength();
142	if (l >= 1) {
143	double percent= 0.0;
144	boolean hasConfidentResult= true;
145	if (l > 1) {
146	// hasConfidentResult= Utils.hasConfidentResult(variations, scenario.getScenarioName(),referenceBuildId,configDescriptor.name);
147	hasConfidentResult= Utils.hasConfidentResult(timeSeries);
148	/*if (!rejectNullHypothesis) {
149	NumberFormat percentFormatter= NumberFormat.getPercentInstance();
150	String statisticsComment= "There is not enough evidence to reject the null hypothesis at the " + percentFormatter.format(percentile.inside()) + "level";
151	if (comment == null)
152	comment= statisticsComment;
153	else
154	comment+= statisticsComment;
155	setComment(scenarioName, comment);
156	}
157	*/
158	double ref= timeSeries.getValue(0);
159	double val= timeSeries.getValue(1);
160	percent= 100.0 - ((val / ref) * 100.0);
161	}
162	if (Math.abs(percent) < 200) {
163	String n= name + " (" + dims[i].getName() + ")" + refData;
164	bar.addItem(n, percent,configDescriptor.name+"/"+(scenarioName.replace('#','.').replace(':','_').replace('\\','_'))+".html#"+dims[i].getName(),comment, hasConfidentResult); //$NON-NLS-1$ //$NON-NLS-2$
165	}
166	}
167	}
168	//scenario.dump(System.out);
169
170	}
171
172	private void save(String output) {
173
174	//if (bar.getFItems().size()==0)
175	//return;
176
177	Display display= Display.getDefault();
178
179	int height= bar.getHeight();
180	Image image= new Image(display, GRAPH_WIDTH, height);
181
182	GC gc= new GC(image);
183	bar.paint(display, GRAPH_WIDTH, height, gc);
184	gc.dispose();
185
186	ImageData data = Utils.downSample(image);
187	ImageLoader il= new ImageLoader();
188	il.data= new ImageData[] { data };
189
190	OutputStream out= null;
191	try {
192	out= new BufferedOutputStream(new FileOutputStream(output + ".gif")); //$NON-NLS-1$
193	//System.out.println("writing: " + output);
194	il.save(out, SWT.IMAGE_GIF);
195	} catch (FileNotFoundException e) {
196	e.printStackTrace();
197	} finally {
198	image.dispose();
199	if (out != null) {
200	try {
201	out.close();
202	} catch (IOException e1) {
203	// silently ignored
204	}
205	}
206	}
207	}
208
209	/*
210	* Displays bar graph in window
211	*
212	private void show(final BarGraph bar) {
213	Display display= new Display();
214
215	Shell shell= new Shell(display);
216	shell.setLayout(new FillLayout());
217
218	final Canvas canvas= new Canvas(shell, SWT.NO_BACKGROUND);
219	canvas.addPaintListener(new PaintListener() {
220	public void paintControl(PaintEvent e) {
221	Point s= canvas.getSize();
222	bar.paint(canvas.getDisplay(), s.x, s.y, e.gc);
223	}
224	});
225
226	shell.open();
227
228	while (!shell.isDisposed())
229	if (!display.readAndDispatch())
230	display.sleep();
231
232	display.dispose();
233	}
234	public BarGraph getBar() {
235	return bar;
236	}	64	}
237	public String getOutName() {	65	int currentUnderscoreIndex = buildName.indexOf('_');
238	return outName;	66	if (currentUnderscoreIndex != -1){
		67	buildName = buildName.substring(0, currentUnderscoreIndex);
239	}	68	}
240	*/	69	StringBuffer buffer = new StringBuffer("FP_");
		70	if (this.component != null) {
		71	buffer.append(this.component);
		72	buffer.append('_');
		73	}
		74	buffer.append(baselinePrefix);
		75	buffer.append('_');
		76	buffer.append(buildName);
		77	buffer.append('.');
		78	String filePrefix = buffer.toString();
		79
		80	// Create each fingerprint and save it
		81	String[] configNames = performanceResults.getConfigNames(false/* not sorted*/);
		82	String[] configBoxes = performanceResults.getConfigBoxes(false/* not sorted*/);
		83	int length = configNames.length;
		84	for (int c=0; c<length; c++) {
		85	String configName = configNames[c];
		86	List scenarii = performanceResults.getComponentSummaryScenarii(this.component, configName);
		87	if (scenarii == null) continue;
		88
		89	// Create BarGraph
		90	// BarGraph barGraph = new BarGraph(null);
		91	BarGraph barGraph = null;
		92	for (int i=0, size=scenarii.size(); i<size; i++) {
		93	ScenarioResults scenarioResults = (ScenarioResults) scenarii.get(i);
		94	ConfigResults configResults = scenarioResults.getConfigResults(configName);
		95	if (configResults == null \|\| !configResults.isValid()) continue;
		96	double[] results = configResults.getCurrentBuildDeviation();
		97	double percent = -results[0] * 100.0;
		98	if (results != null && Math.abs(percent) < 200) {
		99	String defaultDimensionName = AbstractResults.SUPPORTED_DIMS[0].getName();
		100	String name = scenarioResults.getLabel() + " (" + defaultDimensionName + ")";
		101	if (!configResults.getCurrentBuildName().equals(buildName)) {
		102	continue; // the test didn't run on last build, skip it
		103	}
		104	if (!configResults.isBaselined()) {
		105	name = "*" + name + " (" + configResults.getBaselineBuildName() + ")";
		106	}
		107	if (barGraph == null) {
		108	barGraph = new BarGraph(null);
		109	}
		110	barGraph.addItem(name,
		111	results,
		112	configName + "/" + scenarioResults.getFileName() + ".html#" + defaultDimensionName,
		113	configResults.getCurrentBuildResults().getComment(),
		114	(Utils.confidenceLevel(results) & Utils.ERR) == 0);
		115	}
		116	}
		117	if (barGraph == null) continue;
241		118
242	/**	119	// Save image file
243	* @return - an html representation of the fingerprint.	120	String fileName = filePrefix + configName ;
244	*/	121	File outputFile = new File(this.outputDir, fileName+".gif");
245	public String getImageMap() {	122	save(barGraph, outputFile);
246	String componentDescription = this.configDescriptor.description;	123
247	String areas = this.bar.getAreas();	124	// Print image file reference in stream
248	if (areas == null)	125	String boxName = configBoxes[c];
249	areas = "";	126	if (outputFile.exists()) {
250	String output = "";	127	String areas = barGraph.getAreas();
251	if (new File(this.outputDirectory, this.outName + ".gif").exists()) {	128	if (areas == null) areas = "";
252	output = "<h4>" + componentDescription + "</h4>";	129	this.stream.print("<h4>");
253	output = output.concat("<img src=\"" + this.outName + ".gif\" usemap=\"#" + this.outName + "\">" + "<map name=\"" + this.outName + "\">" + areas + "</map>\n");	130	this.stream.print(boxName);
		131	this.stream.print("</h4>");
		132	this.stream.print("<img src=\"");
		133	this.stream.print(fileName);
		134	this.stream.print(".gif\" usemap=\"#");
		135	this.stream.print(fileName);
		136	this.stream.print("\"><map name=\"");
		137	this.stream.print(fileName);
		138	this.stream.print("\">");
		139	this.stream.print(areas);
		140	this.stream.print("</map>\n");
254	} else {	141	} else {
255	output = output.concat("<br><br>There is no fingerprint for " + componentDescription + "<br><br>\n");	142	this.stream.print("<br><br>There is no fingerprint for ");
		143	this.stream.print(boxName);
		144	this.stream.print("<br><br>\n");
256	}	145	}
257	return output;
258	}	146	}
259	}	147	}
		148
		149	/*
		150	* Save the computed bar graph.
		151	*/
		152	private void save(BarGraph barGraph, File outputFile) {
		153
		154	// Create and paint image
		155	Display display = Display.getDefault();
		156	int height = barGraph.getHeight();
		157	Image image = new Image(display, GRAPH_WIDTH, height);
		158	GC gc = new GC(image);
		159	barGraph.paint(display, GRAPH_WIDTH, height, gc);
		160	gc.dispose();
		161
		162	// Save image
		163	ImageData data = Utils.downSample(image);
		164	ImageLoader imageLoader = new ImageLoader();
		165	imageLoader.data = new ImageData[] { data };
		166
		167	OutputStream out = null;
		168	try {
		169	out = new BufferedOutputStream(new FileOutputStream(outputFile));
		170	imageLoader.save(out, SWT.IMAGE_GIF);
		171	} catch (FileNotFoundException e) {
		172	e.printStackTrace();
		173	} finally {
		174	image.dispose();
		175	if (out != null) {
		176	try {
		177	out.close();
		178	} catch (IOException e1) {
		179	// silently ignored
		180	}
		181	}
		182	}
		183	}
		184	}

Lines 10-259 Link Here

(-)src/org/eclipse/test/performance/ui/RawDataTable.java (-228 / +152 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.test.performance.ui;	11	package org.eclipse.test.performance.ui;
12		12
		13	import java.io.PrintStream;
13	import java.util.ArrayList;	14	import java.util.ArrayList;
14	import java.util.Arrays;	15	import java.util.Collections;
15	import java.util.Hashtable;	16	import java.util.List;
16	import java.util.Iterator;
17	import java.util.Set;
18		17
19	import org.eclipse.test.internal.performance.data.Dim;	18	import org.eclipse.test.internal.performance.data.Dim;
20	import org.eclipse.test.internal.performance.db.Scenario;	19	import org.eclipse.test.internal.performance.results.AbstractResults;
21	import org.eclipse.test.internal.performance.db.TimeSeries;	20	import org.eclipse.test.internal.performance.results.BuildResults;
22		21	import org.eclipse.test.internal.performance.results.ConfigResults;
		22
		23	/**
		24	* Class used to fill details file of scenario builds data.
		25	* @see ScenarioData
		26	*/
23	public class RawDataTable {	27	public class RawDataTable {
24		28
25	private Scenario scenario;	29	private ConfigResults configResults;
26	private String currentBuild;	30	private List buildPrefixes;
27	private Dim[] dimensions;	31	private PrintStream stream;
28	private Hashtable buildIDTable;	32	private Dim[] dimensions = AbstractResults.SUPPORTED_DIMS;
29	private Hashtable derivedValues;	33	private boolean debug = false;
30	private String TOTAL="total";	34
31	private String SAMPLECOUNT="n";	35	private RawDataTable(ConfigResults results, PrintStream ps) {
32	private String MEAN="mean";	36	this.configResults = results;
33	private String STDDEV="stddev";	37	this.stream = ps;
34	private String CV="cv";	38	}
35	private ArrayList buildIDPatterns;
36
37
38	public RawDataTable(Scenario scenario, Dim[] dimensions, ArrayList buildIDPatterns, String currentBuild) {
39	this.scenario = scenario;
40	this.dimensions = dimensions;
41	this.buildIDPatterns=buildIDPatterns;
42	this.currentBuild=currentBuild;
43	buildIDTable = new Hashtable();
44	derivedValues=new Hashtable();
45	fill();
46	}
47
48	public RawDataTable(Scenario scenario, Dim[] dimensions, String buildIDPrefix,String currentBuild) {
49	buildIDPatterns=new ArrayList();
50	buildIDPatterns.add(buildIDPrefix);
51	this.currentBuild=currentBuild;
52	this.scenario = scenario;
53	this.dimensions = dimensions;
54	buildIDTable = new Hashtable();
55	derivedValues=new Hashtable();
56	fill();
57	}
58
59	private void fill() {
60
61	for (int i = 0; i < dimensions.length; i++) {
62	TimeSeries ts = scenario.getTimeSeries(dimensions[i]);
63	double total = 0.0;
64	int samplesCount=0;
65	for (int j = 0; j < ts.getLength(); j++) {
66	String buildID = ts.getLabel(j);
67	double value = 0.0;
68	boolean buildIDmatches=false;
69	Iterator iterator=buildIDPatterns.iterator();
70	while (iterator.hasNext()){
71	Object tmp=iterator.next();
72	if (tmp==null)
73	continue;
74	if (buildID.startsWith(tmp.toString())){
75	buildIDmatches=true;
76	break;
77	}
78	}
79	if (!buildIDmatches)
80	continue;
81
82	Hashtable samples=(Hashtable)buildIDTable.get(buildID);
83	if (samples==null)
84	samples=new Hashtable();
85	value = ts.getValue(j);
86
87	// store result for build
88	samples.put(dimensions[i].getName(),new Double(value));
89	buildIDTable.put(buildID,samples);
90
91	//keep count of samples added and total value
92	total+=value;
93	samplesCount++;
94
95	//quit after current build
96	if (buildID.equals(currentBuild))
97	break;
98	}
99
100	double mean = total / samplesCount;
101	double squaredValues = 0.0;
102
103	String[] buildIDs=(String[])buildIDTable.keySet().toArray(new String[buildIDTable.size()]);
104	for (int j = 0; j < buildIDs.length; j++) {
105	String buildID = buildIDs[j];
106	Hashtable storedValues=(Hashtable)buildIDTable.get(buildID);
107	double value = ((Double) (storedValues.get(dimensions[i].getName()))).doubleValue();
108	double squaredValue = Math.pow(value - mean, 2);
109	squaredValues += squaredValue;
110	}
111		39
112	double standardDeviation = Math.sqrt((squaredValues / (samplesCount - 1)));	40	public RawDataTable(ConfigResults results, List prefixes, PrintStream ps) {
113	double coefficientOfVariation = Math.round(((standardDeviation) / mean) * 100 * 100) / 100;	41	this(results, ps);
114		42	this.buildPrefixes = prefixes;
115	if (coefficientOfVariation>10&&dimensions[i].getName().startsWith("Elapsed"))	43	}
116	System.out.println(scenario.getScenarioName()+": "+" "+coefficientOfVariation);	44	public RawDataTable(ConfigResults results, String baselinePrefix, PrintStream ps) {
117		45	this(results, ps);
118	//store derived values	46	this.buildPrefixes = new ArrayList();
119	Hashtable calculatedValuesForDimension=new Hashtable();	47	this.buildPrefixes.add(baselinePrefix);
120	calculatedValuesForDimension.put(TOTAL,dimensions[i].getDisplayValue(total));	48	}
121	calculatedValuesForDimension.put(SAMPLECOUNT,new Integer(samplesCount));
122	calculatedValuesForDimension.put(MEAN, dimensions[i].getDisplayValue(mean));
123	calculatedValuesForDimension.put(STDDEV, dimensions[i].getDisplayValue(standardDeviation));
124	calculatedValuesForDimension.put(CV, coefficientOfVariation+"%");
125	derivedValues.put(dimensions[i].getName(),calculatedValuesForDimension);
126
127	}
128	}
129		49
130	public String toHtmlString(){	50	/**
131	return "<table border=\"1\">"+htmlSummary()+htmlDetails()+"</table>\n";	51	* Print all build data to the current stream.
132	}	52	*/
133		53	public void print(){
134	private String[] sortBuildIDsByDate(String[] buildIDs) {	54	stream.print("<table border=\"1\">");
135	Hashtable tmp = new Hashtable();	55	printSummary();
136	String[] result = new String[buildIDs.length];	56	printDetails();
137		57	stream.println("</table>");
138	for (int i = 0; i < buildIDs.length; i++) {	58	}
139	String date=Utils.getDateFromBuildID(buildIDs[i], true)+"";
140	if (date.equals("-1"))
141	date=buildIDs[i];
142	tmp.put(date, buildIDs[i]);
143	}
144	String[] dates = (String[]) tmp.keySet().toArray(new String[tmp.size()]);
145	Arrays.sort(dates);
146	for (int i = 0; i < dates.length; i++) {
147	result[i] = tmp.get(dates[i]).toString();
148	}
149		59
150	return result;	60	/*
		61	* Print table columns headers.
		62	*/
		63	private void printColumnHeaders() {
		64	StringBuffer buffer = new StringBuffer();
		65	int length = this.dimensions.length;
		66	for (int i=0; i<length; i++) {
		67	buffer.append("<td><b>");
		68	buffer.append(this.dimensions[i].getName());
		69	buffer.append("</b></td>");
151	}	70	}
		71	stream.print(buffer.toString());
		72	}
152		73
153	private String htmlDimensionColumnHeaders() {	74	/*
154	String result="";	75	* Print all build results in the table.
155	for (int i=0;i<dimensions.length;i++){	76	*/
156	result = result.concat("<td><b>"+dimensions[i].getName()+"</b></td>");	77	private void printDetails() {
		78	stream.print("<tr><td><b>Build ID</b></td>");
		79	printColumnHeaders();
		80	stream.println("</tr>");
		81
		82	List builds = this.configResults.getBuildsMatchingPrefixes(this.buildPrefixes);
		83	Collections.reverse(builds);
		84	int size = builds.size();
		85	for (int i=0; i<size; i++) {
		86	BuildResults buildResults = (BuildResults) builds.get(i);
		87	stream.print("<tr><td>");
		88	stream.print(buildResults.getName());
		89	stream.print("</td>");
		90	int dimLength = this.dimensions.length;
		91	for (int d=0; d<dimLength; d++) {
		92	int dim_id = this.dimensions[d].getId();
		93	double value = buildResults.getValue(dim_id);
		94	printDimTitle(this.dimensions[d].getName());
		95	String displayValue = this.dimensions[d].getDisplayValue(value);
		96	stream.print(displayValue);
		97	if (debug) System.out.print("\t"+displayValue);
		98	stream.print("</td>");
157	}	99	}
158	return result;	100	if (debug) System.out.println();
		101	stream.println("</tr>");
159	}	102	}
		103	if (debug) System.out.println("\n");
		104	}
160		105
161	private String htmlDetails() {	106	/*
162	String result="<tr><td><b>Build ID</b></td>";	107	* Print summary on top of the table.
163	result = result.concat(htmlDimensionColumnHeaders());	108	*/
164	result = result.concat("</tr>\n");	109	private void printSummary() {
165		110	stream.print("<tr><td><b>Stats</b></td>");
166	Set sampleKeys = buildIDTable.keySet();	111	printColumnHeaders();
167	String[] buildIDs = sortBuildIDsByDate((String[]) sampleKeys.toArray(new String[buildIDTable.size()]));	112	stream.println("</tr>");
168		113
169	for (int i = buildIDs.length; i > 0; i--) {	114	int length = this.dimensions.length;
170	String buildID = buildIDs[i-1];	115	double[][] dimStats = new double[2][];
171	if (buildID == null)	116	for (int i=0; i<this.dimensions.length; i++) {
172	continue;	117	dimStats[i] = this.configResults.getStatistics(this.buildPrefixes, this.dimensions[i].getId());
173		118	}
174	Hashtable values=(Hashtable)buildIDTable.get(buildID);	119
175	if (values==null)	120	stream.print("<tr><td>#BUILDS SAMPLED</td>");
176	continue;	121	for (int i=0; i<length; i++) {
177		122	String dimName = this.dimensions[i].getName();
178	result = result.concat("<tr><td>" + buildID + "</td>\n");	123	printDimTitle(dimName);
179		124	stream.print((int)dimStats[i][0]);
180	for (int j=0;j<dimensions.length;j++){	125	stream.print("</td>");
181	double value = 0.0;	126	}
182	String dimensionName=dimensions[j].getName();	127	stream.println("</tr>");
183	value = ((Double) (values.get(dimensionName))).doubleValue();	128	stream.print("<tr><td>MEAN</td>");
184	result = result.concat("<td title=\""+dimensionName+"\">" + dimensions[j].getDisplayValue(value) + "</td>");	129	printRowDoubles(dimStats, 1);
185	}	130	stream.println("</tr>");
186	}	131	stream.print("<tr><td>STD DEV</td>");
187	result=result.concat("</tr>\n");	132	printRowDoubles(dimStats, 2);
188	return result;	133	stream.println("</tr>");
		134	stream.print("<tr><td>COEF. VAR</td>");
		135	printRowDoubles(dimStats, 3);
		136	stream.println("</tr>");
		137
		138	// Blank line
		139	stream.print("<tr>");
		140	for (int i=0; i<length+1; i++){
		141	stream.print("<td> </td>");
189	}	142	}
		143	stream.println("</tr>");
		144	}
190		145
191	private String htmlSummary() {	146	/*
192	if (derivedValues==null)	147	* Print values in table row.
193	return "";	148	*/
194	//print summary values	149	private void printRowDoubles(double[][] stats, int idx) {
195	//print totals	150	int length = this.dimensions.length;
196	String result="<tr><td><b>Stats</b></td>";	151	for (int i=0; i<length; i++) {
197	result = result.concat(htmlDimensionColumnHeaders());	152	double value = stats[i][idx];
198	result = result.concat("</tr><tr>\n");	153	String dimName = this.dimensions[i].getName();
199		154	if (idx == 3) {
200	//print sample counts	155	if (value>10 && value<20) {
201		156	stream.print("<td bgcolor=\"yellow\" title=\"");
202	result = result.concat("<td>#BUILDS SAMPLED</td>\n");	157	} else if (value>=20) {
203	result = result.concat(htmSummaryRow(SAMPLECOUNT));	158	stream.print("<td bgcolor=\"FF9900\" title=\"");
204		159	} else {
205	//print averages	160	stream.print("<td title=\"");
206	result = result.concat("</tr><tr><td>MEAN</td>\n");	161	}
207	result = result.concat(htmSummaryRow(MEAN));	162	stream.print(dimName);
208		163	stream.print("\">");
209	//print standard deviation	164	stream.print(value);
210	result = result.concat("</tr><tr><td>STD DEV</td>\n");	165	stream.print("%</td>");
211	result = result.concat(htmSummaryRow(STDDEV));	166	} else {
212		167	printDimTitle(dimName);
213	//print coefficient of variation	168	stream.print(this.dimensions[i].getDisplayValue(value));
214	result = result.concat("</tr><tr><td>CV</td>\n");	169	stream.print("</td>");
215	result = result.concat(htmSummaryRow(CV));
216
217	result = result.concat("</tr><tr>\n");
218	for (int i=0;i<dimensions.length+1;i++){
219	result=result.concat("<td> </td>");
220	}
221	result=result.concat("</tr>\n");
222
223	return result;
224	}
225
226	private String htmSummaryRow(String summaryType) {
227	String result="";
228	Hashtable tmp;
229	for (int j=0;j<dimensions.length;j++){
230	String dimensionName=dimensions[j].getName();
231	tmp=(Hashtable)(derivedValues.get(dimensionName));
232	String displayValue=tmp.get(summaryType).toString();
233	if (summaryType.equals(CV)){
234	displayValue=displayValue.substring(0,displayValue.length()-1);
235	double value=Double.valueOf(displayValue).doubleValue();
236	if (value>10&&value<20)
237	result = result.concat("<td bgcolor=\"yellow\" title=\""+dimensionName+"\">"+displayValue+"%</td>");
238	else if (value>=20)
239	result = result.concat("<td bgcolor=\"FF9900\" title=\""+dimensionName+"\">"+displayValue+"%</td>");
240	else
241	result = result.concat("<td title=\""+dimensionName+"\">"+displayValue+"%</td>");
242	} else
243	result= result.concat("<td title=\""+dimensionName+"\">"+displayValue+"</td>");
244	}	170	}
245	return result;
246	}	171	}
		172	}
247		173
248	public String getCV() {	174	/*
249	Hashtable tmp;	175	* Print dim title inside value reference.
250	String dimensionName="Elapsed Process";	176	* TODO (frederic) See if this title is really necessary
251	tmp=(Hashtable)(derivedValues.get(dimensionName));	177	*/
252	if (tmp==null)	178	private void printDimTitle(String dimName) {
253	return "n/a";	179	stream.print("<td title=\"");
254	if (tmp.get(CV)!=null)	180	stream.print(dimName);
255	return tmp.get(CV).toString();	181	stream.print("\">");
256	return "n/a";	182	}
257
258	}
259	}	183	}

Lines 8-50 Link Here

(-)src/org/eclipse/test/internal/performance/data/DimensionMessages.properties (-40 / +84 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	###############################################################################	10	###############################################################################
11	Dimension.2=System Time	11
12	Dimension.3=Used Java Heap	12	# Dimension Name
13	Dimension.4=Working Set	13	dimension.2=System Time
14	Dimension.7=Committed	14	dimension.3=Used Java Heap
15	Dimension.8=Working Set Peak	15	dimension.4=Working Set
16	Dimension.9=Elapsed Process	16	dimension.7=Committed
17	Dimension.10=User time	17	dimension.8=Working Set Peak
18	Dimension.11=Kernel time	18	dimension.9=Elapsed Process
19	Dimension.19=Page Faults	19	dimension.10=User time
20	Dimension.20=CPU Time	20	dimension.11=Kernel time
21	Dimension.22=Commit Limit	21	dimension.19=Page Faults
22	Dimension.23=Commit Peak	22	dimension.20=CPU Time
23	Dimension.24=Physical Memory	23	dimension.22=Commit Limit
24	Dimension.25=Physical Available	24	dimension.23=Commit Peak
25	Dimension.26=System Cache	25	dimension.24=Physical Memory
26	Dimension.27=Kernel Total	26	dimension.25=Physical Available
27	Dimension.28=Kernel Paged	27	dimension.26=System Cache
28	Dimension.29=Kernel Nonpaged	28	dimension.27=Kernel Total
29	Dimension.30=Page Size	29	dimension.28=Kernel Paged
30	Dimension.31=Handle Count	30	dimension.29=Kernel Nonpaged
31	Dimension.32=Process Count	31	dimension.30=Page Size
32	Dimension.33=Thread Count	32	dimension.31=Handle Count
33	Dimension.34=GDI Objects	33	dimension.32=Process Count
34	Dimension.35=USER Objects	34	dimension.33=Thread Count
35	Dimension.36=Open Handles	35	dimension.34=GDI Objects
36	Dimension.37=Commit Total	36	dimension.35=USER Objects
37	Dimension.38=Read Count	37	dimension.36=Open Handles
38	Dimension.39=Write Count	38	dimension.37=Commit Total
39	Dimension.40=Bytes Read	39	dimension.38=Read Count
40	Dimension.41=Bytes Written	40	dimension.39=Write Count
41	Dimension.42=Hard Page Faults	41	dimension.40=Bytes Read
42	Dimension.43=Soft Page Faults	42	dimension.41=Bytes Written
43	Dimension.44=Text Size	43	dimension.42=Hard Page Faults
44	Dimension.45=Data Size	44	dimension.43=Soft Page Faults
45	Dimension.46=Library Size	45	dimension.44=Text Size
46	Dimension.48=Used Memory	46	dimension.45=Data Size
47	Dimension.49=Free Memory	47	dimension.46=Library Size
48	Dimension.50=Buffers Memory	48	dimension.48=Used Memory
49	Dimension.51=Free Java Memory	49	dimension.49=Free Memory
50	Dimension.52=Invocation Count	50	dimension.50=Buffers Memory
		51	dimension.51=Free Java Memory
		52	dimension.52=Invocation Count
		53
		54	# Dimension Description
		55	dimension.description.2=* no longer measured, same as elapsed time, see PerformanceMonitor *
		56	dimension.description.3=Change in the amount of memory allocated for Java objects.
		57	dimension.description.4=Change in the amount of physical memory used by the process (other data resides in swap space).
		58	dimension.description.7=Change in the amount of allocated memory (both, in physical memory and swap space, can be preallocated for future use).
		59	dimension.description.8=Increase of the maximum working set size, useful with start-up tests.
		60	dimension.description.9=Amount of wall-clock time.
		61	dimension.description.10=User time
		62	dimension.description.11=Amount of time the process ran on the CPU, while the CPU was in kernel mode.
		63	dimension.description.19=Number of memory pages that were loaded from swap space on disk or from memory (i.e., in the latter case, they were not mapped in the process' page table, but already present in memory for some reason).
		64	dimension.description.20=Amount of time the process ran on the CPU.
		65	dimension.description.22=Commit Limit
		66	dimension.description.23=Commit Peak
		67	dimension.description.24=Physical Memory
		68	dimension.description.25=Physical Available
		69	dimension.description.26=System Cache
		70	dimension.description.27=Kernel Total
		71	dimension.description.28=Kernel Paged
		72	dimension.description.29=Kernel Nonpaged
		73	dimension.description.30=Page Size
		74	dimension.description.31=Handle Count
		75	dimension.description.32=Process Count
		76	dimension.description.33=Thread Count
		77	dimension.description.34=Change in the number of GDI (Graphics Device Interface) objects, can be useful for UI tests (particularly start-up tests).
		78	dimension.description.35=USER Objects
		79	dimension.description.36=Open Handles
		80	dimension.description.37=Commit Total
		81	dimension.description.38=Read Count
		82	dimension.description.39=Write Count
		83	dimension.description.40=Bytes Read
		84	dimension.description.41=Bytes Written
		85	dimension.description.42=Number of memory pages that were loaded from swap space on disk.
		86	dimension.description.43=Number of memory pages that were loaded from memory (i.e., they were not mapped in the process' page table, but already present in memory for some reason).
		87	dimension.description.44=Change in the process' code memory size, useful with start-up tests.
		88	dimension.description.45=Change in the process' data and stack memory size.
		89	dimension.description.46=Change in the process' library memory size.
		90	dimension.description.48=Used Memory
		91	dimension.description.49=Free Memory
		92	dimension.description.50=Buffers Memory
		93	dimension.description.51=Free Java Memory
		94	dimension.description.52=Invocation Count

Lines 1-64 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-64 / +67 lines)
1	#Wed Apr 19 13:00:25 CEST 2006	1	#Fri Aug 10 17:30:18 CEST 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.builder.cleanOutputFolder=clean	3	org.eclipse.jdt.core.builder.cleanOutputFolder=clean
4	org.eclipse.jdt.core.builder.duplicateResourceTask=warning	4	org.eclipse.jdt.core.builder.duplicateResourceTask=warning
5	org.eclipse.jdt.core.builder.invalidClasspath=abort	5	org.eclipse.jdt.core.builder.invalidClasspath=abort
6	org.eclipse.jdt.core.builder.resourceCopyExclusionFilter=*.launch	6	org.eclipse.jdt.core.builder.resourceCopyExclusionFilter=*.launch
7	org.eclipse.jdt.core.circularClasspath=error	7	org.eclipse.jdt.core.circularClasspath=error
8	org.eclipse.jdt.core.classpath.exclusionPatterns=enabled	8	org.eclipse.jdt.core.classpath.exclusionPatterns=enabled
9	org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled	9	org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled
10	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	10	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
11	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.2	11	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.2
12	org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve	12	org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
13	org.eclipse.jdt.core.compiler.compliance=1.4	13	org.eclipse.jdt.core.compiler.compliance=1.4
14	org.eclipse.jdt.core.compiler.debug.lineNumber=generate	14	org.eclipse.jdt.core.compiler.debug.lineNumber=generate
15	org.eclipse.jdt.core.compiler.debug.localVariable=generate	15	org.eclipse.jdt.core.compiler.debug.localVariable=generate
16	org.eclipse.jdt.core.compiler.debug.sourceFile=generate	16	org.eclipse.jdt.core.compiler.debug.sourceFile=generate
17	org.eclipse.jdt.core.compiler.doc.comment.support=enabled	17	org.eclipse.jdt.core.compiler.doc.comment.support=enabled
18	org.eclipse.jdt.core.compiler.maxProblemPerUnit=100	18	org.eclipse.jdt.core.compiler.maxProblemPerUnit=100
19	org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning	19	org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning
20	org.eclipse.jdt.core.compiler.problem.deprecation=warning	20	org.eclipse.jdt.core.compiler.problem.deprecation=warning
21	org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled	21	org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
22	org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled	22	org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
23	org.eclipse.jdt.core.compiler.problem.emptyStatement=warning	23	org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
24	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	24	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
25	org.eclipse.jdt.core.compiler.problem.fieldHiding=warning	25	org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
26	org.eclipse.jdt.core.compiler.problem.finalParameterBound=ignore	26	org.eclipse.jdt.core.compiler.problem.finalParameterBound=ignore
27	org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning	27	org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
28	org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=error	28	org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=error
29	org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=error	29	org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=error
30	org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning	30	org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning
31	org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning	31	org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
32	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=private	32	org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
33	org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning	33	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
34	org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=error	34	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=disabled
35	org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore	35	org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=private
36	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=enabled	36	org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
37	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public	37	org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=error
38	org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning	38	org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore
39	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=enabled	39	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=enabled
40	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=private	40	org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public
41	org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning	41	org.eclipse.jdt.core.compiler.problem.missingJavadocTags=warning
42	org.eclipse.jdt.core.compiler.problem.noEffectAssignment=error	42	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=enabled
43	org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=error	43	org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=private
44	org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning	44	org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
45	org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=error	45	org.eclipse.jdt.core.compiler.problem.noEffectAssignment=error
46	org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=error	46	org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=error
47	org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled	47	org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=warning
48	org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=error	48	org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=error
49	org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore	49	org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=error
50	org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=warning	50	org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
51	org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning	51	org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=error
52	org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error	52	org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
53	org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore	53	org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=warning
54	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore	54	org.eclipse.jdt.core.compiler.problem.unnecessaryElse=warning
55	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=enabled	55	org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=error
56	org.eclipse.jdt.core.compiler.problem.unusedImport=warning	56	org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
57	org.eclipse.jdt.core.compiler.problem.unusedLocal=warning	57	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
58	org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore	58	org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=enabled
59	org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled	59	org.eclipse.jdt.core.compiler.problem.unusedImport=warning
60	org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled	60	org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
61	org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning	61	org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
62	org.eclipse.jdt.core.compiler.source=1.3	62	org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
63	org.eclipse.jdt.core.incompatibleJDKLevel=ignore	63	org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
64	org.eclipse.jdt.core.incompleteClasspath=error	64	org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
		65	org.eclipse.jdt.core.compiler.source=1.3
		66	org.eclipse.jdt.core.incompatibleJDKLevel=ignore
		67	org.eclipse.jdt.core.incompleteClasspath=error

Lines 25-31 Link Here

(-)src/org/eclipse/test/internal/performance/db/SQL.java (-3 / +3 lines)
25		25
26	private boolean fCompatibility= false;	26	private boolean fCompatibility= false;
27		27
28	private Connection fConnection;	28	protected Connection fConnection;
29		29
30	private PreparedStatement fInsertVariation, fInsertScenario, fInsertSample, fInsertDataPoint, fInsertScalar;	30	private PreparedStatement fInsertVariation, fInsertScenario, fInsertSample, fInsertDataPoint, fInsertScalar;
31	private PreparedStatement fQueryComment, fInsertComment, fQueryComment2;	31	private PreparedStatement fQueryComment, fInsertComment, fQueryComment2;
Lines 35-41 Link Here
35	fQuerySummaryEntries;	35	fQuerySummaryEntries;
36	private PreparedStatement fInsertFailure, fQueryFailure;	36	private PreparedStatement fInsertFailure, fQueryFailure;
37		37
38	SQL(Connection con) throws SQLException {	38	protected SQL(Connection con) throws SQLException {
39	fConnection= con;	39	fConnection= con;
40		40
41	boolean needsUpgrade= true;	41	boolean needsUpgrade= true;
Lines 78-84 Link Here
78	}	78	}
79	}	79	}
80		80
81	public void dispose() throws SQLException {	81	protected void dispose() throws SQLException {
82	if (fInsertVariation != null)	82	if (fInsertVariation != null)
83	fInsertVariation.close();	83	fInsertVariation.close();
84	if (fInsertScenario != null)	84	if (fInsertScenario != null)

Lines 11-22 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
11	org.eclipse.test.internal.performance.data,	11	org.eclipse.test.internal.performance.data,
12	org.eclipse.test.internal.performance.db,	12	org.eclipse.test.internal.performance.db,
13	org.eclipse.test.internal.performance.eval,	13	org.eclipse.test.internal.performance.eval,
		14	org.eclipse.test.internal.performance.results,
14	org.eclipse.test.internal.performance.tests,	15	org.eclipse.test.internal.performance.tests,
15	org.eclipse.test.performance	16	org.eclipse.test.performance
16	Require-Bundle: org.eclipse.core.runtime,	17	Require-Bundle: org.eclipse.core.runtime,
17	org.junit,	18	org.junit,
18	org.apache.derby;resolution:=optional,	19	org.apache.derby;resolution:=optional,
19	org.apache.derby.core;resolution:=optional,
20	Cloudscape;resolution:=optional	20	Cloudscape;resolution:=optional
21	Eclipse-LazyStart: true	21	Eclipse-LazyStart: true
22	Bundle-ClassPath: .	22	Bundle-ClassPath: .

Added Link Here

(-)src/org/eclipse/test/internal/performance/results/PerformanceResults.java (+244 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.test.internal.performance.results;
12
13	import java.util.*;
14
15
16	/**
17	* Root class to handle performance results.
18	*
19	* Usually performance results are built for a current build vs. a baseline build.
20	*
21	* This class allow to read all data from releng performance database for given
22	* configurations and scenario pattern.
23	*
24	* Then it provides easy and speedy access to all stored results.
25	*/
26	public class PerformanceResults extends AbstractResults {
27
28	final String baselineName; // Name of the baseline build used for comparison
29	final String baselinePrefix;
30	private String scenarioPattern;
31	private List components;
32	private String[] configNames, sortedConfigNames;
33	private String[] configBoxes, sortedConfigBoxes;
34
35	public PerformanceResults(String name, String baseline, boolean print) {
36	super(null, name);
37	this.baselineName = baseline;
38	this.baselinePrefix = baseline.substring(0, baseline.lastIndexOf('_'));
39	this.print = print;
40	}
41
42	/**
43	* Returns the name of the baseline used for extracted results
44	*
45	* @return The build name of the baseline of <code>null</code>
46	* if no specific baseline is used for the extracted results.
47	*/
48	public String getBaselineName() {
49	return this.baselineName;
50	}
51
52	String getBaselinePrefix() {
53	return this.baselinePrefix;
54	}
55
56	/**
57	* Return the list of components concerned by performance results.
58	*
59	* @return The list of the components
60	*/
61	public List getComponents() {
62	return components;
63	}
64
65	/**
66	* Get the scenarii of a given component.
67	*
68	* @param componentName The component name. Should not be <code>null</code>
69	* @return A list of {@link ScenarioResults scenario results}
70	*/
71	public List getComponentScenarii(String componentName) {
72	ComponentResults componentResults = (ComponentResults) getResults(componentName);
73	if (componentResults == null) return null;
74	return Collections.unmodifiableList(componentResults.children);
75	}
76
77	/**
78	* Get the scenarii which have a summary for a given component.
79	*
80	* @param componentName The component name
81	* @param config Configuration name
82	* @return A list of {@link ScenarioResults scenario results} which have a summary
83	*/
84	public List getComponentSummaryScenarii(String componentName, String config) {
85	if (componentName == null) {
86	int size = size();
87	List scenarii = new ArrayList();
88	for (int i=0; i< size; i++) {
89	ComponentResults componentResults = (ComponentResults) this.children.get(i);
90	scenarii.addAll(componentResults.getSummaryScenarii(true, config));
91	}
92	return scenarii;
93	}
94	ComponentResults componentResults = (ComponentResults) getResults(componentName);
95	return componentResults.getSummaryScenarii(false, config);
96	}
97
98	/**
99	* Return the configuration boxes considered for this performance results
100	* sorted or not depending on the given flag.
101	*
102	* @param sort Indicates whether the list must be sorted or not.
103	* The order is defined by the configuration names, not by the box names
104	* @return The list of configuration boxes sorted by configuration names
105	*/
106	public String[] getConfigBoxes(boolean sort) {
107	return sort ? this.sortedConfigBoxes : this.configBoxes;
108	}
109
110	/**
111	* Return the configuration names considered for this performance results
112	* sorted or not depending on the given flag.
113	*
114	* @param sort Indicates whether the list must be sorted or not
115	* @return The list of configuration names
116	*/
117	public String[] getConfigNames(boolean sort) {
118	return sort ?this.sortedConfigNames : this.configNames;
119	}
120
121	String getConfigurationsPattern() {
122	int length = this.sortedConfigNames == null ? 0 : this.sortedConfigNames.length;
123	if (length == 0) return null;
124	String configurations = this.sortedConfigNames[0];
125	int refLength = configurations.length();
126	for (int i=1; i<length; i++) {
127	String config = this.sortedConfigNames[i];
128	StringBuffer newConfig = null;
129	if (refLength != config.length()) return null; // strings have not the same length => cannot find a pattern
130	for (int j=0; j<refLength; j++) {
131	char c = configurations.charAt(j);
132	if (config.charAt(j) != c) {
133	if (newConfig == null) {
134	newConfig = new StringBuffer(refLength);
135	if (j == 0) return null; // first char is already different => cannot find a pattern
136	newConfig.append(configurations.substring(0, j));
137	}
138	newConfig.append('_');
139	} else if (newConfig != null) {
140	newConfig.append(c);
141	}
142	}
143	if (newConfig != null) {
144	configurations = newConfig.toString();
145	}
146	}
147	return configurations;
148	}
149
150	PerformanceResults getPerformance() {
151	return this;
152	}
153
154	/**
155	* Get the results of a given scenario.
156	*
157	* @param scenarioName The scenario name
158	* @return The {@link ScenarioResults scenario results}
159	*/
160	public ScenarioResults getScenarioResults(String scenarioName) {
161	ComponentResults componentResults = (ComponentResults) getResults(DB_Results.getComponentNameFromScenario(scenarioName));
162	return componentResults == null ? null : (ScenarioResults) componentResults.getResults(scenarioName);
163	}
164
165	/**
166	* Read all data from performance database for the given configurations
167	* and scenario pattern.
168	*
169	* @param configs All configs to extract results. If <code>null</code>,
170	* then all known configurations ({@link #CONFIGS}) are read.
171	* @param pattern The pattern of the concerned scenarii
172	*/
173	public void read(String[][] configs, String pattern) {
174
175	this.scenarioPattern = pattern;
176
177	// Print title
178	StringBuffer buffer = new StringBuffer("Read performance results until build '"); //$NON-NLS-1$
179	buffer.append(this.name);
180	if (scenarioPattern == null) {
181	buffer.append("':"); //$NON-NLS-1$
182	} else {
183	buffer.append("' using scenario pattern '"); //$NON-NLS-1$
184	buffer.append(scenarioPattern);
185	buffer.append("':"); //$NON-NLS-1$
186	}
187	println(buffer);
188
189	// Store given configs
190	if (configs == null) {
191	int length=CONFIGS.length;
192	this.configNames = new String[length];
193	this.sortedConfigNames = new String[length];
194	this.configBoxes = new String[length];
195	for (int i=0; i<length; i++) {
196	this.configNames[i] = this.sortedConfigNames[i] = CONFIGS[i];
197	this.configBoxes[i] = BOXES[i];
198	}
199	} else {
200	int length = configs.length;
201	this.configNames = new String[length];
202	this.sortedConfigNames = new String[length];
203	this.configBoxes = new String[length];
204	for (int i=0; i<length; i++) {
205	this.configNames[i] = this.sortedConfigNames[i] = configs[i][0];
206	this.configBoxes[i] = configs[i][1];
207	}
208	}
209	Arrays.sort(this.sortedConfigNames);
210	int length = this.sortedConfigNames.length;
211	this.sortedConfigBoxes = new String[length];
212	for (int i=0; i<length; i++) {
213	for (int j=0; j<length; j++) {
214	if (this.sortedConfigNames[i] == this.configNames[j]) { // == is intentional!
215	this.sortedConfigBoxes[i] = this.configBoxes[j];
216	break;
217	}
218	}
219	}
220
221	// Get scenarii from the given pattern
222	print(" + get all scenarii for build: "+this.name); //$NON-NLS-1$
223	long start = System.currentTimeMillis();
224	Map allScenarii = DB_Results.queryAllScenarii(this.scenarioPattern, this.name);
225	println(" -> "+(System.currentTimeMillis()-start)+"ms"); //$NON-NLS-1$ //$NON-NLS-2$
226
227	// Create corresponding children
228	List allComponents = DB_Results.getAllComponents();
229	int size = allComponents.size();
230	this.components = new ArrayList(size);
231	for (int i=0; i<size; i++) {
232	String componentName = (String) allComponents.get(i);
233	List scenarii = (List) allScenarii.get(componentName);
234	if (scenarii == null) continue;
235	this.components.add(componentName);
236	ComponentResults componentResults = new ComponentResults(this, componentName);
237	addChild(componentResults, true);
238	componentResults.read(scenarii);
239	}
240
241	// Print time
242	printGlobalTime(start);
243	}
244	}

Added Link Here

(-)src/org/eclipse/test/internal/performance/results/SQL_Results.java (+202 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.test.internal.performance.results;
12
13	import java.sql.Connection;
14	import java.sql.PreparedStatement;
15	import java.sql.ResultSet;
16	import java.sql.SQLException;
17
18	import org.eclipse.test.internal.performance.InternalDimensions;
19	import org.eclipse.test.internal.performance.db.SQL;
20
21	/**
22	* Specific implementation for massive database requests.
23	*/
24	public class SQL_Results extends SQL {
25
26	private PreparedStatement queryBuildScenarii, queryScenarioFailures, queryScenarioSummaries, queryAllComments, queryScenariiBuilds, queryScenarioDataPoints, queryDimScalars, queryAllVariations;
27
28
29	SQL_Results(Connection con) throws SQLException {
30	super(con);
31	// TODO Auto-generated constructor stub
32	}
33
34	protected void dispose() throws SQLException {
35	super.dispose();
36	if (this.queryBuildScenarii != null)
37	this.queryBuildScenarii.close();
38	if (this.queryScenarioFailures != null)
39	this.queryScenarioFailures.close();
40	if (this.queryScenarioSummaries != null)
41	this.queryScenarioSummaries.close();
42	if (this.queryAllComments != null)
43	this.queryAllComments.close();
44	if (this.queryScenariiBuilds != null)
45	this.queryScenariiBuilds.close();
46	if (this.queryScenarioDataPoints != null)
47	this.queryScenarioDataPoints.close();
48	if (this.queryDimScalars != null)
49	this.queryDimScalars.close();
50	if (this.queryAllVariations != null)
51	this.queryAllVariations.close();
52	}
53
54	/**
55	* Get all comments from database
56	*
57	* @return A set of the query result
58	* @throws SQLException
59	*/
60	ResultSet queryAllComments() throws SQLException {
61	if (this.queryAllComments == null)
62	this.queryAllComments = fConnection.prepareStatement("select ID, KIND, TEXT from COMMENT"); //$NON-NLS-1$
63	return this.queryAllComments.executeQuery();
64	}
65
66	/**
67	* Get all variations from database.
68	*
69	* @param configPattern The pattern for all the concerned configurations
70	* @return A set of the query result
71	* @throws SQLException
72	*/
73	ResultSet queryAllVariations(String configPattern) throws SQLException {
74	long start = System.currentTimeMillis();
75	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print("[SQL query (config pattern="+configPattern); //$NON-NLS-1$
76	if (this.queryAllVariations == null) {
77	this.queryAllVariations = fConnection.prepareStatement("select KEYVALPAIRS from VARIATION where KEYVALPAIRS like ? order by KEYVALPAIRS"); //$NON-NLS-1$
78	}
79	this.queryAllVariations.setString(1, "%"+configPattern+"%"); //$NON-NLS-1$ //$NON-NLS-2$
80	ResultSet resultSet = this.queryAllVariations.executeQuery();
81	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print(")=" + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
82	return resultSet;
83	}
84
85	/**
86	* Query all scenarii corresponding to a given scenario pattern
87	* and for a specific build name.
88	*
89	* @param scenarioPattern The pattern for all the concerned scenarii
90	* @param buildName The name of the concerned build
91	* @return Set of the query result
92	* @throws SQLException
93	*/
94	ResultSet queryBuildScenarii(String scenarioPattern, String buildName) throws SQLException {
95	if (this.queryBuildScenarii == null) {
96	String statement = "select distinct SCENARIO.ID, SCENARIO.NAME , SCENARIO.SHORT_NAME from SCENARIO, SAMPLE, VARIATION where " + //$NON-NLS-1$
97	"SAMPLE.VARIATION_ID = VARIATION.ID and VARIATION.KEYVALPAIRS LIKE ? and " + //$NON-NLS-1$
98	"SAMPLE.SCENARIO_ID = SCENARIO.ID and SCENARIO.NAME LIKE ? " + //$NON-NLS-1$
99	"order by SCENARIO.NAME"; //$NON-NLS-1$
100	this.queryBuildScenarii = fConnection.prepareStatement(statement);
101	}
102	this.queryBuildScenarii.setString(1, "\|build=" + buildName + '%'); //$NON-NLS-1$
103	this.queryBuildScenarii.setString(2, scenarioPattern);
104	return this.queryBuildScenarii.executeQuery();
105	}
106
107	/**
108	* Query all scalars for a given data point.
109	*
110	* @param datapointId The id of the data point
111	* @return Set of the query result
112	* @throws SQLException
113	*/
114	ResultSet queryDimScalars(int datapointId) throws SQLException {
115	if (this.queryDimScalars == null) {
116	this.queryDimScalars = fConnection.prepareStatement("select DIM_ID, VALUE from SCALAR where " + //$NON-NLS-1$
117	"DATAPOINT_ID = ? and " + //$NON-NLS-1$
118	"(DIM_ID = "+InternalDimensions.CPU_TIME.getId()+" or DIM_ID = "+InternalDimensions.ELAPSED_PROCESS.getId()+") " + //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
119	"order by DIM_ID"); //$NON-NLS-1$
120	}
121	this.queryDimScalars.setInt(1, datapointId);
122	return this.queryDimScalars.executeQuery();
123	}
124
125	/**
126	* Get all data points for a given scenario and configuration.
127	*
128	* @param config The name of the concerned configuration
129	* @param scenarioID The id of the scenario
130	* @return A set of the query result
131	* @throws SQLException
132	*/
133	ResultSet queryScenarioDataPoints(String config, int scenarioID) throws SQLException {
134	long start = System.currentTimeMillis();
135	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print("[SQL query (config="+config+", scenario ID="+scenarioID); //$NON-NLS-1$ //$NON-NLS-2$
136	if (this.queryScenarioDataPoints== null) {
137	String statement = "select DATAPOINT.ID, DATAPOINT.STEP, VARIATION.KEYVALPAIRS from VARIATION, SAMPLE, DATAPOINT where " + //$NON-NLS-1$
138	"VARIATION.KEYVALPAIRS like ? and SAMPLE.VARIATION_ID = VARIATION.ID and " + //$NON-NLS-1$
139	"SAMPLE.SCENARIO_ID = ? and " + //$NON-NLS-1$
140	"DATAPOINT.SAMPLE_ID = SAMPLE.ID " + //$NON-NLS-1$
141	"ORDER BY DATAPOINT.ID, DATAPOINT.STEP"; //$NON-NLS-1$
142	this.queryScenarioDataPoints = fConnection.prepareStatement(statement);
143	}
144	this.queryScenarioDataPoints.setString(1, "%"+config+"%"); //$NON-NLS-1$ //$NON-NLS-2$
145	this.queryScenarioDataPoints.setInt(2, scenarioID);
146	ResultSet resultSet = this.queryScenarioDataPoints.executeQuery();
147	if (DB_Results.DEBUG) DB_Results.LOG_WRITER.print(")=" + (System.currentTimeMillis() - start) + "ms]"); //$NON-NLS-1$ //$NON-NLS-2$
148	return resultSet;
149	}
150
151	/**
152	* Query all failures from database for a given scenario,
153	* configuration and builds.
154	*
155	* @param config The name of the concerned configuration
156	* @param scenarioID The id of the scenario
157	* @param currentBuildName The name of the current build
158	* @param baselineBuildName The name of the baseline build
159	* @return A set of the query result
160	* @throws SQLException
161	*/
162	ResultSet queryScenarioFailures(int scenarioID, String config, String currentBuildName, String baselineBuildName) throws SQLException {
163	if (this.queryScenarioFailures == null) {
164	this.queryScenarioFailures = fConnection.prepareStatement("select KEYVALPAIRS, MESSAGE from VARIATION, FAILURE where " + //$NON-NLS-1$
165	"(KEYVALPAIRS like ? or KEYVALPAIRS like ?) and " + //$NON-NLS-1$
166	"VARIATION_ID = VARIATION.ID and " + //$NON-NLS-1$
167	"SCENARIO_ID = ? " + //$NON-NLS-1$
168	"ORDER BY VARIATION_ID"); //$NON-NLS-1$
169	}
170	this.queryScenarioFailures.setString(1, "\|build=" + currentBuildName+ "\|\|config="+ config + "\|\|jvm=sun\|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
171	this.queryScenarioFailures.setString(2, "\|build=" + baselineBuildName+ "\|\|config="+ config + "\|\|jvm=sun\|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
172	this.queryScenarioFailures.setInt(3, scenarioID);
173	return this.queryScenarioFailures.executeQuery();
174	}
175
176	/**
177	* Query all summaries from database for a given scenario,
178	* configuration and builds.
179	*
180	* @param config The name of the concerned configuration
181	* @param scenarioID The id of the scenario
182	* @param currentBuildName The name of the current build
183	* @param baselineBuildName The name of the baseline build
184	* @return Set of the query result
185	* @throws SQLException
186	*/
187	ResultSet queryScenarioSummaries(int scenarioID, String config, String currentBuildName, String baselineBuildName) throws SQLException {
188	if (this.queryScenarioSummaries == null) {
189	this.queryScenarioSummaries= fConnection.prepareStatement("select KEYVALPAIRS, IS_GLOBAL, COMMENT_ID from VARIATION, SUMMARYENTRY where " + //$NON-NLS-1$
190	"(KEYVALPAIRS like ? or KEYVALPAIRS like ?) and " + //$NON-NLS-1$
191	"VARIATION_ID = VARIATION.ID and " + //$NON-NLS-1$
192	"SCENARIO_ID = ? and " + //$NON-NLS-1$
193	"DIM_ID = " + InternalDimensions.ELAPSED_PROCESS.getId() + //$NON-NLS-1$
194	" order by VARIATION_ID"); //$NON-NLS-1$
195	}
196	this.queryScenarioSummaries.setString(1, "\|build=" + currentBuildName+ "\|\|config="+ config + "\|\|jvm=sun\|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
197	this.queryScenarioSummaries.setString(2, "\|build=" + baselineBuildName+ "\|\|config="+ config + "\|\|jvm=sun\|"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
198	this.queryScenarioSummaries.setInt(3, scenarioID);
199	return this.queryScenarioSummaries.executeQuery();
200	}
201
202	}