Benchmarks: comparison between JSS R1 and tabular algorithms (0299a6b7) · Commits · Program Slicing / e-Knife for Erlang with Constrained Edges

e-Knife/src/test/java/eknife/benchmark/AbstractBenchmark.java

+15 −2

Original line number	Diff line number	Diff line
		@@ -110,10 +110,23 @@ public abstract class AbstractBenchmark {
		}
		}

		protected static void printEachSCData(File file, String moduleName, String funName, int iteration, double[] consTime, int cacheHits, double hitRatio) {
		protected static void printEachSCData(File file, String moduleName, String funName, int iteration, double[] time) {
		try (FileWriter fw = new FileWriter(file, true)) {
		// FILE, FunName, #SC, ConstrainedTIME, cacheHits, hitRatio => ROW FORMAT
		for (double v : consTime)
		for (double v : time)
		fw.append(moduleName).append(',').append(funName).append(',')
		.append('#').append(String.valueOf(iteration)).append(',')
		.append(String.valueOf(v)).append("\n");
		} catch (IOException e) {
		System.out.println("FILE NOT FOUND ERROR");
		}
		}


		protected static void printEachSCData(File file, String moduleName, String funName, int iteration, double[] time, int cacheHits, double hitRatio) {
		try (FileWriter fw = new FileWriter(file, true)) {
		// FILE, FunName, #SC, ConstrainedTIME, cacheHits, hitRatio => ROW FORMAT
		for (double v : time)
		fw.append(moduleName).append(',').append(funName).append(',')
		.append('#').append(String.valueOf(iteration)).append(',')
		.append(String.valueOf(v)).append(',')

e-Knife/src/test/java/eknife/benchmark/JSSBenchmark.java

0 → 100644

+159 −0

Original line number	Diff line number	Diff line
		package eknife.benchmark;

		import edg.EDGFactory;
		import edg.constraint.AccessConstraint;
		import edg.graph.EDG;
		import edg.graph.LAST;
		import edg.graph.Node;
		import edg.slicing.AdaptedStandardAlgorithm;
		import edg.slicing.OnePassConstrainedAlgorithm;
		import edg.slicing.SlicingAlgorithm;
		import eknife.EKnife;
		import eknife.LASTFactory;
		import eknife.erlang.ErlangCodeFactory;

		import java.io.File;
		import java.io.FileWriter;
		import java.io.IOException;
		import java.util.HashMap;
		import java.util.List;
		import java.util.Map;
		import java.util.Set;

		public class JSSBenchmark extends AbstractBenchmark {

		public static void main(String[] args) {
		new JSSBenchmark(System.getProperty("bench.setName", "bencher"))
		.benchmarkAll(new File(System.getProperty("bench.baseDir", "e-Knife/src/test/resources/bencher-no-lambdas")));
		}

		protected static final int STANDARD = 1, CONSTRAINED = 2;

		protected int algorithm;

		public JSSBenchmark(String setName) {
		super(setName);
		}

		@Override
		public void benchmarkProgram(File programFile) {
		String filePath = programFile.getAbsolutePath();
		String moduleName = fileNameRemoveExtension(programFile.getName());

		// Prepare directories
		if (countAccessConstraints)
		new File(outputSizeFolder + setName + "/").mkdirs();
		if (measureGenerationTime)
		new File(outputTimeFolder).mkdirs();

		// Access constraint counting (graph)
		if (countAccessConstraints) {
		long accessConstraints = buildEDG(filePath).edgeSet().stream()
		.filter(e -> e.getConstraint() instanceof AccessConstraint)
		.count();
		try (FileWriter out = new FileWriter(outputSizeFolder + setName + "/accessConstraints.txt", true)) {
		out.write(String.format("%s;%d\n", moduleName, accessConstraints));
		} catch (IOException e) {
		throw new RuntimeException(e);
		}
		}

		if (measureGenerationTime)
		measureGenerationTime(programFile, moduleName);

		EDG edg = buildEDG(filePath);

		Map<Node, List<Node>> clause2resNodes = new HashMap<>();
		Map<Node, String> clause2name = new HashMap<>();
		populateClauseMaps(edg, clause2resNodes, clause2name);

		algorithm = STANDARD;
		measureSlicing(moduleName, edg, clause2resNodes, clause2name, "standard");
		algorithm = CONSTRAINED;
		measureSlicing(moduleName, edg, clause2resNodes, clause2name, "constrained");
		}

		protected SlicingAlgorithm createAlgorithm(EDG edg) {
		switch (algorithm) {
		case STANDARD: return new AdaptedStandardAlgorithm(edg);
		case CONSTRAINED: return new OnePassConstrainedAlgorithm(edg);
		default: throw new IllegalStateException();
		}
		}

		protected void measureGenerationTime(File programFile, String moduleName) {
		double[] StructuralTime = new double[numberOfIterationsGen];
		double[] CFGTime = new double[numberOfIterationsGen];
		double[] ValueTime = new double[numberOfIterationsGen];
		double[] CompositeTime = new double[numberOfIterationsGen];
		double[] ControlTime = new double[numberOfIterationsGen];
		double[] FlowTime = new double[numberOfIterationsGen];
		double[] IPTime = new double[numberOfIterationsGen];

		double[] standardTime = new double[numberOfIterationsGen];
		double[] constrainedTime = new double[numberOfIterationsGen];

		for (int i = -1; i < numberOfIterationsGen; i++) {
		LAST last = LASTFactory.createLAST(EKnife.Language.Erlang, programFile.getAbsolutePath(), true);
		EDG edg = new EDGFactory(last).createEDG();

		if (i == -1)
		continue;

		StructuralTime[i] = edg.getGenerationTime().getStructureTime();
		CFGTime[i] = edg.getGenerationTime().getControlFlowTime();
		ValueTime[i] = edg.getGenerationTime().getValueTime();
		CompositeTime[i] = edg.getGenerationTime().getCompositeTime();
		ControlTime[i] = edg.getGenerationTime().getControlTime();
		FlowTime[i] = edg.getGenerationTime().getFlowTime();
		IPTime[i] = edg.getGenerationTime().getInterproceduralTime();

		standardTime[i] = StructuralTime[i] + CFGTime[i] + ValueTime[i] - CompositeTime[i]
		+ ControlTime[i] + FlowTime[i] + IPTime[i];
		constrainedTime[i] = StructuralTime[i] + CFGTime[i] + ValueTime[i]
		+ ControlTime[i] + FlowTime[i] + IPTime[i];
		}

		// Print RESULTS:
		try (FileWriter f1 = new FileWriter(getGraphGenerationTimeFile("PDG"), true);
		FileWriter f2 = new FileWriter(getGraphGenerationTimeFile("CE-PDG"), true)) {
		for (int i = 0; i < numberOfIterationsGen; i++) {
		f1.append(moduleName).append(",").append(String.valueOf(standardTime[i])).append("\n");
		f2.append(moduleName).append(",").append(String.valueOf(constrainedTime[i])).append("\n");
		}
		} catch (IOException e) {
		e.printStackTrace();
		}
		}

		protected void measureSlicing(String moduleName, EDG edg, Map<Node, List<Node>> clause2resNodes, Map<Node, String> clause2name, String benchName) {
		String bench = setName + "_" + benchName;
		getSliceTimeFolder(bench).mkdirs();
		for (Node clause : clause2resNodes.keySet()) {
		for (Node SC : clause2resNodes.get(clause)) {
		if (printSlices) {
		File outFile = getSliceCodeFile(moduleName, benchName, SC.getId());
		outFile.getParentFile().mkdirs();
		edg.clearState();
		Set<Node> slice = createAlgorithm(edg).slice(SC);
		ErlangCodeFactory.createErlangFile(outFile, edg, slice);
		}

		if (measureSlicingTime) {
		double[] times = new double[numberOfIterationsSlice];
		for (int j = -1; j < numberOfIterationsSlice; j++) {
		edg.clearState();
		long initialTime = System.nanoTime();
		createAlgorithm(edg).slice(SC);
		long finalTime = System.nanoTime();
		if (j == -1)
		continue;
		times[j] = (finalTime - initialTime) / 1000.0;
		}

		printEachSCData(getSliceTimeFile(bench, moduleName), moduleName, clause2name.get(clause), SC.getId(), times);
		}
		}
		}
		}
		}

e-Knife/src/test/java/eknife/benchmark/TabularBenchmark.java

0 → 100644

+36 −0

Original line number	Diff line number	Diff line
		package eknife.benchmark;

		import edg.graph.EDG;
		import edg.slicing.ConstrainedTabularAlgorithm;
		import edg.slicing.SlicingAlgorithm;
		import edg.slicing.TabularAlgorithm;

		import java.io.File;

		public class TabularBenchmark extends JSSBenchmark {
		public static void main(String[] args) {
		new TabularBenchmark(System.getProperty("bench.setName", "bencher"))
		.benchmarkAll(new File(System.getProperty("bench.baseDir", "e-Knife/src/test/resources/bencher-no-lambdas")));
		}

		public TabularBenchmark(String setName) {
		super(setName);
		}

		@Override
		public void benchmarkProgram(File programFile) {
		String setName = this.setName;
		this.setName += "_tabular";
		super.benchmarkProgram(programFile);
		this.setName = setName;
		}

		@Override
		protected SlicingAlgorithm createAlgorithm(EDG edg) {
		switch (algorithm) {
		case STANDARD: return new TabularAlgorithm(edg);
		case CONSTRAINED: return new ConstrainedTabularAlgorithm(edg);
		default: throw new IllegalStateException();
		}
		}
		}