| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2009-2012. 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) |
| // |
| // See http://www.boost.org/libs/interprocess for documentation. |
| // |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| #ifndef BOOST_INTERPROCESS_INTERMODULE_SINGLETON_COMMON_HPP |
| #define BOOST_INTERPROCESS_INTERMODULE_SINGLETON_COMMON_HPP |
| |
| #ifndef BOOST_CONFIG_HPP |
| # include <boost/config.hpp> |
| #endif |
| # |
| #if defined(BOOST_HAS_PRAGMA_ONCE) |
| #pragma once |
| #endif |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| |
| #include <boost/interprocess/detail/atomic.hpp> |
| #include <boost/interprocess/detail/os_thread_functions.hpp> |
| #include <boost/interprocess/exceptions.hpp> |
| #include <boost/container/detail/type_traits.hpp> //alignment_of, aligned_storage |
| #include <boost/interprocess/detail/mpl.hpp> |
| #include <boost/interprocess/sync/spin/wait.hpp> |
| #include <boost/assert.hpp> |
| #include <cstddef> |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| #include <string> |
| #include <sstream> |
| |
| namespace boost{ |
| namespace interprocess{ |
| namespace ipcdetail{ |
| |
| namespace intermodule_singleton_helpers { |
| |
| inline void get_pid_creation_time_str(std::string &s) |
| { |
| std::stringstream stream; |
| stream << get_current_process_id() << '_'; |
| stream.precision(6); |
| stream << std::fixed << get_current_process_creation_time(); |
| s = stream.str(); |
| } |
| |
| inline const char *get_map_base_name() |
| { return "bip.gmem.map."; } |
| |
| inline void get_map_name(std::string &map_name) |
| { |
| get_pid_creation_time_str(map_name); |
| map_name.insert(0, get_map_base_name()); |
| } |
| |
| inline std::size_t get_map_size() |
| { return 65536; } |
| |
| template<class ThreadSafeGlobalMap> |
| struct thread_safe_global_map_dependant; |
| |
| } //namespace intermodule_singleton_helpers { |
| |
| //This class contains common code for all singleton types, so that we instantiate this |
| //code just once per module. This class also holds a thread soafe global map |
| //to be used by all instances protected with a reference count |
| template<class ThreadSafeGlobalMap> |
| class intermodule_singleton_common |
| { |
| public: |
| typedef void*(singleton_constructor_t)(ThreadSafeGlobalMap &); |
| typedef void (singleton_destructor_t)(void *, ThreadSafeGlobalMap &); |
| |
| static const ::boost::uint32_t Uninitialized = 0u; |
| static const ::boost::uint32_t Initializing = 1u; |
| static const ::boost::uint32_t Initialized = 2u; |
| static const ::boost::uint32_t Broken = 3u; |
| static const ::boost::uint32_t Destroyed = 4u; |
| |
| //Initialize this_module_singleton_ptr, creates the global map if needed and also creates an unique |
| //opaque type in global map through a singleton_constructor_t function call, |
| //initializing the passed pointer to that unique instance. |
| // |
| //We have two concurrency types here. a)the global map/singleton creation must |
| //be safe between threads of this process but in different modules/dlls. b) |
| //the pointer to the singleton is per-module, so we have to protect this |
| //initization between threads of the same module. |
| // |
| //All static variables declared here are shared between inside a module |
| //so atomic operations will synchronize only threads of the same module. |
| static void initialize_singleton_logic |
| (void *&ptr, volatile boost::uint32_t &this_module_singleton_initialized, singleton_constructor_t constructor, bool phoenix) |
| { |
| //If current module is not initialized enter to lock free logic |
| if(atomic_read32(&this_module_singleton_initialized) != Initialized){ |
| //Now a single thread of the module will succeed in this CAS. |
| //trying to pass from Uninitialized to Initializing |
| ::boost::uint32_t previous_module_singleton_initialized = atomic_cas32 |
| (&this_module_singleton_initialized, Initializing, Uninitialized); |
| //If the thread succeeded the CAS (winner) it will compete with other |
| //winner threads from other modules to create the global map |
| if(previous_module_singleton_initialized == Destroyed){ |
| //Trying to resurrect a dead Phoenix singleton. Just try to |
| //mark it as uninitialized and start again |
| if(phoenix){ |
| atomic_cas32(&this_module_singleton_initialized, Uninitialized, Destroyed); |
| previous_module_singleton_initialized = atomic_cas32 |
| (&this_module_singleton_initialized, Initializing, Uninitialized); |
| } |
| //Trying to resurrect a non-Phoenix dead singleton is an error |
| else{ |
| throw interprocess_exception("Boost.Interprocess: Dead reference on non-Phoenix singleton of type"); |
| } |
| } |
| if(previous_module_singleton_initialized == Uninitialized){ |
| try{ |
| //Now initialize the global map, this function must solve concurrency |
| //issues between threads of several modules |
| initialize_global_map_handle(); |
| //Now try to create the singleton in global map. |
| //This function solves concurrency issues |
| //between threads of several modules |
| ThreadSafeGlobalMap *const pmap = get_map_ptr(); |
| void *tmp = constructor(*pmap); |
| //Increment the module reference count that reflects how many |
| //singletons this module holds, so that we can safely destroy |
| //module global map object when no singleton is left |
| atomic_inc32(&this_module_singleton_count); |
| //Insert a barrier before assigning the pointer to |
| //make sure this assignment comes after the initialization |
| atomic_write32(&this_module_singleton_initialized, Initializing); |
| //Assign the singleton address to the module-local pointer |
| ptr = tmp; |
| //Memory barrier inserted, all previous operations should complete |
| //before this one. Now marked as initialized |
| atomic_write32(&this_module_singleton_initialized, Initialized); |
| } |
| catch(...){ |
| //Mark singleton failed to initialize |
| atomic_write32(&this_module_singleton_initialized, Broken); |
| throw; |
| } |
| } |
| //If previous state was initializing, this means that another winner thread is |
| //trying to initialize the singleton. Just wait until completes its work. |
| else if(previous_module_singleton_initialized == Initializing){ |
| spin_wait swait; |
| while(1){ |
| previous_module_singleton_initialized = atomic_read32(&this_module_singleton_initialized); |
| if(previous_module_singleton_initialized >= Initialized){ |
| //Already initialized, or exception thrown by initializer thread |
| break; |
| } |
| else if(previous_module_singleton_initialized == Initializing){ |
| swait.yield(); |
| } |
| else{ |
| //This can't be happening! |
| BOOST_ASSERT(0); |
| } |
| } |
| } |
| else if(previous_module_singleton_initialized == Initialized){ |
| //Nothing to do here, the singleton is ready |
| } |
| //If previous state was greater than initialized, then memory is broken |
| //trying to initialize the singleton. |
| else{//(previous_module_singleton_initialized > Initialized) |
| throw interprocess_exception("boost::interprocess::intermodule_singleton initialization failed"); |
| } |
| } |
| BOOST_ASSERT(ptr != 0); |
| } |
| |
| static void finalize_singleton_logic(void *&ptr, volatile boost::uint32_t &this_module_singleton_initialized, singleton_destructor_t destructor) |
| { |
| //Protect destruction against lazy singletons not initialized in this execution |
| if(ptr){ |
| //Note: this destructor might provoke a Phoenix singleton |
| //resurrection. This means that this_module_singleton_count |
| //might change after this call. |
| ThreadSafeGlobalMap * const pmap = get_map_ptr(); |
| destructor(ptr, *pmap); |
| ptr = 0; |
| |
| //Memory barrier to make sure pointer is nulled. |
| //Mark this singleton as destroyed. |
| atomic_write32(&this_module_singleton_initialized, Destroyed); |
| |
| //If this is the last singleton of this module |
| //apply map destruction. |
| //Note: singletons are destroyed when the module is unloaded |
| //so no threads should be executing or holding references |
| //to this module |
| if(1 == atomic_dec32(&this_module_singleton_count)){ |
| destroy_global_map_handle(); |
| } |
| } |
| } |
| |
| private: |
| static ThreadSafeGlobalMap *get_map_ptr() |
| { |
| return static_cast<ThreadSafeGlobalMap *>(static_cast<void*>(mem_holder.map_mem)); |
| } |
| |
| static void initialize_global_map_handle() |
| { |
| //Obtain unique map name and size |
| spin_wait swait; |
| while(1){ |
| //Try to pass map state to initializing |
| ::boost::uint32_t tmp = atomic_cas32(&this_module_map_initialized, Initializing, Uninitialized); |
| if(tmp == Initialized || tmp == Broken){ |
| break; |
| } |
| else if(tmp == Destroyed){ |
| tmp = atomic_cas32(&this_module_map_initialized, Uninitialized, Destroyed); |
| continue; |
| } |
| //If some other thread is doing the work wait |
| else if(tmp == Initializing){ |
| swait.yield(); |
| } |
| else{ //(tmp == Uninitialized) |
| //If not initialized try it again? |
| try{ |
| //Remove old global map from the system |
| intermodule_singleton_helpers::thread_safe_global_map_dependant<ThreadSafeGlobalMap>::remove_old_gmem(); |
| //in-place construction of the global map class |
| ThreadSafeGlobalMap * const pmap = get_map_ptr(); |
| intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::construct_map(static_cast<void*>(pmap)); |
| //Use global map's internal lock to initialize the lock file |
| //that will mark this gmem as "in use". |
| typename intermodule_singleton_helpers::thread_safe_global_map_dependant<ThreadSafeGlobalMap>:: |
| lock_file_logic f(*pmap); |
| //If function failed (maybe a competing process has erased the shared |
| //memory between creation and file locking), retry with a new instance. |
| if(f.retry()){ |
| pmap->~ThreadSafeGlobalMap(); |
| atomic_write32(&this_module_map_initialized, Destroyed); |
| } |
| else{ |
| //Locking succeeded, so this global map module-instance is ready |
| atomic_write32(&this_module_map_initialized, Initialized); |
| break; |
| } |
| } |
| catch(...){ |
| // |
| throw; |
| } |
| } |
| } |
| } |
| |
| static void destroy_global_map_handle() |
| { |
| if(!atomic_read32(&this_module_singleton_count)){ |
| //This module is being unloaded, so destroy |
| //the global map object of this module |
| //and unlink the global map if it's the last |
| ThreadSafeGlobalMap * const pmap = get_map_ptr(); |
| typename intermodule_singleton_helpers::thread_safe_global_map_dependant<ThreadSafeGlobalMap>:: |
| unlink_map_logic f(*pmap); |
| pmap->~ThreadSafeGlobalMap(); |
| atomic_write32(&this_module_map_initialized, Destroyed); |
| //Do some cleanup for other processes old gmem instances |
| intermodule_singleton_helpers::thread_safe_global_map_dependant<ThreadSafeGlobalMap>::remove_old_gmem(); |
| } |
| } |
| |
| //Static data, zero-initalized without any dependencies |
| //this_module_singleton_count is the number of singletons used by this module |
| static volatile boost::uint32_t this_module_singleton_count; |
| |
| //this_module_map_initialized is the state of this module's map class object. |
| //Values: Uninitialized, Initializing, Initialized, Broken |
| static volatile boost::uint32_t this_module_map_initialized; |
| |
| //Raw memory to construct the global map manager |
| static union mem_holder_t |
| { |
| unsigned char map_mem [sizeof(ThreadSafeGlobalMap)]; |
| ::boost::container::container_detail::max_align_t aligner; |
| } mem_holder; |
| }; |
| |
| template<class ThreadSafeGlobalMap> |
| volatile boost::uint32_t intermodule_singleton_common<ThreadSafeGlobalMap>::this_module_singleton_count; |
| |
| template<class ThreadSafeGlobalMap> |
| volatile boost::uint32_t intermodule_singleton_common<ThreadSafeGlobalMap>::this_module_map_initialized; |
| |
| template<class ThreadSafeGlobalMap> |
| typename intermodule_singleton_common<ThreadSafeGlobalMap>::mem_holder_t |
| intermodule_singleton_common<ThreadSafeGlobalMap>::mem_holder; |
| |
| //A reference count to be stored in global map holding the number |
| //of singletons (one per module) attached to the instance pointed by |
| //the internal ptr. |
| struct ref_count_ptr |
| { |
| ref_count_ptr(void *p, boost::uint32_t count) |
| : ptr(p), singleton_ref_count(count) |
| {} |
| void *ptr; |
| //This reference count serves to count the number of attached |
| //modules to this singleton |
| volatile boost::uint32_t singleton_ref_count; |
| }; |
| |
| |
| //Now this class is a singleton, initializing the singleton in |
| //the first get() function call if LazyInit is true. If false |
| //then the singleton will be initialized when loading the module. |
| template<typename C, bool LazyInit, bool Phoenix, class ThreadSafeGlobalMap> |
| class intermodule_singleton_impl |
| { |
| public: |
| |
| static C& get() //Let's make inlining easy |
| { |
| if(!this_module_singleton_ptr){ |
| if(lifetime.dummy_function()){ //This forces lifetime instantiation, for reference counted destruction |
| atentry_work(); |
| } |
| } |
| return *static_cast<C*>(this_module_singleton_ptr); |
| } |
| |
| private: |
| |
| static void atentry_work() |
| { |
| intermodule_singleton_common<ThreadSafeGlobalMap>::initialize_singleton_logic |
| (this_module_singleton_ptr, this_module_singleton_initialized, singleton_constructor, Phoenix); |
| } |
| |
| static void atexit_work() |
| { |
| intermodule_singleton_common<ThreadSafeGlobalMap>::finalize_singleton_logic |
| (this_module_singleton_ptr, this_module_singleton_initialized, singleton_destructor); |
| } |
| |
| //These statics will be zero-initialized without any constructor call dependency |
| //this_module_singleton_ptr will be a module-local pointer to the singleton |
| static void* this_module_singleton_ptr; |
| |
| //this_module_singleton_count will be used to synchronize threads of the same module |
| //for access to a singleton instance, and to flag the state of the |
| //singleton. |
| static volatile boost::uint32_t this_module_singleton_initialized; |
| |
| //This class destructor will trigger singleton destruction |
| struct lifetime_type_lazy |
| { |
| bool dummy_function() |
| { return m_dummy == 0; } |
| |
| ~lifetime_type_lazy() |
| { |
| //if(!Phoenix){ |
| //atexit_work(); |
| //} |
| } |
| |
| //Dummy volatile so that the compiler can't resolve its value at compile-time |
| //and can't avoid lifetime_type instantiation if dummy_function() is called. |
| static volatile int m_dummy; |
| }; |
| |
| struct lifetime_type_static |
| : public lifetime_type_lazy |
| { |
| lifetime_type_static() |
| { atentry_work(); } |
| }; |
| |
| typedef typename if_c |
| <LazyInit, lifetime_type_lazy, lifetime_type_static>::type lifetime_type; |
| |
| static lifetime_type lifetime; |
| |
| //A functor to be executed inside global map lock that just |
| //searches for the singleton in map and if not present creates a new one. |
| //If singleton constructor throws, the exception is propagated |
| struct init_atomic_func |
| { |
| init_atomic_func(ThreadSafeGlobalMap &m) |
| : m_map(m), ret_ptr() |
| {} |
| |
| void operator()() |
| { |
| ref_count_ptr *rcount = intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::find(m_map, typeid(C).name()); |
| if(!rcount){ |
| C *p = new C; |
| try{ |
| ref_count_ptr val(p, 0u); |
| rcount = intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::insert(m_map, typeid(C).name(), val); |
| } |
| catch(...){ |
| intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::erase(m_map, typeid(C).name()); |
| delete p; |
| throw; |
| } |
| } |
| //if(Phoenix){ |
| std::atexit(&atexit_work); |
| //} |
| atomic_inc32(&rcount->singleton_ref_count); |
| ret_ptr = rcount->ptr; |
| } |
| void *data() const |
| { return ret_ptr; } |
| |
| private: |
| ThreadSafeGlobalMap &m_map; |
| void *ret_ptr; |
| }; |
| |
| //A functor to be executed inside global map lock that just |
| //deletes the singleton in map if the attached count reaches to zero |
| struct fini_atomic_func |
| { |
| fini_atomic_func(ThreadSafeGlobalMap &m) |
| : m_map(m) |
| {} |
| |
| void operator()() |
| { |
| ref_count_ptr *rcount = intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::find(m_map, typeid(C).name()); |
| //The object must exist |
| BOOST_ASSERT(rcount); |
| BOOST_ASSERT(rcount->singleton_ref_count > 0); |
| //Check if last reference |
| if(atomic_dec32(&rcount->singleton_ref_count) == 1){ |
| //If last, destroy the object |
| BOOST_ASSERT(rcount->ptr != 0); |
| C *pc = static_cast<C*>(rcount->ptr); |
| //Now destroy map entry |
| bool destroyed = intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::erase(m_map, typeid(C).name()); |
| (void)destroyed; BOOST_ASSERT(destroyed == true); |
| delete pc; |
| } |
| } |
| |
| private: |
| ThreadSafeGlobalMap &m_map; |
| }; |
| |
| //A wrapper to execute init_atomic_func |
| static void *singleton_constructor(ThreadSafeGlobalMap &map) |
| { |
| init_atomic_func f(map); |
| intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::atomic_func(map, f); |
| return f.data(); |
| } |
| |
| //A wrapper to execute fini_atomic_func |
| static void singleton_destructor(void *p, ThreadSafeGlobalMap &map) |
| { (void)p; |
| fini_atomic_func f(map); |
| intermodule_singleton_helpers::thread_safe_global_map_dependant |
| <ThreadSafeGlobalMap>::atomic_func(map, f); |
| } |
| }; |
| |
| template <typename C, bool L, bool P, class ThreadSafeGlobalMap> |
| volatile int intermodule_singleton_impl<C, L, P, ThreadSafeGlobalMap>::lifetime_type_lazy::m_dummy = 0; |
| |
| //These will be zero-initialized by the loader |
| template <typename C, bool L, bool P, class ThreadSafeGlobalMap> |
| void *intermodule_singleton_impl<C, L, P, ThreadSafeGlobalMap>::this_module_singleton_ptr = 0; |
| |
| template <typename C, bool L, bool P, class ThreadSafeGlobalMap> |
| volatile boost::uint32_t intermodule_singleton_impl<C, L, P, ThreadSafeGlobalMap>::this_module_singleton_initialized = 0; |
| |
| template <typename C, bool L, bool P, class ThreadSafeGlobalMap> |
| typename intermodule_singleton_impl<C, L, P, ThreadSafeGlobalMap>::lifetime_type |
| intermodule_singleton_impl<C, L, P, ThreadSafeGlobalMap>::lifetime; |
| |
| } //namespace ipcdetail{ |
| } //namespace interprocess{ |
| } //namespace boost{ |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif //#ifndef BOOST_INTERPROCESS_INTERMODULE_SINGLETON_COMMON_HPP |