diff --git a/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/BddVarOrderTest.java b/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/BddVarOrderTest.java new file mode 100644 index 0000000000000000000000000000000000000000..86a6f4bad269baa990d5d7354ac9884a83689d50 --- /dev/null +++ b/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/BddVarOrderTest.java @@ -0,0 +1,95 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available +// under the terms of the MIT License which is available at +// https://opensource.org/licenses/MIT +// +// SPDX-License-Identifier: MIT +////////////////////////////////////////////////////////////////////////////// + +package org.eclipse.escet.cif.datasynth.varorder.helper; + +import static org.eclipse.escet.common.java.Lists.list; +import static org.junit.Assert.assertEquals; + +import java.util.List; +import java.util.stream.Collectors; + +import org.junit.Test; + +import com.github.javabdd.BDD; +import com.github.javabdd.BDDFactory; + +/** BDD variable order tests. */ +public class BddVarOrderTest { + @Test + @SuppressWarnings("javadoc") + public void testHighLowBit() { + // Create factory with 3 variables: a < b < c. + BDDFactory factory = BDDFactory.init("java", 100, 100); + factory.setVarNum(3); + + // Get each variable. + BDD a = factory.ithVar(0); + BDD b = factory.ithVar(1); + BDD c = factory.ithVar(2); + + // Each variable's 0-based index corresponds to its level. + assertEquals(0, a.level()); + assertEquals(1, b.level()); + assertEquals(2, c.level()); + + // Create '(!a and b and c) or (a and !b and !c)' BDD. + BDD pred = a.not().and(b).and(c).or(a.and(b.not()).and(c.not())); + + // Check satisfying assignments. + assertEquals("!a b c, a !b !c", bddToAllSatText(pred)); + + // Reverse variable order. + factory.setVarOrder(new int[] {2, 1, 0}); // New order: c < b < a. + + // Check reverse levels. + assertEquals(2, a.level()); + assertEquals(1, b.level()); + assertEquals(0, c.level()); + + // Check reverse satisfying assignments. + assertEquals("!c !b a, c b !a", bddToAllSatText(pred)); + } + + /** + * Get text representing all satisfying assignments to the given BDD. + * + * @param bdd The BDD. + * @return The text. + */ + private static String bddToAllSatText(BDD bdd) { + List sats = list(); + bddToAllSatTexts(bdd, "", sats); + return sats.stream().map(String::trim).collect(Collectors.joining(", ")); + } + + /** + * Get texts representing all satisfying assignments to the given BDD. + * + * @param bdd The BDD. + * @param cursat The current satisfying assignment based on ancestor BDD nodes. + * @param sats The satisfying assignments. + */ + private static void bddToAllSatTexts(BDD bdd, String cursat, List sats) { + if (bdd.isOne()) { + sats.add(cursat); + } else if (bdd.isZero()) { + // Ignore. + } else { + int var = bdd.getFactory().level2Var(bdd.level()); + char c = (char)('a' + var); + bddToAllSatTexts(bdd.low(), cursat + " !" + c, sats); + bddToAllSatTexts(bdd.high(), cursat + " " + c, sats); + } + } +} diff --git a/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelperTest.java b/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelperTest.java index f9e413d003fea566937c3c35054c5caefb42317f..50dd08f415b48eb397eba38933a6e21f1c26b002 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelperTest.java +++ b/cif/org.eclipse.escet.cif.datasynth/src-test/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelperTest.java @@ -16,14 +16,25 @@ package org.eclipse.escet.cif.datasynth.varorder.helper; import static org.eclipse.escet.cif.metamodel.java.CifConstructors.newInputVariable; import static org.eclipse.escet.cif.metamodel.java.CifConstructors.newIntType; import static org.eclipse.escet.cif.metamodel.java.CifConstructors.newSpecification; +import static org.eclipse.escet.common.java.Lists.list; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertSame; +import java.util.Arrays; +import java.util.BitSet; import java.util.List; +import org.eclipse.escet.cif.datasynth.spec.SynthesisDiscVariable; import org.eclipse.escet.cif.datasynth.spec.SynthesisInputVariable; import org.eclipse.escet.cif.datasynth.spec.SynthesisVariable; +import org.eclipse.escet.cif.datasynth.varorder.graph.Graph; +import org.eclipse.escet.cif.io.CifReader; import org.eclipse.escet.cif.metamodel.cif.Specification; +import org.eclipse.escet.cif.metamodel.cif.automata.Automaton; +import org.eclipse.escet.cif.metamodel.cif.declarations.DiscVariable; import org.eclipse.escet.cif.metamodel.cif.declarations.InputVariable; +import org.eclipse.escet.common.box.CodeBox; +import org.eclipse.escet.common.box.MemoryCodeBox; import org.junit.Test; /** Tests for {@link VarOrdererHelper}. */ @@ -50,7 +61,7 @@ public class VarOrdererHelperTest { SynthesisVariable c = new SynthesisInputVariable(vc, newIntType(0, null, 0), 1, 0, 0); SynthesisVariable d = new SynthesisInputVariable(vd, newIntType(0, null, 0), 1, 0, 0); SynthesisVariable e = new SynthesisInputVariable(ve, newIntType(0, null, 0), 1, 0, 0); - SynthesisVariable[] variables = {a, b, c, d, e}; + List variables = list(a, b, c, d, e); // Reorder the variables. int[] newIndices = {0, 4, 1, 2, 3}; // For each variable in 'variables', its new 0-based index. @@ -64,4 +75,86 @@ public class VarOrdererHelperTest { assertSame(e, ordered.get(3)); assertSame(b, ordered.get(4)); } + + @SuppressWarnings("javadoc") + @Test + public void testRepresentationsAndMetrics() { + // CIF specification. + CodeBox box = new MemoryCodeBox(); + box.add("input int[0..2] a;"); + box.add("input int[0..2] b;"); + box.add("input int[0..2] d;"); + box.add("input int[0..2] e;"); + box.add("controllable c_e;"); + box.add("plant p:"); + box.add(" disc int[0..2] c;"); + box.add(" location:"); + box.add(" initial; marked;"); + box.add(" edge c_e when a = b or b = a;"); + box.add(" edge c_e when a = c;"); + box.add(" edge c_e do c := d;"); + box.add(" edge c_e do c := d;"); + box.add(" edge c_e do c := d;"); + box.add("end"); + box.add("invariant p.c != e;"); + + // Read CIF specification. + CifReader reader = new CifReader(); + reader.init("memory", "/memory", false); + Specification spec = reader.read(box.toString()); + + // Create synthesis variables. + Automaton p = (Automaton)spec.getComponents().get(0); + InputVariable va = (InputVariable)spec.getDeclarations().get(0); + InputVariable vb = (InputVariable)spec.getDeclarations().get(1); + InputVariable vd = (InputVariable)spec.getDeclarations().get(2); + InputVariable ve = (InputVariable)spec.getDeclarations().get(3); + DiscVariable vc = (DiscVariable)p.getDeclarations().get(0); + SynthesisVariable a = new SynthesisInputVariable(va, newIntType(0, null, 2), 3, 0, 2); + SynthesisVariable b = new SynthesisInputVariable(vb, newIntType(0, null, 2), 3, 0, 2); + SynthesisVariable c = new SynthesisDiscVariable(vc, newIntType(0, null, 2), 3, 0, 2); + SynthesisVariable d = new SynthesisInputVariable(vd, newIntType(0, null, 2), 3, 0, 2); + SynthesisVariable e = new SynthesisInputVariable(ve, newIntType(0, null, 2), 3, 0, 2); + List variables = list(a, b, c, d, e); + + // Create helper. + VarOrdererHelper helper = new VarOrdererHelper(spec, variables); + + // Test hyper-edges: c/e (invariant), a/b (guard), b/a (guard), a/c (guard), c/d (update), c/d (update), c/d + // (update), a/b/c/d (event c_e). + BitSet[] hyperEdges = helper.getHyperEdges(); + assertEquals("[{2, 4}, {0, 1}, {0, 1}, {0, 2}, {2, 3}, {2, 3}, {2, 3}, {0, 1, 2, 3}]", + Arrays.toString(hyperEdges)); + + // Test graph edges: (b, 3, a), (a, 2, c), (a, 1, d), (b, 1, c), (b, 1, d), (c, 4, d), (c, 1, e). + Graph graph = helper.getGraph(); + String expectedGraphText = String.join("\n", list( // + ".321.", // + "3.11.", // + "21.41", // + "114..", // + "..1..")); + assertEquals(expectedGraphText, graph.toString()); + + // Test metrics for original order. + // Total span = 2 + 1 + 1 + 2 + 1 + 1 + 1 + 3 = 12. + // WES = 8/5*3/40 + 2/5*2/40 + 2/5*2/40 + 4/5*3/40 + 6/5*2/40 + 6/5*2/40 + 6/5*2/40 + 6/5*4/40 = 0.52. + int[] defaultIndices = {0, 1, 2, 3, 4}; // For each variable in 'variables', its new 0-based index. + assertEquals("Total span: 12 (total) 1.50 (avg/edge) / WES: 0.520000 (total) 0.065000 (avg/edge) [x]", + helper.fmtMetrics(defaultIndices, "x")); + + // Test metrics for reverse order. + // Total span: unchanged from original order. + // WES = 4/5*3/40 + 8/5*2/40 + 8/5*2/40 + 8/5*3/40 + 4/5*2/40 + 4/5*2/40 + 4/5*2/40 + 8/5*4/40 = 0.52. + int[] reverseIndices = {4, 3, 2, 1, 0}; // For each variable in 'variables', its new 0-based index. + assertEquals("Total span: 12 (total) 1.50 (avg/edge) / WES: 0.620000 (total) 0.077500 (avg/edge) [x]", + helper.fmtMetrics(reverseIndices, "x")); + + // Test metrics for a random order. + // Total span: 2 + 4 + 4 + 1 + 1 + 1 + 1 + 4 = 18. + // WES: 6/5*3/40 + 8/5*5/40 + 8/5*5/40 + 2/5*2/40 + 4/5*2/40 + 4/5*2/40 + 4/5*2/40 + 8/5*5/40 = 0.83. + int[] randomIndices = {0, 4, 1, 2, 3}; // For each variable in 'variables', its new 0-based index. + assertEquals("Total span: 18 (total) 2.25 (avg/edge) / WES: 0.830000 (total) 0.103750 (avg/edge) [x]", + helper.fmtMetrics(randomIndices, "x")); + } } diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/conversion/CifToSynthesisConverter.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/conversion/CifToSynthesisConverter.java index 946bd9a710e1f96f10c9f203ca882698b5e75da1..f754c78b118318c437f0aa29fed266f030eeceb4 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/conversion/CifToSynthesisConverter.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/conversion/CifToSynthesisConverter.java @@ -931,7 +931,8 @@ public class CifToSynthesisConverter { // Only apply a variable ordering algorithm if there are hyper-edges and graph edges, to ensures that variable // relations exist for improving the variable order. It also avoids division by zero issues. - VarOrdererHelper helper = new VarOrdererHelper(spec, synthAut.variables); + List variables = Arrays.asList(synthAut.variables); + VarOrdererHelper helper = new VarOrdererHelper(spec, variables); long graphEdgeCount = helper.getGraph().edgeCount(); if (helper.getHyperEdges().length == 0) { if (dbgEnabled) { @@ -960,7 +961,7 @@ public class CifToSynthesisConverter { } VarOrderer orderer = (orderers.size() == 1) ? first(orderers) : new SequentialVarOrderer(orderers); List curOrder = Arrays.asList(synthAut.variables); - List newOrder = orderer.order(helper, Arrays.asList(synthAut.variables), dbgEnabled, 1); + List newOrder = orderer.order(helper, variables, dbgEnabled, 1); // If the new order differs from the current order, reorder. boolean orderChanged = !curOrder.equals(newOrder); diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ChoiceVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ChoiceVarOrderer.java index 7479b6a4cd412d872b674e926c79b401858df6ff..11b41a7b2d52572aa24a6b397b2b77d7dc9d9f8c 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ChoiceVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ChoiceVarOrderer.java @@ -17,9 +17,10 @@ import java.util.List; import org.eclipse.escet.cif.datasynth.spec.SynthesisVariable; import org.eclipse.escet.cif.datasynth.varorder.helper.VarOrdererHelper; +import org.eclipse.escet.cif.datasynth.varorder.helper.VarOrdererMetric; import org.eclipse.escet.common.java.Assert; -/** Variable ordering algorithm that applies multiple other algorithms, and picks the one with the lowest total span. */ +/** Variable ordering algorithm that applies multiple other algorithms, and picks the best order. */ public class ChoiceVarOrderer implements VarOrderer { /** The name of the choice-based algorithm, or {@code null} if no name is given. */ private final String name; @@ -27,13 +28,17 @@ public class ChoiceVarOrderer implements VarOrderer { /** The algorithms to apply. At least two algorithms. */ private final List algorithms; + /** The metric to use to pick the best order. */ + private final VarOrdererMetric metric; + /** * Constructor for the {@link ChoiceVarOrderer} class. Does not name the choice-based algorithm. * * @param algorithms The sequence of algorithms to apply. Must be at least two algorithms. + * @param metric The metric to use to pick the best order. */ - public ChoiceVarOrderer(List algorithms) { - this(null, algorithms); + public ChoiceVarOrderer(List algorithms, VarOrdererMetric metric) { + this(null, algorithms, metric); } /** @@ -41,10 +46,12 @@ public class ChoiceVarOrderer implements VarOrderer { * * @param name The name of the choice-based algorithm. * @param algorithms The sequence of algorithms to apply. Must be at least two algorithms. + * @param metric The metric to use to pick the best order. */ - public ChoiceVarOrderer(String name, List algorithms) { + public ChoiceVarOrderer(String name, List algorithms, VarOrdererMetric metric) { this.name = name; this.algorithms = algorithms; + this.metric = metric; Assert.check(algorithms.size() >= 2); } @@ -61,9 +68,9 @@ public class ChoiceVarOrderer implements VarOrderer { } } - // Initialize best order (with lowest span). + // Initialize best order (the lower the metric value the better). List bestOrder = null; - long bestSpan = Long.MAX_VALUE; + double bestMetric = Double.POSITIVE_INFINITY; // Apply each algorithm. for (int i = 0; i < algorithms.size(); i++) { @@ -76,11 +83,11 @@ public class ChoiceVarOrderer implements VarOrderer { VarOrderer algorithm = algorithms.get(i); List algoOrder = algorithm.order(helper, inputOrder, dbgEnabled, dbgLevel + 1); - // Update best order (with lowest span). - long algoSpan = helper.computeTotalSpanForVarOrder(algoOrder); - if (algoSpan < bestSpan) { + // Update best order (with lowest metric value). + double algoMetric = metric.compute(helper, algoOrder); + if (algoMetric < bestMetric) { bestOrder = algoOrder; - bestSpan = algoSpan; + bestMetric = algoMetric; if (dbgEnabled) { helper.dbg(dbgLevel + 1, "Found new best variable order."); diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/DcshVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/DcshVarOrderer.java index 2aa7e89878fee701c8261a1d7810006c21f2137a..4dbb97ba866abf7994281fd131fc11fb169c49f4 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/DcshVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/DcshVarOrderer.java @@ -15,6 +15,8 @@ package org.eclipse.escet.cif.datasynth.varorder; import static org.eclipse.escet.common.java.Lists.list; +import org.eclipse.escet.cif.datasynth.varorder.helper.VarOrdererHelper; + /** * DSM-based Cuthill-McKee/Sloan variable ordering Heuristic (DCSH). * @@ -32,6 +34,6 @@ public class DcshVarOrderer extends ChoiceVarOrderer { new SloanVarOrderer(), // Second algorithm. new ReverseVarOrderer(new WeightedCuthillMcKeeVarOrderer()), // Reverse first algorithm. new ReverseVarOrderer(new SloanVarOrderer()) // Reverse second algorithm. - )); + ), VarOrdererHelper::computeWesForVarOrder); } } diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ForceVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ForceVarOrderer.java index 4035bdac81ad74bebd909c5e2c81f362f7d39f57..413158e8cef27f497a78508ecf6c9ff85bf4464a 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ForceVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ForceVarOrderer.java @@ -86,7 +86,7 @@ public class ForceVarOrderer implements VarOrderer { long curTotalSpan = helper.computeTotalSpanForNewIndices(curIndices); long bestTotalSpan = curTotalSpan; if (dbgEnabled) { - helper.dbgTotalSpan(dbgLevel, curTotalSpan, "before"); + helper.dbgMetricsForNewIndices(dbgLevel, curIndices, "before"); } // Perform iterations of the algorithm. @@ -127,7 +127,7 @@ public class ForceVarOrderer implements VarOrderer { // Get new total span. long newTotalSpan = helper.computeTotalSpanForNewIndices(curIndices); if (dbgEnabled) { - helper.dbgTotalSpan(dbgLevel, newTotalSpan, fmt("iteration %,d", curIter + 1)); + helper.dbgMetricsForNewIndices(dbgLevel, curIndices, fmt("iteration %,d", curIter + 1)); } // Stop when total span stops changing. We could stop as soon as it stops decreasing. However, we may end @@ -151,7 +151,7 @@ public class ForceVarOrderer implements VarOrderer { // Debug output after applying the algorithm. if (dbgEnabled) { - helper.dbgTotalSpan(dbgLevel, bestTotalSpan, "after"); + helper.dbgMetricsForNewIndices(dbgLevel, bestIndices, "after"); } // Return the best order. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ReverseVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ReverseVarOrderer.java index 87a3372034e10e4aab8bce9f7c1bdd52c4d2994b..c9235d194f641ed5498b0f03de0172fd09fb4366 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ReverseVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/ReverseVarOrderer.java @@ -51,7 +51,7 @@ public class ReverseVarOrderer implements VarOrderer { // Debug output after applying the algorithm. if (dbgEnabled) { helper.dbg(dbgLevel, "Reversed the variable order."); - helper.dbgTotalSpanForVarOrder(dbgLevel, order, "reversed"); + helper.dbgMetricsForVarOrder(dbgLevel, order, "reversed"); } // Return the resulting variable order. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SlidingWindowVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SlidingWindowVarOrderer.java index d99fe211817aefa3ed33af7161e1449957340fbc..8ea85adf6899bd3b0f531c365125d502945bbc19 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SlidingWindowVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SlidingWindowVarOrderer.java @@ -57,7 +57,7 @@ public class SlidingWindowVarOrderer implements VarOrderer { int[] curIndices = helper.getNewIndicesForVarOrder(inputOrder); long curSpan = helper.computeTotalSpanForNewIndices(curIndices); if (dbgEnabled) { - helper.dbgTotalSpan(dbgLevel, curSpan, "before"); + helper.dbgMetricsForNewIndices(dbgLevel, curIndices, "before"); } // Process all windows. @@ -87,14 +87,15 @@ public class SlidingWindowVarOrderer implements VarOrderer { System.arraycopy(windowPerms[bestIdx], 0, curIndices, offset, length); if (dbgEnabled) { - helper.dbgTotalSpan(dbgLevel, curSpan, fmt("window %d..%d", offset, offset + length - 1)); + helper.dbgMetricsForNewIndices(dbgLevel, curIndices, + fmt("window %d..%d", offset, offset + length - 1)); } } } // Debug output after applying the algorithm. if (dbgEnabled) { - helper.dbgTotalSpan(dbgLevel, curSpan, "after"); + helper.dbgMetricsForNewIndices(dbgLevel, curIndices, "after"); } // Return the resulting order. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SloanVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SloanVarOrderer.java index c05087cc3ec3fd506a31e66c74b1974c99fc17fb..d4432dd28bc4e65bb61c95d89dcb593e31dd635a 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SloanVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/SloanVarOrderer.java @@ -37,7 +37,7 @@ public class SloanVarOrderer implements VarOrderer { // Debug output before applying the algorithm. if (dbgEnabled) { helper.dbg(dbgLevel, "Applying Sloan algorithm."); - helper.dbgTotalSpanForVarOrder(dbgLevel, inputOrder, "before"); + helper.dbgMetricsForVarOrder(dbgLevel, inputOrder, "before"); } // Apply algorithm. @@ -45,7 +45,7 @@ public class SloanVarOrderer implements VarOrderer { // Debug output after applying the algorithm. if (dbgEnabled) { - helper.dbgTotalSpanForNodeOrder(dbgLevel, order, "after"); + helper.dbgMetricsForNodeOrder(dbgLevel, order, "after"); } // Return the resulting order. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/WeightedCuthillMcKeeVarOrderer.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/WeightedCuthillMcKeeVarOrderer.java index 7acfddb93ce859e70f94485c61cd518ec5884f2b..8177cf007c09a9715a865a286724d92223a22be3 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/WeightedCuthillMcKeeVarOrderer.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/WeightedCuthillMcKeeVarOrderer.java @@ -37,7 +37,7 @@ public class WeightedCuthillMcKeeVarOrderer implements VarOrderer { // Debug output before applying the algorithm. if (dbgEnabled) { helper.dbg(dbgLevel, "Applying Weighted Cuthill-McKee algorithm."); - helper.dbgTotalSpanForVarOrder(dbgLevel, inputOrder, "before"); + helper.dbgMetricsForVarOrder(dbgLevel, inputOrder, "before"); } // Apply algorithm. @@ -45,7 +45,7 @@ public class WeightedCuthillMcKeeVarOrderer implements VarOrderer { // Debug output after applying the algorithm. if (dbgEnabled) { - helper.dbgTotalSpanForNodeOrder(dbgLevel, order, "after"); + helper.dbgMetricsForNodeOrder(dbgLevel, order, "after"); } // Return the resulting order. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/HyperEdgeCreator.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/HyperEdgeCreator.java index 066cc61d645ab2e053bf93e1d48c257a979a105a..fcfc4800ac051510e14099e8e5439da1ddc173a2 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/HyperEdgeCreator.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/HyperEdgeCreator.java @@ -48,7 +48,7 @@ import org.eclipse.escet.common.position.metamodel.position.PositionObject; /** Automatic variable ordering hyper-edge creator. */ class HyperEdgeCreator { /** The synthesis variables. */ - private SynthesisVariable[] variables; + private List variables; /** The hyper-edges created so far. */ private List hyperEdges = list(); @@ -63,7 +63,7 @@ class HyperEdgeCreator { * @param variables The synthesis variables. * @return The hyper-edges. */ - List getHyperEdges(Specification spec, SynthesisVariable[] variables) { + List getHyperEdges(Specification spec, List variables) { // Initialization. this.variables = variables; this.hyperEdges = list(); @@ -221,12 +221,12 @@ class HyperEdgeCreator { } // Create bit set. - BitSet hyperEdge = new BitSet(variables.length); + BitSet hyperEdge = new BitSet(variables.size()); for (PositionObject var: vars) { int matchIdx = -1; - for (int i = 0; i < variables.length; i++) { + for (int i = 0; i < variables.size(); i++) { // Get synthesis variable. - SynthesisVariable synthVar = variables[i]; + SynthesisVariable synthVar = variables.get(i); Assert.notNull(synthVar == null); // Check for matching variable. diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelper.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelper.java index 32108b17a6fdf5cea66987d0b9eabdb51ff431f7..16399aa4be6f2c054adcc74157507b3d0ef41990 100644 --- a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelper.java +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererHelper.java @@ -15,6 +15,7 @@ package org.eclipse.escet.cif.datasynth.varorder.helper; import static org.eclipse.escet.common.java.Maps.mapc; import static org.eclipse.escet.common.java.Pair.pair; +import static org.eclipse.escet.common.java.Strings.fmt; import java.util.Arrays; import java.util.BitSet; @@ -46,7 +47,7 @@ public class VarOrdererHelper { private final Specification spec; /** The synthesis variables, in their original order, before applying any algorithm on it. */ - private final SynthesisVariable[] variables; + private final List variables; /** For each synthesis variable in the original variable order, its 0-based index within that order. */ private final Map origIndices; @@ -63,19 +64,49 @@ public class VarOrdererHelper { */ private final Graph graph; + /** The number of characters to use for printing the total span metric in debug output. */ + private final int metricLengthTotalSpan; + + /** The number of characters to use for printing the total span metric, as average per edge, in debug output. */ + private final int metricLengthTotalSpanAvg; + + /** The number of characters to use for printing the Weighted Event Span (WES) metric in debug output. */ + private final int metricLengthWes; + + /** + * The number of characters to use for printing the Weighted Event Span (WES) metric, as average per edge, in debug + * output. + */ + private final int metricLengthWesAvg; + /** * Constructor for the {@link VarOrdererHelper} class. * * @param spec The CIF specification. * @param variables The synthesis variables, in their original order, before applying any algorithm on it. */ - public VarOrdererHelper(Specification spec, SynthesisVariable[] variables) { + public VarOrdererHelper(Specification spec, List variables) { + // Store the input. this.spec = spec; this.variables = variables; - this.origIndices = IntStream.range(0, variables.length).boxed() - .collect(Collectors.toMap(i -> variables[i], i -> i)); + + // Compute and store different representations of the specification. this.hyperEdges = createHyperEdges(); this.graph = createGraph(); + + // Store additional derivative information used to improve performance of some helper operations. + this.origIndices = IntStream.range(0, variables.size()).boxed() + .collect(Collectors.toMap(i -> variables.get(i), i -> i)); + + // Store the number of characters to use to print various metrics. We compute the length needed to print the + // current value of each metric, and allow for two additional characters. Based on the assumption that the + // metrics won't get a 100 times worse, this should provide enough space to neatly print them. If they do get + // over a 100 times worse, printing may be slightly less neat, but will still work. + this.metricLengthTotalSpan = fmt("%,d", computeTotalSpanForVarOrder(variables)).length() + 2; + this.metricLengthTotalSpanAvg = fmt("%,.2f", (double)computeTotalSpanForVarOrder(variables) / hyperEdges.length) + .length() + 2; + this.metricLengthWes = fmt("%,.6f", computeWesForVarOrder(variables)).length() + 2; + this.metricLengthWesAvg = fmt("%,.6f", computeWesForVarOrder(variables) / hyperEdges.length).length() + 2; } /** @@ -123,7 +154,7 @@ public class VarOrdererHelper { } // Create undirected weighted graph. - Graph graph = new Graph(variables.length); + Graph graph = new Graph(variables.size()); for (Entry, Integer> graphEdge: graphEdges.entrySet()) { Node ni = graph.node(graphEdge.getKey().left); Node nj = graph.node(graphEdge.getKey().right); @@ -168,7 +199,7 @@ public class VarOrdererHelper { } /** - * Computes the total span metric. + * Compute the total span metric. * * @param order The variable order. * @return The total span. @@ -179,7 +210,7 @@ public class VarOrdererHelper { } /** - * Computes the total span metric. + * Compute the total span metric. * * @param order The node order. * @return The total span. @@ -190,7 +221,7 @@ public class VarOrdererHelper { } /** - * Computes the total span metric. + * Compute the total span metric. * * @param newIndices For each variable, its new 0-based index. * @return The total span. @@ -216,51 +247,119 @@ public class VarOrdererHelper { } /** - * Prints the total span as debug output, for the given variable order. + * Compute the Weighted Event Span (WES) metric. + * + * @param order The variable order. + * @return The Weighted Event Span (WES). + */ + public double computeWesForVarOrder(List order) { + int[] newIndices = getNewIndicesForVarOrder(order); + return computeWesForNewIndices(newIndices); + } + + /** + * Compute the Weighted Event Span (WES) metric. + * + * @param order The node order. + * @return The Weighted Event Span (WES). + */ + public double computeWesForNodeOrder(List order) { + int[] newIndices = getNewIndicesForNodeOrder(order); + return computeWesForNewIndices(newIndices); + } + + /** + * Compute the Weighted Event Span (WES) metric. + * + * @param newIndices For each variable, its new 0-based index. + * @return The Weighted Event Span (WES). + */ + public double computeWesForNewIndices(int[] newIndices) { + // This method is based on formula 7 from: Sam Lousberg, Sander Thuijsman and Michel Reniers, "DSM-based + // variable ordering heuristic for reduced computational effort of symbolic supervisor synthesis", + // IFAC-PapersOnLine, volume 53, issue 4, pages 429-436, 2020, https://doi.org/10.1016/j.ifacol.2021.04.058. + // + // The formula is: WES = SUM_{e in E} (2 * x_b) / |x| * (x_b - x_t + 1) / (|x| * |E|) + // Where: + // 1) 'E' is the set of edges. We use the hyper-edges. + // 2) 'x' the current-state variables. We use the synthesis variables. + // 3) 'x_b'/'x_t' the indices of the bottom/top BDD-variable in 'T_e(X)', the transition relation of edge 'e'. + // Note that we use hyper-edges as edges. Also, variables in the variable order with lower indices are higher + // (less deep, closer to the root) in the BDDs, while variables with higher indices are lower (deeper, closer + // to the leafs) in the BDDs. Therefore, we use for each hyper-edge: the highest index of a variable with an + // enabled bit in that hyper-edge as 'x_b', and the lowest index of a variable with an enabled bit in that + // hyper-edge as 'x_t'. + double nx = variables.size(); + double nE = hyperEdges.length; + double wes = 0; + for (BitSet edge: hyperEdges) { + // Compute 'x_t' and 'x_b' for this edge. + int xT = Integer.MAX_VALUE; + int xB = 0; + for (int i: BitSets.iterateTrueBits(edge)) { + int newIdx = newIndices[i]; + xT = Math.min(xT, newIdx); + xB = Math.max(xB, newIdx); + } + + // Update WES for this edge. + wes += (2 * xB) / nx * (xB - xT + 1) / (nx * nE); + } + return wes; + } + + /** + * Print various metrics as debug output, for the given variable order. * * @param dbgLevel The debug indentation level. * @param order The variable order. - * @param annotation A human-readable text indicating the reason for printing the total span. + * @param annotation A human-readable text indicating the reason for printing the metrics. */ - public void dbgTotalSpanForVarOrder(int dbgLevel, List order, String annotation) { + public void dbgMetricsForVarOrder(int dbgLevel, List order, String annotation) { int[] newIndices = getNewIndicesForVarOrder(order); - dbgTotalSpanForNewIndices(dbgLevel, newIndices, annotation); + dbgMetricsForNewIndices(dbgLevel, newIndices, annotation); } /** - * Prints the total span as debug output, for the given node order. + * Print various metrics as debug output, for the given node order. * * @param dbgLevel The debug indentation level. * @param order The node order. - * @param annotation A human-readable text indicating the reason for printing the total span. + * @param annotation A human-readable text indicating the reason for printing the metrics. */ - public void dbgTotalSpanForNodeOrder(int dbgLevel, List order, String annotation) { + public void dbgMetricsForNodeOrder(int dbgLevel, List order, String annotation) { int[] newIndices = getNewIndicesForNodeOrder(order); - dbgTotalSpanForNewIndices(dbgLevel, newIndices, annotation); + dbgMetricsForNewIndices(dbgLevel, newIndices, annotation); } /** - * Prints the total span as debug output, for the given new indices of the variables. + * Print various metrics as debug output, for the given new indices of the variables. * * @param dbgLevel The debug indentation level. * @param newIndices For each variable, its new 0-based index. - * @param annotation A human-readable text indicating the reason for printing the total span. + * @param annotation A human-readable text indicating the reason for printing the metrics. */ - public void dbgTotalSpanForNewIndices(int dbgLevel, int[] newIndices, String annotation) { - long totalSpan = computeTotalSpanForNewIndices(newIndices); - dbgTotalSpan(dbgLevel, totalSpan, annotation); + public void dbgMetricsForNewIndices(int dbgLevel, int[] newIndices, String annotation) { + String msg = fmtMetrics(newIndices, annotation); + dbg(dbgLevel, msg); } /** - * Prints the given total span as debug output. + * Format various metrics, for the given new indices of the variables. * - * @param dbgLevel The debug indentation level. - * @param totalSpan The given total span. - * @param annotation A human-readable text indicating the reason for printing the total span. + * @param newIndices For each variable, its new 0-based index. + * @param annotation A human-readable text indicating the reason for formatting the metrics. + * @return The formatted metrics. */ - public void dbgTotalSpan(int dbgLevel, long totalSpan, String annotation) { - dbg(dbgLevel, "Total span: %,20d (total) %,20.2f (avg/edge) [%s]", totalSpan, - (double)totalSpan / hyperEdges.length, annotation); + public String fmtMetrics(int[] newIndices, String annotation) { + long totalSpan = computeTotalSpanForNewIndices(newIndices); + double wes = computeWesForNewIndices(newIndices); + String fmtTotalSpan = fmt("%," + metricLengthTotalSpan + "d", totalSpan); + String fmtTotalSpanAvg = fmt("%," + metricLengthTotalSpanAvg + ".2f", (double)totalSpan / hyperEdges.length); + String fmtWes = fmt("%," + metricLengthWes + ".6f", wes); + String fmtWesAvg = fmt("%," + metricLengthWesAvg + ".6f", wes / hyperEdges.length); + return fmt("Total span: %s (total) %s (avg/edge) / WES: %s (total) %s (avg/edge) [%s]", fmtTotalSpan, + fmtTotalSpanAvg, fmtWes, fmtWesAvg, annotation); } /** @@ -309,10 +408,10 @@ public class VarOrdererHelper { * @return The synthesis variables, in their new order. */ public List reorderForNewIndices(int[] newIndices) { - Assert.areEqual(variables.length, newIndices.length); - SynthesisVariable[] result = new SynthesisVariable[variables.length]; + Assert.areEqual(variables.size(), newIndices.length); + SynthesisVariable[] result = new SynthesisVariable[variables.size()]; for (int i = 0; i < newIndices.length; i++) { - result[newIndices[i]] = variables[i]; + result[newIndices[i]] = variables.get(i); } return Arrays.asList(result); } diff --git a/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererMetric.java b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererMetric.java new file mode 100644 index 0000000000000000000000000000000000000000..9f1dabfa721aa23945675706f8aad6fd89723aef --- /dev/null +++ b/cif/org.eclipse.escet.cif.datasynth/src/org/eclipse/escet/cif/datasynth/varorder/helper/VarOrdererMetric.java @@ -0,0 +1,30 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available +// under the terms of the MIT License which is available at +// https://opensource.org/licenses/MIT +// +// SPDX-License-Identifier: MIT +////////////////////////////////////////////////////////////////////////////// + +package org.eclipse.escet.cif.datasynth.varorder.helper; + +import java.util.List; + +import org.eclipse.escet.cif.datasynth.spec.SynthesisVariable; + +/** Variable orderer metric. Lower metric values (heuristically) indicate better variable orders. */ +public interface VarOrdererMetric { + /** + * Compute the metric value. Lower metric values (heuristically) indicate better variable orders. + * + * @param helper Helper for variable ordering algorithms. + * @param order The variable order. + * @return The metric value. + */ + public double compute(VarOrdererHelper helper, List order); +} diff --git a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth.asciidoc b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth.asciidoc index 97bad42db2bd6cf411aaa522f098e2ca4406d1d6..225a7ad91ce8315418e2e48955148856d704e481 100644 --- a/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth.asciidoc +++ b/cif/org.eclipse.escet.cif.documentation/asciidoc/tools/datasynth.asciidoc @@ -1128,7 +1128,7 @@ The following variable ordering algorithms are available: The DCSH algorithm of <> aims to find good global variable orders. + DCSH applies two algorithms, the Weighted Cuthill-McKee bandwidth-reducing algorithm and the Sloan profile/wavefront-reducing algorithm. -It then chooses the best order out of the orders produced by these two algorithms as well as their reverse orders, based on the total span metric. +It then chooses the best order out of the orders produced by these two algorithms as well as their reverse orders, based on the Weighted Event Span (WES) metric. + The DCSH algorithm is currently considered experimental. It is therefore disabled by default, but can be enabled using the _BDD DCSH variable ordering algorithm_ option (see <> section above). diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out index 33b444d73ce930c333d8036ddcc2d8a58c38a4a6..753b0732e71f3b28aef82117925193d4d44eeea4 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/alg_vars.cif.out @@ -20,14 +20,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 0.15 (avg/edge) [before] - Total span: 2 (total) 0.15 (avg/edge) [iteration 1] - Total span: 2 (total) 0.15 (avg/edge) [after] + Total span: 2 (total) 0.15 (avg/edge) / WES: 0.196923 (total) 0.015148 (avg/edge) [before] + Total span: 2 (total) 0.15 (avg/edge) / WES: 0.196923 (total) 0.015148 (avg/edge) [iteration 1] + Total span: 2 (total) 0.15 (avg/edge) / WES: 0.196923 (total) 0.015148 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 2 (total) 0.15 (avg/edge) [before] - Total span: 2 (total) 0.15 (avg/edge) [after] + Total span: 2 (total) 0.15 (avg/edge) / WES: 0.196923 (total) 0.015148 (avg/edge) [before] + Total span: 2 (total) 0.15 (avg/edge) / WES: 0.196923 (total) 0.015148 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out index 517211a81163aea437848ce07fdd2c3c206eb286..53253a0c79df0dd44779115ffba3fc9764311e6b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_div.cif.out @@ -21,16 +21,16 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 15 (total) 1.50 (avg/edge) [before] - Total span: 11 (total) 1.10 (avg/edge) [iteration 1] - Total span: 9 (total) 0.90 (avg/edge) [iteration 2] - Total span: 9 (total) 0.90 (avg/edge) [iteration 3] - Total span: 9 (total) 0.90 (avg/edge) [after] + Total span: 15 (total) 1.50 (avg/edge) / WES: 0.472222 (total) 0.047222 (avg/edge) [before] + Total span: 11 (total) 1.10 (avg/edge) / WES: 0.388889 (total) 0.038889 (avg/edge) [iteration 1] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [iteration 2] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [iteration 3] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 9 (total) 0.90 (avg/edge) [before] - Total span: 9 (total) 0.90 (avg/edge) [after] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [before] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out index e3831ae0acf63f2ca80f51132bc9c569a32d27a5..3cef743adabf2fa43b7cf4ff37a1b4a91f032eb8 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_mod.cif.out @@ -21,16 +21,16 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 15 (total) 1.50 (avg/edge) [before] - Total span: 11 (total) 1.10 (avg/edge) [iteration 1] - Total span: 9 (total) 0.90 (avg/edge) [iteration 2] - Total span: 9 (total) 0.90 (avg/edge) [iteration 3] - Total span: 9 (total) 0.90 (avg/edge) [after] + Total span: 15 (total) 1.50 (avg/edge) / WES: 0.472222 (total) 0.047222 (avg/edge) [before] + Total span: 11 (total) 1.10 (avg/edge) / WES: 0.388889 (total) 0.038889 (avg/edge) [iteration 1] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [iteration 2] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [iteration 3] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 9 (total) 0.90 (avg/edge) [before] - Total span: 9 (total) 0.90 (avg/edge) [after] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [before] + Total span: 9 (total) 0.90 (avg/edge) / WES: 0.338889 (total) 0.033889 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out index 70ff3f981b6ca354c06f36549cb961d037a7f7e9..227541d8e05a7c4c46c7c7c19ba3627550450cc1 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/asgn_var_copy.cif.out @@ -20,15 +20,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 8 (total) 1.00 (avg/edge) [before] - Total span: 6 (total) 0.75 (avg/edge) [iteration 1] - Total span: 6 (total) 0.75 (avg/edge) [iteration 2] - Total span: 6 (total) 0.75 (avg/edge) [after] + Total span: 8 (total) 1.00 (avg/edge) / WES: 0.420000 (total) 0.052500 (avg/edge) [before] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.340000 (total) 0.042500 (avg/edge) [iteration 1] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.340000 (total) 0.042500 (avg/edge) [iteration 2] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.340000 (total) 0.042500 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 6 (total) 0.75 (avg/edge) [before] - Total span: 6 (total) 0.75 (avg/edge) [after] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.340000 (total) 0.042500 (avg/edge) [before] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.340000 (total) 0.042500 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out index d6ef684310201a485bcc106af67777748368aa49..e1b43678867347f52b086c6016fc89cd3c4d3d2a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bad_locs.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.22 (avg/edge) [before] - Total span: 2 (total) 0.22 (avg/edge) [iteration 1] - Total span: 2 (total) 0.22 (avg/edge) [after] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [before] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [iteration 1] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.22 (avg/edge) [before] - Total span: 2 (total) 0.22 (avg/edge) [after] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [before] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out index ec9dc893c47ca4fe4383a02754115a2d432857a2..2692fba4bad01f36860ab1d9a344b264384f46e3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/bdd_out_nodes.cif.out @@ -21,15 +21,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 6 (total) 0.75 (avg/edge) [before] - Total span: 6 (total) 0.75 (avg/edge) [iteration 1] - Total span: 6 (total) 0.75 (avg/edge) [after] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.291667 (total) 0.036458 (avg/edge) [before] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.291667 (total) 0.036458 (avg/edge) [iteration 1] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.291667 (total) 0.036458 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 6 (total) 0.75 (avg/edge) [before] - Total span: 3 (total) 0.38 (avg/edge) [window 0..3] - Total span: 3 (total) 0.38 (avg/edge) [after] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.291667 (total) 0.036458 (avg/edge) [before] + Total span: 3 (total) 0.38 (avg/edge) / WES: 0.166667 (total) 0.020833 (avg/edge) [window 0..3] + Total span: 3 (total) 0.38 (avg/edge) / WES: 0.166667 (total) 0.020833 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out index b5b418b9521c0eeb95cac025de20b6166a204277..11947cde92b4731e1ae7549a6295c006e517f457 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/booleans.cif.out @@ -20,15 +20,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 1 (total) 0.13 (avg/edge) [iteration 1] - Total span: 1 (total) 0.13 (avg/edge) [iteration 2] - Total span: 1 (total) 0.13 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.190000 (total) 0.023750 (avg/edge) [before] + Total span: 1 (total) 0.13 (avg/edge) / WES: 0.110000 (total) 0.013750 (avg/edge) [iteration 1] + Total span: 1 (total) 0.13 (avg/edge) / WES: 0.110000 (total) 0.013750 (avg/edge) [iteration 2] + Total span: 1 (total) 0.13 (avg/edge) / WES: 0.110000 (total) 0.013750 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 1 (total) 0.13 (avg/edge) [before] - Total span: 1 (total) 0.13 (avg/edge) [after] + Total span: 1 (total) 0.13 (avg/edge) / WES: 0.110000 (total) 0.013750 (avg/edge) [before] + Total span: 1 (total) 0.13 (avg/edge) / WES: 0.110000 (total) 0.013750 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out index 577ea0d27fab7fd88c167e48e58a161a5d7377f5..0bc8433c13ded8736d28be48519f9e273e13faeb 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/channel.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.27 (avg/edge) [before] - Total span: 3 (total) 0.27 (avg/edge) [iteration 1] - Total span: 3 (total) 0.27 (avg/edge) [after] + Total span: 3 (total) 0.27 (avg/edge) / WES: 0.262626 (total) 0.023875 (avg/edge) [before] + Total span: 3 (total) 0.27 (avg/edge) / WES: 0.262626 (total) 0.023875 (avg/edge) [iteration 1] + Total span: 3 (total) 0.27 (avg/edge) / WES: 0.262626 (total) 0.023875 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.27 (avg/edge) [before] - Total span: 3 (total) 0.27 (avg/edge) [after] + Total span: 3 (total) 0.27 (avg/edge) / WES: 0.262626 (total) 0.023875 (avg/edge) [before] + Total span: 3 (total) 0.27 (avg/edge) / WES: 0.262626 (total) 0.023875 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out index 0b939529aefd4c1a82e4edf74978be234ae6446b..8875514c6c68b8fcf124dad18ed44c7dac511999 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/ctrl_sys.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [iteration 1] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [iteration 1] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out index 219fd1e6aca520b4e9f53d0da87d76612f90bb3a..97744f727d335064a7819e29162694964d1f8d13 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/diamond.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 6 (total) 1.50 (avg/edge) [before] - Total span: 4 (total) 1.00 (avg/edge) [iteration 1] - Total span: 4 (total) 1.00 (avg/edge) [iteration 2] - Total span: 4 (total) 1.00 (avg/edge) [after] + Total span: 6 (total) 1.50 (avg/edge) / WES: 1.111111 (total) 0.277778 (avg/edge) [before] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [iteration 1] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [iteration 2] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 4 (total) 1.00 (avg/edge) [before] - Total span: 4 (total) 1.00 (avg/edge) [after] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [before] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out index af796243619eaf939fcfbb4f02c89a2cfedd947b..42cd702f9c5d093e9ed4bcacfda36a2260553105 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/dining_philosophers4.cif.out @@ -23,16 +23,16 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 30 - Total span: 51 (total) 4.25 (avg/edge) [before] - Total span: 27 (total) 2.25 (avg/edge) [iteration 1] - Total span: 26 (total) 2.17 (avg/edge) [iteration 2] - Total span: 26 (total) 2.17 (avg/edge) [iteration 3] - Total span: 26 (total) 2.17 (avg/edge) [after] + Total span: 51 (total) 4.25 (avg/edge) / WES: 0.929688 (total) 0.077474 (avg/edge) [before] + Total span: 27 (total) 2.25 (avg/edge) / WES: 0.494792 (total) 0.041233 (avg/edge) [iteration 1] + Total span: 26 (total) 2.17 (avg/edge) / WES: 0.466146 (total) 0.038845 (avg/edge) [iteration 2] + Total span: 26 (total) 2.17 (avg/edge) / WES: 0.466146 (total) 0.038845 (avg/edge) [iteration 3] + Total span: 26 (total) 2.17 (avg/edge) / WES: 0.466146 (total) 0.038845 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 26 (total) 2.17 (avg/edge) [before] - Total span: 26 (total) 2.17 (avg/edge) [after] + Total span: 26 (total) 2.17 (avg/edge) / WES: 0.466146 (total) 0.038845 (avg/edge) [before] + Total span: 26 (total) 2.17 (avg/edge) / WES: 0.466146 (total) 0.038845 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out index d2b2428e28ad2a8e3bd3fc5e34a0d6248301ebe9..5378300f438bd40389e111124497c1aa00e91bfe 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/double_loop.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 5 (total) 0.23 (avg/edge) [before] - Total span: 5 (total) 0.23 (avg/edge) [iteration 1] - Total span: 5 (total) 0.23 (avg/edge) [after] + Total span: 5 (total) 0.23 (avg/edge) / WES: 0.424242 (total) 0.019284 (avg/edge) [before] + Total span: 5 (total) 0.23 (avg/edge) / WES: 0.424242 (total) 0.019284 (avg/edge) [iteration 1] + Total span: 5 (total) 0.23 (avg/edge) / WES: 0.424242 (total) 0.019284 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 5 (total) 0.23 (avg/edge) [before] - Total span: 5 (total) 0.23 (avg/edge) [after] + Total span: 5 (total) 0.23 (avg/edge) / WES: 0.424242 (total) 0.019284 (avg/edge) [before] + Total span: 5 (total) 0.23 (avg/edge) / WES: 0.424242 (total) 0.019284 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out index 4e9c5df3f03d6e724f66b12b70e32c24a158d986..ea65c8ac05ae23eb606c70798ad7080491ef0e02 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/event_warnings.cif.out @@ -22,15 +22,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 18 (total) 0.45 (avg/edge) [before] - Total span: 18 (total) 0.45 (avg/edge) [iteration 1] - Total span: 18 (total) 0.45 (avg/edge) [after] + Total span: 18 (total) 0.45 (avg/edge) / WES: 0.150000 (total) 0.003750 (avg/edge) [before] + Total span: 18 (total) 0.45 (avg/edge) / WES: 0.150000 (total) 0.003750 (avg/edge) [iteration 1] + Total span: 18 (total) 0.45 (avg/edge) / WES: 0.150000 (total) 0.003750 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 18 (total) 0.45 (avg/edge) [before] - Total span: 11 (total) 0.28 (avg/edge) [window 0..3] - Total span: 11 (total) 0.28 (avg/edge) [after] + Total span: 18 (total) 0.45 (avg/edge) / WES: 0.150000 (total) 0.003750 (avg/edge) [before] + Total span: 11 (total) 0.28 (avg/edge) / WES: 0.131633 (total) 0.003291 (avg/edge) [window 0..3] + Total span: 11 (total) 0.28 (avg/edge) / WES: 0.131633 (total) 0.003291 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out index 7ff2dc461d0bb631600dfa7a9f99dad6fe695d9d..db5b759c754c3a9ba6b7504d480a8e4a92140c81 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/example_button_lamp.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 6 (total) 1.50 (avg/edge) [before] - Total span: 4 (total) 1.00 (avg/edge) [iteration 1] - Total span: 4 (total) 1.00 (avg/edge) [iteration 2] - Total span: 4 (total) 1.00 (avg/edge) [after] + Total span: 6 (total) 1.50 (avg/edge) / WES: 1.111111 (total) 0.277778 (avg/edge) [before] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [iteration 1] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [iteration 2] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 4 (total) 1.00 (avg/edge) [before] - Total span: 4 (total) 1.00 (avg/edge) [after] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [before] + Total span: 4 (total) 1.00 (avg/edge) / WES: 0.666667 (total) 0.166667 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out index 8b08b19437e3706cd382f7814e35946cd18edd7c..1e178b86a3185834cbb3e13e3b12c8a47e2d541a 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2a.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [iteration 1] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [iteration 1] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.625000 (total) 0.078125 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out index 3215049aba5df5e8e63af36e1febdbfd2b938a9f..ce27d5e1bb50265b38c8a202309f912504f38cc0 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/fig2b.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.22 (avg/edge) [before] - Total span: 2 (total) 0.22 (avg/edge) [iteration 1] - Total span: 2 (total) 0.22 (avg/edge) [after] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [before] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [iteration 1] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.22 (avg/edge) [before] - Total span: 2 (total) 0.22 (avg/edge) [after] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [before] + Total span: 2 (total) 0.22 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out index 6d4f37741edad2998609d4ae594f5aa77520927f..b371fca54f8892fa7f8960ea45b640bcb165fb75 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_off.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.12 (avg/edge) [before] - Total span: 2 (total) 0.12 (avg/edge) [iteration 1] - Total span: 2 (total) 0.12 (avg/edge) [after] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [before] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [iteration 1] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.12 (avg/edge) [before] - Total span: 2 (total) 0.12 (avg/edge) [after] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [before] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out index ee58aa1e15bba5ca4d3a1a461c907fab3df4f325..0447036d4f8a48889d79f4c4fbf08f724637d7d2 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/forward_reach_on.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.12 (avg/edge) [before] - Total span: 2 (total) 0.12 (avg/edge) [iteration 1] - Total span: 2 (total) 0.12 (avg/edge) [after] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [before] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [iteration 1] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.12 (avg/edge) [before] - Total span: 2 (total) 0.12 (avg/edge) [after] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [before] + Total span: 2 (total) 0.12 (avg/edge) / WES: 0.117647 (total) 0.006920 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out index e89f310d8349d552ea2766001f9b526338df18fc..8c4855f73da9bd007d3d7c0387fc365038540bce 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/guards_upds.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.43 (avg/edge) [before] - Total span: 3 (total) 0.43 (avg/edge) [iteration 1] - Total span: 3 (total) 0.43 (avg/edge) [after] + Total span: 3 (total) 0.43 (avg/edge) / WES: 0.476190 (total) 0.068027 (avg/edge) [before] + Total span: 3 (total) 0.43 (avg/edge) / WES: 0.476190 (total) 0.068027 (avg/edge) [iteration 1] + Total span: 3 (total) 0.43 (avg/edge) / WES: 0.476190 (total) 0.068027 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.43 (avg/edge) [before] - Total span: 3 (total) 0.43 (avg/edge) [after] + Total span: 3 (total) 0.43 (avg/edge) / WES: 0.476190 (total) 0.068027 (avg/edge) [before] + Total span: 3 (total) 0.43 (avg/edge) / WES: 0.476190 (total) 0.068027 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out index d52aa0087a6b7d271c9b505f98e45bc9b9b3739f..d5c42c2d65ff6469f226f2392a904dd4b1354b45 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_expr.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 3 (total) 0.60 (avg/edge) [iteration 1] - Total span: 3 (total) 0.60 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [iteration 1] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 2 (total) 0.40 (avg/edge) [window 0..2] - Total span: 2 (total) 0.40 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [window 0..2] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out index 3d5b46a268f0e0c0d6a59cffb6df7bc95c3d514c..5a2b4fa63b873c391a93f862cb2ba7a04feb874c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/if_preds.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 3 (total) 0.60 (avg/edge) [iteration 1] - Total span: 3 (total) 0.60 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [iteration 1] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 2 (total) 0.40 (avg/edge) [window 0..2] - Total span: 2 (total) 0.40 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [window 0..2] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out index ea27ddff44c6d6727be2654ede55fd7e161f9bf1..180a0e72b456fe626a36e6a640d2832e5bfd2ced 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars1.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 2.00 (avg/edge) [before] - Total span: 2 (total) 2.00 (avg/edge) [iteration 1] - Total span: 2 (total) 2.00 (avg/edge) [after] + Total span: 2 (total) 2.00 (avg/edge) / WES: 1.333333 (total) 1.333333 (avg/edge) [before] + Total span: 2 (total) 2.00 (avg/edge) / WES: 1.333333 (total) 1.333333 (avg/edge) [iteration 1] + Total span: 2 (total) 2.00 (avg/edge) / WES: 1.333333 (total) 1.333333 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 2 (total) 2.00 (avg/edge) [before] - Total span: 2 (total) 2.00 (avg/edge) [after] + Total span: 2 (total) 2.00 (avg/edge) / WES: 1.333333 (total) 1.333333 (avg/edge) [before] + Total span: 2 (total) 2.00 (avg/edge) / WES: 1.333333 (total) 1.333333 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out index 82953ac4dee08948a3d22d03dfc60c9ddbfe7247..f82efbd7cff82c9f058497b9eb5c9fd4c55ad408 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars3.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 0.50 (avg/edge) [before] - Total span: 2 (total) 0.50 (avg/edge) [iteration 1] - Total span: 2 (total) 0.50 (avg/edge) [after] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.444444 (total) 0.111111 (avg/edge) [before] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.444444 (total) 0.111111 (avg/edge) [iteration 1] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.444444 (total) 0.111111 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 2 (total) 0.50 (avg/edge) [before] - Total span: 2 (total) 0.50 (avg/edge) [after] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.444444 (total) 0.111111 (avg/edge) [before] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.444444 (total) 0.111111 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out index de1859420e7abca4d6c9ba1b4aae7b4fda35da89..807656b5e1b0c8204b44d8bd24b64c58eec42763 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/input_vars7.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 1 (total) 1.00 (avg/edge) [before] - Total span: 1 (total) 1.00 (avg/edge) [iteration 1] - Total span: 1 (total) 1.00 (avg/edge) [after] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.888889 (total) 0.888889 (avg/edge) [before] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.444444 (total) 0.444444 (avg/edge) [iteration 1] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.888889 (total) 0.888889 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 1 (total) 1.00 (avg/edge) [before] - Total span: 1 (total) 1.00 (avg/edge) [after] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.888889 (total) 0.888889 (avg/edge) [before] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.888889 (total) 0.888889 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out index cfa52eed97e0e5fa3077748af0cde8d5050ccc2f..6424fe68b55e7249cacddcf2b564ac6535829bd6 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_plant_loc.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 4 (total) 0.08 (avg/edge) [before] - Total span: 4 (total) 0.08 (avg/edge) [iteration 1] - Total span: 4 (total) 0.08 (avg/edge) [after] + Total span: 4 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.009600 (avg/edge) [before] + Total span: 4 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.009600 (avg/edge) [iteration 1] + Total span: 4 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.009600 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 4 (total) 0.08 (avg/edge) [before] - Total span: 4 (total) 0.08 (avg/edge) [after] + Total span: 4 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.009600 (avg/edge) [before] + Total span: 4 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.009600 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out index 37daa0dbce9b11102f315dbafd0180ced9003213..3bd34b7ee4e74dc1ac317e9d957447b4ba501a16 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/inv_state_evt_exclusion_req_loc.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.08 (avg/edge) [before] - Total span: 2 (total) 0.08 (avg/edge) [iteration 1] - Total span: 2 (total) 0.08 (avg/edge) [after] + Total span: 2 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.019200 (avg/edge) [before] + Total span: 2 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.019200 (avg/edge) [iteration 1] + Total span: 2 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.019200 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.08 (avg/edge) [before] - Total span: 2 (total) 0.08 (avg/edge) [after] + Total span: 2 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.019200 (avg/edge) [before] + Total span: 2 (total) 0.08 (avg/edge) / WES: 0.480000 (total) 0.019200 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/invalid8.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/invalid8.cif.out index f7d105d5894ad7b7240f079519ccd3a6af3d14d9..31a6d20f03a848ae59a3937ef576efe352dfa4bf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/invalid8.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/invalid8.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 1 (total) 0.04 (avg/edge) [before] - Total span: 1 (total) 0.04 (avg/edge) [iteration 1] - Total span: 1 (total) 0.04 (avg/edge) [after] + Total span: 1 (total) 0.04 (avg/edge) / WES: 0.077295 (total) 0.003361 (avg/edge) [before] + Total span: 1 (total) 0.04 (avg/edge) / WES: 0.077295 (total) 0.003361 (avg/edge) [iteration 1] + Total span: 1 (total) 0.04 (avg/edge) / WES: 0.077295 (total) 0.003361 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 1 (total) 0.04 (avg/edge) [before] - Total span: 1 (total) 0.04 (avg/edge) [after] + Total span: 1 (total) 0.04 (avg/edge) / WES: 0.077295 (total) 0.003361 (avg/edge) [before] + Total span: 1 (total) 0.04 (avg/edge) / WES: 0.077295 (total) 0.003361 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out index 368310711dd8bad56193b79ab820fb369f4b9923..5e674055de77567cf01408d5e5ba1c98d84e3ca6 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/loop.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.50 (avg/edge) [before] - Total span: 2 (total) 0.50 (avg/edge) [iteration 1] - Total span: 2 (total) 0.50 (avg/edge) [after] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.750000 (total) 0.187500 (avg/edge) [before] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.750000 (total) 0.187500 (avg/edge) [iteration 1] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.750000 (total) 0.187500 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.50 (avg/edge) [before] - Total span: 2 (total) 0.50 (avg/edge) [after] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.750000 (total) 0.187500 (avg/edge) [before] + Total span: 2 (total) 0.50 (avg/edge) / WES: 0.750000 (total) 0.187500 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out index c66390b5018c1cecfe45ceaad967f0f72bc86f13..66faedd415a98cad82bc71cd1e8ef171735782ba 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/many_rounds.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 7 (total) 0.37 (avg/edge) [before] - Total span: 7 (total) 0.37 (avg/edge) [iteration 1] - Total span: 7 (total) 0.37 (avg/edge) [after] + Total span: 7 (total) 0.37 (avg/edge) / WES: 0.684211 (total) 0.036011 (avg/edge) [before] + Total span: 7 (total) 0.37 (avg/edge) / WES: 0.684211 (total) 0.036011 (avg/edge) [iteration 1] + Total span: 7 (total) 0.37 (avg/edge) / WES: 0.684211 (total) 0.036011 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 7 (total) 0.37 (avg/edge) [before] - Total span: 7 (total) 0.37 (avg/edge) [after] + Total span: 7 (total) 0.37 (avg/edge) / WES: 0.684211 (total) 0.036011 (avg/edge) [before] + Total span: 7 (total) 0.37 (avg/edge) / WES: 0.684211 (total) 0.036011 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out index c58f638772b1a04a16b6ba4c409b0e6293114fd7..85d299c06048478ab146d188f3b84b06d2f95ff3 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/marking1.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 1.00 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [iteration 1] - Total span: 1 (total) 0.50 (avg/edge) [iteration 2] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 2 (total) 1.00 (avg/edge) / WES: 0.888889 (total) 0.444444 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.333333 (total) 0.166667 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.333333 (total) 0.166667 (avg/edge) [iteration 2] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.333333 (total) 0.166667 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.333333 (total) 0.166667 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.333333 (total) 0.166667 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out index 16889745351fe63ed8491286495b0e62b345803e..1c89838e8886e4e382538dcac975ded963bc6c05 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_plants.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 4 (total) 0.67 (avg/edge) [before] - Total span: 4 (total) 0.67 (avg/edge) [iteration 1] - Total span: 4 (total) 0.67 (avg/edge) [after] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [before] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [iteration 1] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 4 (total) 0.67 (avg/edge) [before] - Total span: 4 (total) 0.67 (avg/edge) [after] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [before] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out index 48125be1b3d842e3b9019f5c0bbc96107f28193d..8e55a925180c2cd6ad732575552a171dd048b52f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_auts.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.75 (avg/edge) [before] - Total span: 3 (total) 0.75 (avg/edge) [iteration 1] - Total span: 3 (total) 0.75 (avg/edge) [after] + Total span: 3 (total) 0.75 (avg/edge) / WES: 0.555556 (total) 0.138889 (avg/edge) [before] + Total span: 3 (total) 0.75 (avg/edge) / WES: 0.555556 (total) 0.138889 (avg/edge) [iteration 1] + Total span: 3 (total) 0.75 (avg/edge) / WES: 0.555556 (total) 0.138889 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.75 (avg/edge) [before] - Total span: 3 (total) 0.75 (avg/edge) [after] + Total span: 3 (total) 0.75 (avg/edge) / WES: 0.555556 (total) 0.138889 (avg/edge) [before] + Total span: 3 (total) 0.75 (avg/edge) / WES: 0.555556 (total) 0.138889 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out index c91875edb5d89cecd8f8bb6e734771feaa39d756..5f42c0988214e414d280bcf8cf0ce36d45928a36 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs1.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.09 (avg/edge) [before] - Total span: 1 (total) 0.09 (avg/edge) [iteration 1] - Total span: 1 (total) 0.09 (avg/edge) [after] + Total span: 1 (total) 0.09 (avg/edge) / WES: 0.272727 (total) 0.024793 (avg/edge) [before] + Total span: 1 (total) 0.09 (avg/edge) / WES: 0.272727 (total) 0.024793 (avg/edge) [iteration 1] + Total span: 1 (total) 0.09 (avg/edge) / WES: 0.272727 (total) 0.024793 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.09 (avg/edge) [before] - Total span: 1 (total) 0.09 (avg/edge) [after] + Total span: 1 (total) 0.09 (avg/edge) / WES: 0.272727 (total) 0.024793 (avg/edge) [before] + Total span: 1 (total) 0.09 (avg/edge) / WES: 0.272727 (total) 0.024793 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out index 5ff2eea12319eb44806842f3370c7370b402ff18..d8299fd1b3f13c762b4d7b3c877d5ea92982dd1f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/multi_req_invs2.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 5 (total) 0.45 (avg/edge) [before] - Total span: 5 (total) 0.45 (avg/edge) [iteration 1] - Total span: 5 (total) 0.45 (avg/edge) [after] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.590909 (total) 0.053719 (avg/edge) [before] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.590909 (total) 0.053719 (avg/edge) [iteration 1] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.590909 (total) 0.053719 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 5 (total) 0.45 (avg/edge) [before] - Total span: 5 (total) 0.45 (avg/edge) [after] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.590909 (total) 0.053719 (avg/edge) [before] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.590909 (total) 0.053719 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out index 24bda63e7c7f60ef011d4caf25ca904eeff2da2a..1dc41ed5b4fb770107a6fcef5d06f4c7e02a9410 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex1.cif.out @@ -19,15 +19,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 6 (total) 0.55 (avg/edge) [before] - Total span: 6 (total) 0.55 (avg/edge) [iteration 1] - Total span: 6 (total) 0.55 (avg/edge) [after] + Total span: 6 (total) 0.55 (avg/edge) / WES: 0.397727 (total) 0.036157 (avg/edge) [before] + Total span: 6 (total) 0.55 (avg/edge) / WES: 0.397727 (total) 0.036157 (avg/edge) [iteration 1] + Total span: 6 (total) 0.55 (avg/edge) / WES: 0.397727 (total) 0.036157 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 6 (total) 0.55 (avg/edge) [before] - Total span: 5 (total) 0.45 (avg/edge) [window 0..3] - Total span: 5 (total) 0.45 (avg/edge) [after] + Total span: 6 (total) 0.55 (avg/edge) / WES: 0.397727 (total) 0.036157 (avg/edge) [before] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.329545 (total) 0.029959 (avg/edge) [window 0..3] + Total span: 5 (total) 0.45 (avg/edge) / WES: 0.329545 (total) 0.029959 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out index e37a61d6a94266bdb69176206d5196bc5b65e142..55e32e992c0f5e2e8cebc1f193dea1c11c52559d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/mutex2.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.14 (avg/edge) [before] - Total span: 1 (total) 0.14 (avg/edge) [iteration 1] - Total span: 1 (total) 0.14 (avg/edge) [after] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.357143 (total) 0.051020 (avg/edge) [before] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.357143 (total) 0.051020 (avg/edge) [iteration 1] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.357143 (total) 0.051020 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.14 (avg/edge) [before] - Total span: 1 (total) 0.14 (avg/edge) [after] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.357143 (total) 0.051020 (avg/edge) [before] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.357143 (total) 0.051020 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out index cca55d3ec8528d361519a21465d321bca96f9da6..6f5683aac3a58bcec62cf80e1f85e7c4c32e5e94 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/namespace.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 4 (total) 0.67 (avg/edge) [before] - Total span: 4 (total) 0.67 (avg/edge) [iteration 1] - Total span: 4 (total) 0.67 (avg/edge) [after] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.518519 (total) 0.086420 (avg/edge) [before] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.518519 (total) 0.086420 (avg/edge) [iteration 1] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.518519 (total) 0.086420 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 4 (total) 0.67 (avg/edge) [before] - Total span: 3 (total) 0.50 (avg/edge) [window 0..2] - Total span: 3 (total) 0.50 (avg/edge) [after] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.518519 (total) 0.086420 (avg/edge) [before] + Total span: 3 (total) 0.50 (avg/edge) / WES: 0.370370 (total) 0.061728 (avg/edge) [window 0..2] + Total span: 3 (total) 0.50 (avg/edge) / WES: 0.370370 (total) 0.061728 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out index c8162a7be137c1d3dbb5d4fd33798b84ab44790c..c147367651957b1c9bc1f41ab97642eb9fc4a638 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/no_marked1.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 2.00 (avg/edge) [before] - Total span: 1 (total) 1.00 (avg/edge) [iteration 1] - Total span: 1 (total) 1.00 (avg/edge) [iteration 2] - Total span: 1 (total) 1.00 (avg/edge) [after] + Total span: 2 (total) 2.00 (avg/edge) / WES: 1.333333 (total) 1.333333 (avg/edge) [before] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.444444 (total) 0.444444 (avg/edge) [iteration 1] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.444444 (total) 0.444444 (avg/edge) [iteration 2] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.444444 (total) 0.444444 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 1 (total) 1.00 (avg/edge) [before] - Total span: 1 (total) 1.00 (avg/edge) [after] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.444444 (total) 0.444444 (avg/edge) [before] + Total span: 1 (total) 1.00 (avg/edge) / WES: 0.444444 (total) 0.444444 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out index 618f456dac8c19d6c49b0671730e06caededb5a0..fa1ccf7569091417968cde751de95745cc843c81 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/non_determinism.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 5 (total) 0.83 (avg/edge) [before] - Total span: 5 (total) 0.83 (avg/edge) [iteration 1] - Total span: 5 (total) 0.83 (avg/edge) [after] + Total span: 5 (total) 0.83 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [before] + Total span: 5 (total) 0.83 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [iteration 1] + Total span: 5 (total) 0.83 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 5 (total) 0.83 (avg/edge) [before] - Total span: 4 (total) 0.67 (avg/edge) [window 0..2] - Total span: 4 (total) 0.67 (avg/edge) [after] + Total span: 5 (total) 0.83 (avg/edge) / WES: 0.629630 (total) 0.104938 (avg/edge) [before] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.555556 (total) 0.092593 (avg/edge) [window 0..2] + Total span: 4 (total) 0.67 (avg/edge) / WES: 0.555556 (total) 0.092593 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out index 6d842a54189239e0dd8ad5274aa9391fb5f97a54..631306e85e9831b7e07ed31dbe04ad1bf4fd0eba 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/predicates.cif.out @@ -24,17 +24,17 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 30 - Total span: 183 (total) 1.74 (avg/edge) [before] - Total span: 103 (total) 0.98 (avg/edge) [iteration 1] - Total span: 92 (total) 0.88 (avg/edge) [iteration 2] - Total span: 92 (total) 0.88 (avg/edge) [iteration 3] - Total span: 92 (total) 0.88 (avg/edge) [after] + Total span: 183 (total) 1.74 (avg/edge) / WES: 0.295591 (total) 0.002815 (avg/edge) [before] + Total span: 103 (total) 0.98 (avg/edge) / WES: 0.217519 (total) 0.002072 (avg/edge) [iteration 1] + Total span: 92 (total) 0.88 (avg/edge) / WES: 0.193768 (total) 0.001845 (avg/edge) [iteration 2] + Total span: 92 (total) 0.88 (avg/edge) / WES: 0.193768 (total) 0.001845 (avg/edge) [iteration 3] + Total span: 92 (total) 0.88 (avg/edge) / WES: 0.193768 (total) 0.001845 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 92 (total) 0.88 (avg/edge) [before] - Total span: 88 (total) 0.84 (avg/edge) [window 3..6] - Total span: 88 (total) 0.84 (avg/edge) [after] + Total span: 92 (total) 0.88 (avg/edge) / WES: 0.193768 (total) 0.001845 (avg/edge) [before] + Total span: 88 (total) 0.84 (avg/edge) / WES: 0.186008 (total) 0.001772 (avg/edge) [window 3..6] + Total span: 88 (total) 0.84 (avg/edge) / WES: 0.186008 (total) 0.001772 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out index 57d0cb9a9184b69fc4ac9a2e25dafdb8dffb9a8c..217f3ed03a382ce0e2dd8f2d07d1d801cfa0fbab 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_counter.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.33 (avg/edge) [before] - Total span: 2 (total) 0.33 (avg/edge) [iteration 1] - Total span: 2 (total) 0.33 (avg/edge) [after] + Total span: 2 (total) 0.33 (avg/edge) / WES: 0.666667 (total) 0.111111 (avg/edge) [before] + Total span: 2 (total) 0.33 (avg/edge) / WES: 0.666667 (total) 0.111111 (avg/edge) [iteration 1] + Total span: 2 (total) 0.33 (avg/edge) / WES: 0.666667 (total) 0.111111 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.33 (avg/edge) [before] - Total span: 2 (total) 0.33 (avg/edge) [after] + Total span: 2 (total) 0.33 (avg/edge) / WES: 0.666667 (total) 0.111111 (avg/edge) [before] + Total span: 2 (total) 0.33 (avg/edge) / WES: 0.666667 (total) 0.111111 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out index 70fbdf69d44615dd07b08404825c97918d376944..91381dd30ca2bd376fc6c339dd1517e765d05a65 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_ctrl.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.14 (avg/edge) [before] - Total span: 1 (total) 0.14 (avg/edge) [iteration 1] - Total span: 1 (total) 0.14 (avg/edge) [after] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [before] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [iteration 1] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.14 (avg/edge) [before] - Total span: 1 (total) 0.14 (avg/edge) [after] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [before] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out index b14526ed06e6480cb2b8647ffee2b563417199f6..9f075b640ebd8a958ee1af7bb02c993ec254df28 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_evt_not_in_plant_unctrl.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.14 (avg/edge) [before] - Total span: 1 (total) 0.14 (avg/edge) [iteration 1] - Total span: 1 (total) 0.14 (avg/edge) [after] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [before] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [iteration 1] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.14 (avg/edge) [before] - Total span: 1 (total) 0.14 (avg/edge) [after] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [before] + Total span: 1 (total) 0.14 (avg/edge) / WES: 0.214286 (total) 0.030612 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_loc_no_name.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_loc_no_name.cif.out index 0d83673e45dc16aff3cf08d0cb04e96e7c8b3e8c..0fb3596c7e652cdb880dd4c90e18a835c8964512 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_loc_no_name.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_loc_no_name.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.67 (avg/edge) [before] - Total span: 2 (total) 0.67 (avg/edge) [iteration 1] - Total span: 2 (total) 0.67 (avg/edge) [after] + Total span: 2 (total) 0.67 (avg/edge) / WES: 0.833333 (total) 0.277778 (avg/edge) [before] + Total span: 2 (total) 0.67 (avg/edge) / WES: 0.833333 (total) 0.277778 (avg/edge) [iteration 1] + Total span: 2 (total) 0.67 (avg/edge) / WES: 0.833333 (total) 0.277778 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.67 (avg/edge) [before] - Total span: 2 (total) 0.67 (avg/edge) [after] + Total span: 2 (total) 0.67 (avg/edge) / WES: 0.833333 (total) 0.277778 (avg/edge) [before] + Total span: 2 (total) 0.67 (avg/edge) / WES: 0.833333 (total) 0.277778 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out index 3050084e5626724b594bdddc711719a932b9eef3..f98041cc2482698909873355a98da28efacfbe55 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/req_monitor.cif.out @@ -19,14 +19,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 6 (total) 0.75 (avg/edge) [before] - Total span: 6 (total) 0.75 (avg/edge) [iteration 1] - Total span: 6 (total) 0.75 (avg/edge) [after] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.562500 (total) 0.070313 (avg/edge) [before] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.515625 (total) 0.064453 (avg/edge) [iteration 1] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.562500 (total) 0.070313 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 6 (total) 0.75 (avg/edge) [before] - Total span: 6 (total) 0.75 (avg/edge) [after] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.562500 (total) 0.070313 (avg/edge) [before] + Total span: 6 (total) 0.75 (avg/edge) / WES: 0.562500 (total) 0.070313 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out index 76fbb676de9f187ff21260fb6affbb3d97f164f0..9c7e981a17e0e810a15d618a7efd7e53feb01f80 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/scopes.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.40 (avg/edge) [before] - Total span: 2 (total) 0.40 (avg/edge) [iteration 1] - Total span: 2 (total) 0.40 (avg/edge) [after] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.500000 (total) 0.100000 (avg/edge) [before] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.500000 (total) 0.100000 (avg/edge) [iteration 1] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.500000 (total) 0.100000 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.40 (avg/edge) [before] - Total span: 2 (total) 0.40 (avg/edge) [after] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.500000 (total) 0.100000 (avg/edge) [before] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.500000 (total) 0.100000 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out index 7c7b6d12d215881ed2f91ede7ebf13e625f2240b..ec929b091de80b283a7a05125f1b8dad0ac85423 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/seq.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 3 (total) 0.33 (avg/edge) [before] - Total span: 3 (total) 0.33 (avg/edge) [iteration 1] - Total span: 3 (total) 0.33 (avg/edge) [after] + Total span: 3 (total) 0.33 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [before] + Total span: 3 (total) 0.33 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [iteration 1] + Total span: 3 (total) 0.33 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 3 (total) 0.33 (avg/edge) [before] - Total span: 3 (total) 0.33 (avg/edge) [after] + Total span: 3 (total) 0.33 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [before] + Total span: 3 (total) 0.33 (avg/edge) / WES: 0.611111 (total) 0.067901 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out index e8bf5570dac3a75b4eeb467646efae0ed74d65e3..e59d80eb6f62b0bf2bb5eff2c72fdc57d615c24f 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_off.cif.out @@ -19,14 +19,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [iteration 1] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [iteration 1] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out index 77f622380a3f0d374c9fcd182b21bd6f533e12bc..5c0add15b873eac9a7c6c6207bf6d2d350c4ae65 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_ctrl_beh_on.cif.out @@ -19,14 +19,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [iteration 1] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [iteration 1] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 2 (total) 0.25 (avg/edge) [before] - Total span: 2 (total) 0.25 (avg/edge) [after] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [before] + Total span: 2 (total) 0.25 (avg/edge) / WES: 0.281250 (total) 0.035156 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out index 923b22a149a8db6814eb24cb52b5b0c0286f2f91..3b343014b3b646fda50951a1ac65d68270d9d02c 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_all.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 1 (total) 0.20 (avg/edge) [before] - Total span: 1 (total) 0.20 (avg/edge) [iteration 1] - Total span: 1 (total) 0.20 (avg/edge) [after] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [before] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [iteration 1] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 1 (total) 0.20 (avg/edge) [before] - Total span: 1 (total) 0.20 (avg/edge) [after] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [before] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out index 956f49a51b24f4c3b8b9cb6f7250a1ec88412f24..dc905e7b0de34bda9a5e985e791de4f5c32222b9 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_propagation_none.cif.out @@ -18,14 +18,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 1 (total) 0.20 (avg/edge) [before] - Total span: 1 (total) 0.20 (avg/edge) [iteration 1] - Total span: 1 (total) 0.20 (avg/edge) [after] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [before] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [iteration 1] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 1 (total) 0.20 (avg/edge) [before] - Total span: 1 (total) 0.20 (avg/edge) [after] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [before] + Total span: 1 (total) 0.20 (avg/edge) / WES: 0.311111 (total) 0.062222 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out index 21aba9eae4d6b7c004e89a98210ecf89eec80a0c..b03160aa1e2082a4a2ad5e57d675797ca272721d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_off.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [iteration 1] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out index dfd5b82b1bbe593fc54f93eaad051874b230ea08..b43c7bc432fa96c10a522b10064bb254bde38f8d 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_plant_invs_on.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [iteration 1] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out index a98d3aea606ff92c95685f821513253d7057105e..7c9c825b535711980296e7d98914be98898b5967 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_off.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [iteration 1] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out index 3d718549e8443ccfc438127d6614b5460fcba92a..f7b287db977f749e785f998652ef3e4a33b9bdcf 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/simplify_state_req_invs_on.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [iteration 1] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [iteration 1] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 1 (total) 0.50 (avg/edge) [before] - Total span: 1 (total) 0.50 (avg/edge) [after] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [before] + Total span: 1 (total) 0.50 (avg/edge) / WES: 0.500000 (total) 0.250000 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out index e386589d46a92db2e28d3e7082b6c3de6f7fb95b..d70ad28046a5838c075bfedb123e96d291ee9238 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_expr.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 3 (total) 0.60 (avg/edge) [iteration 1] - Total span: 3 (total) 0.60 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [iteration 1] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 2 (total) 0.40 (avg/edge) [window 0..2] - Total span: 2 (total) 0.40 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [window 0..2] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out index e3cfda218fc5c390786616d90a434fd55396a959..b98ce9587e19807a1bcb68f9182a92c301cd2400 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/switch_preds.cif.out @@ -18,15 +18,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 3 (total) 0.60 (avg/edge) [iteration 1] - Total span: 3 (total) 0.60 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [iteration 1] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [after] Applying sliding window algorithm. Window length: 3 - Total span: 3 (total) 0.60 (avg/edge) [before] - Total span: 2 (total) 0.40 (avg/edge) [window 0..2] - Total span: 2 (total) 0.40 (avg/edge) [after] + Total span: 3 (total) 0.60 (avg/edge) / WES: 0.488889 (total) 0.097778 (avg/edge) [before] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [window 0..2] + Total span: 2 (total) 0.40 (avg/edge) / WES: 0.400000 (total) 0.080000 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out index 5873a9724ea7012d525af493490d06de9923a5a6..7367176153bf80c3083c963ae05503f30d0f007b 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/update_complex.cif.out @@ -20,14 +20,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 7 (total) 3.50 (avg/edge) [before] - Total span: 7 (total) 3.50 (avg/edge) [iteration 1] - Total span: 7 (total) 3.50 (avg/edge) [after] + Total span: 7 (total) 3.50 (avg/edge) / WES: 1.440000 (total) 0.720000 (avg/edge) [before] + Total span: 7 (total) 3.50 (avg/edge) / WES: 1.440000 (total) 0.720000 (avg/edge) [iteration 1] + Total span: 7 (total) 3.50 (avg/edge) / WES: 1.440000 (total) 0.720000 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 7 (total) 3.50 (avg/edge) [before] - Total span: 7 (total) 3.50 (avg/edge) [after] + Total span: 7 (total) 3.50 (avg/edge) / WES: 1.440000 (total) 0.720000 (avg/edge) [before] + Total span: 7 (total) 3.50 (avg/edge) / WES: 1.440000 (total) 0.720000 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out index 8a131254f0c5fe29d04305517cf94afd5f5e7e35..aeb1f0e6242310e3f3da1586755b0f822a663cec 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/updates.cif.out @@ -17,14 +17,14 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 10 - Total span: 2 (total) 0.04 (avg/edge) [before] - Total span: 2 (total) 0.04 (avg/edge) [iteration 1] - Total span: 2 (total) 0.04 (avg/edge) [after] + Total span: 2 (total) 0.04 (avg/edge) / WES: 0.039216 (total) 0.000769 (avg/edge) [before] + Total span: 2 (total) 0.04 (avg/edge) / WES: 0.039216 (total) 0.000769 (avg/edge) [iteration 1] + Total span: 2 (total) 0.04 (avg/edge) / WES: 0.039216 (total) 0.000769 (avg/edge) [after] Applying sliding window algorithm. Window length: 2 - Total span: 2 (total) 0.04 (avg/edge) [before] - Total span: 2 (total) 0.04 (avg/edge) [after] + Total span: 2 (total) 0.04 (avg/edge) / WES: 0.039216 (total) 0.000769 (avg/edge) [before] + Total span: 2 (total) 0.04 (avg/edge) / WES: 0.039216 (total) 0.000769 (avg/edge) [after] Variable order unchanged. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_force_on.cif.out index 824740ca4a468bf5cb3bd352e4179946fc533a19..4ef34513fef628e53f4e046a80814ebd0f261629 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_custom_force_on.cif.out @@ -21,17 +21,17 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 29 (total) 1.32 (avg/edge) [before] - Total span: 24 (total) 1.09 (avg/edge) [iteration 1] - Total span: 18 (total) 0.82 (avg/edge) [iteration 2] - Total span: 13 (total) 0.59 (avg/edge) [iteration 3] - Total span: 13 (total) 0.59 (avg/edge) [iteration 4] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 29 (total) 1.32 (avg/edge) / WES: 0.431818 (total) 0.019628 (avg/edge) [before] + Total span: 24 (total) 1.09 (avg/edge) / WES: 0.366162 (total) 0.016644 (avg/edge) [iteration 1] + Total span: 18 (total) 0.82 (avg/edge) / WES: 0.300505 (total) 0.013659 (avg/edge) [iteration 2] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [iteration 3] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [iteration 4] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [before] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_force_on.cif.out index 0a5acd6c2c568b2c193cc9a9f9441ea2743ba697..648ac09950f4fad8c57d9111211d77d0ef73db41 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_model_force_on.cif.out @@ -21,15 +21,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 13 (total) 0.59 (avg/edge) [iteration 1] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [before] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [iteration 1] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 12 (total) 0.55 (avg/edge) [window 2..5] - Total span: 12 (total) 0.55 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [before] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [window 2..5] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_force_on.cif.out index d3a639a243eb74a3820aac218ddd3b180ecbdd26..b33340e59a1897729a30f5906f36828f2b8252c4 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_random_force_on.cif.out @@ -21,18 +21,18 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 31 (total) 1.41 (avg/edge) [before] - Total span: 20 (total) 0.91 (avg/edge) [iteration 1] - Total span: 14 (total) 0.64 (avg/edge) [iteration 2] - Total span: 13 (total) 0.59 (avg/edge) [iteration 3] - Total span: 13 (total) 0.59 (avg/edge) [iteration 4] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 31 (total) 1.41 (avg/edge) / WES: 0.472222 (total) 0.021465 (avg/edge) [before] + Total span: 20 (total) 0.91 (avg/edge) / WES: 0.366162 (total) 0.016644 (avg/edge) [iteration 1] + Total span: 14 (total) 0.64 (avg/edge) / WES: 0.282828 (total) 0.012856 (avg/edge) [iteration 2] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [iteration 3] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [iteration 4] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 12 (total) 0.55 (avg/edge) [window 0..3] - Total span: 12 (total) 0.55 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [before] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [window 0..3] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_force_on.cif.out index 9308d78c38096dd822cc5a5028076e020618d632..b2e26165e1043e6c737ab7ee8b7a8155a92b2567 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_model_force_on.cif.out @@ -21,15 +21,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 13 (total) 0.59 (avg/edge) [iteration 1] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [before] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [iteration 1] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 12 (total) 0.55 (avg/edge) [window 0..3] - Total span: 12 (total) 0.55 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [before] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [window 0..3] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_force_on.cif.out index d10b7522f92b43744b9eb90f252c5c8d332aee3e..d335fb1c02f8ae96d437cc53a1adfe71b1f4eae2 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_reverse_sorted_force_on.cif.out @@ -21,15 +21,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 13 (total) 0.59 (avg/edge) [iteration 1] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [before] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [iteration 1] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 12 (total) 0.55 (avg/edge) [window 0..3] - Total span: 12 (total) 0.55 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [before] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [window 0..3] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Variable order changed. diff --git a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_force_on.cif.out b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_force_on.cif.out index 3f9f0156f3cf4787ee4475682e3b61b193228d77..85484ebb88e254ae7efd7beaf17fd82495fcaa98 100644 --- a/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_force_on.cif.out +++ b/cif/org.eclipse.escet.cif.tests/tests/datasynth/var_order_sorted_force_on.cif.out @@ -21,15 +21,15 @@ Applying automatic variable ordering: Applying 2 algorithms, sequentially: Applying FORCE algorithm. Maximum number of iterations: 20 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 13 (total) 0.59 (avg/edge) [iteration 1] - Total span: 13 (total) 0.59 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [before] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [iteration 1] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [after] Applying sliding window algorithm. Window length: 4 - Total span: 13 (total) 0.59 (avg/edge) [before] - Total span: 12 (total) 0.55 (avg/edge) [window 2..5] - Total span: 12 (total) 0.55 (avg/edge) [after] + Total span: 13 (total) 0.59 (avg/edge) / WES: 0.290404 (total) 0.013200 (avg/edge) [before] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [window 2..5] + Total span: 12 (total) 0.55 (avg/edge) / WES: 0.247475 (total) 0.011249 (avg/edge) [after] Variable order changed.