SPLat.java

package Starter;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.LinkedList;

import explosion.ExplosionSPLat;
import inc.IncSPLat;
import nesting.NestSPLat;
import nointeraction.NoSPLat;
import prefix.PrefixSPLat;
import reference.RefSPLat;
/**
 * 
 * Original implementation by 
 * Kim et al. SPLat: Lightweight dynamic analysis for reducing combinatorics in testing configurable systems
 * 
 * @author Jens Meinicke
 *
 */
public class SPLat {

	private static long maxUsedMemory = 0;

	private final static int rounds = 3;

	public static void main(String[] args) {
		ISPLatEvaluation[] testClasses = new ISPLatEvaluation[]{
				new NoSPLat(),
//				new PrefixSPLat(), 
				new RefSPLat(), 
				new IncSPLat(), 
				new NestSPLat(),
//				new ExplosionSPLat()
				};
		for (ISPLatEvaluation testClass : testClasses) {
			System.out.println("Start " + testClass.getClass().getName());
			boolean timedOut = false;
			int maxComplexity = 100;
			if (testClass.getClass() == PrefixSPLat.class) {
				maxComplexity = 10;
			}
			for (int max = 0; max <= maxComplexity; max++) {
				if (timedOut) {
					break;
				}
				for (int i = 0; i < rounds ; i++) {
					long start = System.currentTimeMillis();
					int runs = runSPLat(testClass, max);
					long end = System.currentTimeMillis();
					long time = (end - start);
					System.out.println(" finished after " + runs + " configurations after " + time + "ms " + (maxUsedMemory >> 10) + "MB");
					createOutput(time);
					missingConfigurations.clear();
					Runtime.getRuntime().gc();
					if (time > 120_000) {
						timedOut = true;
						break;
					}
				}
			}
			File resultsFile = new File("SPLat.csv");
			resultsFile.renameTo(new File("SPLat-" + testClass.getClass().getSimpleName() + ".csv"));
		}
	}
	
//	static int maxConfs = 0;
	
	private static int runSPLat(ISPLatEvaluation testClass, int max) {
//		maxConfs = 0;
		System.out.print("#feature " + max);
		nrFeatures = max;
		if (testClass.getClass() == PrefixSPLat.class) {
			nrFeatures = 10;
		}
		int runs = 0;
		maxUsedMemory = 0;
		missingConfigurations.add(new Configuration());
		while (!missingConfigurations.isEmpty()) {
			// include for memory usage
//			if (maxConfs < missingConfigurations.size()) {
//				maxConfs = missingConfigurations.size();
//				System.out.println(maxConfs);
//				Runtime rt = Runtime.getRuntime();
//				Runtime.getRuntime().gc();
//				final long m = rt.totalMemory() - rt.freeMemory();
//				if (m > maxUsedMemory) {
//					maxUsedMemory  = m;
//				}
//			}
//			currentConfiguration = missingConfigurations.remove(0);
			currentConfiguration = missingConfigurations.removeLast();
			testClass.run(max);runs++;
		}
		return runs;
	}
	
	private static void createOutput(long time) {
		File results = new File("SPLat.csv");
		System.out.println("write results to " + results + " " + time);
		try (PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(results, true)))) {
			out.print(time);
			out.print(';');
			out.print(maxUsedMemory >> 20);// MB
			out.println();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	
	static int nrFeatures = 0;
	
	static LinkedList<Configuration> missingConfigurations = new LinkedList<>();
	
	static Configuration currentConfiguration = new Configuration();
	
	public static boolean get(int i) {
		byte selection = currentConfiguration.get(i);
		if (selection == 0) {
			currentConfiguration.set(i, (byte) 1);
			Configuration newConfig = currentConfiguration.copy();
			
			newConfig.set(i, (byte)-1);
			missingConfigurations.add(newConfig);
		}
		
		return currentConfiguration.get(i) == 1;
	}

}
class Configuration {
	byte[] selection = new byte[SPLat.nrFeatures];
	byte get(int i) {
		return selection[i];
	}
	void set(int i, byte j) {
		selection[i] = j;
	}
	
	Configuration copy() {
		Configuration c = new Configuration();
		for (int k = 0; k < selection.length; k++) {
			if (selection[k] != 0) {
				c.selection[k] = selection[k];
			}
		}
		return c;
	}
	
	@Override
	public int hashCode() {
		int hash = 0;
		for (int j = 0; j < selection.length; j++) {
			if (selection[j] != 0 && selection[j] == 1) {
				hash += Math.pow(2, j);
			}
		}
		return hash;
	}
	@Override
	public boolean equals(Object obj) {
		Configuration other = (Configuration) obj;
		return Arrays.equals(selection, other.selection);
	}
	
	@Override
	public String toString() {
		return Arrays.toString(selection);
	}
	
}