TLS tweaks

Author: zajo

include/boost/leaf/config.hpp

@@ -94,6 +94,11 @@
 #   error BOOST_LEAF_CFG_WIN32 must be 0 or 1 or 2.
 #endif
 
+#if BOOST_LEAF_CFG_WIN32 && !defined(_WIN32)
+#   warning "Ignoring BOOST_LEAF_CFG_WIN32 because _WIN32 is not defined"
+#   define BOOST_LEAF_CFG_WIN32 0
+#endif
+
 #if BOOST_LEAF_CFG_GNUC_STMTEXPR != 0 && BOOST_LEAF_CFG_GNUC_STMTEXPR != 1
 #   error BOOST_LEAF_CFG_GNUC_STMTEXPR must be 0 or 1.
 #endif

include/boost/leaf/config/tls.hpp

@@ -1,14 +1,66 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED
 
-// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright 2018-2025 Emil Dotchevski and Reverge Studios, Inc.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <atomic>
+namespace boost { namespace leaf {
+
+// The following declarations specify the thread local storage API used
+// internally by LEAF. To port LEAF to a new TLS API, provide definitions for
+// each of these functions.
+namespace tls
+{
+    // Generate the next unique error_id. Values start at 1 and increment by 4.
+    // Error ids must be unique for the lifetime of the process, and this
+    // function must be thread-safe. Postcondition: (id & 3) == 1 && id != 0.
+    //
+    // This function may not fail.
+    unsigned generate_next_error_id() noexcept;
+
+    // Write x to the TLS for the current error_id. The initial value for each
+    // thread must be 0. Precondition: x == 0 or (x & 3) == 1.
+    //
+    // This function may not fail.
+    void write_current_error_id( unsigned x ) noexcept;
+
+    // Read the current error_id for this thread. The initial value for each
+    // thread must be 0.
+    //
+    // This function may not fail.
+    unsigned read_current_error_id() noexcept;
+
+    // Write p to the TLS for T. The TLS may be allocated dynamically on the
+    // first call to write_ptr_alloc<T>, but subsequent calls must reuse the
+    // same TLS.
+    //
+    // This function may throw on allocation failure.
+    template <class T>
+    void write_ptr_alloc( T * p );
+
+    // Write p to the TLS previously allocated for T by a successful call to
+    // write_ptr_alloc<T>.
+    //
+    // This function may not fail.
+    template <class T>
+    void write_ptr( T * p ) noexcept;
+
+    // Read the T * value previously written in the TLS for T. Returns nullptr
+    // if TLS for T has not yet been allocated.
+    //
+    // This function may not fail.
+    template <class T>
+    T * read_ptr() noexcept;
+}
+
+} }
 
 #if defined(BOOST_LEAF_TLS_FREERTOS)
 #   include <boost/leaf/config/tls_freertos.hpp>
+#   ifndef BOOST_LEAF_USE_TLS_ARRAY
+#       define BOOST_LEAF_USE_TLS_ARRAY
+#   endif
 #endif
 
 #ifndef BOOST_LEAF_USE_TLS_ARRAY
@@ -23,40 +75,14 @@
 #	endif
 #endif
 
-#if BOOST_LEAF_CFG_WIN32 == 2
+#if defined BOOST_LEAF_USE_TLS_ARRAY
+#   include <boost/leaf/config/tls_array.hpp>
+#elif BOOST_LEAF_CFG_WIN32 == 2
 #   include <boost/leaf/config/tls_win32.hpp>
+#elif defined(BOOST_LEAF_NO_THREADS)
+#   include <boost/leaf/config/tls_globals.hpp>
 #else
-#   if defined BOOST_LEAF_USE_TLS_ARRAY
-#       include <boost/leaf/config/tls_array.hpp>
-#   elif defined(BOOST_LEAF_NO_THREADS)
-#       include <boost/leaf/config/tls_globals.hpp>
-#   else
-#       include <boost/leaf/config/tls_cpp11.hpp>
-#   endif
-
-namespace boost { namespace leaf {
-
-namespace detail
-{
-    template <class=void>
-    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
-    {
-        static atomic_unsigned_int counter;
-    };
-
-    template <class T>
-    atomic_unsigned_int id_factory<T>::counter(1);
-
-    inline unsigned generate_next_error_id() noexcept
-    {
-        unsigned id = (id_factory<>::counter += 4);
-        BOOST_LEAF_ASSERT((id&3) == 1);
-        return id;
-    }
-}
-
-} }
-
+#   include <boost/leaf/config/tls_cpp11.hpp>
 #endif
 
 #endif // BOOST_LEAF_CONFIG_TLS_HPP_INCLUDED

include/boost/leaf/config/tls_array.hpp

@@ -1,16 +1,15 @@
 #ifndef BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED
 #define BOOST_LEAF_CONFIG_TLS_ARRAY_HPP_INCLUDED
 
-// Copyright 2018-2024 Emil Dotchevski and Reverge Studios, Inc.
+// Copyright 2018-2025 Emil Dotchevski and Reverge Studios, Inc.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 // Copyright (c) 2022 Khalil Estell
 
-// LEAF requires thread local storage support for pointers and for uin32_t values.
-
-// This header implements thread local storage for pointers and for unsigned int
-// values for platforms that support thread local pointers by index.
+// This header implements the TLS API specified in tls.hpp for platforms that
+// provide TLS by indexing an array (this is typical for embedded platforms).
+// The array is accessed via user-defined functions.
 
 namespace boost { namespace leaf {
 
@@ -26,6 +25,7 @@ namespace tls
 
 ////////////////////////////////////////
 
+#include <atomic>
 #include <limits>
 #include <cstdint>
 #include <type_traits>
@@ -55,16 +55,22 @@ namespace boost { namespace leaf {
 namespace detail
 {
     using atomic_unsigned_int = std::atomic<unsigned int>;
-}
 
-namespace tls
-{
+    template <class=void>
+    struct BOOST_LEAF_SYMBOL_VISIBLE id_factory
+    {
+        static atomic_unsigned_int counter;
+    };
+
+    template <class T>
+    atomic_unsigned_int id_factory<T>::counter(1);
+
     template <class=void>
     class BOOST_LEAF_SYMBOL_VISIBLE index_counter
     {
         static int c_;
 
-        static BOOST_LEAF_CFG_TLS_INDEX_TYPE next_() noexcept
+        BOOST_LEAF_ALWAYS_INLINE static BOOST_LEAF_CFG_TLS_INDEX_TYPE next_() noexcept
         {
             int idx = ++c_;
             BOOST_LEAF_ASSERT(idx > (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1));
@@ -75,76 +81,88 @@ namespace tls
     public:
 
         template <class T>
-        static BOOST_LEAF_CFG_TLS_INDEX_TYPE next() noexcept
+        BOOST_LEAF_ALWAYS_INLINE static BOOST_LEAF_CFG_TLS_INDEX_TYPE next() noexcept
         {
-            return next_(); // Set breakpoint here to monitor TLS index allocation for T.
+            return next_();
         }
     };
 
+    template <class T>
+    int index_counter<T>::c_ = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
+
     template <class T>
     struct BOOST_LEAF_SYMBOL_VISIBLE tls_index
     {
         static BOOST_LEAF_CFG_TLS_INDEX_TYPE idx;
     };
 
+    template <class T>
+    BOOST_LEAF_CFG_TLS_INDEX_TYPE tls_index<T>::idx = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
+
     template <class T>
     struct BOOST_LEAF_SYMBOL_VISIBLE alloc_tls_index
     {
         static BOOST_LEAF_CFG_TLS_INDEX_TYPE const idx;
     };
 
     template <class T>
-    int index_counter<T>::c_ = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
+    BOOST_LEAF_CFG_TLS_INDEX_TYPE const alloc_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next<T>();
+}
 
-    template <class T>
-    BOOST_LEAF_CFG_TLS_INDEX_TYPE tls_index<T>::idx = BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1;
+} }
 
-    template <class T>
-    BOOST_LEAF_CFG_TLS_INDEX_TYPE const alloc_tls_index<T>::idx = tls_index<T>::idx = index_counter<>::next<T>();
+////////////////////////////////////////
 
-    ////////////////////////////////////////
+namespace boost { namespace leaf {
 
-    template <class T>
-    T * read_ptr() noexcept
+namespace tls
+{
+    BOOST_LEAF_ALWAYS_INLINE unsigned generate_next_error_id() noexcept
     {
-        int tls_idx = tls_index<T>::idx;
-        if( tls_idx == (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1) )
-            return nullptr;
-        --tls_idx;
-        return reinterpret_cast<T *>(read_void_ptr(tls_idx));
+        unsigned id = (detail::id_factory<>::counter += 4);
+        BOOST_LEAF_ASSERT((id&3) == 1);
+        return id;
+    }
+
+    BOOST_LEAF_ALWAYS_INLINE void write_current_error_id( unsigned x ) noexcept
+    {
+        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
+        write_void_ptr(BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX, (void *) (std::intptr_t) x);
+    }
+
+    BOOST_LEAF_ALWAYS_INLINE unsigned read_current_error_id() noexcept
+    {
+        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
+        return (unsigned) (std::intptr_t) read_void_ptr(BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX);
     }
 
     template <class T>
-    void alloc_write_ptr( T * p ) noexcept
+    BOOST_LEAF_ALWAYS_INLINE void write_ptr_alloc( T * p )
     {
-        int tls_idx = alloc_tls_index<T>::idx;
+        int tls_idx = detail::alloc_tls_index<T>::idx;
         --tls_idx;
         write_void_ptr(tls_idx, p);
         BOOST_LEAF_ASSERT(read_void_ptr(tls_idx) == p);
     }
 
     template <class T>
-    void write_ptr( T * p ) noexcept
+    BOOST_LEAF_ALWAYS_INLINE void write_ptr( T * p ) noexcept
     {
-        int tls_idx = tls_index<T>::idx;
+        int tls_idx = detail::tls_index<T>::idx;
         BOOST_LEAF_ASSERT(tls_idx != (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1));
         --tls_idx;
         write_void_ptr(tls_idx, p);
         BOOST_LEAF_ASSERT(read_void_ptr(tls_idx) == p);
     }
 
-    ////////////////////////////////////////
-
-    inline unsigned read_current_error_id() noexcept
-    {
-        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
-        return (unsigned) (std::intptr_t) read_void_ptr(BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX);
-    }
-
-    inline void write_current_error_id( unsigned x ) noexcept
+    template <class T>
+    BOOST_LEAF_ALWAYS_INLINE T * read_ptr() noexcept
     {
-        static_assert(sizeof(std::intptr_t) >= sizeof(unsigned), "Incompatible tls_array implementation");
-        write_void_ptr(BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX, (void *) (std::intptr_t) x);
+        int tls_idx = detail::tls_index<T>::idx;
+        if( tls_idx == (BOOST_LEAF_CFG_TLS_ARRAY_START_INDEX + 1) )
+            return nullptr;
+        --tls_idx;
+        return reinterpret_cast<T *>(read_void_ptr(tls_idx));
     }
 }