EIC code displayed by LXR master/​include/​boost/​interprocess/​detail/​intermodule_singleton_common.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-07 08:22:00

 //////////////////////////////////////////////////////////////////////////////
 //
 // (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
 0018 ">#
 #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 <typeinfo>
 #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() << '_';
    const unsigned long long total_microsecs = get_current_process_creation_time();
    const unsigned long secs  = static_cast<unsigned long>(total_microsecs/1000000ul);
    const unsigned long usecs = static_cast<unsigned long>(total_microsecs%1000000ul);
    stream << secs << '.' << usecs;
    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){
             BOOST_INTERPROCESS_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);
             }
             BOOST_INTERPROCESS_CATCH(...){
                //Mark singleton failed to initialize
                atomic_write32(&this_module_singleton_initialized, Broken);
                BOOST_INTERPROCESS_RETHROW
             } BOOST_INTERPROCESS_CATCH_END
          }
          //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?
             BOOST_INTERPROCESS_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;
                }
             }
             BOOST_INTERPROCESS_CATCH(...){
                //
                BOOST_INTERPROCESS_RETHROW
             } BOOST_INTERPROCESS_CATCH_END
          }
       }
    }
 
    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::dtl::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;
             BOOST_INTERPROCESS_TRY{
                ref_count_ptr val(p, 0u);
                rcount = intermodule_singleton_helpers::thread_safe_global_map_dependant
                            <ThreadSafeGlobalMap>::insert(m_map, typeid(C).name(), val);
             }
             BOOST_INTERPROCESS_CATCH(...){
                intermodule_singleton_helpers::thread_safe_global_map_dependant
                            <ThreadSafeGlobalMap>::erase(m_map, typeid(C).name());
                delete p;
                BOOST_INTERPROCESS_RETHROW
             } BOOST_INTERPROCESS_CATCH_END
          }
          //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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team