diff --git a/IncrementalMinimization/results/dependency_heatmap.png b/IncrementalMinimization/results/dependency_heatmap.png new file mode 100644 index 00000000..03495b3f Binary files /dev/null and b/IncrementalMinimization/results/dependency_heatmap.png differ diff --git a/IncrementalMinimization/results/graph_dependency_check.png b/IncrementalMinimization/results/graph_dependency_check.png index 0eb3474c..7fb9d271 100644 Binary files a/IncrementalMinimization/results/graph_dependency_check.png and b/IncrementalMinimization/results/graph_dependency_check.png differ diff --git a/IncrementalMinimization/results/heatmap.png b/IncrementalMinimization/results/heatmap.png deleted file mode 100644 index 3ccfb90e..00000000 Binary files a/IncrementalMinimization/results/heatmap.png and /dev/null differ diff --git a/IncrementalMinimization/results/standard_heatmap.png b/IncrementalMinimization/results/standard_heatmap.png new file mode 100644 index 00000000..c6328fd6 Binary files /dev/null and b/IncrementalMinimization/results/standard_heatmap.png differ diff --git a/IncrementalMinimization/scripts/budget_graph.py b/IncrementalMinimization/scripts/budget_graph.py index 9f146f96..671d11c3 100644 --- a/IncrementalMinimization/scripts/budget_graph.py +++ b/IncrementalMinimization/scripts/budget_graph.py @@ -11,8 +11,9 @@ xIndex = int(sys.argv[2]) percent1_index = int(sys.argv[3]) percent2_index = int(sys.argv[4]) -increment = int(sys.argv[5]) -cutoff = int(sys.argv[6]) +#percent3_index = int(sys.argv[5]) #TODO: generalize to arbitrary number of indices +increment = int(sys.argv[6]) +cutoff = int(sys.argv[7]) def toNum(s): if s.isdigit(): @@ -34,6 +35,7 @@ def get_tick_from_point(point): tick_map = {} p1_data = [] p2_data = [] + p3_data = [] for i in range(0, cutoff, increment): tick_start = i tick_end = (i + increment) - 1 @@ -46,6 +48,7 @@ def get_tick_from_point(point): break p1 = data[row][percent1_index] p2 = data[row][percent2_index] + #p3 = data[row][percent3_index] tick = ticks[cur_index] actual_tick = get_tick_from_point(x) while(tick != actual_tick): @@ -57,18 +60,15 @@ def get_tick_from_point(point): count = 1 p1_data.append(p1) p2_data.append(p2) + #p3_data.append(p3) else: count += 1 p1_data[cur_index] += (p1 - p1_data[cur_index])/float(count) p2_data[cur_index] += (p2 - p2_data[cur_index])/float(count) - print(ticks) - print(len(ticks)) - print(len(p1_data)) - for i in range(0,len(ticks)): - print "{} : {} : {}".format(ticks[i], str(p1_data[i]), str(p2_data[i])) + #p3_data[cur_index] += (p3 - p3_data[cur_index])/float(count) assert(len(ticks) == len(p1_data)) assert(len(p1_data) == len(p2_data)) - return ticks, p1_data, p2_data + return ticks, p1_data, p2_data, p3_data with open(testsfile, "r") as f: fStrings = f.read().split('\n') @@ -77,14 +77,16 @@ def get_tick_from_point(point): fData = [[toNum(datum) for datum in row.split(',') if datum] for row in fStrings[1:] if row] -ticks, p1_data, p2_data = generate_data(fData, increment, cutoff) +ticks, p1_data, p2_data, p3_data = generate_data(fData, increment, cutoff) p1_data = [p1*100 for p1 in p1_data] p2_data = [p2*100 for p2 in p2_data] +#p3_data = [p3*100 for p3 in p3_data] fig, ax = pyplot.subplots(1,1) percent_format = mtick.FormatStrFormatter("%.0f%%") -ax.bar([a - 0.15 for a in range(0,len(p1_data))], p1_data, width=0.30, label="Symbolic Incremental") -ax.bar([b + 0.15 for b in range(0,len(p2_data))], p2_data, width=0.30, label="'Naive' Incremental") +ax.bar([a - 0.15 for a in range(0,len(p1_data))], p1_data, width=0.20, label="Symbolic Incremental") +ax.bar([b + 0.15 for b in range(0,len(p2_data))], p2_data, width=0.20, label="'Naive' Incremental") +#ax.bar([c + 0.20 for c in range(0,len(p3_data))], p3_data, width=0.20, label ="Incremental with Dependency Check") pyplot.xticks(range(0, len(ticks)), ticks, fontsize=6) ax.yaxis.set_major_formatter(percent_format) pyplot.xlabel(xAxis) diff --git a/IncrementalMinimization/scripts/generate_graph.py b/IncrementalMinimization/scripts/generate_graph.py index 9f43e9d1..3d033a6c 100644 --- a/IncrementalMinimization/scripts/generate_graph.py +++ b/IncrementalMinimization/scripts/generate_graph.py @@ -4,6 +4,7 @@ xAxis = "Number of States" yAxis = "Average Minimization Time (ms)" title = "Comparison of SFA Minimization Algorithms" +scale = "log" testsfile = sys.argv[1] xIndex = int(sys.argv[2]) @@ -52,7 +53,7 @@ def mergeData(data, index): for i in graph_indices: graphData = [row[i] for row in fData[:len(xData)]] pyplot.plot(xData, graphData, label=title_row[i], linewidth=1.0) -pyplot.yscale("log") +pyplot.yscale(scale) pyplot.legend(loc=0) pyplot.xlabel(xAxis) pyplot.ylabel(yAxis) diff --git a/IncrementalMinimization/src/minimization/incremental/IncrWithDependencyChecks.java b/IncrementalMinimization/src/minimization/incremental/IncrWithDependencyChecks.java index 6d26e899..f6a8e87b 100644 --- a/IncrementalMinimization/src/minimization/incremental/IncrWithDependencyChecks.java +++ b/IncrementalMinimization/src/minimization/incremental/IncrWithDependencyChecks.java @@ -140,61 +140,6 @@ public void addDependency(List pair, List dependency) } assert(depEntry != null); pairEntry.addDependency(depEntry); - - - /* - //System.out.println(""); - //System.out.println(String.format("Adding %s to %s", dependency.toString(), pair.toString())); - if(dependencies.containsKey(dependency) && !pair.equals(dependency)) - { - //System.out.println("Already seen dependency"); - //Dependency is transitive. So, we flatten the dependency list as much as possible before adding. - /*ArrayList> flatDependencyList = new ArrayList>(); - Queue> nestedDepQueue = new LinkedList>(); - nestedDepQueue.addAll(dependencies.get(dependency)); - //System.out.println(String.format("Deps of dep: %s", nestedDepQueue.toString())); - HashSet> debugTest = new HashSet>(); //TODO: remove. using to check that no infinite loops exist. - while(!nestedDepQueue.isEmpty()) - { - //System.out.println(nestedDepQueue); - System.out.println(String.format("ndq: %d / %d", debugTest.size(), num_pairs)); - List dep = nestedDepQueue.remove(); - if(debugTest.contains(dep)) - { - continue; - } - else if(dependencies.containsKey(dep)) - { - nestedDepQueue.addAll(dependencies.get(dep)); - } - else - { - flatDependencyList.add(dep); - } - debugTest.add(dep); - } - ArrayList> flatDependencyList = dependencies.get(dependency); - if(!dependencies.containsKey(pair)) - { - dependencies.put(pair, new ArrayList>()); - } - dependencies.get(pair).addAll(flatDependencyList); - } - else - { - if(!dependencies.containsKey(pair)) - { - dependencies.put(pair, new ArrayList>()); - } - dependencies.get(pair).add(dependency); - } - System.out.println(dependency); - assert(dependencies.containsKey(dependency)); - if(!dependencies.containsKey(pair)) - { - dependencies.put(pair, new ArrayList>()); - } - dependencies.get(pair).add(dependency); */ } public void addAllDependencies(List pair, ArrayList> dpairs) @@ -205,7 +150,7 @@ public void addAllDependencies(List pair, ArrayList> dpai } } - private void mergePair(StatePair pairEntry, HashSet> badPath) + private void mergePair(StatePair pairEntry, HashSet> badPath) throws TimeoutException { Queue depQueue = new LinkedList(); @@ -232,11 +177,11 @@ private void mergePair(StatePair pairEntry, HashSet> badPath) assert(pairLookup.values().contains(dep)); depQueue.addAll(dep.getDependencies()); } - System.out.println("SQUIBLLITY DOOP BOP"); + System.out.println("SQUIBLLITY DOOP BOP"); //unique string for debug purposes equivClasses.union(pairEntry.pair.get(0), pairEntry.pair.get(1)); } - public void mergeStates(HashSet> badPath) + public void mergeStates(HashSet> badPath) throws TimeoutException { for(StatePair pairEntry : pairLookup.values()) { @@ -258,6 +203,13 @@ else if(badPath.contains(pairEntry.pair)) private Dependencies deps; + public EquivTestDependency (DisjointSets equivClasses, HashSet> equiv, + HashSet> path, Dependencies deps) + { + super(equivClasses, equiv, path); + this.deps = deps; + } + public EquivTestDependency (DisjointSets equivClasses, HashSet> equiv, HashSet> path) { @@ -272,7 +224,7 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException { return false; } - EquivRecord start = new EquivRecord(pStart,qStart,path,equiv); + EquivRecord start = new EquivRecord(pStart,qStart,path); Stack testStack = new Stack(); testStack.add(start); while (!testStack.isEmpty()) @@ -281,7 +233,6 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException Integer p = curEquivTest.pState; Integer q = curEquivTest.qState; HashSet> curPath = curEquivTest.curPath; - HashSet> curEquiv = curEquivTest.curEquiv; List pair = normalize(p,q); HashSet> newPath = new HashSet>(curPath); newPath.add(pair); @@ -295,30 +246,30 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException Integer pNextClass = equivClasses.find(pMove.to); Integer qNextClass = equivClasses.find(qMove.to); List nextPair = normalize(pNextClass, qNextClass); - if(!pNextClass.equals(qNextClass) && !equiv.contains(nextPair)) + if(equiv.contains(nextPair) || path.contains(nextPair)) + { + deps.addDependency(pair, nextPair); + } + else if(!pNextClass.equals(qNextClass)) { if(isKnownNotEqual(pNextClass,qNextClass)) { - newPath.add(nextPair); + for(List pathPair : path) + { + neq.add(pathPair); //TODO: remove this call from outer minimize method + } this.path = newPath; deps.mergeStates(newPath); return false; } - if (!newPath.contains(nextPair)) + else { - HashSet> nextEquiv = new HashSet>(curEquiv); equiv.add(nextPair); - nextEquiv.add(nextPair); - EquivRecord nextTest = new EquivRecord(pNextClass, qNextClass, newPath, nextEquiv); - testStack.push(nextTest); - deps.addDependency(pair, nextPair); + EquivRecord nextTest = new EquivRecord(pNextClass, qNextClass, newPath); + testStack.add(nextTest); } } - else if(equiv.contains(nextPair)) - { - deps.addDependency(pair, nextPair); - } outp.remove(pMove); outq.remove(qMove); P newPGuard = ba.MkAnd(pMove.guard, ba.MkNot(qMove.guard)); @@ -332,7 +283,6 @@ else if(equiv.contains(nextPair)) outq.add(new SFAInputMove(qMove.from, qMove.to, newQGuard)); } } - //deps.satisfyDependency(pair); } equiv.add(normalize(pStart, qStart)); return true; diff --git a/IncrementalMinimization/src/minimization/incremental/IncrementalMinimization.java b/IncrementalMinimization/src/minimization/incremental/IncrementalMinimization.java index 31b87372..ded282b3 100644 --- a/IncrementalMinimization/src/minimization/incremental/IncrementalMinimization.java +++ b/IncrementalMinimization/src/minimization/incremental/IncrementalMinimization.java @@ -34,14 +34,12 @@ protected class EquivRecord public final Integer pState; public final Integer qState; public final HashSet > curPath; - public final HashSet > curEquiv; - public EquivRecord(Integer p, Integer q, HashSet> curPath, HashSet> curEquiv) + public EquivRecord(Integer p, Integer q, HashSet> curPath) { this.pState = p; this.qState = q; this.curPath = curPath; - this.curEquiv = curEquiv; } public String toString() @@ -91,7 +89,7 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException { return false; } - EquivRecord start = new EquivRecord(pStart,qStart,path,equiv); + EquivRecord start = new EquivRecord(pStart,qStart,path); Stack testStack = new Stack(); testStack.add(start); while (!testStack.isEmpty()) @@ -100,7 +98,6 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException Integer p = curEquivTest.pState; Integer q = curEquivTest.qState; HashSet> curPath = curEquivTest.curPath; - HashSet> curEquiv = curEquivTest.curEquiv; List pair = normalize(p,q); HashSet> newPath = new HashSet>(curPath); newPath.add(pair); @@ -118,7 +115,7 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException Integer pNextClass = equivClasses.find(pMove.to); Integer qNextClass = equivClasses.find(qMove.to); List nextPair = normalize(pNextClass, qNextClass); - if(!pNextClass.equals(qNextClass) && !curEquiv.contains(nextPair)) + if(!pNextClass.equals(qNextClass) && !equiv.contains(nextPair)) { if(isKnownNotEqual(pNextClass,qNextClass)) { @@ -127,10 +124,8 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException } if (!newPath.contains(nextPair)) { - HashSet> nextEquiv = new HashSet>(equiv); equiv.add(nextPair); - nextEquiv.add(nextPair); - EquivRecord nextTest = new EquivRecord(pNextClass, qNextClass, newPath, nextEquiv); + EquivRecord nextTest = new EquivRecord(pNextClass, qNextClass, newPath); testStack.push(nextTest); } } @@ -176,7 +171,7 @@ private class StateComparator implements Comparator { public int compare(Integer a, Integer b) { - int diff = distanceToFinalMap.get(a) - distanceToFinalMap.get(b); + int diff = getStateDistanceToFinal(a) - getStateDistanceToFinal(b); if (diff == 0) { return a - b; @@ -193,7 +188,7 @@ public int compare(Integer a, Integer b) protected final int num_pairs; protected HashSet> neq; - private LinkedHashMap distanceToFinalMap; + private LinkedHashMap distanceToFinalMap; //maps states to distance from final state, does not contain sink states private StateComparator stateComp; private Long startTime; private LinkedHashMap record; //maps time stamps to number of states @@ -219,57 +214,28 @@ public IncrementalMinimization(SFA aut, BooleanAlgebra ba) throws Time private LinkedHashMap generateDistanceToFinalMap() { - class StateInfo - { - public final Integer stateID; - public final Integer distanceToFinal; - - public StateInfo(Integer stateID, Integer distanceToFinal) - { - this.stateID = stateID; - this.distanceToFinal = distanceToFinal; - } - - public String toString() - { - return String.format("(%d, %d)", stateID, distanceToFinal); - } - } - LinkedHashMap distanceMap = new LinkedHashMap(); - HashSet visitedStates = new HashSet(); - Queue stateQueue = new LinkedList(); + Queue stateQueue = new LinkedList(); for(Integer finalState : aut.getFinalStates()) { - stateQueue.add(new StateInfo(finalState, 0)); - visitedStates.add(finalState); + stateQueue.add(finalState); + distanceMap.put(finalState, 0); } while(!stateQueue.isEmpty()) { - StateInfo s = stateQueue.poll(); - distanceMap.put(s.stateID, s.distanceToFinal); - Integer nextDistance = s.distanceToFinal + 1; - for (SFAInputMove t : aut.getInputMovesTo(s.stateID)) + Integer state = stateQueue.remove(); + Integer distance = distanceMap.get(state); + for(SFAInputMove t : aut.getInputMovesTo(state)) { - Integer nextState = t.from; - if(!visitedStates.contains(nextState)) + Integer prevState = t.from; + if(!distanceMap.containsKey(prevState)) { - stateQueue.add(new StateInfo(nextState, nextDistance)); - visitedStates.add(nextState); + distanceMap.put(prevState, distance+1); + stateQueue.add(prevState); } } } - - for(Integer state : aut.getNonFinalStates()) - { - if (!visitedStates.contains(state)) - { - assert(!distanceMap.containsKey(state)); //TODO: remove this - distanceMap.put(state, Integer.MAX_VALUE); //indicates sink state - } - } - return distanceMap; } @@ -294,6 +260,18 @@ protected List normalize(Integer p, Integer q) return pair; } + protected Integer getStateDistanceToFinal(Integer state) + { + if(distanceToFinalMap.containsKey(state)) + { + return distanceToFinalMap.get(state); + } + else + { + return Integer.MAX_VALUE; + } + } + protected boolean isKnownNotEqual(Integer p, Integer q) { List normalizedPair = normalize(p,q); @@ -301,7 +279,7 @@ protected boolean isKnownNotEqual(Integer p, Integer q) { return true; } - else if (!distanceToFinalMap.get(p).equals(distanceToFinalMap.get(q))) + else if (!getStateDistanceToFinal(p).equals(getStateDistanceToFinal(q))) { neq.add(normalizedPair); return true; @@ -382,13 +360,13 @@ public SFA minimize(long budget, boolean recordMinimization, boolean debug { equivClasses.make(q); } - for(Integer p : distanceToFinalMap.keySet()) + for(Integer p : aut.getStates()) { - for(Integer q : distanceToFinalMap.keySet()) + for(Integer q : aut.getStates()) { if(stateComp.compare(q,p) <= 0) { - if (distanceToFinalMap.get(p) < distanceToFinalMap.get(q)) + if (getStateDistanceToFinal(p) < getStateDistanceToFinal(q)) { break; //All later qs will be inequivalent } diff --git a/IncrementalMinimization/src/minimization/incremental/IncrementalNaive.java b/IncrementalMinimization/src/minimization/incremental/IncrementalNaive.java index 79b3bb73..909c6cc2 100644 --- a/IncrementalMinimization/src/minimization/incremental/IncrementalNaive.java +++ b/IncrementalMinimization/src/minimization/incremental/IncrementalNaive.java @@ -52,7 +52,7 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException { return false; } - EquivRecord start = new EquivRecord(pStart,qStart,path,equiv); + EquivRecord start = new EquivRecord(pStart,qStart,path); Stack testStack = new Stack(); testStack.add(start); while (!testStack.isEmpty()) @@ -79,7 +79,7 @@ public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException if(!newPath.contains(nextPair)) { equiv.add(nextPair); - EquivRecord nextTest = new EquivRecord(pNextClass, qNextClass, newPath,equiv); + EquivRecord nextTest = new EquivRecord(pNextClass, qNextClass, newPath); testStack.push(nextTest); } } diff --git a/IncrementalMinimization/src/minimization/incremental/IncrementalRecursive.java b/IncrementalMinimization/src/minimization/incremental/IncrementalRecursive.java index 70102ffd..add945cb 100644 --- a/IncrementalMinimization/src/minimization/incremental/IncrementalRecursive.java +++ b/IncrementalMinimization/src/minimization/incremental/IncrementalRecursive.java @@ -36,13 +36,6 @@ public ResultDependencies(boolean result) this.dependencies = new HashSet>(); } - public ResultDependencies(boolean result, List dependency) - { - this(result); - addDependency(dependency); - this.isindependent = false; - } - public boolean resultIsIndependent() { return isindependent; @@ -138,8 +131,6 @@ public void updateDepenencies() } private HashMap, ResultDependencies> equivDepends; - private boolean merged; - private HashSet> mergedStates; public EquivTestRecursive(DisjointSets equivClasses, HashSet> equiv, HashSet> path) @@ -227,8 +218,6 @@ else if(!pair.equals(nextPair)) if(thisResult.resultIsIndependent()) { equivClasses.union(p,q); - this.merged = true; - this.mergedStates.add(pair); } else { @@ -241,15 +230,8 @@ else if(!pair.equals(nextPair)) @Override public boolean isEquiv(Integer pStart, Integer qStart) throws TimeoutException { - this.merged = false; - this.mergedStates = new HashSet>(); ResultDependencies finalResult = isEquivRecursive(pStart, qStart); - boolean bool = finalResult.isEquiv(); - if(!bool & merged) - { - System.out.println("onepokoXXXXXXXXXXXXXXXXXXxxxxxxxxx: " + normalize(pStart,qStart).toString() + ", " + mergedStates.toString()); - } - return bool; + return finalResult.isEquiv(); } } diff --git a/IncrementalMinimization/src/test/TestIncrementalMinimization.java b/IncrementalMinimization/src/test/TestIncrementalMinimization.java index 906cda3a..2e079f84 100644 --- a/IncrementalMinimization/src/test/TestIncrementalMinimization.java +++ b/IncrementalMinimization/src/test/TestIncrementalMinimization.java @@ -10,6 +10,7 @@ import java.io.IOException; import java.io.OutputStreamWriter; import java.io.Writer; +import java.lang.reflect.InvocationTargetException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -51,7 +52,7 @@ public class TestIncrementalMinimization { - public static final String REGEX_FILE = "regex/regexlib-SFA.txt"; + public static final String REGEXLIB_FILE = "regex/regexlib-SFA.txt"; @Test public void testMyAut() throws TimeoutException @@ -59,8 +60,6 @@ public void testMyAut() throws TimeoutException //our algebra is constructed IntegerSolver ba = new IntegerSolver(); IntPred neg = new IntPred(null, new Integer(0)); - IntPred less_neg_ten = new IntPred(null, new Integer(-10)); - IntPred great_pos_ten = new IntPred(new Integer(10), null); IntPred zero = new IntPred(new Integer(0)); IntPred one = new IntPred(1); IntPred zero_five = new IntPred(new Integer(0), new Integer(5)); @@ -154,28 +153,10 @@ public void testCharPred() throws TimeoutException Assert.assertTrue(incrMinAut.stateCount() <= stdMinAut.stateCount()); } - @Test - public void testCompare() throws TimeoutException, IOException + private void compareRuntimeFromRegex(List regexList, String outfile) throws TimeoutException, IOException { - System.out.println("========================"); - System.out.println("STARTING COMPARISON TEST"); - System.out.println("========================"); + //Given a list of regex, runs all minimization algorithms on each and output results to the given file. - //import list of regex. Heavily borrowed code from symbolic automata library - FileReader regexFile = new FileReader(REGEX_FILE); - BufferedReader read = new BufferedReader(regexFile); - ArrayList regexList = new ArrayList(); - String line; - while(true) - { - line = read.readLine(); - if (line == null) - { - break; - } - regexList.add(line); - } - //regex converted to SFAs and minimized UnaryCharIntervalSolver ba = new UnaryCharIntervalSolver(); //System.out.println(regexList.size()); ArrayList messageList = new ArrayList(); @@ -360,7 +341,7 @@ public void testCompare() throws TimeoutException, IOException System.out.println(""); messageList.add(message); } - FileOutputStream file = new FileOutputStream("compare_test.txt"); + FileOutputStream file = new FileOutputStream(outfile); Writer writer = new BufferedWriter(new OutputStreamWriter(file)); writer.write("initial states, final states, transition count, predicate count, minterm count," + "incremental time, standard time, Moore time, upfront incremental time, " + @@ -372,7 +353,71 @@ public void testCompare() throws TimeoutException, IOException writer.close(); } - //@Test + @Test + public void testRegexLib() throws TimeoutException, IOException + { + System.out.println("======================="); + System.out.println("STARTING REGEXLIB TEST"); + System.out.println("======================="); + + //import list of regex. Heavily borrowed code from symbolic automata library + FileReader regexFile = new FileReader(REGEXLIB_FILE); + BufferedReader read = new BufferedReader(regexFile); + ArrayList regexList = new ArrayList(); + String line; + while(true) + { + line = read.readLine(); + if (line == null) + { + break; + } + regexList.add(line); + } + compareRuntimeFromRegex(regexList, "regexlib_compare_test.txt"); + } + + @Test + public void test_powerEN_patterns() throws IOException, TimeoutException + { + System.out.println("======================"); + System.out.println("STARTING powerEN TEST"); + System.out.println("======================"); + File dir = new File("regex/PowerEN_PME/cmplex/multi_ctx/patterns"); + Assert.assertTrue(dir.isDirectory()); + File[] pattern_files = dir.listFiles(); + System.out.println(dir); + List allRegex = new LinkedList(); + for(File pattern_file : pattern_files) + { + FileReader pattern_reader = new FileReader(pattern_file); + BufferedReader read = new BufferedReader(pattern_reader); + LinkedList patternList = new LinkedList(); + String line; + while(true) + { + line = read.readLine(); + if(line == null) + { + break; + } + else if (line.equals("")) + { + continue; + } + int spaceIndex = line.indexOf(" "); + if(spaceIndex != -1) //indicates the line contains a space - not a regex + { + continue; + } + patternList.add(line); + } + allRegex.addAll(patternList); + } + compareRuntimeFromRegex(allRegex, "powerEN_compare_test.txt"); + } + + @Test public void testBudget() throws TimeoutException, IOException { //Similar to Regex test, but incremental minimization only given as long as @@ -382,7 +427,7 @@ public void testBudget() throws TimeoutException, IOException System.out.println("========================="); //import list of regex - FileReader regexFile = new FileReader(REGEX_FILE); + FileReader regexFile = new FileReader(REGEXLIB_FILE); BufferedReader read = new BufferedReader(regexFile); ArrayList regexList = new ArrayList(); String line; @@ -436,7 +481,6 @@ public void testBudget() throws TimeoutException, IOException //Incremental minimization runs with time budget of standard minimization SFA incrMinAut; - SFA upfrontIncrAut; try { IncrementalMinimization incrMin = new IncrementalMinimization(aut,ba); @@ -450,7 +494,11 @@ public void testBudget() throws TimeoutException, IOException { continue; } + Assert.assertTrue(SFA.areEquivalent(aut, incrMinAut, ba)); System.out.println("Incremental minimized."); + + //Naive Minimization runs on time budget + SFA upfrontIncrAut; try { IncrementalNaive naiveMin = new IncrementalNaive(aut, ba); @@ -468,7 +516,26 @@ public void testBudget() throws TimeoutException, IOException { continue; }*/ - System.out.println("Naive incremental minimized.."); + Assert.assertTrue(SFA.areEquivalent(aut, upfrontIncrAut, ba)); + System.out.println("Naive incremental minimized."); + + //Incremental minimization runs with time budget of standard minimization + SFA depMinAut; + try + { + IncrementalMinimization depMin = new IncrWithDependencyChecks(aut,ba); + depMinAut = depMin.minimize(budget); + } + catch(TimeBudgetExceededException e) + { + depMinAut = e.getReturnAut(); + } + catch(TimeoutException e) + { + continue; + } + Assert.assertTrue(SFA.areEquivalent(aut, upfrontIncrAut, ba)); + System.out.println("Incremental w/ Dependency check minimized."); int initialCount = aut.stateCount(); String initialStateCount = Integer.toString(initialCount); @@ -478,6 +545,8 @@ public void testBudget() throws TimeoutException, IOException String incrStateCount= Integer.toString(incrCount); int upfrontCount = upfrontIncrAut.stateCount(); String upfrontStateCount = Integer.toString(upfrontCount); + int depCount = depMinAut.stateCount(); + String depStateCount = Integer.toString(depCount); double incrPercentMinimized; if (incrCount <= finalCount) @@ -499,18 +568,29 @@ public void testBudget() throws TimeoutException, IOException upfPercentMinimized = ((double) initialCount - upfrontCount)/((double)initialCount - finalCount); } String upfPercent = Double.toString(upfPercentMinimized); + double depPercentMinimized; + if (depCount <= finalCount) + { + depPercentMinimized = 1.; + } + else + { + depPercentMinimized = ((double) initialCount - depCount)/((double) initialCount - finalCount); + } + String depPercent = Double.toString(depPercentMinimized); - String msg = String.format("%s, %s, %s, %s, %s, %s", - initialStateCount, finalStateCount, incrStateCount, upfrontCount, - incrPercent, upfPercent); + String msg = String.format("%s, %s, %s, %s, %s, %s, %s, %s", + initialStateCount, finalStateCount, incrStateCount, upfrontCount, depCount, + incrPercent, upfPercent, depPercent); messageList.add(msg); System.out.println(msg); Assert.assertTrue(incrPercentMinimized >= 0); + System.out.println(""); } FileOutputStream file = new FileOutputStream("budget_test.txt"); Writer writer = new BufferedWriter(new OutputStreamWriter(file)); - writer.write("initial states, final states, incremental states, upfront states" + - "incremental percent, upfront percent" + "\n"); + writer.write("initial states, final states, incremental states, upfront states, dependency states" + + "incremental percent, upfront percent, dependency percent" + "\n"); for (String msg : messageList) { writer.write(msg + "\n"); @@ -543,16 +623,13 @@ private Double linearInterpolate(Integer x, Integer x0, Integer x1, Double y0, D return y0 + (x-x0)*slope; } - //@Test - public void testRecord() throws IOException + private void performRecordTest(Class minCls, String outfile) + throws IOException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { //TODO: cleanup + document - System.out.println("===================="); - System.out.println("STARTING RECORD TEST"); - System.out.println("===================="); //import list of regex - FileReader regexFile = new FileReader(REGEX_FILE); + FileReader regexFile = new FileReader(REGEXLIB_FILE); BufferedReader read = new BufferedReader(regexFile); ArrayList regexList = new ArrayList(); String line; @@ -606,8 +683,9 @@ public void testRecord() throws IOException LinkedHashMap record = null; try { + Class[] constructorArgs = {SFA.class, BooleanAlgebra.class}; IncrementalMinimization incrMin = - new IncrementalMinimization(aut, ba); + minCls.getDeclaredConstructor(constructorArgs).newInstance(aut, ba); incrMinAut = incrMin.minimize(Long.MAX_VALUE, true, false); record = incrMin.getRecord(); } @@ -752,6 +830,7 @@ record = incrMin.getRecord(); } otherRepeat.put(initialStateCount, count+1); } + System.out.println(""); } String titleRow = "initial states, "; for (Integer milestone : milestones) @@ -760,7 +839,7 @@ record = incrMin.getRecord(); } titleRow += "\n"; System.out.print(titleRow); - FileOutputStream file = new FileOutputStream("second_record_test.txt"); + FileOutputStream file = new FileOutputStream(outfile); Writer writer = new BufferedWriter(new OutputStreamWriter(file)); writer.write(titleRow); for(Integer stateCount : oppositeMap.keySet()) @@ -779,14 +858,28 @@ record = incrMin.getRecord(); writer.close(); } - //@Test + @Test + public void testRecord() throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, IOException + { + System.out.println("===================="); + System.out.println("STARTING RECORD TEST"); + System.out.println("===================="); + System.out.println("Starting Record Test for Standard Incremental"); + performRecordTest(IncrementalMinimization.class, "standard_record_test.txt"); + System.out.println("Starting Record Test for Naive Incremental"); + performRecordTest(IncrementalNaive.class, "naive_record_test.txt"); + System.out.println("Starting Record Test for Incremental with Dependency Checking"); + performRecordTest(IncrWithDependencyChecks.class, "dependency_record_test.txt"); + } + + @Test public void testDepth() throws IOException, TimeoutException { System.out.println("==================="); System.out.println("STARTING DEPTH TEST"); System.out.println("==================="); //import list of regex - FileReader regexFile = new FileReader(REGEX_FILE); + FileReader regexFile = new FileReader(REGEXLIB_FILE); BufferedReader read = new BufferedReader(regexFile); ArrayList regexList = new ArrayList(); String line; @@ -872,126 +965,6 @@ public void testDepth() throws IOException, TimeoutException } - //@Test - public void test_powerEN_patterns() throws IOException, TimeoutException - { - System.out.println("======================"); - System.out.println("STARTING powerEN TEST"); - System.out.println("======================"); - File dir = new File("regex/PowerEN_PME/cmplex/multi_ctx/patterns"); - Assert.assertTrue(dir.isDirectory()); - File[] pattern_files = dir.listFiles(); - System.out.println(dir); - List allRegex = new LinkedList(); - for(File pattern_file : pattern_files) - { - FileReader pattern_reader = new FileReader(pattern_file); - BufferedReader read = new BufferedReader(pattern_reader); - LinkedList patternList = new LinkedList(); - String line; - while(true) - { - line = read.readLine(); - if(line == null) - { - break; - } - else if (line.equals("")) - { - continue; - } - int spaceIndex = line.indexOf(" "); - if(spaceIndex != -1) //indicates the line contains a space - not a regex - { - continue; - } - patternList.add(line); - } - allRegex.addAll(patternList); - } - UnaryCharIntervalSolver ba = new UnaryCharIntervalSolver(); - long timeout = 3600000; - ArrayList messageList = new ArrayList(); - for(String regex : allRegex) - { - SFA aut = (new SFAprovider(regex, ba)).getSFA(); - try - { - aut = aut.determinize(ba, timeout); - aut = aut.mkTotal(ba); - } - catch(TimeoutException e) - { - continue; - } - catch(OutOfMemoryError e) - { - System.gc(); - continue; - } - System.out.println("Determinized."); - //standard minimization - long stdStart = System.nanoTime(); - SFA stdMinAut; - stdMinAut = aut.minimize(ba); - Double stdTime = ((double)(System.nanoTime() - stdStart)/1000000); - System.out.println("Standard minimized."); - - //incremental minimization - System.out.println("Starting incremental minimization"); - long incrStart = System.nanoTime(); - SFA incrMinAut; - try - { - IncrementalMinimization incrMin = new IncrementalMinimization(aut, ba); - incrMinAut = incrMin.minimize(); - } - catch(TimeoutException e) - { - System.out.println("Skipping because of Timeout Exception"); //TODO Debug - continue; - } - /*catch(OutOfMemoryError e) - { - System.out.println("Skipping because out of heap space"); //TODO Debug - continue; - }*/ - Double incrTime = ((double)(System.nanoTime() - incrStart)/1000000); - Assert.assertTrue(incrMinAut.isDeterministic(ba)); - Assert.assertTrue(SFA.areEquivalent(incrMinAut, stdMinAut, ba)); - Assert.assertTrue(incrMinAut.stateCount() <= stdMinAut.stateCount()); - System.out.println("Incremental minimized."); - - String initialStateCount = Integer.toString(aut.stateCount()); - String transCount = Integer.toString(aut.getTransitionCount()); - String finalStateCount = Integer.toString(stdMinAut.stateCount()); - - HashSet predSet = new HashSet(); - for(SFAInputMove t : aut.getInputMovesFrom(aut.getStates())) - { - predSet.add(t.guard); - } - String predCount = Integer.toString(predSet.size()); - ArrayList predList = new ArrayList(predSet); - String mintermCount = Integer.toString(ba.GetMinterms(predList).size()); - - String message = String.format("%s, %s, %s, %s, %s, %s, %s", - initialStateCount, finalStateCount, transCount, predCount, mintermCount, - Double.toString(incrTime), Double.toString(stdTime)); - System.out.println(message); - messageList.add(message); - } - FileOutputStream file = new FileOutputStream("powerEN_test.txt"); - Writer writer = new BufferedWriter(new OutputStreamWriter(file)); - writer.write("initial states, final states, transition count, predicate count, minterm count," + - "incremental time, standard time, Moore time, upfront incremental time, " + - "recursive symbolic incremental, With Dependency check \n"); - for (String msg : messageList) - { - writer.write(msg + "\n"); - } - writer.close(); - - } + }