[Boost-commit] svn:boost r86390 - in trunk: boost/sync/detail libs/sync/build libs/sync/src

Subject: [Boost-commit] svn:boost r86390 - in trunk: boost/sync/detail libs/sync/build libs/sync/src
From: andrey.semashev_at_[hidden]
Date: 2013-10-22 09:31:21

Author: andysem
Date: 2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)
New Revision: 86390
URL: http://svn.boost.org/trac/boost/changeset/86390

Log:
Added preliminary implementation of internal TLS.

Added:
   trunk/libs/sync/build/
   trunk/libs/sync/build/Jamfile.v2   (contents, props changed)
   trunk/libs/sync/src/
   trunk/libs/sync/src/tss_manager.hpp   (contents, props changed)
   trunk/libs/sync/src/tss_pthread.cpp   (contents, props changed)
   trunk/libs/sync/src/tss_windows.cpp   (contents, props changed)
   trunk/libs/sync/src/tss_windows_dll.cpp   (contents, props changed)
   trunk/libs/sync/src/tss_windows_hooks.hpp   (contents, props changed)
   trunk/libs/sync/src/tss_windows_pe.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/sync/detail/tss.hpp           |     7                                         
   trunk/libs/sync/build/Jamfile.v2          |   179 ++++++++++++++++++++                    
   trunk/libs/sync/src/tss_manager.hpp       |   246 ++++++++++++++++++++++++++++            
   trunk/libs/sync/src/tss_pthread.cpp       |   129 ++++++++++++++                          
   trunk/libs/sync/src/tss_windows.cpp       |   188 +++++++++++++++++++++                   
   trunk/libs/sync/src/tss_windows_dll.cpp   |    86 +++++++++                               
   trunk/libs/sync/src/tss_windows_hooks.hpp |    75 ++++++++                                
   trunk/libs/sync/src/tss_windows_pe.cpp    |   348 ++++++++++++++++++++++++++++++++++++++++
   8 files changed, 1256 insertions(+), 2 deletions(-)

Modified: trunk/boost/sync/detail/tss.hpp
==============================================================================
--- trunk/boost/sync/detail/tss.hpp	Tue Oct 22 09:28:27 2013	(r86389)
+++ trunk/boost/sync/detail/tss.hpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -30,7 +30,7 @@
 namespace detail {
 
 typedef unsigned int thread_specific_key;
-typedef void (*at_thread_exit_callback)(void*) BOOST_NOEXCEPT;
+typedef void (*at_thread_exit_callback)(void*);
 
 /*!
  * \brief Adds a callback to be invoked when the current thread terminates
@@ -47,10 +47,13 @@
  * \brief Creates a thread-specific key
  *
  * \param callback The callback to be called when a thread that used the key terminates. The callback will also be called when the key is deleted.
+ * \param cleanup_at_delete If \c true, The \a callback will be called for all non-NULL thread-specific values associated with this key at the point
+ *        of \c delete_thread_specific_key call. The user's code should be prepared that the cleanup function can be called not only in the context of the
+ *        thread that initialized the specific value.
  *
  * \returns The created key.
  */
-BOOST_SYNC_API thread_specific_key new_thread_specific_key(at_thread_exit_callback callback);
+BOOST_SYNC_API thread_specific_key new_thread_specific_key(at_thread_exit_callback callback, bool cleanup_at_delete);
 /*!
  * \brief Destroys the thread-specific key and all associated values.
  *

Added: trunk/libs/sync/build/Jamfile.v2
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/build/Jamfile.v2	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,179 @@
+# Copyright 2006-2007 Roland Schwarz.
+# Copyright 2007 Anthony Williams
+# Copyright 2011-2012 Vicente J.Botet Escriba.
+# Copyright 2013 Andrey Semashev
+# 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)
+
+#########################################################################
+# The Boost.Sync library can be built on top of different API's on Windows.
+# Currently this is the win32 API and the pthreads API.
+# Pthread is native on unix variants.
+# To get pthread on windows you need the pthread win32 library
+# http://sourceware.org/pthreads-win32 which is available under LGPL.
+#
+# You need to provide the include path and lib path in the variables
+# PTW32_INCLUDE and PTW32_LIB respectively. You can specify these
+# paths in site-config.jam, user-config.jam or in the environment.
+# Boost.Sync also makes use of the threadapi feature defined by Boost.Thread:
+# <threadapi>win32 and <threadapi>pthread.
+#
+# To request the pthread variant on windows, from boost root you would
+# say e.g:
+# bjam msvc-8.0 --with-sync install threadapi=pthread
+#########################################################################
+
+import os ;
+import feature ;
+import indirect ;
+import path ;
+import configure ;
+
+project boost/sync
+    : source-location ../src
+    : requirements
+      <threading>multi
+      <link>static:<define>BOOST_SYNC_STATIC_LINK=1
+      <link>shared:<define>BOOST_SYNC_DYN_LINK=1
+      <define>BOOST_SYNC_BUILDING=1
+      <target-os>windows:<define>BOOST_USE_WINDOWS_H=1
+      <target-os>windows:<define>WIN32_LEAN_AND_MEAN=1
+      <library>/boost/system//boost_system
+
+    : usage-requirements  # pass these requirement to dependents (i.e. users)
+      <link>static:<define>BOOST_SYNC_STATIC_LINK=1
+      <link>shared:<define>BOOST_SYNC_DYN_LINK=1
+      <library>/boost/system//boost_system
+    ;
+
+rule win32_pthread_paths ( properties * )
+{
+    local result ;
+    local PTW32_INCLUDE ;
+    local PTW32_LIB ;
+    PTW32_INCLUDE  = [ modules.peek             : PTW32_INCLUDE ] ;
+    PTW32_LIB      = [ modules.peek             : PTW32_LIB     ] ;
+    PTW32_INCLUDE ?= [ modules.peek user-config : PTW32_INCLUDE ] ;
+    PTW32_LIB     ?= [ modules.peek user-config : PTW32_LIB     ] ;
+    PTW32_INCLUDE ?= [ modules.peek site-config : PTW32_INCLUDE ] ;
+    PTW32_LIB     ?= [ modules.peek site-config : PTW32_LIB     ] ;
+
+    if ! ( $(PTW32_INCLUDE) && $(PTW32_LIB) )
+    {
+        if  ! $(.notified)
+        {
+            echo "************************************************************" ;
+            echo "Trying to build Boost.Sync with pthread support."             ;
+            echo "If you need pthread you should specify the paths."            ;
+            echo "You can specify them in site-config.jam, user-config.jam"     ;
+            echo "or in the environment."                                       ;
+            echo "For example:"                                                 ;
+            echo "PTW32_INCLUDE=C:\\Program Files\\ptw32\\Pre-built2\\include"  ;
+            echo "PTW32_LIB=C:\\Program Files\\ptw32\\Pre-built2\\lib"          ;
+            echo "************************************************************" ;
+            .notified = true ;
+        }
+    }
+    else
+    {
+        local include_path = [ path.make $(PTW32_INCLUDE) ] ;
+        local lib_path = [ path.make $(PTW32_LIB) ] ;
+        local libname = pthread ;
+        if <toolset>msvc in $(properties)
+        {
+            libname = $(libname)VC2.lib ;
+        }
+        if <toolset>gcc in $(properties)
+        {
+            libname = lib$(libname)GC2.a ;
+        }
+        lib_path = [ path.glob $(lib_path) : $(libname) ] ;
+        if ! $(lib_path)
+        {
+            if  ! $(.notified)
+            {
+                echo "************************************************************" ;
+                echo "Trying to build Boost.Sync with pthread support."             ;
+                echo "But the library" $(libname) "could not be found in path"      ;
+                echo $(PTW32_LIB)                                                   ;
+                echo "************************************************************" ;
+                .notified = true ;
+            }
+        }
+        else
+        {
+            result += <include>$(include_path) ;
+            result += <library>$(lib_path) ;
+        }
+    }
+    return $(result) ;
+}
+
+rule usage-requirements ( properties * )
+{
+    local result ;
+    if <threadapi>pthread in $(properties)
+    {
+        if <target-os>windows in $(properties)
+        {
+            result += <define>BOOST_SYNC_USE_PTHREAD ;
+            result += [ win32_pthread_paths $(properties) ] ;
+            # TODO: What is for static linking? Is the <library> also needed
+            # in that case?
+        }
+    }
+
+    return $(result) ;
+}
+
+rule requirements ( properties * )
+{
+    local result ;
+
+    if <threadapi>pthread in $(properties)
+    {
+        result += <define>BOOST_SYNC_USE_PTHREAD ;
+        if <target-os>windows in $(properties)
+        {
+            local paths = [ win32_pthread_paths $(properties) ] ;
+            if $(paths)
+            {
+                result += $(paths) ;
+            }
+            else
+            {
+                result = <build>no ;
+            }
+        }
+    }
+
+    return $(result) ;
+}
+
+alias sync_platform_sources
+    :
+      tss_windows_dll.cpp
+      tss_windows_pe.cpp
+      tss_windows.cpp
+      tss_pthread.cpp
+    :
+      <target-os>windows
+    ;
+
+alias sync_platform_sources
+    :
+      tss_pthread.cpp
+    ;
+
+explicit sync_platform_sources ;
+
+lib boost_sync
+    :
+      sync_platform_sources
+    :
+      <conditional>@requirements
+    :
+    :
+      <conditional>@usage-requirements
+    ;

Added: trunk/libs/sync/src/tss_manager.hpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/src/tss_manager.hpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,246 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file   tss_manager.hpp
+ *
+ * \brief  This header is the Boost.Sync library implementation, see the library documentation
+ *         at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#ifndef BOOST_SYNC_IMPL_TSS_MANAGER_HPP_INCLUDED_
+#define BOOST_SYNC_IMPL_TSS_MANAGER_HPP_INCLUDED_
+
+#include <stack>
+#include <vector>
+#include <boost/assert.hpp>
+#include <boost/intrusive/options.hpp>
+#include <boost/intrusive/list.hpp>
+#include <boost/intrusive/list_hook.hpp>
+#include <boost/sync/detail/config.hpp>
+#include <boost/sync/locks/lock_guard.hpp>
+#include <boost/sync/locks/unique_lock.hpp>
+#include <boost/sync/mutexes/mutex.hpp>
+#include <boost/sync/detail/tss.hpp>
+#include <boost/sync/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+class tss_manager
+{
+public:
+    typedef intrusive::list_base_hook<
+        intrusive::tag< struct for_thread_context_list >,
+        intrusive::link_mode< intrusive::safe_link >
+    > thread_context_list_hook;
+
+    class thread_context :
+        public thread_context_list_hook
+    {
+        friend class tss_manager;
+
+    private:
+        struct at_exit_entry
+        {
+            at_thread_exit_callback callback;
+            void* context;
+        };
+
+    private:
+        std::vector< void* > m_storage;
+        std::vector< at_exit_entry > m_at_exit_functions;
+
+    public:
+        void* get_value(thread_specific_key key) const BOOST_NOEXCEPT
+        {
+            if (key < m_storage.size())
+                return m_storage[key];
+            else
+                return NULL;
+        }
+
+        void set_value(thread_specific_key key, void* value)
+        {
+            if (key >= m_storage.size())
+                m_storage.resize(key + 1, static_cast< void* >(NULL));
+            m_storage[key] = value;
+        }
+
+        void add_at_exit_entry(at_thread_exit_callback callback, void* context)
+        {
+            at_exit_entry entry;
+            entry.callback = callback;
+            entry.context = context;
+            m_at_exit_functions.push_back(entry);
+        }
+    };
+
+private:
+    typedef sync::mutex mutex_type;
+
+    typedef intrusive::list<
+        thread_context,
+        intrusive::base_hook< thread_context_list_hook >,
+        intrusive::constant_time_size< false >
+    > thread_context_list;
+
+    struct cleanup_info
+    {
+        at_thread_exit_callback cleanup;
+        bool cleanup_at_delete;
+    };
+
+private:
+    //! Thread synchronization primitive
+    mutex_type m_mutex;
+    //! The list of thread contexts
+    thread_context_list m_thread_contexts;
+    //! The list of cleanup functions for TLS
+    std::vector< cleanup_info > m_storage_cleanup;
+    //! The list of TLS keys released
+    std::stack< thread_specific_key > m_freed_keys;
+
+public:
+    BOOST_DEFAULTED_FUNCTION(tss_manager(), {})
+
+    ~tss_manager()
+    {
+        while (!m_thread_contexts.empty())
+            destroy_thread_context(&m_thread_contexts.front());
+    }
+
+    thread_context* create_thread_context()
+    {
+        thread_context* p = new thread_context();
+
+        sync::lock_guard< mutex_type > lock(m_mutex);
+        m_thread_contexts.push_back(*p);
+
+        return p;
+    }
+
+    void destroy_thread_context(thread_context* p) BOOST_NOEXCEPT
+    {
+        // Run cleanup functions
+        while (!p->m_at_exit_functions.empty())
+        {
+            std::vector< thread_context::at_exit_entry > at_exit_functions;
+            at_exit_functions.swap(p->m_at_exit_functions);
+
+            for (std::vector< thread_context::at_exit_entry >::reverse_iterator it = at_exit_functions.rbegin(), end = at_exit_functions.rend(); it != end; ++it)
+            {
+                it->callback(it->context);
+            }
+        }
+
+        // Destroy TLS
+        while (!p->m_storage.empty())
+        {
+            std::vector< void* > storage;
+            storage.swap(p->m_storage);
+            for (thread_specific_key key = 0, n = storage.size(); key < n; ++key)
+            {
+                void* const value = storage[key];
+                if (value)
+                {
+                    const at_thread_exit_callback cleanup = m_storage_cleanup[key].cleanup;
+                    if (cleanup)
+                        cleanup(value);
+                }
+            }
+        }
+
+        // Destroy the context
+        {
+            sync::lock_guard< mutex_type > lock(m_mutex);
+            m_thread_contexts.erase(m_thread_contexts.iterator_to(*p));
+        }
+        delete p;
+    }
+
+    thread_specific_key new_key(at_thread_exit_callback cleanup, bool cleanup_at_delete)
+    {
+        sync::lock_guard< mutex_type > lock(m_mutex);
+
+        // See if we can recycle some key
+        thread_specific_key key;
+        if (!m_freed_keys.empty())
+        {
+            key = m_freed_keys.top();
+            m_freed_keys.pop();
+            cleanup_info& info = m_storage_cleanup[key];
+            info.cleanup = cleanup;
+            info.cleanup_at_delete = cleanup_at_delete;
+        }
+        else
+        {
+            key = static_cast< thread_specific_key >(m_storage_cleanup.size());
+            cleanup_info info;
+            info.cleanup = cleanup;
+            info.cleanup_at_delete = cleanup_at_delete;
+            m_storage_cleanup.push_back(info);
+        }
+
+        return key;
+    }
+
+    void delete_key(thread_specific_key key)
+    {
+        sync::unique_lock< mutex_type > lock(m_mutex);
+
+        BOOST_ASSERT(key < m_storage_cleanup.size());
+
+        cleanup_info& info = m_storage_cleanup[key];
+        if (info.cleanup_at_delete)
+        {
+            std::vector< void* > storage;
+            const at_thread_exit_callback cleanup = info.cleanup;
+            info.cleanup = NULL;
+
+            for (thread_context_list::iterator it = m_thread_contexts.begin(), end = m_thread_contexts.end(); it != end; ++it)
+            {
+                if (it->m_storage.size() > key && it->m_storage[key] != NULL)
+                {
+                    if (cleanup)
+                        storage.push_back(it->m_storage[key]);
+                    it->m_storage[key] = NULL;
+                }
+            }
+
+            m_freed_keys.push(key);
+
+            lock.unlock();
+
+            // Run cleanup routines while the lock is released
+            for (std::vector< void* >::iterator it = storage.begin(), end = storage.end(); it != end; ++it)
+            {
+                cleanup(*it);
+            }
+        }
+    }
+
+    BOOST_DELETED_FUNCTION(tss_manager(tss_manager const&))
+    BOOST_DELETED_FUNCTION(tss_manager& operator= (tss_manager const&))
+};
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // BOOST_SYNC_IMPL_TSS_MANAGER_HPP_INCLUDED_

Added: trunk/libs/sync/src/tss_pthread.cpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/src/tss_pthread.cpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,129 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2004 Michael Glassford
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file   tss_pthread.cpp
+ *
+ * \brief  This header is the Boost.Sync library implementation, see the library documentation
+ *         at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#include <boost/sync/detail/config.hpp>
+
+#if !defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
+
+#include <cstddef>
+#include <cstdlib>
+#include <pthread.h>
+#include <boost/sync/detail/tss.hpp>
+#include "tss_manager.hpp"
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+namespace {
+
+static pthread_once_t init_tss_once_flag = PTHREAD_ONCE_INIT;
+static tss_manager* tss_mgr = NULL;
+static pthread_key_t tss_key;
+
+extern "C" {
+
+static void tss_cleanup(void* p)
+{
+    if (tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(p))
+    {
+        tss_mgr->destroy_thread_context(ctx);
+    }
+}
+
+static void init_tss()
+{
+    try
+    {
+        tss_mgr = new tss_manager();
+    }
+    catch (...)
+    {
+        std::abort();
+    }
+
+    if (pthread_key_create(&tss_key, &tss_cleanup) != 0)
+        std::abort();
+}
+
+} // extern "C"
+
+} // namespace
+
+BOOST_SYNC_API void add_thread_exit_callback(at_thread_exit_callback callback, void* context)
+{
+    pthread_once(&init_tss_once_flag, &init_tss);
+    tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(pthread_getspecific(tss_key));
+
+    if (!ctx)
+    {
+        ctx = tss_mgr->create_thread_context();
+        pthread_setspecific(tss_key, ctx);
+    }
+
+    ctx->add_at_exit_entry(callback, context);
+}
+
+BOOST_SYNC_API thread_specific_key new_thread_specific_key(at_thread_exit_callback callback, bool cleanup_at_delete)
+{
+    pthread_once(&init_tss_once_flag, &init_tss);
+    return tss_mgr->new_key(callback, cleanup_at_delete);
+}
+
+BOOST_SYNC_API void delete_thread_specific_key(thread_specific_key key) BOOST_NOEXCEPT
+{
+    try
+    {
+        tss_mgr->delete_key(key);
+    }
+    catch (...)
+    {
+        std::abort();
+    }
+}
+
+BOOST_SYNC_API void* get_thread_specific(thread_specific_key key)
+{
+    tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(pthread_getspecific(tss_key));
+    if (ctx)
+        return ctx->get_value(key);
+    return NULL;
+}
+
+BOOST_SYNC_API void set_thread_specific(thread_specific_key key, void* p)
+{
+    tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(pthread_getspecific(tss_key));
+
+    if (!ctx)
+    {
+        ctx = tss_mgr->create_thread_context();
+        pthread_setspecific(tss_key, ctx);
+    }
+
+    ctx->set_value(key, p);
+}
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // !defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)

Added: trunk/libs/sync/src/tss_windows.cpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/src/tss_windows.cpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,188 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2004 Michael Glassford
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file   tss_windows.cpp
+ *
+ * \brief  This header is the Boost.Sync library implementation, see the library documentation
+ *         at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#include <boost/sync/detail/config.hpp>
+
+#if defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)
+
+#include <cstddef>
+#include <cstdlib>
+#include <boost/sync/detail/interlocked.hpp>
+#include <boost/sync/detail/tss.hpp>
+#include "tss_manager.hpp"
+#include "tss_windows_hooks.hpp"
+#include <windows.h>
+#include <boost/sync/detail/header.hpp>
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+namespace {
+
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+static INIT_ONCE init_tss_once_flag = INIT_ONCE_STATIC_INIT;
+#else
+static long init_tss_once_flag = 0;
+#endif
+static tss_manager* tss_mgr = NULL;
+static DWORD tss_key = TLS_OUT_OF_INDEXES;
+
+extern "C" {
+
+static BOOL WINAPI init_tss(void*, void*, void**)
+{
+    try
+    {
+        tss_mgr = new tss_manager();
+    }
+    catch (...)
+    {
+        std::abort();
+    }
+
+    tss_key = TlsAlloc();
+    if (tss_key == TLS_OUT_OF_INDEXES)
+        std::abort();
+
+    return TRUE;
+}
+
+} // extern "C"
+
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+BOOST_FORCEINLINE void init_tss_once()
+{
+    InitOnceExecuteOnce(&init_tss_once_flag, (PINIT_ONCE_FN)&init_tss, NULL, NULL);
+}
+
+#else // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+BOOST_FORCEINLINE void init_tss_once()
+{
+    if (const_cast< long volatile& >(init_tss_once_flag) != 2)
+    {
+        while (true)
+        {
+            long old_val = BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&init_tss_once_flag, 1, 0);
+            if (old_val == 2)
+                break;
+            else if (old_val == 1)
+                SwitchToThread();
+            else
+            {
+                init_tss(NUll, NULL, NULL);
+                BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&init_tss_once_flag, 2);
+                break;
+            }
+        }
+    }
+}
+
+#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+} // namespace
+
+namespace windows {
+
+void on_process_enter()
+{
+}
+
+void on_process_exit()
+{
+}
+
+void on_thread_enter()
+{
+}
+
+void on_thread_exit()
+{
+    // This callback may be called before tss manager is initialized
+    init_tss_once();
+    if (tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(TlsGetValue(tss_key)))
+    {
+        tss_mgr->destroy_thread_context(ctx);
+    }
+}
+
+} // namespace windows
+
+BOOST_SYNC_API void add_thread_exit_callback(at_thread_exit_callback callback, void* context)
+{
+    init_tss_once();
+    tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(pthread_getspecific(tss_key));
+
+    if (!ctx)
+    {
+        ctx = tss_mgr->create_thread_context();
+        pthread_setspecific(tss_key, ctx);
+    }
+
+    ctx->add_at_exit_entry(callback, context);
+}
+
+BOOST_SYNC_API thread_specific_key new_thread_specific_key(at_thread_exit_callback callback, bool cleanup_at_delete)
+{
+    init_tss_once();
+    return tss_mgr->new_key(callback, cleanup_at_delete);
+}
+
+BOOST_SYNC_API void delete_thread_specific_key(thread_specific_key key) BOOST_NOEXCEPT
+{
+    try
+    {
+        tss_mgr->delete_key(key);
+    }
+    catch (...)
+    {
+        std::abort();
+    }
+}
+
+BOOST_SYNC_API void* get_thread_specific(thread_specific_key key)
+{
+    tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(TlsGetValue(tss_key));
+    if (ctx)
+        return ctx->get_value(key);
+    return NULL;
+}
+
+BOOST_SYNC_API void set_thread_specific(thread_specific_key key, void* p)
+{
+    tss_manager::thread_context* ctx = static_cast< tss_manager::thread_context* >(TlsGetValue(tss_key));
+
+    if (!ctx)
+    {
+        ctx = tss_mgr->create_thread_context();
+        TlsSetValue(tss_key, ctx);
+    }
+
+    ctx->set_value(key, p);
+}
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#include <boost/sync/detail/footer.hpp>
+
+#endif // defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI)

Added: trunk/libs/sync/src/tss_windows_dll.cpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/src/tss_windows_dll.cpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,86 @@
+// (C) Copyright Michael Glassford 2004.
+// Use, modification and distribution are subject to 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 <boost/sync/detail/config.hpp>
+
+#if defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI) && defined(BOOST_SYNC_DYN_LINK)
+
+#include <windows.h>
+#include "tss_windows_hooks.hpp"
+
+#if defined(__BORLANDC__)
+extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+#elif defined(_WIN32_WCE)
+extern "C" BOOL WINAPI DllMain(HANDLE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+#else
+extern "C" BOOL WINAPI DllMain(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+#endif
+{
+    switch(dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+        {
+            boost::on_process_enter();
+            boost::on_thread_enter();
+            break;
+        }
+
+    case DLL_THREAD_ATTACH:
+        {
+            boost::on_thread_enter();
+            break;
+        }
+
+    case DLL_THREAD_DETACH:
+        {
+            boost::on_thread_exit();
+            break;
+        }
+
+    case DLL_PROCESS_DETACH:
+        {
+            boost::on_thread_exit();
+            boost::on_process_exit();
+            break;
+        }
+    }
+
+    return TRUE;
+}
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+namespace windows {
+
+void tss_cleanup_implemented()
+{
+    /*
+    This function's sole purpose is to cause a link error in cases where
+    automatic tss cleanup is not implemented by Boost.Threads as a
+    reminder that user code is responsible for calling the necessary
+    functions at the appropriate times (and for implementing an a
+    tss_cleanup_implemented() function to eliminate the linker's
+    missing symbol error).
+
+    If Boost.Threads later implements automatic tss cleanup in cases
+    where it currently doesn't (which is the plan), the duplicate
+    symbol error will warn the user that their custom solution is no
+    longer needed and can be removed.
+    */
+}
+
+} // namespace windows
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#endif // defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI) && defined(BOOST_SYNC_DYN_LINK)

Added: trunk/libs/sync/src/tss_windows_hooks.hpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/src/tss_windows_hooks.hpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,75 @@
+/*
+ * 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)
+ *
+ * (C) Copyright 2004 Michael Glassford
+ * (C) Copyright 2013 Andrey Semashev
+ */
+/*!
+ * \file   tss_windows_hooks.hpp
+ *
+ * \brief  This header is the Boost.Sync library implementation, see the library documentation
+ *         at http://www.boost.org/doc/libs/release/libs/sync/doc/html/index.html.
+ */
+
+#ifndef BOOST_SYNC_IMPL_TSS_WINDOWS_HOOKS_HPP_INCLUDED_
+#define BOOST_SYNC_IMPL_TSS_WINDOWS_HOOKS_HPP_INCLUDED_
+
+#include <boost/sync/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+namespace windows {
+
+/*!
+ * Function to be called when the exe or dll that uses Boost.Sync first starts or is first loaded.
+ * Should be called only before the first call to \c on_thread_enter. Called automatically by
+ * Boost.Sync when a method for doing so has been discovered. May be omitted; may be called multiple times.
+ */
+void on_process_enter();
+
+/*!
+ * Function to be called when the exe or dll that uses Boost.Sync first starts or is first loaded.
+ * Should be called only after the last call to \c on_thread_exit. Called automatically by Boost.Sync
+ * when a method for doing so has been discovered. Must not be omitted; may be called multiple times.
+ */
+void on_process_exit();
+
+/*!
+ * Function to be called just after a thread starts in an exe or dll that uses Boost.Sync.
+ * Must be called in the context of the thread that is starting. Called automatically by Boost.Sync
+ * when a method for doing so has been discovered. May be omitted; may be called multiple times.
+ */
+void on_thread_enter();
+
+/*!
+ * Function to be called just be fore a thread ends in an exe or dll that uses Boost.Sync.
+ * Must be called in the context of the thread that is ending. Called automatically by Boost.Sync
+ * when a method for doing so has been discovered. Must not be omitted; may be called multiple times.
+ */
+void on_thread_exit();
+
+/*!
+ * Dummy function used both to detect whether tss cleanup cleanup has been implemented and to force
+ * it to be linked into the Boost.Sync library.
+ */
+void tss_cleanup_implemented();
+
+} // namespace windows
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#endif // BOOST_SYNC_IMPL_TSS_WINDOWS_HOOKS_HPP_INCLUDED_

Added: trunk/libs/sync/src/tss_windows_pe.cpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/sync/src/tss_windows_pe.cpp	2013-10-22 09:31:21 EDT (Tue, 22 Oct 2013)	(r86390)
@@ -0,0 +1,348 @@
+// (C) Copyright Aaron W. LaFramboise, Roland Schwarz, Michael Glassford 2004.
+// (C) Copyright 2007 Roland Schwarz
+// (C) Copyright 2007 Anthony Williams
+// (C) Copyright 2007 David Deakins
+// Use, modification and distribution are subject to 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 <boost/sync/detail/config.hpp>
+
+#if defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI) && defined(BOOST_SYNC_STATIC_LINK)
+
+#if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR)
+
+#include <cstdlib>
+#include <windows.h>
+#include "tss_windows_hooks.hpp"
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+namespace windows {
+
+void tss_cleanup_implemented()
+{
+}
+
+} // namespace windows
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+namespace {
+
+void NTAPI on_tls_callback(void*, DWORD dwReason, PVOID)
+{
+    switch (dwReason)
+    {
+    case DLL_THREAD_DETACH:
+        {
+            boost::on_thread_exit();
+            break;
+        }
+    }
+}
+
+} // namespace
+
+#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION > 3) || \
+    ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 18))
+extern "C"
+{
+    PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;
+}
+#else
+extern "C" {
+
+    void (* after_ctors )() __attribute__((section(".ctors")))     = boost::on_process_enter;
+    void (* before_dtors)() __attribute__((section(".dtors")))     = boost::on_thread_exit;
+    void (* after_dtors )() __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;
+
+    ULONG __tls_index__ = 0;
+    char __tls_end__ __attribute__((section(".tls$zzz"))) = 0;
+    char __tls_start__ __attribute__((section(".tls"))) = 0;
+
+
+    PIMAGE_TLS_CALLBACK __crt_xl_start__ __attribute__ ((section(".CRT$XLA"))) = 0;
+    PIMAGE_TLS_CALLBACK __crt_xl_end__ __attribute__ ((section(".CRT$XLZ"))) = 0;
+}
+extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata$T"))) =
+{
+        (DWORD) &__tls_start__,
+        (DWORD) &__tls_end__,
+        (DWORD) &__tls_index__,
+        (DWORD) (&__crt_xl_start__+1),
+        (DWORD) 0,
+        (DWORD) 0
+};
+#endif
+
+
+#elif  defined(_MSC_VER) && !defined(UNDER_CE)
+
+#include <stdlib.h>
+#include <windows.h>
+#include "tss_windows_hooks.hpp"
+
+// _pRawDllMainOrig can be defined by including boost/thread/win32/mfc_thread_init.hpp
+// into your dll; it ensures that MFC-Dll-initialization will be done properly
+// The following code is adapted from the MFC-Dll-init code
+/*
+ * _pRawDllMainOrig MUST be an extern const variable, which will be aliased to
+ * _pDefaultRawDllMainOrig if no real user definition is present, thanks to the
+ * alternatename directive.
+ */
+
+// work at least with _MSC_VER 1500 (MSVC++ 9.0, VS 2008)
+#if (_MSC_VER >= 1500)
+
+extern "C" {
+extern BOOL (WINAPI * const _pRawDllMainOrig)(HANDLE, DWORD, LPVOID);
+extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NULL;
+#if defined (_M_IX86)
+#pragma comment(linker, "/alternatename:__pRawDllMainOrig=__pDefaultRawDllMainOrig")
+#elif defined (_M_X64) || defined (_M_ARM)
+#pragma comment(linker, "/alternatename:_pRawDllMainOrig=_pDefaultRawDllMainOrig")
+#else  /* defined (_M_X64) || defined (_M_ARM) */
+#error Unsupported platform
+#endif  /* defined (_M_X64) || defined (_M_ARM) */
+}
+
+#endif
+
+
+//Definitions required by implementation
+
+#if (_MSC_VER < 1300) // 1300 == VC++ 7.0
+    typedef void (__cdecl *_PVFV)();
+    #define INIRETSUCCESS
+    #define PVAPI void __cdecl
+#else
+    typedef int (__cdecl *_PVFV)();
+    #define INIRETSUCCESS 0
+    #define PVAPI int __cdecl
+#endif
+
+typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
+
+//Symbols for connection to the runtime environment
+
+extern "C"
+{
+    extern DWORD _tls_used; //the tls directory (located in .rdata segment)
+    extern _TLSCB __xl_a[], __xl_z[];    //tls initializers */
+}
+
+namespace
+{
+    //Forward declarations
+
+    static PVAPI on_tls_prepare();
+    static PVAPI on_process_init();
+    static PVAPI on_process_term();
+    static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);
+
+    //The .CRT$Xxx information is taken from Codeguru:
+    //http://www.codeguru.com/Cpp/misc/misc/threadsprocesses/article.php/c6945__2/
+
+#if (_MSC_VER >= 1400)
+#pragma section(".CRT$XIU",long,read)
+#pragma section(".CRT$XCU",long,read)
+#pragma section(".CRT$XTU",long,read)
+#pragma section(".CRT$XLC",long,read)
+    __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
+    __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+    __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+    __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
+#else
+    #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
+    #   pragma data_seg(push, old_seg)
+    #endif
+        //Callback to run tls glue code first.
+        //I don't think it is necessary to run it
+        //at .CRT$XIB level, since we are only
+        //interested in thread detachement. But
+        //this could be changed easily if required.
+
+        #pragma data_seg(".CRT$XIU")
+        static _PVFV p_tls_prepare = on_tls_prepare;
+        #pragma data_seg()
+
+        //Callback after all global ctors.
+
+        #pragma data_seg(".CRT$XCU")
+        static _PVFV p_process_init = on_process_init;
+        #pragma data_seg()
+
+        //Callback for tls notifications.
+
+        #pragma data_seg(".CRT$XLB")
+        _TLSCB p_thread_callback = on_tls_callback;
+        #pragma data_seg()
+        //Callback for termination.
+
+        #pragma data_seg(".CRT$XTU")
+        static _PVFV p_process_term = on_process_term;
+        #pragma data_seg()
+    #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
+    #   pragma data_seg(pop, old_seg)
+    #endif
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4189)
+#endif
+
+PVAPI on_tls_prepare()
+{
+    //The following line has an important side effect:
+    //if the TLS directory is not already there, it will
+    //be created by the linker. In other words, it forces a tls
+    //directory to be generated by the linker even when static tls
+    //(i.e. __declspec(thread)) is not used.
+    //The volatile should prevent the optimizer
+    //from removing the reference.
+
+    DWORD volatile dw = _tls_used;
+
+    #if (_MSC_VER < 1300) // 1300 == VC++ 7.0
+        _TLSCB* pfbegin = __xl_a;
+        _TLSCB* pfend = __xl_z;
+        _TLSCB* pfdst = pfbegin;
+        //pfdst = (_TLSCB*)_tls_used.AddressOfCallBacks;
+
+        //The following loop will merge the address pointers
+        //into a contiguous area, since the tlssup code seems
+        //to require this (at least on MSVC 6)
+
+        while (pfbegin < pfend)
+        {
+            if (*pfbegin != 0)
+            {
+                *pfdst = *pfbegin;
+                ++pfdst;
+            }
+            ++pfbegin;
+        }
+
+        *pfdst = 0;
+    #endif
+
+    return INIRETSUCCESS;
+}
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+PVAPI on_process_init()
+{
+    //Schedule on_thread_exit() to be called for the main
+    //thread before destructors of global objects have been
+    //called.
+
+    //It will not be run when 'quick' exiting the
+    //library; however, this is the standard behaviour
+    //for destructors of global objects, so that
+    //shouldn't be a problem.
+
+    atexit(boost::on_thread_exit);
+
+    //Call Boost process entry callback here
+
+    boost::on_process_enter();
+
+    return INIRETSUCCESS;
+}
+
+PVAPI on_process_term()
+{
+    boost::on_process_exit();
+    return INIRETSUCCESS;
+}
+
+void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
+{
+    switch (dwReason)
+    {
+    case DLL_THREAD_DETACH:
+        boost::on_thread_exit();
+        break;
+    }
+}
+
+#if (_MSC_VER >= 1500)
+BOOL WINAPI dll_callback(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
+#else
+BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)
+#endif
+{
+    switch (dwReason)
+    {
+    case DLL_THREAD_DETACH:
+        boost::on_thread_exit();
+        break;
+    case DLL_PROCESS_DETACH:
+        boost::on_process_exit();
+        break;
+    }
+
+#if (_MSC_VER >= 1500)
+    if( _pRawDllMainOrig )
+    {
+        return _pRawDllMainOrig(hInstance, dwReason, lpReserved);
+    }
+#endif
+    return true;
+}
+
+} //namespace
+
+extern "C"
+{
+    extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID) = &dll_callback;
+}
+
+namespace boost {
+
+namespace sync {
+
+namespace detail {
+
+namespace windows {
+
+void tss_cleanup_implemented()
+{
+    /*
+    This function's sole purpose is to cause a link error in cases where
+    automatic tss cleanup is not implemented by Boost.Threads as a
+    reminder that user code is responsible for calling the necessary
+    functions at the appropriate times (and for implementing an a
+    tss_cleanup_implemented() function to eliminate the linker's
+    missing symbol error).
+
+    If Boost.Threads later implements automatic tss cleanup in cases
+    where it currently doesn't (which is the plan), the duplicate
+    symbol error will warn the user that their custom solution is no
+    longer needed and can be removed.
+    */
+}
+
+} // namespace windows
+
+} // namespace detail
+
+} // namespace sync
+
+} // namespace boost
+
+#endif //defined(_MSC_VER) && !defined(UNDER_CE)
+
+#endif //defined(BOOST_SYNC_DETAIL_PLATFORM_WINAPI) && defined(BOOST_SYNC_STATIC_LINK)