domino sorting and automatic freeing of SPLCommits

Author: pmbittner

src/main/java/de/variantsync/evolution/Main.java

@@ -107,12 +107,12 @@ public static void main(final String[] args) throws IOException, Resources.Resou
         final VariabilityDatasetLoader datasetLoader = new VariabilityDatasetLoader();
         assert datasetLoader.canLoad(variabilityDatasetDir);
         variabilityDataset = datasetLoader.load(variabilityDatasetDir).getSuccess();
-        final Set<SPLCommitPair> commitPairs = variabilityDataset.getCommitPairsForEvolutionStudy();
+        final Set<EvolutionStep<SPLCommit>> evolutionSteps = variabilityDataset.getCommitPairsForEvolutionStudy();
         Logger.info("The dataset contains " + variabilityDataset.getSuccessCommits().size() + " commits for which the variability extraction succeeded.");
         Logger.info("The dataset contains " + variabilityDataset.getErrorCommits().size() + " commits for which the variability extraction failed.");
         Logger.info("The dataset contains " + variabilityDataset.getPartialSuccessCommits().size() + " commits that for which the file presence conditions are missing.");
-        Logger.info("The dataset contains " + commitPairs.size() + " usable pairs.");
-        for (final SPLCommitPair pair : commitPairs) {
+        Logger.info("The dataset contains " + evolutionSteps.size() + " usable pairs.");
+        for (final EvolutionStep<SPLCommit> pair : evolutionSteps) {
             Logger.debug("<<CHILD> " + pair.child().id() + "> -- <<PARENT> " + pair.parent().id() + ">");
             Logger.debug("<<CHILD> " + pair.child().id() + "> -- <<SPL_COMMIT> " + pair.child().id() + ">");
             Logger.debug("<<PARENT> " + pair.parent().id() + "> -- <<SPL_COMMIT> " + pair.parent().id() + ">");

src/main/java/de/variantsync/evolution/util/functional/CachedValue.java

@@ -0,0 +1,5 @@
+package de.variantsync.evolution.util.functional;
+
+public interface CachedValue {
+    void forget();
+}

src/main/java/de/variantsync/evolution/util/functional/Lazy.java

@@ -21,7 +21,7 @@
  * @param <A> The return type of this lazy computation.
  */
 @SuppressWarnings("rawtypes")
-public class Lazy<A> implements Functor<Lazy, A> {
+public class Lazy<A> implements Functor<Lazy, A>, CachedValue {
     /**
      * Lazy is a monoid if the lazy values are monoidal.
      * Creates a Monoid for Lazy<A> from the monoid of the value type A.
@@ -99,12 +99,9 @@ public A take() {
 
     /**
      * Clears the cached value, such that it has to be recomputed next time it is queried.
-     * @return True if a value was cleared. False if there was no cached value to forget.
      */
-    public boolean forget() {
-        final boolean aValueWasForgotten = val != null;
+    public void forget() {
         val = null;
-        return aValueWasForgotten;
     }
 
     /**

src/main/java/de/variantsync/evolution/util/list/StackUtil.java

@@ -0,0 +1,9 @@
+package de.variantsync.evolution.util.list;
+
+import java.util.Stack;
+
+public class StackUtil {
+    public static <T> void pushAToB(final Stack<T> a, final Stack<T> b) {
+        b.addAll(a);
+    }
+}

src/main/java/de/variantsync/evolution/variability/DominoSortedEvolutionSteps.java

@@ -0,0 +1,115 @@
+package de.variantsync.evolution.variability;
+
+import de.variantsync.evolution.repository.Commit;
+import de.variantsync.evolution.util.functional.CachedValue;
+import de.variantsync.evolution.util.list.StackUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+public class DominoSortedEvolutionSteps<C extends Commit & CachedValue> implements Iterator<EvolutionStep<C>>, Iterable<EvolutionStep<C>> {
+    private final Stack<Stack<C>> dominos;
+    private final List<C> garbage;
+
+    public DominoSortedEvolutionSteps(final Stream<EvolutionStep<C>> steps) {
+        this.dominos = DominoSort(steps);
+        this.garbage = new ArrayList<>();
+    }
+
+    public void clearCaches() {
+        for (final C c : garbage) {
+            c.forget();
+        }
+        garbage.clear();
+    }
+
+    @Override
+    public boolean hasNext() {
+        return !dominos.isEmpty();
+    }
+
+    @Override
+    public EvolutionStep<C> next() {
+        clearCaches();
+
+        final Stack<C> currentRow = dominos.peek();
+
+        assert !currentRow.isEmpty();
+        final C child = currentRow.pop();
+        garbage.add(child);
+
+        assert !currentRow.isEmpty();
+        final C parent = currentRow.peek();
+
+        final EvolutionStep<C> result = new EvolutionStep<C>(parent, child);
+        if (currentRow.size() == 1) {
+            garbage.add(parent);
+            dominos.pop();
+        }
+        return result;
+    }
+
+    @NotNull
+    @Override
+    public Iterator<EvolutionStep<C>> iterator() {
+        return this;
+    }
+
+    private static <C extends Commit> Stack<Stack<C>> DominoSort(final Stream<EvolutionStep<C>> dominos) {
+        final Stack<Stack<C>> chains = new Stack<>();
+
+        dominos.forEach(domino -> {
+            // push the domino to an existing stack if possible
+            for (final Stack<C> row : chains) {
+                if (row.peek().equals(domino.parent())) {
+                    row.push(domino.child());
+                    return;
+                }
+            }
+
+            // if there was no suitable stack, create one
+            final Stack<C> newRow = new Stack<>();
+            newRow.add(domino.parent());
+            newRow.add(domino.child());
+            chains.push(newRow);
+        });
+
+        // Merge all stacks until they cannot be reduced anymore.
+        final Stack<Stack<C>> finalRows = new Stack<>();
+        do {
+            Stack<C> current = chains.pop();
+//            System.out.println("Inspecting " + current);
+            final Set<Stack<C>> mergedStacks = new HashSet<>();
+            do {
+                mergedStacks.clear();
+                for (final Stack<C> other : chains) {
+                    if (current.firstElement().equals(other.lastElement())) {
+//                        System.out.println("  pushing it to " + other);
+                        other.pop();
+                        StackUtil.pushAToB(current, other);
+                        current = other;
+//                        System.out.println("  got " + current);
+                        mergedStacks.add(other);
+                    } else if (other.firstElement().equals(current.lastElement())) {
+//                        System.out.println("  pushed " + other + " onto it");
+                        current.pop();
+                        StackUtil.pushAToB(other, current);
+//                        System.out.println("  got " + current);
+                        mergedStacks.add(other);
+                    }
+                }
+                chains.removeAll(mergedStacks);
+            } while (!mergedStacks.isEmpty());
+
+            finalRows.push(current);
+        } while (!chains.isEmpty());
+
+        return finalRows;
+    }
+
+    @Override
+    public String toString() {
+        return "DominoSortedEvolutionSteps{" + dominos + '}';
+    }
+}

src/main/java/de/variantsync/evolution/variability/EvolutionStep.java

@@ -0,0 +1,10 @@
+package de.variantsync.evolution.variability;
+
+import de.variantsync.evolution.repository.Commit;
+
+public record EvolutionStep<T extends Commit>(T parent, T child) {
+    @Override
+    public String toString() {
+        return "(" + parent  + ", " + child + ")";
+    }
+}

src/main/java/de/variantsync/evolution/variability/SPLCommit.java

@@ -4,6 +4,7 @@
 import de.variantsync.evolution.io.Resources;
 import de.variantsync.evolution.repository.Commit;
 import de.variantsync.evolution.util.Logger;
+import de.variantsync.evolution.util.functional.CachedValue;
 import de.variantsync.evolution.util.functional.Functional;
 import de.variantsync.evolution.util.functional.Lazy;
 import de.variantsync.evolution.util.functional.interfaces.FragileFunction;
@@ -19,7 +20,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-public class SPLCommit extends Commit {
+public class SPLCommit extends Commit implements CachedValue {
     private final Lazy<Optional<String>> kernelHavenLog;
     private final Lazy<Optional<IFeatureModel>> featureModel;
     private final Lazy<Optional<Artefact>> presenceConditions;
@@ -118,7 +119,8 @@ private static Path tryUnzip(final Path path) throws ZipException {
     /**
      * Clears all cached values by calling {@link Lazy#forget()} on all fields.
      */
-    public void clearCaches() {
+    @Override
+    public void forget() {
         kernelHavenLog.forget();
         featureModel.forget();
         presenceConditions.forget();

src/main/java/de/variantsync/evolution/variability/SPLCommitPair.java

@@ -6,7 +6,6 @@
 
 import java.util.*;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
 public class VariabilityDataset {
     private final Set<SPLCommit> allCommits;
@@ -96,27 +95,28 @@ public VariabilityHistory getVariabilityHistory(final Function<Collection<SPLCom
      *
      * @return Set of commit pairs that can be used in a variability evolution study
      */
-    public Set<SPLCommitPair> getCommitPairsForEvolutionStudy() {
-        Logger.info("Retrieving commit pairs for study...");
-        final var set = successCommits.stream()
-                .map(c -> {
-                    if (c.parents().isPresent()) {
-                        final SPLCommit[] parents = c.parents().get();
-                        // We only consider commits that did not process a merge
-                        final boolean notAMerge = parents.length == 1;
-                        final SPLCommit p = parents[0];
-                        // We only consider commits that processed an SPL commit whose parent was also processed
-                        final boolean parentSuccess = successCommits.contains(p);
-                        if (notAMerge && parentSuccess) {
-                            return new SPLCommitPair(p, c);
-                        }
-                    }
-                    return null;
-                })
-                .filter(Objects::nonNull)
-                .collect(Collectors.toSet());
-        Logger.info("Done.");
-        return set;
+    public DominoSortedEvolutionSteps<SPLCommit> getCommitPairsForEvolutionStudy() {
+        Logger.debug("Retrieving commit pairs for study...");
+        final var steps = new DominoSortedEvolutionSteps<>(
+                successCommits.stream()
+                        .map(c -> {
+                            if (c.parents().isPresent()) {
+                                final SPLCommit[] parents = c.parents().get();
+                                // We only consider commits that did not process a merge
+                                final boolean notAMerge = parents.length == 1;
+                                final SPLCommit p = parents[0];
+                                // We only consider commits that processed an SPL commit whose parent was also processed
+                                final boolean parentSuccess = successCommits.contains(p);
+                                if (notAMerge && parentSuccess) {
+                                    return new EvolutionStep<>(p, c);
+                                }
+                            }
+                            return null;
+                        })
+                        .filter(Objects::nonNull)
+        );
+        Logger.debug("Done.");
+        return steps;
     }
 
 }

src/main/java/de/variantsync/evolution/variability/VariabilityDataset.java

@@ -0,0 +1,73 @@
+package de.variantsync.evolution;
+
+import de.variantsync.evolution.repository.Commit;
+import de.variantsync.evolution.util.functional.CachedValue;
+import de.variantsync.evolution.util.list.StackUtil;
+import de.variantsync.evolution.variability.DominoSortedEvolutionSteps;
+import de.variantsync.evolution.variability.EvolutionStep;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Stack;
+
+public class StackTest {
+    private static class TestCommit extends Commit implements CachedValue {
+        public TestCommit(final String commitId) {
+            super(commitId);
+        }
+        @Override
+        public void forget() {
+            System.out.println("forget(" + super.id() + ")");
+        }
+    }
+
+    private static TestCommit commit(final String id) {
+        return new TestCommit(id);
+    }
+
+    private static EvolutionStep<TestCommit> pair(final String parent, final String child) {
+        return new EvolutionStep<>(commit(parent), commit(child));
+    }
+
+    @Test
+    public void testMergeStacks() {
+        final Stack<Integer> b = new Stack<>();
+        b.push(1);
+        b.push(2);
+        final Stack<Integer> a = new Stack<>();
+        a.push(3);
+        a.push(4);
+        final Stack<Integer> result = new Stack<>();
+        result.push(1);
+        result.push(2);
+        result.push(3);
+        result.push(4);
+
+        StackUtil.pushAToB(a, b);
+        Assert.assertEquals(b, result);
+    }
+
+    @Test
+    public void evolSteps() {
+        final List<EvolutionStep<TestCommit>> input = List.of(
+                pair("1", "2"),
+                pair("4", "5"),
+                pair("2", "3"),
+                pair("3", "4"),
+
+                pair("12", "13"),
+                pair("10", "11"),
+                pair("11", "12")
+        );
+
+        final DominoSortedEvolutionSteps<TestCommit> steps = new DominoSortedEvolutionSteps<>(input.stream());
+        System.out.println("Sorted steps: " + steps);
+
+        for (final EvolutionStep<TestCommit> step : steps) {
+            System.out.println("Processing " + step);
+        }
+        System.out.println("Manual cleanup");
+        steps.clearCaches();
+    }
+}