/**
    * 
    */
   package pt.digitalis.sampleApp.iss;
   
   import java.io.File;
   import java.util.Properties;
   
   import pt.digitalis.iss.ISS;
  import pt.digitalis.iss.ISSManager;
  import pt.digitalis.iss.ProcessResults;
  import pt.digitalis.log.ILogWrapper;
  import pt.digitalis.log.LogLevel;
  import pt.digitalis.log.LogWrapperLog4JImpl;
  import pt.digitalis.sampleApp.util.Utilities;
  import pt.digitalis.sampleApp.util.stats.Series;
  import pt.digitalis.sampleApp.util.stats.StatsGenerator;
  
  /**
   * @author Pedro Viegas <a
   *         href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a>
   * @created Aug 5, 2007
   * 
   */
  public class ISSPerformanceTester {
  
  	/** The log level that all tests will use */
  	final static LogLevel TEST_LOG_LEVEL = LogLevel.INFO;
  
  	/** the Logger for test output */
  	static private ILogWrapper logger = new LogWrapperLog4JImpl(
  			"Performance tester");
  
  	/** Cooldown factor. Number of seconds to pause between tests */
  	static private int cooldown_factor = 3;
  
  	/** Number of processes to launch */
  	static private int total_processes = 600;
  
  	/** Interactions for first process and minimal value */
  	static private int iteractions_start = 1000;
  
  	/** Max interactions for all process */
  	static private int max_iteractions = 10000;
  
  	/** Interactions increment for each new process */
  	static private int iteractions_increment = 100;
  
  	/** Array that will keep all the generated Processes */
  	static private BaseWriterProcess[] processes;
  
  	/** Array that will keep all the generated process threads */
  	static private myProcessCaller[] myProcessCallers;
  
  	/** Test types to run... */
  	private enum TestType {
  		/** ISS Managed execution */
  		ISS_MANAGED,
  		/** Sequential process execution */
  		SEQUENTIAL,
  		/** Threaded process execution - Parallel */
  		THREADED
  	}
  
  	/**
  	 * Initialize all necessary objects for the test
  	 * 
  	 * @param description
  	 *            The description for this test
  	 * @param processClazz
  	 *            the class to instantiate
  	 * 
  	 * @return a ISS for process execution
  	 * 
  	 * @throws IllegalAccessException
  	 *             when the processClazz is not a BaseWriterProcess class
  	 * @throws InstantiationException
  	 *             when the processClazz is not a BaseWriterProcess class
  	 */
  	static private ISS init(String description, Class<?> processClazz)
  			throws InstantiationException, IllegalAccessException {
  
  		BaseWriterProcess process;
  		long start;
  		long elapsedTime;
  		ProcessResults results;
  
  		logger.info("");
  		logger.info("Starting " + description + "...");
  		logger
  				.info("----------------------------------------------------------------------------");
  		logger.info("");
  		logger.debug(Utilities.logMemoryMessage());
  
  		if (cooldown_factor > 0) {
  			try {
  
  				logger.info("Waiting " + cooldown_factor
  						+ " seconds to cool down running processes...");
 				Thread.sleep(cooldown_factor * 1000);
 			} catch (InterruptedException e) {
 				logger.warn(e);
 			}
 		}
 
 		ISSManager.setLogger(logger);
 
 		/*
 		 * A tunned configuration for the intended load
 		 */
 		Properties tunnedConfig = new Properties();
 		// Populate them
 		tunnedConfig.setProperty("PerformanceTester.stats.numberOfGroups", "4");
 		tunnedConfig.setProperty("PerformanceTester.stats.elementsPerGroup",
 				"10");
 		tunnedConfig.setProperty(
 				"PerformanceTester.iss.asynchronicityThreshold", "5");
 		tunnedConfig.setProperty("PerformanceTester.iss.minimumThreshold", "1");
 		tunnedConfig.setProperty("PerformanceTester.iss.maximumThreshold", "5");
 		tunnedConfig.setProperty("PerformanceTester.iss.maximumActiveWorkers",
 				"5");
 		tunnedConfig.setProperty("PerformanceTester.iss.minimumExecutionTime",
 				"85");
 		tunnedConfig.setProperty("PerformanceTester.iss.maximumExecutionTime",
 				"200");
 
 		ISS testISS = ISSManager.getISS("PerformanceTester", tunnedConfig);
 		testISS.setStatisticsDumpEnabled(false);
 
 		logger.debug("Got the ISS instance");
 
 		// Testing the minimal interactions process execution without any load
 		process = (BaseWriterProcess) processClazz.newInstance();
 		process.init(iteractions_start, 9999);
 
 		start = System.currentTimeMillis();
 		results = process.execute();
 		elapsedTime = System.currentTimeMillis() - start;
 
 		logger.debug("Minimal interactions process ["
 				+ results.getResult("lines") + "]: " + elapsedTime + "ms");
 
 		// Testing the maximal interactions process execution without any load
 		process = (BaseWriterProcess) processClazz.newInstance();
 		process.init(max_iteractions, 9999);
 
 		start = System.currentTimeMillis();
 		results = process.execute();
 		elapsedTime = System.currentTimeMillis() - start;
 
 		logger.debug("Maximal interactions process ["
 				+ results.getResult("lines") + "]: " + elapsedTime + "ms");
 
 		return testISS;
 	}
 
 	/**
 	 * Cleanup method for the test
 	 * 
 	 * @param processClazz
 	 *            the class to instantiate
 	 */
 	static private void end(Class<?> processClazz) {
 
 		logger.info("");
 		logger.debug(Utilities.logMemoryMessage() + " - Cleaning up....");
 
 		processes = null;
 		myProcessCallers = null;
 
 		Runtime.getRuntime().gc();
 		logger.debug(Utilities.logMemoryMessage()
 				+ " - After Garbage Collector....");
 
 		if (processClazz == WriterProcessFileImpl.class) {
 			logger.debug("Deleting the created output files from disk...");
 
 			File dir = new File(".");
 			String patt = "ProcessOutputFile";
 
 			String[] files = dir.list();
 
 			for (String fileName : files) {
 
 				File n = new File(fileName);
 
 				if (n.isFile() && fileName.indexOf(patt) != -1) {
 					// Is a file and one of the output files we've created
 
 					if (n.delete())
 						logger.debug(n.getPath() + " deleted...");
 					else
 						logger.error("Couldn't delete " + n.getPath() + "!");
 				}
 			}
 		}
 
 		logger.debug("Test ended.");
 	}
 
 	/**
 	 * Executes all processes
 	 * 
 	 * @param incrementLoad
 	 *            true increments load on each new execution
 	 * @param testType
 	 *            the type of test to run
 	 * @param processClazz
 	 *            the class to instantiate
 	 * 
 	 * @return the execution times in a Series object
 	 * 
 	 * @throws IllegalAccessException
 	 *             when the processClazz is not a BaseWriterProcess class
 	 * @throws InstantiationException
 	 *             when the processClazz is not a BaseWriterProcess class
 	 */
 	static public Series ExecuteProcesses(boolean incrementLoad,
 			TestType testType, Class<?> processClazz)
 			throws InstantiationException, IllegalAccessException {
 
 		long start;
 		double elapsedTime;
 		String testTitle;
 		ISS theISS;
 		long[] executionTimes = new long[total_processes];
 
 		processes = null;
 		myProcessCallers = null;
 
 		if (testType == TestType.ISS_MANAGED)
 			testTitle = "ISS Managed: ";
 		else if (testType == TestType.THREADED)
 			testTitle = "Threaded: ";
 		else
 			testTitle = "Sequential: ";
 
 		testTitle += (incrementLoad ? "IncrementingLoad" : "EqualLoad")
 				+ " test - " + processClazz.getSimpleName();
 
 		theISS = init(testTitle, processClazz);
 
 		// Initialize process/thread arrays
 		if (testType == TestType.SEQUENTIAL)
 			processes = new BaseWriterProcess[total_processes];
 		else
 			myProcessCallers = new myProcessCaller[total_processes];
 
 		// Discart the ISS manager if not needed
 		if (testType != TestType.ISS_MANAGED)
 			theISS = null;
 
 		logger.info("Starting executing processes...");
 
 		// Init processes
 
 		int currentInteractions = iteractions_start;
 		long totalLines = 0;
 		int totalErrors = 0;
 
 		BaseWriterProcess process;
 		ProcessResults results;
 
 		start = System.currentTimeMillis();
 
 		try {
 			for (int i = 0; i < total_processes; ++i) {
 
 				// Init the execution time with a error execution value. If the
 				// process never executes the initial 0s would be interpreted
 				// with an instantaneous execution.
 				executionTimes[i] = -1;
 
 				if (incrementLoad && (currentInteractions < max_iteractions))
 					currentInteractions += iteractions_increment;
 
 				process = (BaseWriterProcess) processClazz.newInstance();
 				process.init(currentInteractions, i);
 
 				if (testType == TestType.SEQUENTIAL) {
 
 					// In sequential mode execute directly the operation
 
 					processes[i] = process;
 					results = processes[i].execute();
 
 					executionTimes[i] = process.getEndTime() - start;
 
 					totalLines += (Long) results.getResult("lines");
 
 					if ((i > 0) && (i % 50 == 0))
 						logger.info(Utilities.logMemoryMessage() + " - " + i
 								+ " processes in "
 								+ ((System.currentTimeMillis() - start) / 1000)
 								+ "s");
 
 					processes[i] = null;
 
 				} else {
 
 					// In threaded or ISS managed mode delegate to a new Thread
 					// the
 					// execution
 
 					myProcessCallers[i] = new myProcessCaller(process, theISS,
 							String.valueOf(i));
 					myProcessCallers[i].start();
 				}
 			}
 
 			// In non sequential mode we have to monitor the process now!
 			if (testType != TestType.SEQUENTIAL) {
 				elapsedTime = System.currentTimeMillis() - start;
 
 				logger.info(Utilities.logMemoryMessage()
 						+ " - Processes launched in... " + elapsedTime / 1000
 						+ "s");
 
 				// Monitoring processes and discarting executed ones
 				for (int i = 0; i < total_processes; ++i) {
 
 					try {
 						myProcessCallers[i].join();
 
 						if (myProcessCallers[i].getResults() != null) {
 
 							process = (BaseWriterProcess) myProcessCallers[i]
 									.getTheProcess();
 
 							executionTimes[i] = process.getEndTime() - start;
 
 							process = null;
 
 							totalLines += (Long) myProcessCallers[i]
 									.getResults().getResult("lines");
 
 						} else
 							totalErrors++;
 
 					} catch (InterruptedException e) {
 						logger.error(e);
 					}
 
 					if ((i > 0) && (i % 50 == 0)) {
 						logger.info(Utilities.logMemoryMessage() + " - " + i
 								+ " processes in "
 								+ ((System.currentTimeMillis() - start) / 1000)
 								+ "s");
 					}
 
 					myProcessCallers[i] = null;
 				}
 			}
 
 			logger.info(Utilities.logMemoryMessage() + " - Executed "
 					+ total_processes + " processes in "
 					+ ((System.currentTimeMillis() - start) / 1000)
 					+ " seconds");
 
 			elapsedTime = System.currentTimeMillis() - start;
 
 			logger.debug("Wrote " + totalLines + " lines in " + elapsedTime
 					/ 1000 + "s");
 
 			if (totalErrors > 0)
 				logger.debug("(with " + totalErrors
 						+ " failed process executions!)");
 		} catch (OutOfMemoryError e) {
 			logger
 					.error("Current test case has failed with out of memory. Cleaning up and exiting.");
 
 		} finally {
 			end(processClazz);
 		}
 
 		return new Series(testTitle, executionTimes);
 
 	}
 
 	/**
 	 * Performs the performance tests
 	 * 
 	 * @param args
 	 *            pass ["quick"] for a quick run
 	 * @throws InstantiationException
 	 * @throws IllegalAccessException
 	 */
 	static public void main(String[] args) throws InstantiationException,
 			IllegalAccessException {
 
 		// Quick mode, used for the JUnit call
 		if (args != null && args.length > 0 && "quick".equals(args[0])) {
 			cooldown_factor = 0;
 			total_processes = 100;
 			max_iteractions = 1000;
 			iteractions_start = 10;
 			iteractions_increment = 10;
 		}
 		
 		long [] nullArray = new long[1];
 		nullArray[0] = 0;
 
 		Class<?> testerClass = WriterProcessFileImpl.class;
 
 		logger.setLevel(TEST_LOG_LEVEL);
 
 		// Equal load section
 		StatsGenerator stats = new StatsGenerator(logger);
 
 		stats
 				.addSerie(ExecuteProcesses(false, TestType.SEQUENTIAL,
 						testerClass));
 		stats.addSerie(ExecuteProcesses(false, TestType.ISS_MANAGED,
 				testerClass));
 		stats.addSerie(ExecuteProcesses(false, TestType.THREADED, testerClass));
 
 		stats.printAsciiChart();
 		stats.buildChartData(100);
 		stats.exportToExcel("iss_equalLoad.xls");
 		stats.createChartAsPNG("iss_equalLoad.png");
 
 		// Incremental load section
 		StatsGenerator statsWithISS = new StatsGenerator(logger);
 		Series serie;
 
 		stats = new StatsGenerator(logger);
 
 		serie = ExecuteProcesses(true, TestType.SEQUENTIAL, testerClass);
 		stats.addSerie(serie);
 		statsWithISS.addSerie(serie);
 
 		serie = ExecuteProcesses(true, TestType.ISS_MANAGED, testerClass);
 		stats.addSerie(serie.getName(), nullArray);
 		statsWithISS.addSerie(serie);
 
 		serie = ExecuteProcesses(true, TestType.THREADED, testerClass);
 		stats.addSerie(serie);
 		statsWithISS.addSerie(serie);
 
 		statsWithISS.printAsciiChart();
 		stats.buildChartData(100);
 		stats.exportToExcel("iss_incrementalLoad.xls");
 		stats.createChartAsPNG("iss_incrementalLoadWithoutISS.png");
 
 		statsWithISS.buildChartData(100);
 		statsWithISS.createChartAsPNG("iss_incrementalLoadWithISS.png");
 	}
 }