Sync engine source with the macOS version

After openvanilla/McBopomofo#856

Also remove two unnecessary copy/link of .clang-format. We'll simply let
clang-format find the top-level .clang-format at the project root.

Also format ByteBlockBackedDictionaryTest.cpp.

Author: lukhnos

src/Engine/ByteBlockBackedDictionaryTest.cpp

@@ -47,11 +47,12 @@ TEST(ByteBlockBackedDictionaryTest, Simple2) {
 }
 
 TEST(ByteBlockBackedDictionaryTest, EncodingAgnostic1) {
-  const auto *data = u8"smile 😊";
-  const char *charData = reinterpret_cast<const char*>(data);
+  const auto* data = u8"smile 😊";
+  const char* charData = reinterpret_cast<const char*>(data);
   ByteBlockBackedDictionary dict;
   ASSERT_TRUE(dict.parse(charData, strlen(charData)));
-  ASSERT_EQ(dict.getValues("smile").at(0), reinterpret_cast<const char*>(u8"😊"));
+  ASSERT_EQ(dict.getValues("smile").at(0),
+            reinterpret_cast<const char*>(u8"😊"));
 }
 
 TEST(ByteBlockBackedDictionaryTest, EncodingAgnostic2) {

src/Engine/CMakeLists.txt

@@ -126,5 +126,15 @@ if (ENABLE_TEST)
                     COMMAND ${CMAKE_CURRENT_BINARY_DIR}/ParselessLMBenchmark
             )
             add_dependencies(runParselessLMBenchmark ParselessLMBenchmark)
+
+            add_executable(ParselessPhraseDBBenchmark
+                    ParselessPhraseDBBenchmark.cpp)
+            target_link_libraries(ParselessPhraseDBBenchmark McBopomofoLMLib benchmark::benchmark)
+
+            add_custom_target(
+                    runParselessPhraseDBBenchmark
+                    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/ParselessPhraseDBBenchmark
+            )
+            add_dependencies(runParselessPhraseDBBenchmark ParselessPhraseDBBenchmark)
         endif ()
 endif ()

src/Engine/Mandarin/.clang-format

@@ -25,6 +25,9 @@
 
 #include <cassert>
 #include <filesystem>
+#include <fstream>
+#include <string>
+#include <vector>
 
 #include "ParselessLM.h"
 
@@ -35,6 +38,23 @@ using ParselessLM = McBopomofo::ParselessLM;
 static const char* kDataPath = "data.txt";
 static const char* kUnigramSearchKey = "ㄕˋ-ㄕˊ";
 
+std::vector<std::string> LoadRealKeys() {
+  std::ifstream input(kDataPath);
+  assert(input.is_open());
+
+  std::vector<std::string> keys;
+  std::string line;
+  std::getline(input, line);
+  while (std::getline(input, line)) {
+    const size_t separator = line.find(' ');
+    if (separator != std::string::npos) {
+      keys.emplace_back(line.substr(0, separator));
+    }
+  }
+  assert(!keys.empty());
+  return keys;
+}
+
 static void BM_ParselessLMOpenClose(benchmark::State& state) {
   assert(std::filesystem::exists(kDataPath));
   for (auto _ : state) {
@@ -56,6 +76,49 @@ static void BM_ParselessLMFindUnigrams(benchmark::State& state) {
 }
 BENCHMARK(BM_ParselessLMFindUnigrams);
 
+static void BM_ParselessLMHasUnigramsRealKeys(benchmark::State& state) {
+  assert(std::filesystem::exists(kDataPath));
+  ParselessLM lm;
+  lm.open(kDataPath);
+  const std::vector<std::string> keys = LoadRealKeys();
+  auto key = keys.begin();
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(lm.hasUnigrams(*key));
+    if (++key == keys.end()) {
+      key = keys.begin();
+    }
+  }
+  lm.close();
+}
+BENCHMARK(BM_ParselessLMHasUnigramsRealKeys);
+
+static void BM_ParselessLMFindUnigramsRealKeys(benchmark::State& state) {
+  assert(std::filesystem::exists(kDataPath));
+  ParselessLM lm;
+  lm.open(kDataPath);
+  const std::vector<std::string> keys = LoadRealKeys();
+  auto key = keys.begin();
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(lm.getUnigrams(*key));
+    if (++key == keys.end()) {
+      key = keys.begin();
+    }
+  }
+  lm.close();
+}
+BENCHMARK(BM_ParselessLMFindUnigramsRealKeys);
+
+static void BM_ParselessLMGetReadingsMissingValue(benchmark::State& state) {
+  assert(std::filesystem::exists(kDataPath));
+  ParselessLM lm;
+  lm.open(kDataPath);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(lm.getReadings("missing"));
+  }
+  lm.close();
+}
+BENCHMARK(BM_ParselessLMGetReadingsMissingValue);
+
 };  // namespace
 
 BENCHMARK_MAIN();

src/Engine/ParselessLMBenchmark.cpp

@@ -28,8 +28,97 @@
 #include <string>
 #include <vector>
 
+#ifdef ENABLE_EXPERIMENTAL_SIMD_SUPPORT_NEON
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+
+#include <cstdint>
+#else
+#error ARM NEON support required
+#endif
+#endif
+
 namespace McBopomofo {
 
+namespace {
+
+#ifdef ENABLE_EXPERIMENTAL_SIMD_SUPPORT_NEON
+
+int FirstNonZeroLane16(uint8x16_t value) {
+  // value must be a comparison mask whose lanes are either 0x00 or 0xff.
+  // Taking the maximum across the reversed masked lane indices locates the
+  // first matching lane and avoids a scalar loop.
+  alignas(16) static constexpr uint8_t kReverseLaneIndices[16] = {
+      16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
+  };
+  const uint8x16_t laneIndices = vld1q_u8(kReverseLaneIndices);
+  return 16 - static_cast<int>(vmaxvq_u8(vandq_u8(value, laneIndices)));
+}
+
+int LastNonZeroLane16(uint8x16_t value) {
+  // value must be a comparison mask whose lanes are either 0x00 or 0xff.
+  // Taking the maximum across the masked lane indices locates the last matching
+  // lane and avoids a scalar loop that compilers may expand into up to 16 umov
+  // and cbnz branch pairs.
+  alignas(16) static constexpr uint8_t kLaneIndices[16] = {
+      1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+  };
+  const uint8x16_t laneIndices = vld1q_u8(kLaneIndices);
+  return static_cast<int>(vmaxvq_u8(vandq_u8(value, laneIndices))) - 1;
+}
+
+#endif
+
+const char* FindNextCharacter(const char* position, const char* end,
+                              char character) {
+  const char* cursor = position;
+
+#ifdef ENABLE_EXPERIMENTAL_SIMD_SUPPORT_NEON
+  const uint8x16_t characters = vdupq_n_u8(static_cast<uint8_t>(character));
+  while (end - cursor >= 16) {
+    const uint8x16_t block = vld1q_u8(reinterpret_cast<const uint8_t*>(cursor));
+    const int positionInBlock = FirstNonZeroLane16(vceqq_u8(block, characters));
+    if (positionInBlock != 16) {
+      return cursor + positionInBlock;
+    }
+    cursor += 16;
+  }
+#endif
+
+  while (cursor != end && *cursor != character) {
+    ++cursor;
+  }
+  return cursor;
+}
+
+const char* FindLineStart(const char* begin, const char* position) {
+  const char* cursor = position;
+
+#ifdef ENABLE_EXPERIMENTAL_SIMD_SUPPORT_NEON
+  const uint8x16_t linefeeds = vdupq_n_u8(static_cast<uint8_t>('\n'));
+  while (cursor - begin >= 16) {
+    const char* blockStart = cursor - 16;
+    const uint8x16_t block =
+        vld1q_u8(reinterpret_cast<const uint8_t*>(blockStart));
+    const int positionInBlock = LastNonZeroLane16(vceqq_u8(block, linefeeds));
+    if (positionInBlock >= 0) {
+      return blockStart + positionInBlock + 1;
+    }
+    cursor = blockStart;
+  }
+#endif
+
+  while (cursor != begin) {
+    --cursor;
+    if (*cursor == '\n') {
+      return cursor + 1;
+    }
+  }
+  return begin;
+}
+
+}  // namespace
+
 bool ParselessPhraseDB::ValidatePragma(const char* buf, size_t length) {
   if (length < SORTED_PRAGMA_HEADER.length()) {
     return false;
@@ -80,11 +169,7 @@ std::vector<std::string_view> ParselessPhraseDB::findRows(
 
   while (ptr + key.length() <= end_ &&
          memcmp(ptr, key.data(), key.length()) == 0) {
-    const char* eol = ptr;
-
-    while (eol != end_ && *eol != '\n') {
-      ++eol;
-    }
+    const char* eol = FindNextCharacter(ptr, end_, '\n');
 
     rows.emplace_back(ptr, eol - ptr);
     if (eol == end_) {
@@ -114,20 +199,11 @@ const char* ParselessPhraseDB::findFirstMatchingLine(
 
   while (top < bottom) {
     const char* mid = top + ((bottom - top) / 2);
-    const char* ptr = mid;
-
-    if (ptr != begin_) {
-      --ptr;
-    }
-
-    while (ptr != begin_ && *ptr != '\n') {
-      --ptr;
-    }
+    const char* ptr = FindLineStart(begin_, mid);
 
     const char* prev = nullptr;
-    if (*ptr == '\n') {
-      prev = ptr;
-      ++ptr;
+    if (ptr != begin_) {
+      prev = ptr - 1;
     }
 
     // ptr is now in the "current" line we're interested in.
@@ -153,15 +229,7 @@ const char* ParselessPhraseDB::findFirstMatchingLine(
     }
 
     // Move the prev so that it reaches the previous line.
-    if (prev != begin_) {
-      --prev;
-    }
-    while (prev != begin_ && *prev != '\n') {
-      --prev;
-    }
-    if (*prev == '\n') {
-      ++prev;
-    }
+    prev = FindLineStart(begin_, prev);
 
     int prev_cmp = memcmp(prev, key.data(), key.length());
 
@@ -187,20 +255,15 @@ std::vector<std::string> ParselessPhraseDB::reverseFindRows(
     const char* ptr = recordBegin;
 
     // skip over the key to find the field separator
-    while (ptr < end_ && *ptr != ' ') {
-      ++ptr;
-    }
+    ptr = FindNextCharacter(ptr, end_, ' ');
     // skip over the field separator. there should be just one, but loop just in
     // case.
     while (ptr < end_ && *ptr == ' ') {
       ++ptr;
     }
 
     // now walk to the end of this record
-    const char* recordEnd = ptr;
-    while (recordEnd < end_ && *recordEnd != '\n') {
-      ++recordEnd;
-    }
+    const char* recordEnd = FindNextCharacter(ptr, end_, '\n');
 
     if (ptr + value.length() < end_ &&
         memcmp(ptr, value.data(), value.length()) == 0) {