improve parallelizability of TTT

closes #140 (the original issue was not a bug but this one came up in the resulting disucssion)

Author: mtf90

CHANGELOG.md

@@ -28,6 +28,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * The `AbstractVisualizationTest` has been refactored into the `VisualizationUtils` factory.
 * Various counters (especially `*Counter*SUL`s) have been streamlined. In most cases there now exists a single counter that tracks multiple properties.
 * The `ReuseOracleBuilder` and `ReuseTreeBuilder` classes are now auto-generated and therefore reside in the respective packages of their previously enclosing classes.
+* The `TTTLearnerMealy#createTransition` method no longer queries for its transition output directly, but instead requires a call to `initTransitions` now.
 * With the removal of the `learnlib-annotation-processor` artifact (see below), the `learnlib-build-config` artifact is now part of the `de.learnlib` group again.
 * The `learnlib-datastructure-ot`, `learnlib-datastructure-dt`, `learnlib-datastructure-list`, and `learnlib-datastructure-pta` artifacts have been merged into a new `learnlib-datastructures` artifact.
 * The `learnlib-oml` artifact (including its packages and class names) has been renamed to `learnlib-lambda`.
@@ -40,6 +41,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * `PropertyOracle`s can no longer set a property. This value is now immutable and must be provided during instantiation. Previously, the internal state wasn't updated accordingly if a property was overridden.
 * `SymbolQueryOracle`s (and related code such as the respective caches, counters, etc.) have been removed without replacement. Equivalent functionality on the basis of the new `AdaptiveMembershipOracle`s is available instead.
 
+### Fixed
+
+* Improved query batching of `TTT` learner (both the regular and visibly push-down version).
+
 
 ## [0.17.0] - 2023-11-15
 

algorithms/active/observation-pack-vpa/src/main/java/de/learnlib/algorithm/observationpack/vpa/AbstractVPALearner.java

@@ -20,7 +20,6 @@
 import java.util.Iterator;
 import java.util.List;
 
-import de.learnlib.AccessSequenceProvider;
 import de.learnlib.acex.AcexAnalyzer;
 import de.learnlib.acex.AcexAnalyzers;
 import de.learnlib.algorithm.LearningAlgorithm;
@@ -263,10 +262,6 @@ protected HypLoc<I> createLocation(AbstractHypTrans<I> trans) {
         return hypothesis.createLocation(false, trans);
     }
 
-    protected Boolean query(AccessSequenceProvider<I> asp, ContextPair<I> context) {
-        return oracle.answerQuery(context.getPrefix().concat(asp.getAccessSequence()), context.getSuffix());
-    }
-
     public static final class BuilderDefaults {
 
         private BuilderDefaults() {

algorithms/active/ttt-vpa/src/main/java/de/learnlib/algorithm/ttt/vpa/TTTLearnerVPA.java

@@ -37,6 +37,7 @@
 import de.learnlib.datastructure.list.IntrusiveList;
 import de.learnlib.oracle.MembershipOracle.DFAMembershipOracle;
 import de.learnlib.query.DefaultQuery;
+import de.learnlib.query.Query;
 import de.learnlib.tooling.annotation.builder.GenerateBuilder;
 import net.automatalib.alphabet.VPAlphabet;
 import net.automatalib.automaton.vpa.SEVPA;
@@ -432,6 +433,7 @@ private ContextPair<I> prepareSplit(DTNode<I> node, Splitter<I> splitter) {
         ContextPair<I> discriminator = splitter.getNewDiscriminator();
 
         Deque<DTNode<I>> dfsStack = new ArrayDeque<>();
+        List<SplitQuery<I>> queries = new ArrayList<>();
 
         DTNode<I> succSeparator = splitter.succSeparator;
 
@@ -445,9 +447,18 @@ private ContextPair<I> prepareSplit(DTNode<I> node, Splitter<I> splitter) {
             curr.setSplitData(new SplitData<>(TransList::new));
 
             for (AbstractHypTrans<I> trans : curr.getIncoming()) {
-                Boolean outcome = query(trans, discriminator);
-                curr.getSplitData().getIncoming(outcome).add(trans);
-                markAndPropagate(curr, outcome);
+                queries.add(new SplitQuery<>(trans, discriminator));
+            }
+
+            if (!queries.isEmpty()) {
+                oracle.processQueries(queries);
+
+                for (SplitQuery<I> query : queries) {
+                    curr.getSplitData().getIncoming(query.output).add(query.transition);
+                    markAndPropagate(curr, query.output);
+                }
+
+                queries.clear();
             }
 
             if (curr.isInner()) {
@@ -627,4 +638,30 @@ protected void determinize(State<HypLoc<I>> state, Word<I> suffix) {
         }
     }
 
+    private static final class SplitQuery<I> extends Query<I, Boolean> {
+
+        private final AbstractHypTrans<I> transition;
+        private final ContextPair<I> discriminator;
+        private Boolean output;
+
+        SplitQuery(AbstractHypTrans<I> transition, ContextPair<I> discriminator) {
+            this.transition = transition;
+            this.discriminator = discriminator;
+        }
+
+        @Override
+        public void answer(Boolean output) {
+            this.output = output;
+        }
+
+        @Override
+        public Word<I> getPrefix() {
+            return discriminator.getPrefix().concat(transition.getAccessSequence());
+        }
+
+        @Override
+        public Word<I> getSuffix() {
+            return discriminator.getSuffix();
+        }
+    }
 }

algorithms/active/ttt/src/main/java/de/learnlib/algorithm/ttt/base/AbstractTTTLearner.java

@@ -28,7 +28,6 @@
 import java.util.Objects;
 import java.util.Set;
 
-import de.learnlib.AccessSequenceProvider;
 import de.learnlib.Resumable;
 import de.learnlib.acex.AcexAnalyzer;
 import de.learnlib.acex.AcexAnalyzers;
@@ -39,6 +38,7 @@
 import de.learnlib.logging.Category;
 import de.learnlib.oracle.MembershipOracle;
 import de.learnlib.query.DefaultQuery;
+import de.learnlib.query.Query;
 import net.automatalib.alphabet.Alphabet;
 import net.automatalib.alphabet.SupportsGrowingAlphabet;
 import net.automatalib.common.smartcollection.ElementReference;
@@ -188,19 +188,34 @@ public boolean refineHypothesis(DefaultQuery<I, D> ceQuery) {
      *         the state to initialize
      */
     protected void initializeState(TTTState<I, D> state) {
+        TTTTransition<I, D> head = null;
         for (int i = 0; i < alphabet.size(); i++) {
             I sym = alphabet.getSymbol(i);
             TTTTransition<I, D> trans = createTransition(state, sym);
             trans.setNonTreeTarget(dtree.getRoot());
             state.setTransition(i, trans);
             openTransitions.add(trans);
+            head = trans;
         }
+        initTransitions(head, alphabet.size());
     }
 
     protected TTTTransition<I, D> createTransition(TTTState<I, D> state, I sym) {
         return new TTTTransition<>(state, sym);
     }
 
+    /**
+     * A post-processing hook for transitions created by {@link #createTransition(TTTState, Object)}, e.g., after
+     * {@link #initializeState(TTTState)} or {@link #addAlphabetSymbol(Object)}. This is mainly useful for transition
+     * output hypotheses that want to initialize the transition outputs in a bulk operation.
+     *
+     * @param head
+     *         the head of (the list of) the created transitions
+     * @param num
+     *         the number of created transitions
+     */
+    protected void initTransitions(TTTTransition<I, D> head, int num) {}
+
     /**
      * Performs a single refinement of the hypothesis, i.e., without repeated counterexample evaluation. The parameter
      * and return value have the same significance as in {@link #refineHypothesis(DefaultQuery)}.
@@ -618,6 +633,7 @@ private Word<I> prepareSplit(AbstractBaseDTNode<I, D> node, Splitter<I, D> split
         Word<I> discriminator = splitter.getDiscriminator().prepend(symbol);
 
         Deque<AbstractBaseDTNode<I, D>> dfsStack = new ArrayDeque<>();
+        List<SplitQuery<I, D>> queries = new ArrayList<>();
 
         AbstractBaseDTNode<I, D> succSeparator = splitter.succSeparator;
 
@@ -631,9 +647,18 @@ private Word<I> prepareSplit(AbstractBaseDTNode<I, D> node, Splitter<I, D> split
             curr.setSplitData(new SplitData<>(IntrusiveList::new));
 
             for (TTTTransition<I, D> trans : curr.getIncoming()) {
-                D outcome = query(trans, discriminator);
-                curr.getSplitData().getIncoming(outcome).add(trans);
-                markAndPropagate(curr, outcome);
+                queries.add(new SplitQuery<>(trans, discriminator));
+            }
+
+            if (!queries.isEmpty()) {
+                oracle.processQueries(queries);
+
+                for (SplitQuery<I, D> query : queries) {
+                    curr.getSplitData().getIncoming(query.output).add(query.transition);
+                    markAndPropagate(curr, query.output);
+                }
+
+                queries.clear();
             }
 
             if (curr.isInner()) {
@@ -905,34 +930,6 @@ private List<AbstractBaseDTNode<I, D>> updateDTTargets(List<TTTTransition<I, D>>
         return result;
     }
 
-    /**
-     * Performs a membership query.
-     *
-     * @param prefix
-     *         the prefix part of the query
-     * @param suffix
-     *         the suffix part of the query
-     *
-     * @return the output
-     */
-    protected D query(Word<I> prefix, Word<I> suffix) {
-        return oracle.answerQuery(prefix, suffix);
-    }
-
-    /**
-     * Performs a membership query, using an access sequence as its prefix.
-     *
-     * @param accessSeqProvider
-     *         the object from which to obtain the access sequence
-     * @param suffix
-     *         the suffix part of the query
-     *
-     * @return the output
-     */
-    protected D query(AccessSequenceProvider<I> accessSeqProvider, Word<I> suffix) {
-        return query(accessSeqProvider.getAccessSequence(), suffix);
-    }
-
     /**
      * Returns the discrimination tree.
      *
@@ -956,14 +953,17 @@ public void addAlphabetSymbol(I symbol) {
         if (this.hypothesis.getInitialState() != null && this.hypothesis.getState(Word.fromLetter(symbol)) == null) {
 
             final int newSymbolIdx = this.alphabet.getSymbolIndex(symbol);
+            TTTTransition<I, D> head = null;
 
             for (TTTState<I, D> s : this.hypothesis.getStates()) {
                 final TTTTransition<I, D> trans = createTransition(s, symbol);
                 trans.setNonTreeTarget(dtree.getRoot());
                 s.setTransition(newSymbolIdx, trans);
                 openTransitions.add(trans);
+                head = trans;
             }
 
+            this.initTransitions(head, this.hypothesis.size());
             this.closeTransitions();
         }
     }
@@ -1076,4 +1076,31 @@ private static final class ExtractRecord<I, D> {
             this.extracted = extracted;
         }
     }
+
+    private static final class SplitQuery<I, D> extends Query<I, D> {
+
+        private final TTTTransition<I, D> transition;
+        private final Word<I> discriminator;
+        private D output;
+
+        SplitQuery(TTTTransition<I, D> transition, Word<I> discriminator) {
+            this.transition = transition;
+            this.discriminator = discriminator;
+        }
+
+        @Override
+        public void answer(D output) {
+            this.output = output;
+        }
+
+        @Override
+        public Word<I> getPrefix() {
+            return transition.getAccessSequence();
+        }
+
+        @Override
+        public Word<I> getSuffix() {
+            return discriminator;
+        }
+    }
 }

algorithms/active/ttt/src/main/java/de/learnlib/algorithm/ttt/mealy/TTTLearnerMealy.java

@@ -15,6 +15,9 @@
  */
 package de.learnlib.algorithm.ttt.mealy;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import de.learnlib.acex.AcexAnalyzer;
 import de.learnlib.acex.MealyOutInconsPrefixTransformAcex;
 import de.learnlib.acex.OutInconsPrefixTransformAcex;
@@ -25,8 +28,10 @@
 import de.learnlib.algorithm.ttt.base.OutputInconsistency;
 import de.learnlib.algorithm.ttt.base.TTTState;
 import de.learnlib.algorithm.ttt.base.TTTTransition;
+import de.learnlib.datastructure.list.IntrusiveListEntry;
 import de.learnlib.oracle.MembershipOracle;
 import de.learnlib.query.DefaultQuery;
+import de.learnlib.query.Query;
 import de.learnlib.tooling.annotation.builder.GenerateBuilder;
 import de.learnlib.util.mealy.MealyUtil;
 import net.automatalib.alphabet.Alphabet;
@@ -62,9 +67,21 @@ public TTTLearnerMealy(Alphabet<I> alphabet, MembershipOracle<I, Word<O>> oracle
 
     @Override
     protected TTTTransition<I, Word<O>> createTransition(TTTState<I, Word<O>> state, I sym) {
-        TTTTransitionMealy<I, O> trans = new TTTTransitionMealy<>(state, sym);
-        trans.output = query(state, Word.fromLetter(sym)).firstSymbol();
-        return trans;
+        return new TTTTransitionMealy<>(state, sym);
+    }
+
+    @Override
+    protected void initTransitions(TTTTransition<I, Word<O>> head, int num) {
+        final List<TransitionOutputQuery<I, O>> queries = new ArrayList<>(num);
+        IntrusiveListEntry<TTTTransition<I, Word<O>>> iter = head;
+
+        for (int i = 0; i < num; i++) {
+            assert iter != null;
+            queries.add(new TransitionOutputQuery<>((TTTTransitionMealy<I, O>) iter.getElement()));
+            iter = iter.getNext();
+        }
+
+        oracle.processQueries(queries);
     }
 
     @Override
@@ -151,4 +168,28 @@ protected AbstractBaseDTNode<I, Word<O>> createNewNode(AbstractBaseDTNode<I, Wor
                                                            Word<O> parentOutput) {
         return new TTTDTNodeMealy<>(parent, parentOutput);
     }
+
+    private static final class TransitionOutputQuery<I, O> extends Query<I, Word<O>> {
+
+        private final TTTTransitionMealy<I, O> transition;
+
+        TransitionOutputQuery(TTTTransitionMealy<I, O> transition) {
+            this.transition = transition;
+        }
+
+        @Override
+        public void answer(Word<O> output) {
+            transition.output = output.firstSymbol();
+        }
+
+        @Override
+        public Word<I> getPrefix() {
+            return transition.getSource().getAccessSequence();
+        }
+
+        @Override
+        public Word<I> getSuffix() {
+            return Word.fromLetter(transition.getInput());
+        }
+    }
 }

commons/datastructures/src/main/java/de/learnlib/datastructure/discriminationtree/model/AbstractDiscriminationTree.java

@@ -102,11 +102,11 @@ protected List<N> sift(List<N> starts, List<Word<I>> prefixes, Predicate<N> cont
             activeVector.set(i, continueExploring.test(result.get(i)));
         }
 
+        final List<DefaultQuery<I, O>> queries = new ArrayList<>(activeVector.cardinality());
         final List<Word<I>> prefixStorage = CollectionUtil.randomAccessList(prefixes);
 
         while (!activeVector.isEmpty()) {
 
-            final List<DefaultQuery<I, O>> queries = new ArrayList<>(activeVector.cardinality());
             final BitSetIterator preIter = new BitSetIterator(activeVector);
 
             while (preIter.hasNext()) {
@@ -130,6 +130,8 @@ protected List<N> sift(List<N> starts, List<Word<I>> prefixes, Predicate<N> cont
                     activeVector.clear(idx);
                 }
             }
+
+            queries.clear();
         }
 
         return result;