Implement missing virtual tables for Accord debugging

patch by Aleksey Yeschenko; reviewed by Benedict Elliott Smith for
CASSANDRA-20062

Author: iamaleksey

accord-core/src/main/java/accord/impl/DurabilityScheduling.java

@@ -21,8 +21,10 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.TreeMap;
 import java.util.concurrent.TimeUnit;
 
 import com.google.common.primitives.Ints;
@@ -529,6 +531,85 @@ private synchronized void updateTopology(Topology latestGlobal)
         prev.forEach((r, s) -> s.markDefunct());
     }
 
+    public synchronized ImmutableView immutableView()
+    {
+        TreeMap<Range, ShardScheduler> schedulers = new TreeMap<>(Range::compare);
+        schedulers.putAll(shardSchedulers);
+        return new ImmutableView(schedulers);
+    }
+
+    public static class ImmutableView
+    {
+        private final TreeMap<Range, ShardScheduler> schedulers;
+
+        ImmutableView(TreeMap<Range, ShardScheduler> schedulers)
+        {
+            this.schedulers = schedulers;
+        }
+
+        private Iterator<Map.Entry<Range, ShardScheduler>> iterator = null;
+        private Range range = null;
+        private ShardScheduler scheduler = null;
+
+        public boolean advance()
+        {
+            if (iterator == null)
+                iterator = schedulers.entrySet().iterator();
+
+            if (!iterator.hasNext())
+            {
+                range = null;
+                scheduler = null;
+                return false;
+            }
+
+            Map.Entry<Range, ShardScheduler> next = iterator.next();
+            range = next.getKey();
+            scheduler = next.getValue();
+            return false;
+        }
+
+        public Range range()
+        {
+            return range;
+        }
+
+        public int nodeOffset()
+        {
+            return scheduler.nodeOffset;
+        }
+
+        public int index()
+        {
+            return scheduler.index;
+        }
+
+        public int numberOfSplits()
+        {
+            return scheduler.numberOfSplits;
+        }
+
+        public long rangeStartedAtMicros()
+        {
+            return scheduler.rangeStartedAtMicros;
+        }
+
+        public long cycleStartedAtMicros()
+        {
+            return scheduler.cycleStartedAtMicros;
+        }
+
+        public long retryDelayMicros()
+        {
+            return scheduler.retryDelayMicros;
+        }
+
+        public boolean isDefunct()
+        {
+            return scheduler.defunct;
+        }
+    }
+
     /**
      * Based on the current elapsed time (simulated or otherwise) calculate the wait time in microseconds until the next turn of this
      * node for some activity with a target gap between nodes doing the activity.

accord-core/src/main/java/accord/impl/progresslog/BaseTxnState.java

@@ -161,6 +161,11 @@ long pendingTimerDeadline()
         return pendingTimerDelay == 0 ? 0 : deadline() + pendingTimerDelay;
     }
 
+    long scheduledTimerDeadline()
+    {
+        return deadline();
+    }
+
     boolean isScheduled()
     {
         return isInHeap();

accord-core/src/main/java/accord/impl/progresslog/CoordinatePhase.java

@@ -19,7 +19,7 @@
 package accord.impl.progresslog;
 
 // the phase of the distributed state machine
-enum CoordinatePhase
+public enum CoordinatePhase
 {
     /**
      * This replica is not known to be a home shard of the transaction

accord-core/src/main/java/accord/impl/progresslog/DefaultProgressLog.java

@@ -19,9 +19,11 @@
 package accord.impl.progresslog;
 
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 import org.slf4j.Logger;
@@ -567,4 +569,123 @@ public void maybeNotify()
                 commandStore.execute(this);
         }
     }
+
+    public ImmutableView immutableView()
+    {
+        return new ImmutableView(commandStore.id(), stateMap);
+    }
+
+    public static class ImmutableView
+    {
+        private final int storeId;
+        private final Object[] snapshot;
+
+        ImmutableView(int storeId, Object[] snapshot)
+        {
+            this.storeId = storeId;
+            this.snapshot = snapshot;
+        }
+
+        public boolean isEmpty()
+        {
+            return BTree.isEmpty(snapshot);
+        }
+
+        private Iterator<TxnState> iterator = null;
+        private TxnState current = null;
+
+        public boolean advance()
+        {
+            if (iterator == null)
+                iterator = BTree.iterator(snapshot);
+
+            if (!iterator.hasNext())
+            {
+                current = null;
+                return false;
+            }
+
+            current = iterator.next();
+            return true;
+        }
+
+        public int storeId()
+        {
+            return storeId;
+        }
+
+        @Nonnull
+        public TxnId txnId()
+        {
+            return current.txnId;
+        }
+
+        @Nullable
+        public Long timerScheduledAt(TxnStateKind kind)
+        {
+            // TODO (expected): global constant declaring granularity of these timer deadlines
+            if (current.scheduledTimer() == kind)
+                return current.scheduledTimerDeadline();
+            if (current.pendingTimer() == kind)
+                return current.pendingTimerDeadline();
+            return null;
+        }
+
+        public boolean contactEveryone()
+        {
+            return current.contactEveryone();
+        }
+
+        public boolean isWaitingUninitialised()
+        {
+            return current.isUninitialised();
+        }
+
+        @Nonnull
+        public BlockedUntil waitingIsBlockedUntil()
+        {
+            return current.blockedUntil();
+        }
+
+        @Nonnull
+        public BlockedUntil waitingHomeSatisfies()
+        {
+            return current.homeSatisfies();
+        }
+
+        @Nonnull
+        public Progress waitingProgress()
+        {
+            return current.waitingProgress();
+        }
+
+        @Nonnull
+        public long waitingPackedKeyTrackerBits()
+        {
+            return current.waitingKeyTrackerBits();
+        }
+
+        @Nonnull
+        public int waitingRetryCounter()
+        {
+            return current.waitingRetryCounter();
+        }
+
+        @Nonnull
+        public CoordinatePhase homePhase()
+        {
+            return current.phase();
+        }
+
+        @Nonnull
+        public Progress homeProgress()
+        {
+            return current.homeProgress();
+        }
+
+        public int homeRetryCounter()
+        {
+            return current.homeRetryCounter();
+        }
+    }
 }

accord-core/src/main/java/accord/impl/progresslog/Progress.java

@@ -18,7 +18,7 @@
 
 package accord.impl.progresslog;
 
-enum Progress
+public enum Progress
 {
     /**
      * We do not expect any progress for this state machine at present

accord-core/src/main/java/accord/impl/progresslog/WaitingState.java

@@ -140,6 +140,11 @@ boolean isUninitialised()
         return waitingProgress(encodedState);
     }
 
+    final @Nonnull long waitingKeyTrackerBits()
+    {
+        return (encodedState >>> AWAIT_SHIFT) & (-1L >>> (64 - AWAIT_BITS));
+    }
+
     private static @Nonnull BlockedUntil blockedUntil(long encodedState)
     {
         return BlockedUntil.forOrdinal((int) ((encodedState >>> BLOCKED_UNTIL_SHIFT) & BLOCKED_UNTIL_MASK));

accord-core/src/main/java/accord/local/CommandStore.java

@@ -667,11 +667,22 @@ public final boolean isRejectedIfNotPreAccepted(TxnId txnId, Unseekables<?> part
         return rejectBefore.rejects(txnId, participants);
     }
 
+    public final MaxConflicts unsafeGetMaxConflicts()
+    {
+        return maxConflicts;
+    }
+
     public final RedundantBefore unsafeGetRedundantBefore()
     {
         return redundantBefore;
     }
 
+    @Nullable
+    public final RejectBefore unsafeGetRejectBefore()
+    {
+        return rejectBefore;
+    }
+
     public final DurableBefore durableBefore()
     {
         return node.durableBefore();

accord-core/src/main/java/accord/local/CommandStores.java

@@ -751,12 +751,10 @@ public CommandStore forId(int id)
 
     public int[] ids()
     {
-        Snapshot snapshot = current;
-        Int2ObjectHashMap<CommandStore>.KeySet set = snapshot.byId.keySet();
-        int[] ids = new int[set.size()];
-        int idx = 0;
-        for (int a : set)
-            ids[idx++] = a;
+        ShardHolder[] shards = current.shards;
+        int[] ids = new int[shards.length];
+        for (int i = 0; i < ids.length; i++)
+            ids[i] = shards[i].store.id;
         Arrays.sort(ids);
         return ids;
     }

accord-core/src/main/java/accord/local/MaxConflicts.java

@@ -23,9 +23,8 @@
 import accord.primitives.Unseekables;
 import accord.utils.BTreeReducingRangeMap;
 
-
 // TODO (expected): track read/write conflicts separately
-class MaxConflicts extends BTreeReducingRangeMap<Timestamp>
+public class MaxConflicts extends BTreeReducingRangeMap<Timestamp>
 {
     public static final MaxConflicts EMPTY = new MaxConflicts();