From c376c1a62aac628fc50d2d4154ab1de831755b7c Mon Sep 17 00:00:00 2001
From: Roland Schwarz <roland.schwarz@blackspace.at>
Date: Sun, 1 Oct 2006 12:57:18 +0000
Subject: [PATCH] Removed the "intentional memory leak" of the TSS
 implementation.

[SVN r35434]
---
 example/Jamfile              |   2 +-
 include/boost/thread/tss.hpp |  16 ++++-
 src/tss.cpp                  | 129 +++++++++++++++++++++++------------
 3 files changed, 102 insertions(+), 45 deletions(-)

diff --git a/example/Jamfile b/example/Jamfile
index dc499a85..3bb7a90f 100644
--- a/example/Jamfile
+++ b/example/Jamfile
@@ -28,7 +28,7 @@ import ../build/threads ;
     template example
         ## sources ##
         : <template>thread_base
-          <dll>../build/boost_thread
+          <lib>../build/boost_thread
         ## requirements ##
         :
         ## default build ##
diff --git a/include/boost/thread/tss.hpp b/include/boost/thread/tss.hpp
index 2191f6ff..bd873d28 100644
--- a/include/boost/thread/tss.hpp
+++ b/include/boost/thread/tss.hpp
@@ -1,5 +1,5 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+// Copyright (C) 2001-2003 William E. Kempf
+// Copyright (C) 2006 Roland Schwarz
 //
 //  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)
@@ -21,6 +21,13 @@
 
 namespace boost {
 
+// disable warnings about non dll import
+// see: http://www.boost.org/more/separate_compilation.html#dlls
+#ifdef BOOST_MSVC
+#	pragma warning(push)
+#	pragma warning(disable: 4251 4231 4660 4275)
+#endif
+
 namespace detail {
 
 class BOOST_THREAD_DECL tss : private noncopyable
@@ -39,6 +46,7 @@ public:
         }
     }
 
+    ~tss();
     void* get() const;
     void set(void* value);
     void cleanup(void* p);
@@ -98,6 +106,10 @@ private:
     detail::tss m_tss;
 };
 
+#ifdef BOOST_MSVC
+#	pragma warning(pop)
+#endif
+
 } // namespace boost
 
 #endif //BOOST_TSS_WEK070601_HPP
diff --git a/src/tss.cpp b/src/tss.cpp
index 5b2f8031..2c1d020a 100644
--- a/src/tss.cpp
+++ b/src/tss.cpp
@@ -1,5 +1,5 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+// Copyright (C) 2001-2003 William E. Kempf
+// Copyright (C) 2006 Roland Schwarz
 //
 //  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)
@@ -25,63 +25,98 @@
 namespace {
 
 typedef std::vector<void*> tss_slots;
+typedef std::vector<boost::function1<void, void*>*> tss_data_cleanup_handlers_type;
 
-struct tss_data_t
-{
-    boost::mutex mutex;
-    std::vector<boost::function1<void, void*>*> cleanup_handlers;
-#if defined(BOOST_HAS_WINTHREADS)
-    DWORD native_key;
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_key_t native_key;
-#elif defined(BOOST_HAS_MPTASKS)
-    TaskStorageIndex native_key;
-#endif
-};
-
-tss_data_t* tss_data = 0;
 boost::once_flag tss_data_once = BOOST_ONCE_INIT;
+boost::mutex* tss_data_mutex = 0;
+tss_data_cleanup_handlers_type* tss_data_cleanup_handlers = 0;
+#if defined(BOOST_HAS_WINTHREADS)
+    DWORD tss_data_native_key;
+#elif defined(BOOST_HAS_PTHREADS)
+    pthread_key_t tss_data_native_key;
+#elif defined(BOOST_HAS_MPTASKS)
+    TaskStorageIndex tss_data_native_key;
+#endif
+int tss_data_use = 0;
+
+void tss_data_inc_use(boost::mutex::scoped_lock& lk)
+{
+    ++tss_data_use;
+}
+
+void tss_data_dec_use(boost::mutex::scoped_lock& lk)
+{
+    if (0 == --tss_data_use)
+    {
+        tss_data_cleanup_handlers_type::size_type i;
+        for (i = 0; i < tss_data_cleanup_handlers->size(); ++i)
+        {
+            delete (*tss_data_cleanup_handlers)[i];
+        }
+        delete tss_data_cleanup_handlers;
+        tss_data_cleanup_handlers = 0;
+        lk.unlock();
+        delete tss_data_mutex;
+        tss_data_mutex = 0;
+#if defined(BOOST_HAS_WINTHREADS)
+        TlsFree(tss_data_native_key);
+#elif defined(BOOST_HAS_PTHREADS)
+        pthread_key_delete(tss_data_native_key);
+#elif defined(BOOST_HAS_MPTASKS)
+        // Don't know what to put here.
+        // But MPTASKS isn't currently maintained anyways...
+#endif
+    }
+}
 
 extern "C" void cleanup_slots(void* p)
 {
     tss_slots* slots = static_cast<tss_slots*>(p);
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
     for (tss_slots::size_type i = 0; i < slots->size(); ++i)
     {
-        boost::mutex::scoped_lock lock(tss_data->mutex);
-        (*tss_data->cleanup_handlers[i])((*slots)[i]);
+        (*(*tss_data_cleanup_handlers)[i])((*slots)[i]);
         (*slots)[i] = 0;
     }
+    tss_data_dec_use(lock);
     delete slots;
 }
 
 void init_tss_data()
 {
-    std::auto_ptr<tss_data_t> temp(new tss_data_t);
+    std::auto_ptr<tss_data_cleanup_handlers_type> 
+        temp(new tss_data_cleanup_handlers_type);
+
+    std::auto_ptr<boost::mutex> temp_mutex(new boost::mutex);
+    if (temp_mutex.get() == 0)
+        throw boost::thread_resource_error();
 
 #if defined(BOOST_HAS_WINTHREADS)
     //Force the cleanup implementation library to be linked in
     tss_cleanup_implemented();
 
     //Allocate tls slot
-    temp->native_key = TlsAlloc();
-    if (temp->native_key == 0xFFFFFFFF)
+    tss_data_native_key = TlsAlloc();
+    if (tss_data_native_key == 0xFFFFFFFF)
         return;
 #elif defined(BOOST_HAS_PTHREADS)
-    int res = pthread_key_create(&temp->native_key, &cleanup_slots);
+    int res = pthread_key_create(&tss_data_native_key, &cleanup_slots);
     if (res != 0)
         return;
 #elif defined(BOOST_HAS_MPTASKS)
-    OSStatus status = MPAllocateTaskStorageIndex(&temp->native_key);
+    OSStatus status = MPAllocateTaskStorageIndex(&tss_data_native_key);
     if (status != noErr)
         return;
 #endif
 
-    // Intentional memory "leak"
-    // This is the only way to ensure the mutex in the global data
-    // structure is available when cleanup handlers are run, since the
-    // execution order of cleanup handlers is unspecified on any platform
-    // with regards to C++ destructor ordering rules.
-    tss_data = temp.release();
+    // The life time of cleanup handlers and mutex is beeing
+    // managed by a reference counting technique.
+    // This avoids a memory leak by releasing the global data
+    // after last use only, since the execution order of cleanup
+    // handlers is unspecified on any platform with regards to
+    // C++ destructor ordering rules.
+    tss_data_cleanup_handlers = temp.release();
+    tss_data_mutex = temp_mutex.release();
 }
 
 #if defined(BOOST_HAS_WINTHREADS)
@@ -101,13 +136,13 @@ tss_slots* get_slots(bool alloc)
 
 #if defined(BOOST_HAS_WINTHREADS)
     slots = static_cast<tss_slots*>(
-        TlsGetValue(tss_data->native_key));
+        TlsGetValue(tss_data_native_key));
 #elif defined(BOOST_HAS_PTHREADS)
     slots = static_cast<tss_slots*>(
-        pthread_getspecific(tss_data->native_key));
+        pthread_getspecific(tss_data_native_key));
 #elif defined(BOOST_HAS_MPTASKS)
     slots = static_cast<tss_slots*>(
-        MPGetTaskStorageValue(tss_data->native_key));
+        MPGetTaskStorageValue(tss_data_native_key));
 #endif
 
     if (slots == 0 && alloc)
@@ -117,16 +152,19 @@ tss_slots* get_slots(bool alloc)
 #if defined(BOOST_HAS_WINTHREADS)
         if (at_thread_exit(&tss_thread_exit) == -1)
             return 0;
-        if (!TlsSetValue(tss_data->native_key, temp.get()))
+        if (!TlsSetValue(tss_data_native_key, temp.get()))
             return 0;
 #elif defined(BOOST_HAS_PTHREADS)
-        if (pthread_setspecific(tss_data->native_key, temp.get()) != 0)
+        if (pthread_setspecific(tss_data_native_key, temp.get()) != 0)
             return 0;
 #elif defined(BOOST_HAS_MPTASKS)
-        if (MPSetTaskStorageValue(tss_data->native_key, temp.get()) != noErr)
+        if (MPSetTaskStorageValue(tss_data_native_key, temp.get()) != noErr)
             return 0;
 #endif
-
+        {
+            boost::mutex::scoped_lock lock(*tss_data_mutex);
+            tss_data_inc_use(lock);
+        }
         slots = temp.release();
     }
 
@@ -141,13 +179,14 @@ namespace detail {
 void tss::init(boost::function1<void, void*>* pcleanup)
 {
     boost::call_once(&init_tss_data, tss_data_once);
-    if (tss_data == 0)
+    if (tss_data_cleanup_handlers == 0)
         throw thread_resource_error();
-    boost::mutex::scoped_lock lock(tss_data->mutex);
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
     try
     {
-        tss_data->cleanup_handlers.push_back(pcleanup);
-        m_slot = tss_data->cleanup_handlers.size() - 1;
+        tss_data_cleanup_handlers->push_back(pcleanup);
+        m_slot = tss_data_cleanup_handlers->size() - 1;
+        tss_data_inc_use(lock);
     }
     catch (...)
     {
@@ -155,6 +194,12 @@ void tss::init(boost::function1<void, void*>* pcleanup)
     }
 }
 
+tss::~tss()
+{
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
+    tss_data_dec_use(lock);
+}
+
 void* tss::get() const
 {
     tss_slots* slots = get_slots(false);
@@ -192,8 +237,8 @@ void tss::set(void* value)
 
 void tss::cleanup(void* value)
 {
-    boost::mutex::scoped_lock lock(tss_data->mutex);
-    (*tss_data->cleanup_handlers[m_slot])(value);
+    boost::mutex::scoped_lock lock(*tss_data_mutex);
+    (*(*tss_data_cleanup_handlers)[m_slot])(value);
 }
 
 } // namespace detail