Shared trie (#24)

maxitg · web-flow · commit 135f11e5202a · 2021-03-01T20:50:10.000-06:00
## Changes

* Use shared trie for a range evaluation.
* This uses more memory but saves a lot of time because the same evaluation paths ("highways") don't need to be evaluated multiple times.
* To accommodate this case, `MergedWithAnotherInit` was added as a `ConclusionReason`.

## Comments

* There is currently no way to find out which other init this one was merged into. This potentially can be added, but it will require a change in the file format, so I did not add it now.
* A better approach might be to make this optimization invisible by automatically figuring out the values of all evaluation result components based on the information about the merge. I can work on this approach now, but I'm not sure I can finish it today (so it might have to wait until next week).

## Examples

* The difference in performance can be seen with a disabled test:
```c++
TEST(PostTagSearcher, DISABLED_rangePerformance) {
  // With separate tries: 0.36 GB, 1133 seconds
  // With shared trie: 1.1 GB of RAM, 93 seconds, 12x speedup, 3x more memory use
  PostTagSearcher().evaluateRange(30, 0, 1000000, PostTagSearcher::EvaluationParameters());
}
```
diff --git a/libPostTagSystem/CheckpointsTrie.cpp b/libPostTagSystem/CheckpointsTrie.cpp
@@ -18,61 +18,66 @@ class CheckpointsTrie::Implementation {
   MetadataMap metadataMap_;
   TrieNodes trieNodes_;
   Suffixes reverseSuffixes_;  // suffixes are written in reverse order to optimize trie nodes extension
+  std::vector<int> values_;   // each suffix corresponds to one value, even if empty
 
  public:
-  void insert(const ChunkedState& state) {
-    const uint16_t lastChunkSizePhaseIndex = 256 * state.lastChunkSize + state.phase;
+  bool insert(const ChunkedState& key, const int value) {
+    const uint16_t lastChunkSizePhaseIndex = 256 * key.lastChunkSize + key.phase;
 
-    const auto fixedChunkCountIt = metadataMap_.find(state.chunks.size());
+    const auto fixedChunkCountIt = metadataMap_.find(key.chunks.size());
     if (fixedChunkCountIt == metadataMap_.end()) {
-      reverseSuffixes_.push_back(std::vector<uint8_t>(state.chunks.rbegin(), state.chunks.rend()));
+      reverseSuffixes_.push_back(std::vector<uint8_t>(key.chunks.rbegin(), key.chunks.rend()));
+      values_.push_back(value);
       metadataMap_.insert(
-          {state.chunks.size(), {{lastChunkSizePhaseIndex, fromReverseSuffixesIndex(reverseSuffixes_.size() - 1)}}});
-      return;
+          {key.chunks.size(), {{lastChunkSizePhaseIndex, fromReverseSuffixesIndex(reverseSuffixes_.size() - 1)}}});
+      return true;
     }
 
     const auto fixedMetadataIt = fixedChunkCountIt->second.find(lastChunkSizePhaseIndex);
     if (fixedMetadataIt == fixedChunkCountIt->second.end()) {
-      reverseSuffixes_.push_back(std::vector<uint8_t>(state.chunks.rbegin(), state.chunks.rend()));
+      reverseSuffixes_.push_back(std::vector<uint8_t>(key.chunks.rbegin(), key.chunks.rend()));
+      values_.push_back(value);
       fixedChunkCountIt->second.insert(
           {lastChunkSizePhaseIndex, fromReverseSuffixesIndex(reverseSuffixes_.size() - 1)});
-      return;
+      return true;
     }
 
-    insertChunks(&fixedMetadataIt->second, state.chunks.begin(), state.chunks.end());
+    return insertChunks(&fixedMetadataIt->second, key.chunks.begin(), key.chunks.end(), value);
   }
 
-  bool contains(const ChunkedState& state) const {
+  std::optional<int> findValue(const ChunkedState& state) const {
     const auto fixedChunkCountIt = metadataMap_.find(state.chunks.size());
-    if (fixedChunkCountIt == metadataMap_.end()) return false;
+    if (fixedChunkCountIt == metadataMap_.end()) return std::nullopt;
     const auto fixedMetadataIt = fixedChunkCountIt->second.find(256 * state.lastChunkSize + state.phase);
-    if (fixedMetadataIt == fixedChunkCountIt->second.end()) return false;
-    return containsChunks(fixedMetadataIt->second, state.chunks.begin(), state.chunks.end());
+    if (fixedMetadataIt == fixedChunkCountIt->second.end()) return std::nullopt;
+    return findValueInChunks(fixedMetadataIt->second, state.chunks.begin(), state.chunks.end());
   }
 
  private:
   using ChunksIterator = std::deque<uint8_t>::const_iterator;
-  void insertChunks(int64_t* index, ChunksIterator chunksBegin, ChunksIterator chunksEnd) {
-    if (chunksBegin == chunksEnd) return;
+  bool insertChunks(int64_t* index, ChunksIterator chunksBegin, ChunksIterator chunksEnd, const int value) {
+    if (chunksBegin == chunksEnd) return false;  // it's a total match, don't insert a value
 
     if (*index >= 0) {
-      const auto nextChunkIt = trieNodes_[*index].find(*chunksBegin);
-      if (nextChunkIt == trieNodes_[*index].end()) {
+      const auto nextChunkIt = trieNodes_.at(*index).find(*chunksBegin);
+      if (nextChunkIt == trieNodes_.at(*index).end()) {
         reverseSuffixes_.push_back(std::vector<uint8_t>(std::reverse_iterator<ChunksIterator>(chunksEnd),
                                                         std::reverse_iterator<ChunksIterator>(chunksBegin) - 1));
-        trieNodes_[*index].insert({*chunksBegin, fromReverseSuffixesIndex(reverseSuffixes_.size() - 1)});
+        values_.push_back(value);
+        trieNodes_.at(*index).insert({*chunksBegin, fromReverseSuffixesIndex(reverseSuffixes_.size() - 1)});
       } else {
-        insertChunks(&nextChunkIt->second, chunksBegin + 1, chunksEnd);
+        insertChunks(&nextChunkIt->second, chunksBegin + 1, chunksEnd, value);
       }
     } else {
       *index = pushChunk(*index);
-      insertChunks(index, chunksBegin, chunksEnd);
+      insertChunks(index, chunksBegin, chunksEnd, value);
     }
+    return true;
   }
 
   int64_t pushChunk(int64_t negativeIndex) {
-    const auto firstValue = reverseSuffixes_[toReverseSuffixesIndex(negativeIndex)].back();
-    reverseSuffixes_[toReverseSuffixesIndex(negativeIndex)].pop_back();
+    const auto firstValue = reverseSuffixes_.at(toReverseSuffixesIndex(negativeIndex)).back();
+    reverseSuffixes_.at(toReverseSuffixesIndex(negativeIndex)).pop_back();
     trieNodes_.push_back({{firstValue, negativeIndex}});
     return trieNodes_.size() - 1;
   }
@@ -81,30 +86,38 @@ class CheckpointsTrie::Implementation {
 
   static inline int64_t fromReverseSuffixesIndex(int64_t positiveIndex) { return -(positiveIndex + 1); }
 
-  bool containsChunks(int64_t index, ChunksIterator chunksBegin, ChunksIterator chunksEnd) const {
-    if (chunksBegin == chunksEnd) return true;
+  std::optional<int> findValueInChunks(int64_t index, ChunksIterator chunksBegin, ChunksIterator chunksEnd) const {
+    if (chunksBegin == chunksEnd) {
+      return values_.at(toReverseSuffixesIndex(index));
+    }
 
     if (index >= 0) {
-      const auto nextChunkIt = trieNodes_[index].find(*chunksBegin);
-      if (nextChunkIt == trieNodes_[index].end()) {
-        return false;
+      const auto nextChunkIt = trieNodes_.at(index).find(*chunksBegin);
+      if (nextChunkIt == trieNodes_.at(index).end()) {
+        return std::nullopt;
       } else {
-        return containsChunks(nextChunkIt->second, chunksBegin + 1, chunksEnd);
+        return findValueInChunks(nextChunkIt->second, chunksBegin + 1, chunksEnd);
       }
     } else {
       const auto firstMismatch = std::mismatch(chunksBegin,
                                                chunksEnd,
-                                               reverseSuffixes_[toReverseSuffixesIndex(index)].rbegin(),
-                                               reverseSuffixes_[toReverseSuffixesIndex(index)].rend());
-      return firstMismatch.first == chunksEnd;
+                                               reverseSuffixes_.at(toReverseSuffixesIndex(index)).rbegin(),
+                                               reverseSuffixes_.at(toReverseSuffixesIndex(index)).rend());
+      if (firstMismatch.first == chunksEnd) {
+        return values_.at(fromReverseSuffixesIndex(index));
+      } else {
+        return std::nullopt;
+      }
     }
   }
 };
 
 CheckpointsTrie::CheckpointsTrie() { implementation_ = std::make_shared<Implementation>(); }
 
-void CheckpointsTrie::insert(const ChunkedState& state) { implementation_->insert(state); }
+bool CheckpointsTrie::insert(const ChunkedState& key, const int value) { return implementation_->insert(key, value); }
 
-bool CheckpointsTrie::contains(const ChunkedState& state) const { return implementation_->contains(state); }
+std::optional<int> CheckpointsTrie::findValue(const ChunkedState& state) const {
+  return implementation_->findValue(state);
+}
 
 }  // namespace PostTagSystem
diff --git a/libPostTagSystem/CheckpointsTrie.hpp b/libPostTagSystem/CheckpointsTrie.hpp
@@ -2,15 +2,17 @@
 #define LIBPOSTTAGSYSTEM_CHECKPOINTSTRIE_HPP_
 
 #include <memory>
+#include <optional>
 
 #include "ChunkedState.hpp"
 
 namespace PostTagSystem {
 class CheckpointsTrie {
  public:
   CheckpointsTrie();
-  void insert(const ChunkedState& state);
-  bool contains(const ChunkedState& state) const;
+  // returns false if the value already exists, in which case the old key will remain
+  bool insert(const ChunkedState& key, int value);
+  std::optional<int> findValue(const ChunkedState& state) const;
 
  private:
   class Implementation;
diff --git a/libPostTagSystem/PostTagHistory.cpp b/libPostTagSystem/PostTagHistory.cpp
@@ -44,6 +44,8 @@ class PostTagHistory::Implementation {
 
   std::unordered_map<NamedRule, ChunkEvaluationTable> evaluationTables_;
 
+  static constexpr int explicitCheckpoint = -1;
+
  public:
   Implementation() {}
 
@@ -72,24 +74,25 @@ class PostTagHistory::Implementation {
       return std::vector<EvaluationResult>(
           inits.size(), {ConclusionReason::InvalidInput, {{}, std::numeric_limits<uint8_t>::max()}, 0, 0});
     }
-    CheckpointsTrie explicitCheckpointsTrie;
+    CheckpointsTrie checkpointsTrie;
     for (const auto& checkpoint : checkpointSpec.states) {
-      explicitCheckpointsTrie.insert(toChunkedState(checkpoint));
+      checkpointsTrie.insert(toChunkedState(checkpoint), explicitCheckpoint);
     }
 
     std::vector<EvaluationResult> results;
     results.reserve(inits.size());
-    for (const auto& init : inits) {
-      auto chunkedState = toChunkedState(init);
+    for (size_t initIndex = 0; initIndex < inits.size(); ++initIndex) {
+      auto chunkedState = toChunkedState(inits[initIndex]);
       uint64_t maxIntermediateTapeLength = tapeLength(chunkedState);
       ConclusionReason conclusionReason;
       const auto eventCount = evaluate(chunkEvaluationTable,
                                        &chunkedState,
+                                       initIndex,
                                        &conclusionReason,
                                        &maxIntermediateTapeLength,
                                        limits,
                                        endClock,
-                                       explicitCheckpointsTrie,
+                                       &checkpointsTrie,
                                        checkpointSpec.flags);
       results.push_back(
           {conclusionReason, fromChunkedStateDestructively(&chunkedState), eventCount, maxIntermediateTapeLength});
@@ -175,17 +178,17 @@ class PostTagHistory::Implementation {
 
   static uint64_t evaluate(const ChunkEvaluationTable& evaluationTable,
                            ChunkedState* state,
+                           const size_t index,
                            ConclusionReason* conclusionReason,
                            uint64_t* maxIntermediateTapeLength,
                            const EvaluationLimits& limits,
                            std::chrono::time_point<std::chrono::steady_clock> endClock,
-                           const CheckpointsTrie& explicitCheckpoints,
+                           CheckpointsTrie* checkpoints,
                            const CheckpointSpecFlags& checkpointFlags) {
     if (std::chrono::steady_clock::now() > endClock) {
       *conclusionReason = ConclusionReason::NotEvaluated;
       return 0;
     }
-    CheckpointsTrie automaticCheckpoints;
     uint64_t eventCount;
     constexpr int eventsPerClockCheck = 1000;
     for (eventCount = 0; eventCount < limits.maxEventCount && state->chunks.size() > 1;
@@ -198,16 +201,21 @@ class PostTagHistory::Implementation {
         *conclusionReason = ConclusionReason::MaxTapeLengthExceeded;
         return eventCount;
       }
-      if (explicitCheckpoints.contains(*state)) {
-        *conclusionReason = ConclusionReason::ReachedExplicitCheckpoint;
-        return eventCount;
-      }
-      if (automaticCheckpoints.contains(*state)) {
-        *conclusionReason = ConclusionReason::ReachedAutomaticCheckpoint;
-        return eventCount;
+      const auto foundCheckpoint = checkpoints->findValue(*state);
+      if (foundCheckpoint.has_value()) {
+        if (foundCheckpoint.value() == explicitCheckpoint) {
+          *conclusionReason = ConclusionReason::ReachedExplicitCheckpoint;
+          return eventCount;
+        } else if (foundCheckpoint.value() == static_cast<int>(index)) {
+          *conclusionReason = ConclusionReason::ReachedAutomaticCheckpoint;
+          return eventCount;
+        } else {
+          *conclusionReason = ConclusionReason::ReachedPreviousInitCheckpoint;
+          return eventCount;
+        }
       }
       if (checkpointFlags.powerOfTwoEventCounts && !isPowerOfTwo(eventCount)) {
-        automaticCheckpoints.insert(*state);
+        checkpoints->insert(*state, static_cast<int>(index));
       }
       evaluateOnce(evaluationTable, state);
       *maxIntermediateTapeLength = std::max(*maxIntermediateTapeLength, tapeLength(*state));
diff --git a/libPostTagSystem/PostTagHistory.hpp b/libPostTagSystem/PostTagHistory.hpp
@@ -15,6 +15,7 @@ class PostTagHistory {
     Terminated,
     ReachedExplicitCheckpoint,
     ReachedAutomaticCheckpoint,
+    ReachedPreviousInitCheckpoint,
     MaxEventCountExceeded,
     MaxTapeLengthExceeded,
     TimeConstraintExceeded,
diff --git a/libPostTagSystem/PostTagSearcher.cpp b/libPostTagSystem/PostTagSearcher.cpp
@@ -77,6 +77,10 @@ class PostTagSearcher::Implementation {
           result.conclusionReason = ConclusionReason::NotEvaluated;
           break;
 
+        case PostTagHistory::ConclusionReason::ReachedPreviousInitCheckpoint:
+          result.conclusionReason = ConclusionReason::MergedWithAnotherInit;
+          break;
+
         default:
           result.conclusionReason = ConclusionReason::InvalidInput;
       }
diff --git a/libPostTagSystem/PostTagSearcher.hpp b/libPostTagSystem/PostTagSearcher.hpp
@@ -20,7 +20,8 @@ class PostTagSearcher {
     MaxTapeLengthExceeded,
     MaxEventCountExceeded,
     TimeConstraintExceeded,
-    NotEvaluated
+    NotEvaluated,
+    MergedWithAnotherInit
   };
 
   struct EvaluationResult {
diff --git a/libPostTagSystem/test/CheckpointsTrie_test.cpp b/libPostTagSystem/test/CheckpointsTrie_test.cpp
@@ -10,14 +10,14 @@ void checkStateInsertion(const std::vector<ChunkedState>& insertedStates,
                          const std::vector<ChunkedState>& missingStates) {
   CheckpointsTrie trie;
   for (auto insertionIt = insertedStates.begin(); insertionIt != insertedStates.end(); ++insertionIt) {
-    trie.insert(*insertionIt);
+    trie.insert(*insertionIt, static_cast<int>(insertionIt - insertedStates.begin()));
     for (auto checkIt = insertedStates.begin(); checkIt != insertionIt + 1; ++checkIt) {
-      ASSERT_TRUE(trie.contains(*checkIt));
+      ASSERT_EQ(trie.findValue(*checkIt).value(), static_cast<int>(checkIt - insertedStates.begin()));
     }
   }
 
   for (const auto& state : missingStates) {
-    ASSERT_FALSE(trie.contains(state));
+    ASSERT_EQ(trie.findValue(state), std::nullopt);
   }
 }
 }  // namespace
diff --git a/libPostTagSystem/test/PostTagSearcher_test.cpp b/libPostTagSystem/test/PostTagSearcher_test.cpp
@@ -35,20 +35,24 @@ void compareResults(const TagState& init,
 
   if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::InvalidInput) {
     ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::InvalidInput);
-  } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::Terminated) {
-    ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::Terminated);
-  } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::ReachedAutomaticCheckpoint) {
-    ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::ReachedCycle);
-  } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::ReachedExplicitCheckpoint) {
-    ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::ReachedKnownCheckpoint);
-  } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::MaxEventCountExceeded) {
-    ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::MaxEventCountExceeded);
+  } else if (result.conclusionReason != PostTagSearcher::ConclusionReason::MergedWithAnotherInit) {
+    if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::Terminated) {
+      ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::Terminated);
+    } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::ReachedAutomaticCheckpoint) {
+      ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::ReachedCycle);
+    } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::ReachedExplicitCheckpoint) {
+      ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::ReachedKnownCheckpoint);
+    } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::MaxEventCountExceeded) {
+      ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::MaxEventCountExceeded);
+    } else if (singleResult.conclusionReason == PostTagHistory::ConclusionReason::MaxTapeLengthExceeded) {
+      ASSERT_EQ(result.conclusionReason, PostTagSearcher::ConclusionReason::MaxTapeLengthExceeded);
+    }
+    ASSERT_EQ(result.finalState, singleResult.finalState);
+    ASSERT_EQ(result.eventCount, singleResult.eventCount);
+    ASSERT_EQ(result.maxTapeLength, singleResult.maxIntermediateTapeLength);
+    ASSERT_EQ(result.finalTapeLength, singleResult.finalState.tape.size());
   }
 
-  ASSERT_EQ(result.finalState, singleResult.finalState);
-  ASSERT_EQ(result.eventCount, singleResult.eventCount);
-  ASSERT_EQ(result.maxTapeLength, singleResult.maxIntermediateTapeLength);
-  ASSERT_EQ(result.finalTapeLength, singleResult.finalState.tape.size());
   ASSERT_EQ(result.initialState, init);
 }
 
@@ -149,4 +153,10 @@ TEST(PostTagSearcher, smallTimeConstraint) {
   ASSERT_EQ(result.size(), 3);
   ASSERT_EQ(result[0].conclusionReason, PostTagSearcher::ConclusionReason::TimeConstraintExceeded);
 }
+
+TEST(PostTagSearcher, DISABLED_rangePerformance) {
+  // With separate tries: 0.36 GB, 1133 seconds
+  // With shared trie: 1.1 GB of RAM, 93 seconds, 12x speedup, 3x more memory use
+  PostTagSearcher().evaluateRange(30, 0, 1000000, PostTagSearcher::EvaluationParameters());
+}
 }  // namespace PostTagSystem

Original file line number	Diff line number	Diff line change
`@@ -10,14 +10,14 @@ void checkStateInsertion(const std::vector<ChunkedState>& insertedStates,`
`10`	`10`	`const std::vector<ChunkedState>& missingStates) {`
`11`	`11`	`CheckpointsTrie trie;`
`12`	`12`	`for (auto insertionIt = insertedStates.begin(); insertionIt != insertedStates.end(); ++insertionIt) {`
`13`		`- trie.insert(*insertionIt);`
	`13`	`+ trie.insert(*insertionIt, static_cast<int>(insertionIt - insertedStates.begin()));`
`14`	`14`	`for (auto checkIt = insertedStates.begin(); checkIt != insertionIt + 1; ++checkIt) {`
`15`		`- ASSERT_TRUE(trie.contains(*checkIt));`
	`15`	`+ ASSERT_EQ(trie.findValue(*checkIt).value(), static_cast<int>(checkIt - insertedStates.begin()));`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`for (const auto& state : missingStates) {`
`20`		`- ASSERT_FALSE(trie.contains(state));`
	`20`	`+ ASSERT_EQ(trie.findValue(state), std::nullopt);`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`	`} // namespace`