boost/interprocess/segment_manager.hpp
////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2005-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_SEGMENT_MANAGER_HPP #define BOOST_INTERPROCESS_SEGMENT_MANAGER_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/type_traits.hpp> #include <boost/interprocess/detail/transform_iterator.hpp> #include <boost/interprocess/detail/mpl.hpp> #include <boost/interprocess/detail/nothrow.hpp> #include <boost/interprocess/detail/segment_manager_helper.hpp> #include <boost/interprocess/detail/named_proxy.hpp> #include <boost/interprocess/detail/utilities.hpp> #include <boost/interprocess/offset_ptr.hpp> #include <boost/interprocess/indexes/iset_index.hpp> #include <boost/interprocess/exceptions.hpp> #include <boost/interprocess/allocators/allocator.hpp> #include <boost/interprocess/smart_ptr/deleter.hpp> #include <boost/move/utility_core.hpp> #include <boost/interprocess/sync/scoped_lock.hpp> // container/detail #include <boost/container/detail/minimal_char_traits_header.hpp> #include <boost/container/detail/placement_new.hpp> // std #include <cstddef> //std::size_t #include <boost/intrusive/detail/minimal_pair_header.hpp> #include <boost/assert.hpp> #ifndef BOOST_NO_EXCEPTIONS #include <exception> #endif #include <typeinfo> //!\file //!Describes the object placed in a memory segment that provides //!named object allocation capabilities for single-segment and //!multi-segment allocations. namespace boost{ namespace interprocess{ //!This object is the public base class of segment manager. //!This class only depends on the memory allocation algorithm //!and implements all the allocation features not related //!to named or unique objects. //! //!Storing a reference to segment_manager forces //!the holder class to be dependent on index types and character types. //!When such dependence is not desirable and only anonymous and raw //!allocations are needed, segment_manager_base is the correct answer. template<class MemoryAlgorithm> class segment_manager_base : private MemoryAlgorithm { public: typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_type; typedef typename MemoryAlgorithm::void_pointer void_pointer; typedef typename MemoryAlgorithm::mutex_family mutex_family; static const std::size_t MemAlignment = MemoryAlgorithm::Alignment; typedef MemoryAlgorithm memory_algorithm; #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) //Experimental. Don't use typedef typename MemoryAlgorithm::multiallocation_chain multiallocation_chain; typedef typename MemoryAlgorithm::difference_type difference_type; typedef typename MemoryAlgorithm::size_type size_type; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED //!This constant indicates the payload size //!associated with each allocation of the memory algorithm static const size_type PayloadPerAllocation = MemoryAlgorithm::PayloadPerAllocation; //!Constructor of the segment_manager_base //! //!"size" is the size of the memory segment where //!the basic segment manager is being constructed. //! //!"reserved_bytes" is the number of bytes //!after the end of the memory algorithm object itself //!that the memory algorithm will exclude from //!dynamic allocation //! //!Can throw segment_manager_base(size_type sz, size_type reserved_bytes) : MemoryAlgorithm(sz, reserved_bytes) { BOOST_ASSERT((sizeof(segment_manager_base<MemoryAlgorithm>) == sizeof(MemoryAlgorithm))); } //!Returns the size of the memory //!segment size_type get_size() const { return MemoryAlgorithm::get_size(); } //!Returns the number of free bytes of the memory //!segment size_type get_free_memory() const { return MemoryAlgorithm::get_free_memory(); } //!Obtains the minimum size needed by //!the segment manager static size_type get_min_size (size_type size) { return MemoryAlgorithm::get_min_size(size); } //!Allocates nbytes bytes. This function is only used in //!single-segment management. Never throws void * allocate (size_type nbytes, const std::nothrow_t &) { return MemoryAlgorithm::allocate(nbytes); } //!Returns a reference to the internal memory algorithm. //!This function is useful for custom memory algorithms that //!need additional configuration options after construction. Never throws. //!This function should be only used by advanced users. MemoryAlgorithm &get_memory_algorithm() { return static_cast<MemoryAlgorithm&>(*this); } //!Returns a const reference to the internal memory algorithm. //!This function is useful for custom memory algorithms that //!need additional configuration options after construction. Never throws. //!This function should be only used by advanced users. const MemoryAlgorithm &get_memory_algorithm() const { return static_cast<const MemoryAlgorithm&>(*this); } #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) //Experimental. Dont' use. //!Allocates n_elements of elem_bytes bytes. //!Throws bad_alloc on failure. chain.size() is not increased on failure. void allocate_many(size_type elem_bytes, size_type n_elements, multiallocation_chain &chain) { size_type prev_size = chain.size(); MemoryAlgorithm::allocate_many(elem_bytes, n_elements, chain); if(!elem_bytes || chain.size() == prev_size){ throw bad_alloc(); } } //!Allocates n_elements, each one of element_lengths[i]*sizeof_element bytes. //!Throws bad_alloc on failure. chain.size() is not increased on failure. void allocate_many(const size_type *element_lengths, size_type n_elements, size_type sizeof_element, multiallocation_chain &chain) { size_type prev_size = chain.size(); MemoryAlgorithm::allocate_many(element_lengths, n_elements, sizeof_element, chain); if(!sizeof_element || chain.size() == prev_size){ throw bad_alloc(); } } //!Allocates n_elements of elem_bytes bytes. //!Non-throwing version. chain.size() is not increased on failure. void allocate_many(const std::nothrow_t &, size_type elem_bytes, size_type n_elements, multiallocation_chain &chain) { MemoryAlgorithm::allocate_many(elem_bytes, n_elements, chain); } //!Allocates n_elements, each one of //!element_lengths[i]*sizeof_element bytes. //!Non-throwing version. chain.size() is not increased on failure. void allocate_many(const std::nothrow_t &, const size_type *elem_sizes, size_type n_elements, size_type sizeof_element, multiallocation_chain &chain) { MemoryAlgorithm::allocate_many(elem_sizes, n_elements, sizeof_element, chain); } //!Deallocates all elements contained in chain. //!Never throws. void deallocate_many(multiallocation_chain &chain) { MemoryAlgorithm::deallocate_many(chain); } #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED //!Allocates nbytes bytes. Throws boost::interprocess::bad_alloc //!on failure void * allocate(size_type nbytes) { void * ret = MemoryAlgorithm::allocate(nbytes); if(!ret) throw bad_alloc(); return ret; } //!Allocates nbytes bytes. This function is only used in //!single-segment management. Never throws void * allocate_aligned (size_type nbytes, size_type alignment, const std::nothrow_t &) { return MemoryAlgorithm::allocate_aligned(nbytes, alignment); } //!Allocates nbytes bytes. This function is only used in //!single-segment management. Throws bad_alloc when fails void * allocate_aligned(size_type nbytes, size_type alignment) { void * ret = MemoryAlgorithm::allocate_aligned(nbytes, alignment); if(!ret) throw bad_alloc(); return ret; } #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) template<class T> T *allocation_command (boost::interprocess::allocation_type command, size_type limit_size, size_type &prefer_in_recvd_out_size, T *&reuse) { T *ret = MemoryAlgorithm::allocation_command (command | boost::interprocess::nothrow_allocation, limit_size, prefer_in_recvd_out_size, reuse); if(!(command & boost::interprocess::nothrow_allocation) && !ret) throw bad_alloc(); return ret; } void *raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_objects, size_type &prefer_in_recvd_out_size, void *&reuse, size_type sizeof_object = 1) { void *ret = MemoryAlgorithm::raw_allocation_command ( command | boost::interprocess::nothrow_allocation, limit_objects, prefer_in_recvd_out_size, reuse, sizeof_object); if(!(command & boost::interprocess::nothrow_allocation) && !ret) throw bad_alloc(); return ret; } #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED //!Deallocates the bytes allocated with allocate/allocate_many() //!pointed by addr void deallocate (void *addr) { MemoryAlgorithm::deallocate(addr); } //!Increases managed memory in extra_size bytes more. This only works //!with single-segment management. void grow(size_type extra_size) { //Growing managed segments that use raw pointers is UB, so disallow it. BOOST_INTERPROCESS_STATIC_ASSERT(!(ipcdetail::is_same<void*, void_pointer>::value)); MemoryAlgorithm::grow(extra_size); } //!Decreases managed memory to the minimum. This only works //!with single-segment management. void shrink_to_fit() { MemoryAlgorithm::shrink_to_fit(); } //!Returns the result of "all_memory_deallocated()" function //!of the used memory algorithm bool all_memory_deallocated() { return MemoryAlgorithm::all_memory_deallocated(); } //!Returns the result of "check_sanity()" function //!of the used memory algorithm bool check_sanity() { return MemoryAlgorithm::check_sanity(); } //!Writes to zero free memory (memory not yet allocated) //!of the memory algorithm void zero_free_memory() { MemoryAlgorithm::zero_free_memory(); } //!Returns the size of the buffer previously allocated pointed by ptr size_type size(const void *ptr) const { return MemoryAlgorithm::size(ptr); } }; //!This object is placed in the beginning of memory segment and //!implements the allocation (named or anonymous) of portions //!of the segment. This object contains two indexes that //!maintain an association between a name and a portion of the segment. //! //!The first index contains the mappings for normal named objects using the //!char type specified in the template parameter. //! //!The second index contains the association for unique instances. The key will //!be the const char * returned from type_info.name() function for the unique //!type to be constructed. //! //!segment_manager<CharType, MemoryAlgorithm, IndexType> inherits publicly //!from segment_manager_base<MemoryAlgorithm> and inherits from it //!many public functions related to anonymous object and raw memory allocation. //!See segment_manager_base reference to know about those functions. template<class CharType ,class MemoryAlgorithm ,template<class IndexConfig> class IndexType> class segment_manager : public segment_manager_base<MemoryAlgorithm> { #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) //Non-copyable segment_manager(); segment_manager(const segment_manager &); segment_manager &operator=(const segment_manager &); typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_t; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED public: typedef MemoryAlgorithm memory_algorithm; typedef typename segment_manager_base_t::void_pointer void_pointer; typedef typename segment_manager_base_t::size_type size_type; typedef typename segment_manager_base_t::difference_type difference_type; typedef CharType char_type; typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_type; static const size_type PayloadPerAllocation = segment_manager_base_t::PayloadPerAllocation; static const size_type MemAlignment = segment_manager_base_t::MemAlignment; #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) private: typedef ipcdetail::block_header<size_type> block_header_t; typedef ipcdetail::index_config<CharType, MemoryAlgorithm> index_config_named; typedef ipcdetail::index_config<char, MemoryAlgorithm> index_config_unique; typedef IndexType<index_config_named> index_type; typedef ipcdetail::bool_<is_intrusive_index<index_type>::value > is_intrusive_t; typedef ipcdetail::bool_<is_node_index<index_type>::value> is_node_index_t; public: typedef IndexType<index_config_named> named_index_t; typedef IndexType<index_config_unique> unique_index_t; typedef ipcdetail::char_ptr_holder<CharType> char_ptr_holder_t; typedef ipcdetail::segment_manager_iterator_transform <typename named_index_t::const_iterator ,is_intrusive_index<index_type>::value> named_transform; typedef ipcdetail::segment_manager_iterator_transform <typename unique_index_t::const_iterator ,is_intrusive_index<index_type>::value> unique_transform; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED typedef typename segment_manager_base_t::mutex_family mutex_family; typedef transform_iterator <typename named_index_t::const_iterator, named_transform> const_named_iterator; typedef transform_iterator <typename unique_index_t::const_iterator, unique_transform> const_unique_iterator; #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) //!Constructor proxy object definition helper class template<class T> struct construct_proxy { typedef ipcdetail::named_proxy<segment_manager, T, false> type; }; //!Constructor proxy object definition helper class template<class T> struct construct_iter_proxy { typedef ipcdetail::named_proxy<segment_manager, T, true> type; }; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED //!Constructor of the segment manager //!"size" is the size of the memory segment where //!the segment manager is being constructed. //!Can throw explicit segment_manager(size_type segment_size) : segment_manager_base_t(segment_size, priv_get_reserved_bytes()) , m_header(static_cast<segment_manager_base_t*>(get_this_pointer())) { (void) anonymous_instance; (void) unique_instance; //Check EBO is applied, it's required const void * const this_addr = this; const void *const segm_addr = static_cast<segment_manager_base_t*>(this); (void)this_addr; (void)segm_addr; BOOST_ASSERT( this_addr == segm_addr); const std::size_t void_ptr_alignment = boost::move_detail::alignment_of<void_pointer>::value; (void)void_ptr_alignment; BOOST_ASSERT((0 == (std::size_t)this_addr % boost::move_detail::alignment_of<segment_manager>::value)); } //!Tries to find a previous named/unique allocation. Returns the address //!and the object count. On failure the first member of the //!returned pair is 0. template <class T> std::pair<T*, size_type> find (char_ptr_holder_t name) { return this->priv_find_impl<T>(name, true); } //!Tries to find a previous named/unique allocation. Returns the address //!and the object count. On failure the first member of the //!returned pair is 0. This search is not mutex-protected! //!Use it only inside atomic_func() calls, where the internal mutex //!is guaranteed to be locked. template <class T> std::pair<T*, size_type> find_no_lock (char_ptr_holder_t name) { return this->priv_find_impl<T>(name, false); } //!Returns throwing "construct" proxy //!object template <class T> typename construct_proxy<T>::type construct(char_ptr_holder_t name) { return typename construct_proxy<T>::type (this, name, false, true); } //!Returns throwing "search or construct" proxy //!object template <class T> typename construct_proxy<T>::type find_or_construct(char_ptr_holder_t name) { return typename construct_proxy<T>::type (this, name, true, true); } //!Returns no throwing "construct" proxy //!object template <class T> typename construct_proxy<T>::type construct(char_ptr_holder_t name, const std::nothrow_t &) { return typename construct_proxy<T>::type (this, name, false, false); } //!Returns no throwing "search or construct" //!proxy object template <class T> typename construct_proxy<T>::type find_or_construct(char_ptr_holder_t name, const std::nothrow_t &) { return typename construct_proxy<T>::type (this, name, true, false); } //!Returns throwing "construct from iterators" proxy object template <class T> typename construct_iter_proxy<T>::type construct_it(char_ptr_holder_t name) { return typename construct_iter_proxy<T>::type (this, name, false, true); } //!Returns throwing "search or construct from iterators" //!proxy object template <class T> typename construct_iter_proxy<T>::type find_or_construct_it(char_ptr_holder_t name) { return typename construct_iter_proxy<T>::type (this, name, true, true); } //!Returns no throwing "construct from iterators" //!proxy object template <class T> typename construct_iter_proxy<T>::type construct_it(char_ptr_holder_t name, const std::nothrow_t &) { return typename construct_iter_proxy<T>::type (this, name, false, false); } //!Returns no throwing "search or construct from iterators" //!proxy object template <class T> typename construct_iter_proxy<T>::type find_or_construct_it(char_ptr_holder_t name, const std::nothrow_t &) { return typename construct_iter_proxy<T>::type (this, name, true, false); } //!Calls object function blocking recursive interprocess_mutex and guarantees that //!no new named_alloc or destroy will be executed by any process while //!executing the object function call template <class Func> void atomic_func(Func &f) { scoped_lock<rmutex> guard(m_header); f(); } //!Tries to calls a functor guaranteeing that no new construction, search or //!destruction will be executed by any process while executing the object //!function call. If the atomic function can't be immediatelly executed //!because the internal mutex is already locked, returns false. //!If the functor throws, this function throws. template <class Func> bool try_atomic_func(Func &f) { scoped_lock<rmutex> guard(m_header, try_to_lock); if(guard){ f(); return true; } else{ return false; } } //!Destroys a previously created named/unique instance. //!Returns false if the object was not present. template <class T> bool destroy(char_ptr_holder_t name) { BOOST_ASSERT(!name.is_anonymous()); if(name.is_unique()){ return this->priv_generic_named_destroy<T, char>(typeid(T).name(), m_header.m_unique_index); } else{ return this->priv_generic_named_destroy<T, CharType>(name.get(), m_header.m_named_index); } } //!Destroys an anonymous, unique or named object //!using its address template <class T> void destroy_ptr(const T *p) { priv_destroy_ptr(p); } //!Returns the name of an object created with construct/find_or_construct //!functions. Does not throw template<class T> static const CharType *get_instance_name(const T *ptr) { return priv_get_instance_name(block_header_t::block_header_from_value(ptr)); } //!Returns the length of an object created with construct/find_or_construct //!functions. Does not throw. template<class T> static size_type get_instance_length(const T *ptr) { return priv_get_instance_length(block_header_t::block_header_from_value(ptr), sizeof(T)); } //!Returns is the the name of an object created with construct/find_or_construct //!functions. Does not throw template<class T> static instance_type get_instance_type(const T *ptr) { return priv_get_instance_type(block_header_t::block_header_from_value(ptr)); } //!Preallocates needed index resources to optimize the //!creation of "num" named objects in the managed memory segment. //!Can throw boost::interprocess::bad_alloc if there is no enough memory. void reserve_named_objects(size_type num) { //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- m_header.m_named_index.reserve(num); } //!Preallocates needed index resources to optimize the //!creation of "num" unique objects in the managed memory segment. //!Can throw boost::interprocess::bad_alloc if there is no enough memory. void reserve_unique_objects(size_type num) { //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- m_header.m_unique_index.reserve(num); } //!Calls shrink_to_fit in both named and unique object indexes //!to try to free unused memory from those indexes. void shrink_to_fit_indexes() { //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- m_header.m_named_index.shrink_to_fit(); m_header.m_unique_index.shrink_to_fit(); } //!Returns the number of named objects stored in //!the segment. size_type get_num_named_objects() { //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- return m_header.m_named_index.size(); } //!Returns the number of unique objects stored in //!the segment. size_type get_num_unique_objects() { //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- return m_header.m_unique_index.size(); } //!Obtains the minimum size needed by the //!segment manager static size_type get_min_size() { return segment_manager_base_t::get_min_size(priv_get_reserved_bytes()); } //!Returns a constant iterator to the beginning of the information about //!the named allocations performed in this segment manager const_named_iterator named_begin() const { return (make_transform_iterator) (m_header.m_named_index.begin(), named_transform()); } //!Returns a constant iterator to the end of the information about //!the named allocations performed in this segment manager const_named_iterator named_end() const { return (make_transform_iterator) (m_header.m_named_index.end(), named_transform()); } //!Returns a constant iterator to the beginning of the information about //!the unique allocations performed in this segment manager const_unique_iterator unique_begin() const { return (make_transform_iterator) (m_header.m_unique_index.begin(), unique_transform()); } //!Returns a constant iterator to the end of the information about //!the unique allocations performed in this segment manager const_unique_iterator unique_end() const { return (make_transform_iterator) (m_header.m_unique_index.end(), unique_transform()); } //!This is the default allocator to allocate types T //!from this managed segment template<class T> struct allocator { typedef boost::interprocess::allocator<T, segment_manager> type; }; //!Returns an instance of the default allocator for type T //!initialized that allocates memory from this segment manager. template<class T> typename allocator<T>::type get_allocator() { return typename allocator<T>::type(this); } //!This is the default deleter to delete types T //!from this managed segment. template<class T> struct deleter { typedef boost::interprocess::deleter<T, segment_manager> type; }; //!Returns an instance of the default deleter for type T //!that will delete an object constructed in this segment manager. template<class T> typename deleter<T>::type get_deleter() { return typename deleter<T>::type(this); } #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) //!Generic named/anonymous new function. Offers all the possibilities, //!such as throwing, search before creating, and the constructor is //!encapsulated in an object function. template<class Proxy> typename Proxy::object_type * generic_construct (Proxy& pr, const CharType *name, size_type num, bool try2find, bool dothrow) { typedef typename Proxy::object_type object_type; //Security overflow check if(num > ((size_type)-1)/sizeof(object_type)){ return ipcdetail::null_or_bad_alloc<object_type>(dothrow); } if(name == 0){ return this->priv_anonymous_construct(pr, num, dothrow); } else if(name == reinterpret_cast<const CharType*>(-1)){ return this->priv_generic_named_construct (pr, unique_type, typeid(object_type).name(), num, try2find, dothrow, m_header.m_unique_index); } else{ return this->priv_generic_named_construct (pr, named_type, name, num, try2find, dothrow, m_header.m_named_index); } } private: //!Tries to find a previous named allocation. Returns the address //!and the object count. On failure the first member of the //!returned pair is 0. template <class T> std::pair<T*, size_type> priv_find_impl (const CharType* name, bool lock) { //The name can't be null, no anonymous object can be found by name BOOST_ASSERT(name != 0); size_type sz; void *ret; if(name == reinterpret_cast<const CharType*>(-1)){ ret = priv_generic_find<T>(typeid(T).name(), m_header.m_unique_index, sz, lock); } else{ ret = priv_generic_find<T>(name, m_header.m_named_index, sz, lock); } return std::pair<T*, size_type>(static_cast<T*>(ret), sz); } //!Tries to find a previous unique allocation. Returns the address //!and the object count. On failure the first member of the //!returned pair is 0. template <class T> std::pair<T*, size_type> priv_find_impl (const ipcdetail::unique_instance_t*, bool lock) { size_type size; void *ret = priv_generic_find<T>(typeid(T).name(), m_header.m_unique_index, size, lock); return std::pair<T*, size_type>(static_cast<T*>(ret), size); } template<class Proxy> typename Proxy::object_type * priv_anonymous_construct(Proxy pr, size_type num, bool dothrow) { typedef typename Proxy::object_type object_type; BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment = boost::move_detail::alignment_of<object_type>::value; block_header_t block_info ( size_type(sizeof(object_type)*num) , size_type(t_alignment) , anonymous_type , 1 , 0); //Check if there is enough memory const std::size_t total_size = block_info.template total_anonymous_size<t_alignment>(); #if (BOOST_INTERPROCESS_SEGMENT_MANAGER_ABI < 2) void *ptr_struct = this->allocate(total_size, nothrow<>::get()); #else void* ptr_struct = this->allocate_aligned(total_size, t_alignment, nothrow<>::get()); #endif if(!ptr_struct){ return ipcdetail::null_or_bad_alloc<object_type>(dothrow); } //Build scoped ptr to avoid leaks with constructor exception ipcdetail::mem_algo_deallocator<segment_manager_base_type> mem (ptr_struct, *static_cast<segment_manager_base_type*>(this)); //Now construct the header const std::size_t front_space = block_header_t::template front_space_without_header<t_alignment>(); block_header_t * const hdr = ::new((char*)ptr_struct + front_space, boost_container_new_t()) block_header_t(block_info); BOOST_ASSERT(is_ptr_aligned(hdr)); void *ptr = 0; //avoid gcc warning ptr = hdr->value(); //Now call constructors pr.construct_n(ptr, num); //All constructors successful, disable rollback mem.release(); object_type* const pret = static_cast<object_type*>(ptr); BOOST_ASSERT(is_ptr_aligned(pret)); return pret; } //!Calls the destructor and makes an anonymous deallocate template <class T> void priv_anonymous_destroy(const T *object) { BOOST_ASSERT(is_ptr_aligned(object)); //Get control data from associated with this object block_header_t *ctrl_data = block_header_t::block_header_from_value(object); //------------------------------- //scoped_lock<rmutex> guard(m_header); //------------------------------- //This is not an anonymous object, the pointer is wrong! BOOST_ASSERT(ctrl_data->alloc_type() == anonymous_type); //Call destructors and free memory //Build scoped ptr to avoid leaks with destructor exception priv_destroy_n(object, ctrl_data->value_bytes()/sizeof(T)); BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment = boost::move_detail::alignment_of<T>::value; const std::size_t front_space = block_header_t::template front_space_without_header<t_alignment>(); this->deallocate((char*)ctrl_data - front_space); } template<class T> void priv_destroy_ptr(const T *ptr) { BOOST_ASSERT(is_ptr_aligned(ptr)); block_header_t *ctrl_data = block_header_t::block_header_from_value(ptr); switch(ctrl_data->alloc_type()){ case anonymous_type: this->priv_anonymous_destroy(ptr); break; case named_type: this->priv_generic_named_destroy<T, CharType> (ctrl_data, m_header.m_named_index, is_node_index_t()); break; case unique_type: this->priv_generic_named_destroy<T, char> (ctrl_data, m_header.m_unique_index, is_node_index_t()); break; default: //This type is unknown, bad pointer passed to this function! BOOST_ASSERT(0); break; } } template<class T> static void priv_destroy_n(T* memory, std::size_t num) { for (std::size_t destroyed = 0; destroyed < num; ++destroyed) (memory++)->~T(); } //!Returns the name of an object created with construct/find_or_construct //!functions. Does not throw static const CharType *priv_get_instance_name(block_header_t *ctrl_data) { boost::interprocess::allocation_type type = ctrl_data->alloc_type(); if(type == anonymous_type){ BOOST_ASSERT(ctrl_data->name_length() == 0); return 0; } BOOST_ASSERT(ctrl_data->name_length() != 0); CharType *name = static_cast<CharType*>(ctrl_data->template name<CharType>()); //Sanity checks BOOST_ASSERT(ctrl_data->name_length() == std::char_traits<CharType>::length(name)); return name; } static size_type priv_get_instance_length(block_header_t *ctrl_data, size_type sizeofvalue) { //Get header BOOST_ASSERT((ctrl_data->value_bytes() %sizeofvalue) == 0); return ctrl_data->value_bytes()/sizeofvalue; } //!Returns is the the name of an object created with construct/find_or_construct //!functions. Does not throw static instance_type priv_get_instance_type(block_header_t *ctrl_data) { //Get header BOOST_ASSERT((instance_type)ctrl_data->alloc_type() < max_allocation_type); return (instance_type)ctrl_data->alloc_type(); } static size_type priv_get_reserved_bytes() { //Get the number of bytes until the end of (*this) //beginning in the end of the segment_manager_base_t base. return sizeof(segment_manager) - sizeof(segment_manager_base_t); } template <class T, class CharT> T *priv_generic_find (const CharT* name, IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index, size_type &length, bool use_lock) { typedef IndexType<ipcdetail::index_config <CharT, MemoryAlgorithm> > index_t; typedef typename index_t::iterator index_it; typedef typename index_t::compare_key_type compare_key_t; //------------------------------- scoped_lock<rmutex> guard(priv_get_lock(use_lock)); //------------------------------- //Find name in index compare_key_t key (name, std::char_traits<CharT>::length(name)); index_it it = index.find(key); //Initialize return values void *ret_ptr = 0; length = 0; //If found, assign values if(it != index.end()){ //Get header block_header_t *ctrl_data = priv_block_header_from_it(it, is_intrusive_t()); //Sanity check BOOST_ASSERT((ctrl_data->value_bytes() % sizeof(T)) == 0); ret_ptr = ctrl_data->value(); length = ctrl_data->value_bytes()/ sizeof(T); } return static_cast<T*>(ret_ptr); } template <class T, class CharT> bool priv_generic_named_destroy (block_header_t *block_header ,IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index ,ipcdetail::true_ is_node_index) { (void)is_node_index; typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_t; typedef typename index_t::index_data_t index_data_t; index_data_t* si = block_header_t::template to_first_header<index_data_t>(block_header); return this->priv_generic_named_destroy_impl<T, CharT>(*si, index); } template <class T, class CharT> bool priv_generic_named_destroy (block_header_t *block_header ,IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index ,ipcdetail::false_ is_node_index) { (void)is_node_index; CharT *name = static_cast<CharT*>(block_header->template name<CharT>()); return this->priv_generic_named_destroy<T, CharT>(name, index); } template <class T, class CharT> bool priv_generic_named_destroy(const CharT *name, IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index) { typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_t; typedef typename index_t::iterator index_it; typedef typename index_t::compare_key_type compare_key_t; //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- //Find name in index compare_key_t key(name, std::char_traits<CharT>::length(name)); index_it it = index.find(key); //If not found, return false if(it == index.end()){ //This name is not present in the index, wrong pointer or name! //BOOST_ASSERT(0); return false; } return this->priv_generic_named_destroy_impl<T, CharT>(it, index); } template <class T, class CharT> bool priv_generic_named_destroy_impl (typename IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >::iterator it, IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index) { typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_t; typedef typename index_t::index_data_t index_data_t; //Get allocation parameters BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment = boost::move_detail::alignment_of<T>::value; block_header_t *ctrl_data = priv_block_header_from_it(it, is_intrusive_t()); //Sanity checks BOOST_ASSERT((ctrl_data->value_bytes() % sizeof(T)) == 0); //Erase node from index index.erase(it); void *memory; BOOST_IF_CONSTEXPR(is_node_index_t::value || is_intrusive_t::value){ index_data_t*ihdr = block_header_t::template to_first_header<index_data_t>(ctrl_data); const std::size_t front_space = block_header_t::template front_space_with_header<t_alignment, index_data_t>(); memory = (char*)ihdr - front_space; ihdr->~index_data_t(); } else{ const std::size_t front_space = block_header_t::template front_space_without_header<t_alignment>(); memory = (char*)ctrl_data - front_space; } //Call destructors and free memory priv_destroy_n(static_cast<T*>(ctrl_data->value()), ctrl_data->value_bytes()/sizeof(T)); //Destroy the headers ctrl_data->~block_header_t(); this->deallocate(memory); return true; } template<class IndexIt> static block_header_t* priv_block_header_from_it(IndexIt it, ipcdetail::true_) //is_intrusive { return block_header_t::from_first_header(&*it); } template<class IndexIt> static block_header_t* priv_block_header_from_it(IndexIt it, ipcdetail::false_ ) //!is_intrusive { return static_cast<block_header_t*>(ipcdetail::to_raw_pointer(it->second.m_ptr)); } //!Generic named new function for //!named functions template<class Proxy, class CharT> typename Proxy::object_type * priv_generic_named_construct (Proxy pr, unsigned char type, const CharT *name, size_type num, bool try2find, bool dothrow, IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index) { typedef typename Proxy::object_type object_type; std::size_t namelen = std::char_traits<CharT>::length(name); BOOST_CONSTEXPR_OR_CONST std::size_t t_alignment = boost::move_detail::alignment_of<object_type>::value; block_header_t block_info ( size_type(sizeof(object_type)*num) , size_type(t_alignment) , type , sizeof(CharT) , namelen); typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_t; typedef typename index_t::iterator index_it; typedef typename index_t::compare_key_type compare_key_t; typedef typename index_t::insert_commit_data commit_data_t; typedef typename index_t::index_data_t index_data_t; //------------------------------- scoped_lock<rmutex> guard(m_header); //------------------------------- //First, we want to know if the key is already present before //we allocate any memory, and if the key is not present, we //want to allocate all memory in a single buffer that will //contain the name and the user buffer. index_it existing_it; bool found = false; commit_data_t commit_data; BOOST_INTERPROCESS_TRY{ typedef std::pair<index_it, bool> index_ib; index_ib insert_ret = index.insert_check(compare_key_t(name, namelen), commit_data); existing_it = insert_ret.first; found = !insert_ret.second; } //Ignore exceptions BOOST_INTERPROCESS_CATCH(...){ if(dothrow) BOOST_INTERPROCESS_RETHROW return 0; } BOOST_INTERPROCESS_CATCH_END //If found and this is find or construct, return data, error otherwise if(found){ if(try2find){ return static_cast<object_type*>(priv_block_header_from_it(existing_it, is_intrusive_t())->value()); } return ipcdetail::null_or_already_exists<object_type>(dothrow); } //Allocates buffer for name + data, this can throw (it hurts) void *buffer_ptr; block_header_t * hdr; std::size_t front_space; //Allocate and construct the headers BOOST_IF_CONSTEXPR(is_node_index_t::value || is_intrusive_t::value){ const size_type total_size = block_info.template total_named_size_with_header<t_alignment, CharT, index_data_t>(namelen); #if (BOOST_INTERPROCESS_SEGMENT_MANAGER_ABI < 2) buffer_ptr = this->allocate(total_size, nothrow<>::get()); #else buffer_ptr = this->allocate_aligned(total_size, t_alignment, nothrow<>::get()); #endif if(!buffer_ptr) return ipcdetail::null_or_bad_alloc<object_type>(dothrow); front_space = block_header_t::template front_space_with_header<t_alignment, index_data_t>(); hdr = block_header_t::template from_first_header(reinterpret_cast<index_data_t*>((void*)((char*)buffer_ptr + front_space))); } else{ const size_type total_size = block_info.template total_named_size<t_alignment, CharT>(namelen); #if (BOOST_INTERPROCESS_SEGMENT_MANAGER_ABI < 2) buffer_ptr = this->allocate(total_size, nothrow<>::get()); #else buffer_ptr = this->allocate_aligned(total_size, t_alignment, nothrow<>::get()); #endif front_space = block_header_t::template front_space_without_header<t_alignment>(); //Check if there is enough memory if (!buffer_ptr) return ipcdetail::null_or_bad_alloc<object_type>(dothrow); hdr = reinterpret_cast<block_header_t*>((void*)((char*)buffer_ptr + front_space)); } BOOST_ASSERT(is_ptr_aligned(hdr)); hdr = ::new(hdr, boost_container_new_t()) block_header_t(block_info); //Build scoped ptr to avoid leaks with constructor exception ipcdetail::mem_algo_deallocator<segment_manager_base_type> mem (buffer_ptr, *static_cast<segment_manager_base_type*>(this)); void *ptr = hdr->value(); //Copy name to memory segment and insert data hdr->store_name_length(static_cast<typename block_header_t::name_len_t>(namelen)); CharT *name_ptr = static_cast<CharT *>(hdr->template name<CharT>()); std::char_traits<CharT>::copy(name_ptr, name, namelen+1); index_it it; BOOST_INTERPROCESS_TRY{ BOOST_IF_CONSTEXPR(is_node_index_t::value || is_intrusive_t::value) { index_data_t* index_data = ::new((char*)buffer_ptr + front_space, boost_container_new_t()) index_data_t(); BOOST_ASSERT(is_ptr_aligned(index_data)); it = index.insert_commit(compare_key_t(name_ptr, namelen), hdr, *index_data, commit_data); } else{ index_data_t id; it = index.insert_commit(compare_key_t(name_ptr, namelen), hdr, id, commit_data); } } //Ignore exceptions BOOST_INTERPROCESS_CATCH(...){ if(dothrow) BOOST_INTERPROCESS_RETHROW return 0; } BOOST_INTERPROCESS_CATCH_END //Initialize the node value_eraser to erase inserted node //if something goes wrong value_eraser<index_t> v_eraser(index, it); //Construct array, this can throw pr.construct_n(ptr, num); //Release rollbacks since construction was successful v_eraser.release(); mem.release(); object_type* const pret = static_cast<object_type*>(ptr); BOOST_ASSERT(is_ptr_aligned(pret)); return pret; } private: //!Returns the this pointer segment_manager *get_this_pointer() { return this; } typedef typename MemoryAlgorithm::mutex_family::recursive_mutex_type rmutex; scoped_lock<rmutex> priv_get_lock(bool use_lock) { scoped_lock<rmutex> local(m_header, defer_lock); if(use_lock){ local.lock(); } return scoped_lock<rmutex>(boost::move(local)); } //!This struct includes needed data and derives from //!rmutex to allow EBO when using null interprocess_mutex struct header_t : public rmutex { named_index_t m_named_index; unique_index_t m_unique_index; header_t(segment_manager_base_t *segment_mngr_base) : m_named_index (segment_mngr_base) , m_unique_index(segment_mngr_base) {} } m_header; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED }; }} //namespace boost { namespace interprocess #include <boost/interprocess/detail/config_end.hpp> #endif //#ifndef BOOST_INTERPROCESS_SEGMENT_MANAGER_HPP