Use minimal TLS implementation for thread-local mapping objects

production/db/inc/core/db_client.hpp

@@ -115,7 +115,10 @@ class client_t
     thread_local static inline gaia_txn_id_t s_txn_id = c_invalid_gaia_txn_id;
     thread_local static inline log_offset_t s_txn_log_offset = c_invalid_log_offset;
 
-    thread_local static inline mapped_data_t<locators_t> s_private_locators;
+    // NB: We need to use the (nonstandard) __thread attribute rather than
+    // thread_local to ensure that a minimal TLS implementation is used.
+    __thread static inline mapped_data_t<locators_t> s_private_locators{};
+
     thread_local static inline gaia::db::index::indexes_t s_local_indexes{};
 
     // These fields have session lifetime.
@@ -131,11 +134,13 @@ class client_t
 
     thread_local static inline int s_fd_locators = -1;
 
-    thread_local static inline mapped_data_t<counters_t> s_shared_counters;
-    thread_local static inline mapped_data_t<data_t> s_shared_data;
-    thread_local static inline mapped_data_t<logs_t> s_shared_logs;
-    thread_local static inline mapped_data_t<id_index_t> s_shared_id_index;
-    thread_local static inline mapped_data_t<type_index_t> s_shared_type_index;
+    // NB: We need to use the (nonstandard) __thread attribute rather than
+    // thread_local to ensure that a minimal TLS implementation is used.
+    __thread static inline mapped_data_t<counters_t> s_shared_counters{};
+    __thread static inline mapped_data_t<data_t> s_shared_data{};
+    __thread static inline mapped_data_t<logs_t> s_shared_logs{};
+    __thread static inline mapped_data_t<id_index_t> s_shared_id_index{};
+    __thread static inline mapped_data_t<type_index_t> s_shared_type_index{};
 
     thread_local static inline gaia::db::memory_manager::memory_manager_t s_memory_manager{};
     thread_local static inline gaia::db::memory_manager::chunk_manager_t s_chunk_manager{};

production/db/inc/core/db_server.hpp

@@ -147,7 +147,10 @@ class server_t
     thread_local static inline std::vector<std::pair<gaia_txn_id_t, log_offset_t>> s_txn_logs_for_snapshot{};
 
     // Local snapshot for server-side transactions.
-    thread_local static inline mapped_data_t<locators_t> s_local_snapshot_locators{};
+    // NB: We need to use the (nonstandard) __thread attribute rather than
+    // thread_local to ensure that a minimal TLS implementation is used.
+    __thread static inline mapped_data_t<locators_t> s_local_snapshot_locators{};
+
     // Watermark that tracks how many log records have been used for the current snapshot instance.
     // This is used to permit the incremental updating of the snapshot.
     thread_local static inline size_t s_last_snapshot_processed_log_record_count{0};

production/db/inc/core/mapped_data.hpp

@@ -36,15 +36,19 @@ template <typename T_data>
 class core_mapped_data_t : public base_mapped_data_t
 {
 public:
-    core_mapped_data_t();
+    // Thread-local variables cannot have nontrivial constructors without
+    // prohibitive overhead.
+    constexpr core_mapped_data_t() = default;
 
     // Copy semantics is disabled and moves should be performed via reset().
     core_mapped_data_t(const core_mapped_data_t& other) = delete;
     core_mapped_data_t(core_mapped_data_t&& other) = delete;
     core_mapped_data_t& operator=(const core_mapped_data_t& rhs) = delete;
     core_mapped_data_t& operator=(core_mapped_data_t&& rhs) = delete;
 
-    ~core_mapped_data_t();
+    // Thread-local variables cannot have nontrivial destructors without
+    // prohibitive overhead.
+    ~core_mapped_data_t() = default;
 
     // Stops tracking any data and reverts back to uninitialized state.
     void clear();
@@ -67,12 +71,12 @@ class core_mapped_data_t : public base_mapped_data_t
     void close_internal();
 
 protected:
-    bool m_is_set;
-    int m_fd;
-    T_data* m_data;
+    bool m_is_set{false};
+    int m_fd{-1};
+    T_data* m_data{nullptr};
 
     // This is used to track the mapped data size, so we can call unmap_fd_data()/munmap() with the same value.
-    size_t m_mapped_data_size;
+    size_t m_mapped_data_size{0};
 };
 
 // This class abstracts the server and client operations with memory-mapped data.
@@ -81,7 +85,7 @@ template <typename T_data>
 class mapped_data_t : public core_mapped_data_t<T_data>
 {
 public:
-    mapped_data_t() = default;
+    constexpr mapped_data_t() = default;
 
     // Copy semantics is disabled and moves should be performed via reset().
     mapped_data_t(const mapped_data_t& other) = delete;

production/db/inc/core/mapped_data.inc

@@ -3,18 +3,6 @@
 // All rights reserved.
 /////////////////////////////////////////////
 
-template <typename T_data>
-core_mapped_data_t<T_data>::core_mapped_data_t()
-{
-    clear();
-}
-
-template <typename T_data>
-core_mapped_data_t<T_data>::~core_mapped_data_t()
-{
-    close_internal();
-}
-
 template <typename T_data>
 void core_mapped_data_t<T_data>::clear()
 {