Merge remote-tracking branch 'origin/master' into fcitx

Author: Fcitx Bot

src/base/BUILD.bazel

@@ -1032,7 +1032,9 @@ mozc_cc_library(
     name = "thread",
     hdrs = ["thread.h"],
     deps = [
+        "@com_google_absl//absl/base",
         "@com_google_absl//absl/base:core_headers",
+        "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/synchronization",
     ],
 )

src/base/thread.h

@@ -31,12 +31,15 @@
 #define MOZC_BASE_THREAD_H_
 
 #include <atomic>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <utility>
 
+#include "absl/base/internal/sysinfo.h"
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/synchronization/notification.h"
 
@@ -307,6 +310,83 @@ class CopyableAtomic : public std::atomic<T> {
   }
 };
 
+// Simple recursive mutex based on absl::Mutex.
+// The lock() requests from the same thread are not repeated.
+// Recursive locks are used in extremely limited situations, e.g.,
+// introducing thread-safeness to legacy non-thread-safety classes
+// without breaking the current design.
+class ABSL_LOCKABLE RecursiveMutex {
+ public:
+  ~RecursiveMutex() {
+    // when lock/unlock are constantly called, these conditions must be true.
+    DCHECK_EQ(owner_.load(std::memory_order_acquire), 0);
+    DCHECK_EQ(recursion_depth_, 0);
+  }
+
+  void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    const uint32_t current_tid = GetTID();
+
+    // Check if the `current_tid` is the owner
+    if (owner_.load(std::memory_order_acquire) == current_tid) {
+      // Since the owner is guaranteed to be the current thread,
+      // recursion_depth_ can be safely incremented without a lock.
+      ++recursion_depth_;
+      return;
+    }
+
+    // Wait until no one is the owner (owner_ == 0).
+    mutex_.LockWhen(absl::Condition(
+        +[](std::atomic<uint32_t>* owner) {
+          return owner->load(std::memory_order_relaxed) == 0;
+        },
+        &owner_));
+
+    // Acquiring the lock, and set the owner and recursion_depth_.
+    DCHECK_EQ(recursion_depth_, 0);
+    owner_.store(current_tid, std::memory_order_release);
+    recursion_depth_ = 1;
+  }
+
+  void unlock() ABSL_UNLOCK_FUNCTION() {
+    // Assuming the current thread is the owner, no internal Mutex lock is
+    // needed. Decrement the depth.
+    DCHECK(owns_lock());
+    if (--recursion_depth_ > 0) {
+      return;
+    }
+
+    // Depth reached 0, so clear the owner and release the internal Mutex so
+    // other thread can start the task.
+    owner_.store(0, std::memory_order_release);
+    mutex_.unlock();
+  }
+
+  // Returns true if the mute is owned by the current thread.
+  bool owns_lock() const {
+    return owner_.load(std::memory_order_acquire) == GetTID();
+  }
+
+  // Upper case versions are deprecated in absl::Mutex too.
+  // They are not compatible with std::lock_gurad<>/std::unique_lock<>.
+  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { lock(); }
+  inline void Unlock() ABSL_UNLOCK_FUNCTION() { unlock(); }
+
+ private:
+  static inline uint32_t GetTID() {
+    // NOLINTBEGIN(abseil-no-internal-dependencies)
+    // Abseil's cached version is 100 times faster.
+    // Since `pid_t` is not used in all architectures, use uint32_t.
+    return static_cast<uint32_t>(absl::base_internal::GetCachedTID());
+    // NOLINTEND(abseil-no-internal-dependencies)
+  }
+
+  absl::Mutex mutex_;
+  std::atomic<uint32_t> owner_{0};
+  // Accessed only by the thread indicated by owner_, so atomicity is
+  // unnecessary.
+  int recursion_depth_ = 0;
+};
+
 }  // namespace mozc
 
 #endif  // MOZC_BASE_THREAD_H_

src/base/thread_test.cc

@@ -30,9 +30,13 @@
 #include "base/thread.h"
 
 #include <atomic>
+#include <functional>
 #include <memory>
+#include <mutex>
 #include <optional>
+#include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/synchronization/notification.h"
 #include "absl/time/clock.h"
@@ -227,5 +231,34 @@ TEST(CopyableAtomicTest, BasicTest) {
   EXPECT_EQ(f3, 10);
 }
 
+TEST(RecursiveMutexTest, BasicTest) {
+  // Edits the `buffer` from multiple threads.
+  std::string buffer;
+
+  RecursiveMutex mutex;
+  std::vector<Thread> threads;
+
+  // `fib` is recursively called.
+  std::function<int(int)> fib = [&](int n) {
+    std::unique_lock<RecursiveMutex> lock(mutex);
+    buffer += ' ';
+    if (n <= 1) {
+      return n;
+    }
+    return fib(n - 1) + fib(n - 2);
+  };
+
+  constexpr int kNumThreads = 16;
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i] { fib(i); });
+  }
+
+  for (Thread& thread : threads) {
+    thread.Join();
+  }
+
+  EXPECT_TRUE(true);  // Expect to reach here
+}
+
 }  // namespace
 }  // namespace mozc

src/config/BUILD.bazel

@@ -137,6 +137,7 @@ mozc_cc_test(
             "//protocol:config_cc_proto",
         ],
         windows = [
+            "//base:bits",
             "//base/win32:win_api_test_helper",
             "@com_google_absl//absl/base",
             "@com_google_absl//absl/container:flat_hash_map",
@@ -164,6 +165,7 @@ mozc_cc_library(
     ],
     deps = [
         ":config_handler",
+        "//base:bits",
         "//base:config_file_stream",
         "//base:number_util",
         "//base:singleton",

src/config/character_form_manager.cc

@@ -44,6 +44,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "base/bits.h"
 #include "base/config_file_stream.h"
 #include "base/number_util.h"
 #include "base/singleton.h"
@@ -379,7 +380,7 @@ Config::CharacterForm CharacterFormManagerImpl::GetCharacterFormFromStorage(
   if (value == nullptr) {
     return Config::FULL_WIDTH;  // Return default setting
   }
-  const uint32_t ivalue = *reinterpret_cast<const uint32_t*>(value);
+  const uint32_t ivalue = LoadUnaligned<uint32_t>(value);
   return static_cast<Config::CharacterForm>(ivalue);
 }
 

src/config/stats_config_util_test.cc

@@ -42,6 +42,7 @@
 #include <bit>
 
 #include "absl/container/flat_hash_map.h"
+#include "base/bits.h"
 #include "base/singleton.h"
 #include "base/win32/win_api_test_helper.h"
 #endif  // _WIN32
@@ -228,7 +229,7 @@ class RegistryEmulator {
     if (!CheckWritable(key)) {
       return ERROR_ACCESS_DENIED;
     }
-    SetUsagestatsValue(key, *reinterpret_cast<const DWORD*>(data));
+    SetUsagestatsValue(key, LoadUnaligned<DWORD>(data));
     return ERROR_SUCCESS;
   }
   static LSTATUS WINAPI TestRegCloseKey(HKEY key) { return ERROR_SUCCESS; }

src/converter/BUILD.bazel

@@ -222,6 +222,7 @@ mozc_cc_library(
         "//prediction:__pkg__",
     ],
     deps = [
+        "//base:bits",
         "//data_manager",
         "//storage/louds:simple_succinct_bit_vector_index",
         "@com_google_absl//absl/status",
@@ -241,6 +242,7 @@ mozc_cc_test(
     ],
     deps = [
         ":connector",
+        "//base:bits",
         "//base:mmap",
         "//base:vlog",
         "//data_manager:connection_file_reader",

src/converter/connector.cc

@@ -45,6 +45,7 @@
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "base/bits.h"
 #include "data_manager/data_manager.h"
 #include "storage/louds/simple_succinct_bit_vector_index.h"
 
@@ -245,11 +246,11 @@ absl::Status Connector::Init(absl::string_view connection_data) {
     // |ptr| points to here now.  Every uint8_t[] block needs to be aligned at
     // 32-bit boundary.
     VALIDATE_SIZE(ptr, 2, "Compact bits size of row ", i, "/", rsize);
-    const uint16_t compact_bits_size = *reinterpret_cast<const uint16_t*>(ptr);
+    const uint16_t compact_bits_size = LoadUnaligned<uint16_t>(ptr);
     ptr += 2;
 
     VALIDATE_SIZE(ptr, 2, "Values size of row ", i, "/", rsize);
-    const uint16_t values_size = *reinterpret_cast<const uint16_t*>(ptr);
+    const uint16_t values_size = LoadUnaligned<uint16_t>(ptr);
     ptr += 2;
 
     VALIDATE_SIZE(ptr, chunk_bits_size, "Chunk bits of row ", i, "/", rsize);

src/converter/connector_test.cc

@@ -39,6 +39,7 @@
 #include "absl/random/random.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "base/bits.h"
 #include "base/mmap.h"
 #include "base/vlog.h"
 #include "data_manager/connection_file_reader.h"
@@ -102,7 +103,7 @@ TEST(ConnectorTest, BrokenData) {
   // Invalid magic number.
   {
     data.assign(cmmap->begin(), cmmap->size());
-    *reinterpret_cast<uint16_t*>(&data[0]) = 0;
+    StoreUnaligned<uint16_t>(0, &data[0]);
     const auto status = Connector::Create(data).status();
     MOZC_VLOG(1) << status;
     EXPECT_FALSE(status.ok());

src/converter/inner_segment.h

@@ -31,6 +31,7 @@
 #define MOZC_CONVERTER_INNER_SEGMENT_H_
 
 #include <algorithm>
+#include <bit>
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
@@ -94,11 +95,11 @@ inline std::optional<uint32_t> EncodeLengths(uint32_t key_len,
 
   const internal::LengthData data{key_len, value_len, content_key_len,
                                   content_value_len};
-  return *reinterpret_cast<const uint32_t*>(&data);
+  return std::bit_cast<uint32_t>(data);
 }
 
 inline internal::LengthData DecodeLengths(uint32_t encoded) {
-  return *reinterpret_cast<const struct internal::LengthData*>(&encoded);
+  return std::bit_cast<internal::LengthData>(encoded);
 }
 
 // Iterator class to access inner segments.