feat: MOP ancestor search & DeGen (#22316)

Signed-off-by: Lazar Petrovic <[email protected]>
Co-authored-by: Artur Biesiadowski <[email protected]>

Author: lpetrovic05

platform-sdk/consensus-model/src/testFixtures/java/org/hiero/consensus/model/test/fixtures/event/TestingEventBuilder.java

@@ -11,11 +11,14 @@
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.time.Instant;
 import java.util.ArrayList;
+import java.util.HexFormat;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Random;
 import java.util.stream.Stream;
+import org.hiero.base.crypto.DigestType;
+import org.hiero.base.crypto.Hash;
 import org.hiero.base.crypto.SignatureType;
 import org.hiero.base.crypto.test.fixtures.CryptoRandomUtils;
 import org.hiero.base.utility.test.fixtures.RandomUtils;
@@ -138,6 +141,9 @@ public class TestingEventBuilder {
      */
     private long nGen = NonDeterministicGeneration.GENERATION_UNDEFINED;
 
+    /** The hash to use for the event */
+    private Hash hash = null;
+
     /**
      * Constructor
      *
@@ -366,6 +372,23 @@ public TestingEventBuilder(@NonNull final Random random) {
         return this;
     }
 
+    /**
+     * Set a custom hash for the event. This is useful for having a human-readable hash for debugging purposes.
+     *
+     * @param hexString the hash as a hex string
+     * @return this instance
+     */
+    public @NonNull TestingEventBuilder setHash(@NonNull final String hexString) {
+        final byte[] parsedHex = HexFormat.of().parseHex(hexString.toLowerCase());
+        if (parsedHex.length > DigestType.SHA_384.digestLength()) {
+            throw new IllegalArgumentException("Hash length is too long");
+        }
+        final byte[] hash = new byte[DigestType.SHA_384.digestLength()];
+        System.arraycopy(parsedHex, 0, hash, 0, parsedHex.length);
+        this.hash = new Hash(hash);
+        return this;
+    }
+
     /**
      * Generate transactions based on the settings provided.
      * <p>
@@ -494,7 +517,7 @@ private EventDescriptorWrapper createDescriptorFromParent(
 
         final PlatformEvent platformEvent = new PlatformEvent(unsignedEvent, Bytes.wrap(signature));
 
-        platformEvent.setHash(CryptoRandomUtils.randomHash(random));
+        platformEvent.setHash(hash != null ? hash : CryptoRandomUtils.randomHash(random));
 
         platformEvent.setNGen(nGen);
 

platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/AncestorIterator.java

@@ -61,6 +61,10 @@ public class AncestorIterator implements Iterator<EventImpl> {
     private IteratorState state;
     /** is curr a self ancestor of the judge? */
     private boolean selfAncestor;
+    /** stack of the index of the next other parent to try to traverse into */
+    private final Deque<Integer> stackNextOtherParentIndex = new ArrayDeque<>(INITIAL_STACK_SIZE);
+    /** the index of the next other parent to try to traverse into */
+    private int nextOtherParentIndex = 0;
 
     private enum IteratorState {
         TRAVERSING_SELF_PARENT,
@@ -96,6 +100,7 @@ public void initializeSearch(@NonNull final EventImpl root, @NonNull final Predi
         hasNext = true;
         state = IteratorState.TRAVERSING_SELF_PARENT;
         selfAncestor = true;
+        nextOtherParentIndex = 0;
     }
 
     private void clear() {
@@ -148,10 +153,16 @@ public boolean hasNext() {
             switch (state) {
                 case TRAVERSING_SELF_PARENT -> { // try to traverse into selfParent
                     final EventImpl parent = curr.getSelfParent();
-                    state = IteratorState.TRAVERSING_OTHER_PARENT;
+                    if (curr.getOtherParents().isEmpty()) {
+                        state = IteratorState.BOTTOM;
+                    } else {
+                        state = IteratorState.TRAVERSING_OTHER_PARENT;
+                        nextOtherParentIndex = 0;
+                    }
                     if (mark.isNotVisited(parent) && valid.test(parent)) {
                         stackRef.push(curr);
                         stackState.push(state);
+                        stackNextOtherParentIndex.push(nextOtherParentIndex);
                         stackSelfAncestor.push(selfAncestor);
                         stackTime.push(timeReachedRoot);
                         curr = parent;
@@ -162,11 +173,17 @@ public boolean hasNext() {
                     } // there is no selfParent, or it was already visited, or it was not valid
                 }
                 case TRAVERSING_OTHER_PARENT -> { // try to traverse into otherParent
-                    final EventImpl parent = curr.getOtherParent();
-                    state = IteratorState.BOTTOM;
+                    final EventImpl parent = curr.getOtherParents().get(nextOtherParentIndex);
+                    if (nextOtherParentIndex + 1 >= curr.getOtherParents().size()) {
+                        state = IteratorState.BOTTOM;
+                    } else {
+                        state = IteratorState.TRAVERSING_OTHER_PARENT;
+                        nextOtherParentIndex++;
+                    }
                     if (mark.isNotVisited(parent) && valid.test(parent)) {
                         stackRef.push(curr);
                         stackState.push(state);
+                        stackNextOtherParentIndex.push(nextOtherParentIndex);
                         stackSelfAncestor.push(selfAncestor);
                         stackTime.push(timeReachedRoot);
                         curr = parent;
@@ -184,6 +201,7 @@ public boolean hasNext() {
                     final EventImpl toReturn = curr; // else we are done with all the descendents, so backtrack
                     curr = stackRef.pop();
                     state = stackState.pop();
+                    nextOtherParentIndex = stackNextOtherParentIndex.pop();
                     selfAncestor = stackSelfAncestor.pop();
                     timeReachedRoot = stackTime.pop();
                     return toReturn; // return the child of the vertex we just backtracked to

platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/DeGen.java

@@ -25,7 +25,10 @@ public class DeGen {
      * @param event the event to set the DeGen value for
      */
     public static void calculateDeGen(@NonNull final EventImpl event) {
-        final int maxParentDeGen = Math.max(parentDeGen(event.getSelfParent()), parentDeGen(event.getOtherParent()));
+        final int maxParentDeGen = event.getAllParents().stream()
+                .mapToInt(DeGen::parentDeGen)
+                .max()
+                .orElse(GENERATION_UNDEFINED);
         if (maxParentDeGen == GENERATION_UNDEFINED) {
             event.setDeGen(FIRST_GENERATION);
         } else {

platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/consensus/AncestorSearchTest.java

@@ -2,74 +2,125 @@
 package com.swirlds.platform.consensus;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import com.swirlds.common.test.fixtures.Randotron;
 import com.swirlds.platform.internal.EventImpl;
+import com.swirlds.platform.test.fixtures.graph.SimpleGraph;
 import com.swirlds.platform.test.fixtures.graph.SimpleGraphs;
+import edu.umd.cs.findbugs.annotations.NonNull;
 import java.time.Instant;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
+import java.util.Set;
 import java.util.Spliterators;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 import java.util.stream.StreamSupport;
 import org.hiero.base.crypto.Hash;
-import org.hiero.base.utility.test.fixtures.RandomUtils;
-import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
+/**
+ * Tests for the {@link AncestorSearch}
+ */
 class AncestorSearchTest {
+    /** A predicate that matches all events */
+    private static final Predicate<EventImpl> ALL_EVENTS = e -> true;
+    /** A predicate that matches only non-consensus events */
+    private static final Predicate<EventImpl> NON_CONSENSUS_EVENTS = e -> !e.isConsensus();
 
-    final EventVisitedMark mark = new EventVisitedMark();
-    final AncestorSearch search = new AncestorSearch(mark);
-    final List<EventImpl> events = SimpleGraphs.graph9e3n(RandomUtils.getRandomPrintSeed());
-    final EventImpl root = events.get(8);
+    /**
+     * Tests the graph with multiple other-parents
+     */
+    @Test
+    void mopGraph() {
+        final SimpleGraph graph = SimpleGraphs.mopGraph(Randotron.create());
+        final AncestorSearch search = new AncestorSearch();
 
-    @RepeatedTest(3)
-    void basicTest() {
-        searchAndAssert();
-    }
+        assertEquals(graph.hashes(1, 2, 3, 6), getAncestors(search, graph.impl(6)));
+        assertEquals(graph.hashes(0, 4, 8), getAncestors(search, graph.impl(8)));
+        assertEquals(graph.hashes(0, 1, 2, 3, 4, 5, 6, 9), getAncestors(search, graph.impl(9)));
+        assertEquals(graph.hashes(0, 1, 2, 3, 5, 6, 7, 10), getAncestors(search, graph.impl(10)));
+        assertEquals(graph.hashes(3, 7, 11), getAncestors(search, graph.impl(11)));
 
-    @Test
-    void markWraparound() {
-        mark.setMark(-1);
-        searchAndAssert();
-    }
+        assertEquals(
+                graph.hashes(0, 1, 2, 3, 5, 6),
+                search.commonAncestorsOf(graph.impls(9, 10), ALL_EVENTS).stream()
+                        .map(EventImpl::getBaseHash)
+                        .collect(Collectors.toSet()));
+        // clear the recTimes so they don't interfere with the next search
+        graph.impls().forEach(e -> e.setRecTimes(null));
 
-    @Test
-    void markOverflow() {
-        mark.setMark(Integer.MAX_VALUE);
-        searchAndAssert();
+        assertEquals(
+                graph.hashes(0),
+                search.commonAncestorsOf(graph.impls(8, 9, 10), ALL_EVENTS).stream()
+                        .map(EventImpl::getBaseHash)
+                        .collect(Collectors.toSet()));
     }
 
-    @Test
-    void commonAncestors() {
-        final List<EventImpl> ancestors =
-                search.commonAncestorsOf(List.of(events.get(5), events.get(6), events.get(7)), e -> true);
+    /**
+     * Tests the graph with 9 events and 3 nodes. This test is parameterized to run with different starting marks to
+     * ensure that the marking system works correctly. It also validates that the recTimes are set correctly on the
+     * common ancestor.
+     */
+    @ParameterizedTest
+    @ValueSource(ints = {1, -1, Integer.MAX_VALUE})
+    void graph9e3n(final int startingMark) {
+        final EventVisitedMark mark = new EventVisitedMark();
+        final AncestorSearch search = new AncestorSearch(mark);
+        final SimpleGraph graph = SimpleGraphs.graph9e3n(Randotron.create());
+
+        // we test various starting marks to ensure that the marking system works correctly
+        mark.setMark(startingMark);
+
+        // test getting ancestors of the latest event(8)
+        assertEquals(graph.hashes(2, 3, 4, 6, 7, 8), getAncestors(search, graph.impl(8), NON_CONSENSUS_EVENTS));
+
+        // test getting common ancestors of events 5,6 & 7
+        final List<EventImpl> ancestors = search.commonAncestorsOf(graph.impls(5, 6, 7), ALL_EVENTS);
+        // we expect only one common ancestor: event 1
         assertEquals(1, ancestors.size());
-        assertSame(events.get(1), ancestors.get(0));
-        final HashSet<Instant> recTimes = new HashSet<>(events.get(1).getRecTimes());
+        assertSame(graph.impl(1), ancestors.getFirst());
+
+        // verify that recTimes are correct
+        final EventImpl commonAncestor = ancestors.getFirst();
+        assertNotNull(commonAncestor.getRecTimes());
+        final HashSet<Instant> recTimes = new HashSet<>(commonAncestor.getRecTimes());
         assertEquals(3, recTimes.size());
-        assertTrue(recTimes.contains(events.get(3).getTimeCreated()));
-        assertTrue(recTimes.contains(events.get(6).getTimeCreated()));
-        assertTrue(recTimes.contains(events.get(7).getTimeCreated()));
+        assertTrue(recTimes.contains(graph.impl(3).getTimeCreated()));
+        assertTrue(recTimes.contains(graph.impl(6).getTimeCreated()));
+        assertTrue(recTimes.contains(graph.impl(7).getTimeCreated()));
+
+        // verify that other events' recTimes are still null
+        graph.impls(0, 2, 3, 4, 5, 6, 7, 8).stream().map(EventImpl::getRecTimes).forEach(Assertions::assertNull);
+    }
 
-        IntStream.of(0, 2, 3, 4, 5, 6, 7, 8)
-                .forEach(i -> assertNull(events.get(i).getRecTimes()));
-        events.get(1).setRecTimes(null);
+    /**
+     * Same as {@link #getAncestors(AncestorSearch, EventImpl, Predicate)} with a predicate that matches all events
+     */
+    private Set<Hash> getAncestors(@NonNull final AncestorSearch search, @NonNull final EventImpl event) {
+        return getAncestors(search, event, ALL_EVENTS);
     }
 
-    private void searchAndAssert() {
-        // look for non-consensus ancestors of 8
-        final Map<Hash, EventImpl> ancestors = StreamSupport.stream(
-                        Spliterators.spliteratorUnknownSize(search.initializeSearch(root, e -> !e.isConsensus()), 0),
-                        false)
-                .collect(Collectors.toMap(EventImpl::getBaseHash, e -> e));
-        assertEquals(6, ancestors.size());
-        IntStream.of(2, 3, 4, 6, 7, 8)
-                .forEach(i -> assertTrue(ancestors.containsKey(events.get(i).getBaseHash())));
+    /**
+     * Get the ancestors of an event that match the given predicate
+     * @param search the ancestor search instance to use
+     * @param event the event whose ancestors to find
+     * @param predicate the predicate to filter ancestors
+     * @return the set of ancestor hashes that match the predicate
+     */
+    private Set<Hash> getAncestors(
+            @NonNull final AncestorSearch search,
+            @NonNull final EventImpl event,
+            @NonNull final Predicate<EventImpl> predicate) {
+        final AncestorIterator ancestorIterator = search.initializeSearch(event, predicate);
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(ancestorIterator, 0), false)
+                .map(EventImpl::getBaseHash)
+                .collect(Collectors.toSet());
     }
 }