512 lines
15 KiB
C++
512 lines
15 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// (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_BASE_HPP
|
|
#define BOOST_INTERPROCESS_SEGMENT_MANAGER_BASE_HPP
|
|
|
|
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
|
|
# pragma once
|
|
#endif
|
|
|
|
#include <boost/interprocess/detail/config_begin.hpp>
|
|
#include <boost/interprocess/detail/workaround.hpp>
|
|
|
|
#include <boost/intrusive/pointer_traits.hpp>
|
|
|
|
#include <boost/detail/no_exceptions_support.hpp>
|
|
#include <boost/interprocess/detail/type_traits.hpp>
|
|
#include <boost/interprocess/detail/utilities.hpp>
|
|
#include <boost/interprocess/detail/in_place_interface.hpp>
|
|
#include <boost/interprocess/exceptions.hpp>
|
|
#include <boost/type_traits/make_unsigned.hpp>
|
|
#include <boost/type_traits/alignment_of.hpp>
|
|
#include <boost/intrusive/pointer_traits.hpp>
|
|
#include <cstddef> //std::size_t
|
|
#include <string> //char_traits
|
|
#include <new> //std::nothrow
|
|
#include <utility> //std::pair
|
|
#include <boost/assert.hpp> //BOOST_ASSERT
|
|
#include <functional> //unary_function
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
|
#include <exception>
|
|
#endif
|
|
|
|
//!\file
|
|
//!Describes the object placed in a memory segment that provides
|
|
//!named object allocation capabilities.
|
|
|
|
namespace boost{
|
|
namespace interprocess{
|
|
|
|
template<class MemoryManager>
|
|
class segment_manager_base;
|
|
|
|
//!An integer that describes the type of the
|
|
//!instance constructed in memory
|
|
enum instance_type { anonymous_type, named_type, unique_type, max_allocation_type };
|
|
|
|
namespace ipcdetail{
|
|
|
|
template<class MemoryAlgorithm>
|
|
class mem_algo_deallocator
|
|
{
|
|
void * m_ptr;
|
|
MemoryAlgorithm & m_algo;
|
|
|
|
public:
|
|
mem_algo_deallocator(void *ptr, MemoryAlgorithm &algo)
|
|
: m_ptr(ptr), m_algo(algo)
|
|
{}
|
|
|
|
void release()
|
|
{ m_ptr = 0; }
|
|
|
|
~mem_algo_deallocator()
|
|
{ if(m_ptr) m_algo.deallocate(m_ptr); }
|
|
};
|
|
|
|
/// @cond
|
|
template<class size_type>
|
|
struct block_header
|
|
{
|
|
size_type m_value_bytes;
|
|
unsigned short m_num_char;
|
|
unsigned char m_value_alignment;
|
|
unsigned char m_alloc_type_sizeof_char;
|
|
|
|
block_header(size_type val_bytes
|
|
,size_type val_alignment
|
|
,unsigned char al_type
|
|
,std::size_t szof_char
|
|
,std::size_t num_char
|
|
)
|
|
: m_value_bytes(val_bytes)
|
|
, m_num_char((unsigned short)num_char)
|
|
, m_value_alignment((unsigned char)val_alignment)
|
|
, m_alloc_type_sizeof_char( (al_type << 5u) | ((unsigned char)szof_char & 0x1F) )
|
|
{};
|
|
|
|
template<class T>
|
|
block_header &operator= (const T& )
|
|
{ return *this; }
|
|
|
|
size_type total_size() const
|
|
{
|
|
if(alloc_type() != anonymous_type){
|
|
return name_offset() + (m_num_char+1)*sizeof_char();
|
|
}
|
|
else{
|
|
return this->value_offset() + m_value_bytes;
|
|
}
|
|
}
|
|
|
|
size_type value_bytes() const
|
|
{ return m_value_bytes; }
|
|
|
|
template<class Header>
|
|
size_type total_size_with_header() const
|
|
{
|
|
return get_rounded_size
|
|
( size_type(sizeof(Header))
|
|
, size_type(::boost::alignment_of<block_header<size_type> >::value))
|
|
+ total_size();
|
|
}
|
|
|
|
unsigned char alloc_type() const
|
|
{ return (m_alloc_type_sizeof_char >> 5u)&(unsigned char)0x7; }
|
|
|
|
unsigned char sizeof_char() const
|
|
{ return m_alloc_type_sizeof_char & (unsigned char)0x1F; }
|
|
|
|
template<class CharType>
|
|
CharType *name() const
|
|
{
|
|
return const_cast<CharType*>(reinterpret_cast<const CharType*>
|
|
(reinterpret_cast<const char*>(this) + name_offset()));
|
|
}
|
|
|
|
unsigned short name_length() const
|
|
{ return m_num_char; }
|
|
|
|
size_type name_offset() const
|
|
{
|
|
return this->value_offset() + get_rounded_size(size_type(m_value_bytes), size_type(sizeof_char()));
|
|
}
|
|
|
|
void *value() const
|
|
{
|
|
return const_cast<char*>((reinterpret_cast<const char*>(this) + this->value_offset()));
|
|
}
|
|
|
|
size_type value_offset() const
|
|
{
|
|
return get_rounded_size(size_type(sizeof(block_header<size_type>)), size_type(m_value_alignment));
|
|
}
|
|
|
|
template<class CharType>
|
|
bool less_comp(const block_header<size_type> &b) const
|
|
{
|
|
return m_num_char < b.m_num_char ||
|
|
(m_num_char < b.m_num_char &&
|
|
std::char_traits<CharType>::compare
|
|
(name<CharType>(), b.name<CharType>(), m_num_char) < 0);
|
|
}
|
|
|
|
template<class CharType>
|
|
bool equal_comp(const block_header<size_type> &b) const
|
|
{
|
|
return m_num_char == b.m_num_char &&
|
|
std::char_traits<CharType>::compare
|
|
(name<CharType>(), b.name<CharType>(), m_num_char) == 0;
|
|
}
|
|
|
|
template<class T>
|
|
static block_header<size_type> *block_header_from_value(T *value)
|
|
{ return block_header_from_value(value, sizeof(T), ::boost::alignment_of<T>::value); }
|
|
|
|
static block_header<size_type> *block_header_from_value(const void *value, std::size_t sz, std::size_t algn)
|
|
{
|
|
block_header * hdr =
|
|
const_cast<block_header*>
|
|
(reinterpret_cast<const block_header*>(reinterpret_cast<const char*>(value) -
|
|
get_rounded_size(sizeof(block_header), algn)));
|
|
(void)sz;
|
|
//Some sanity checks
|
|
BOOST_ASSERT(hdr->m_value_alignment == algn);
|
|
BOOST_ASSERT(hdr->m_value_bytes % sz == 0);
|
|
return hdr;
|
|
}
|
|
|
|
template<class Header>
|
|
static block_header<size_type> *from_first_header(Header *header)
|
|
{
|
|
block_header<size_type> * hdr =
|
|
reinterpret_cast<block_header<size_type>*>(reinterpret_cast<char*>(header) +
|
|
get_rounded_size(size_type(sizeof(Header)), size_type(::boost::alignment_of<block_header<size_type> >::value)));
|
|
//Some sanity checks
|
|
return hdr;
|
|
}
|
|
|
|
template<class Header>
|
|
static Header *to_first_header(block_header<size_type> *bheader)
|
|
{
|
|
Header * hdr =
|
|
reinterpret_cast<Header*>(reinterpret_cast<char*>(bheader) -
|
|
get_rounded_size(size_type(sizeof(Header)), size_type(::boost::alignment_of<block_header<size_type> >::value)));
|
|
//Some sanity checks
|
|
return hdr;
|
|
}
|
|
};
|
|
|
|
inline void array_construct(void *mem, std::size_t num, in_place_interface &table)
|
|
{
|
|
//Try constructors
|
|
std::size_t constructed = 0;
|
|
BOOST_TRY{
|
|
table.construct_n(mem, num, constructed);
|
|
}
|
|
//If there is an exception call destructors and erase index node
|
|
BOOST_CATCH(...){
|
|
std::size_t destroyed = 0;
|
|
table.destroy_n(mem, constructed, destroyed);
|
|
BOOST_RETHROW
|
|
}
|
|
BOOST_CATCH_END
|
|
}
|
|
|
|
template<class CharT>
|
|
struct intrusive_compare_key
|
|
{
|
|
typedef CharT char_type;
|
|
|
|
intrusive_compare_key(const CharT *str, std::size_t len)
|
|
: mp_str(str), m_len(len)
|
|
{}
|
|
|
|
const CharT * mp_str;
|
|
std::size_t m_len;
|
|
};
|
|
|
|
//!This struct indicates an anonymous object creation
|
|
//!allocation
|
|
template<instance_type type>
|
|
class instance_t
|
|
{
|
|
instance_t(){}
|
|
};
|
|
|
|
template<class T>
|
|
struct char_if_void
|
|
{
|
|
typedef T type;
|
|
};
|
|
|
|
template<>
|
|
struct char_if_void<void>
|
|
{
|
|
typedef char type;
|
|
};
|
|
|
|
typedef instance_t<anonymous_type> anonymous_instance_t;
|
|
typedef instance_t<unique_type> unique_instance_t;
|
|
|
|
|
|
template<class Hook, class CharType, class SizeType>
|
|
struct intrusive_value_type_impl
|
|
: public Hook
|
|
{
|
|
private:
|
|
//Non-copyable
|
|
intrusive_value_type_impl(const intrusive_value_type_impl &);
|
|
intrusive_value_type_impl& operator=(const intrusive_value_type_impl &);
|
|
|
|
public:
|
|
typedef CharType char_type;
|
|
typedef SizeType size_type;
|
|
|
|
intrusive_value_type_impl(){}
|
|
|
|
enum { BlockHdrAlignment = ::boost::alignment_of<block_header<size_type> >::value };
|
|
|
|
block_header<size_type> *get_block_header() const
|
|
{
|
|
return const_cast<block_header<size_type>*>
|
|
(reinterpret_cast<const block_header<size_type> *>(reinterpret_cast<const char*>(this) +
|
|
get_rounded_size(size_type(sizeof(*this)), size_type(BlockHdrAlignment))));
|
|
}
|
|
|
|
bool operator <(const intrusive_value_type_impl<Hook, CharType, SizeType> & other) const
|
|
{ return (this->get_block_header())->template less_comp<CharType>(*other.get_block_header()); }
|
|
|
|
bool operator ==(const intrusive_value_type_impl<Hook, CharType, SizeType> & other) const
|
|
{ return (this->get_block_header())->template equal_comp<CharType>(*other.get_block_header()); }
|
|
|
|
static intrusive_value_type_impl *get_intrusive_value_type(block_header<size_type> *hdr)
|
|
{
|
|
return reinterpret_cast<intrusive_value_type_impl *>(reinterpret_cast<char*>(hdr) -
|
|
get_rounded_size(size_type(sizeof(intrusive_value_type_impl)), size_type(BlockHdrAlignment)));
|
|
}
|
|
|
|
CharType *name() const
|
|
{ return get_block_header()->template name<CharType>(); }
|
|
|
|
unsigned short name_length() const
|
|
{ return get_block_header()->name_length(); }
|
|
|
|
void *value() const
|
|
{ return get_block_header()->value(); }
|
|
};
|
|
|
|
template<class CharType>
|
|
class char_ptr_holder
|
|
{
|
|
public:
|
|
char_ptr_holder(const CharType *name)
|
|
: m_name(name)
|
|
{}
|
|
|
|
char_ptr_holder(const anonymous_instance_t *)
|
|
: m_name(static_cast<CharType*>(0))
|
|
{}
|
|
|
|
char_ptr_holder(const unique_instance_t *)
|
|
: m_name(reinterpret_cast<CharType*>(-1))
|
|
{}
|
|
|
|
operator const CharType *()
|
|
{ return m_name; }
|
|
|
|
private:
|
|
const CharType *m_name;
|
|
};
|
|
|
|
//!The key of the the named allocation information index. Stores an offset pointer
|
|
//!to a null terminated string and the length of the string to speed up sorting
|
|
template<class CharT, class VoidPointer>
|
|
struct index_key
|
|
{
|
|
typedef typename boost::intrusive::
|
|
pointer_traits<VoidPointer>::template
|
|
rebind_pointer<const CharT>::type const_char_ptr_t;
|
|
typedef CharT char_type;
|
|
typedef typename boost::intrusive::pointer_traits<const_char_ptr_t>::difference_type difference_type;
|
|
typedef typename boost::make_unsigned<difference_type>::type size_type;
|
|
|
|
private:
|
|
//Offset pointer to the object's name
|
|
const_char_ptr_t mp_str;
|
|
//Length of the name buffer (null NOT included)
|
|
size_type m_len;
|
|
public:
|
|
|
|
//!Constructor of the key
|
|
index_key (const char_type *nm, size_type length)
|
|
: mp_str(nm), m_len(length)
|
|
{}
|
|
|
|
//!Less than function for index ordering
|
|
bool operator < (const index_key & right) const
|
|
{
|
|
return (m_len < right.m_len) ||
|
|
(m_len == right.m_len &&
|
|
std::char_traits<char_type>::compare
|
|
(to_raw_pointer(mp_str)
|
|
,to_raw_pointer(right.mp_str), m_len) < 0);
|
|
}
|
|
|
|
//!Equal to function for index ordering
|
|
bool operator == (const index_key & right) const
|
|
{
|
|
return m_len == right.m_len &&
|
|
std::char_traits<char_type>::compare
|
|
(to_raw_pointer(mp_str),
|
|
to_raw_pointer(right.mp_str), m_len) == 0;
|
|
}
|
|
|
|
void name(const CharT *nm)
|
|
{ mp_str = nm; }
|
|
|
|
void name_length(size_type len)
|
|
{ m_len = len; }
|
|
|
|
const CharT *name() const
|
|
{ return to_raw_pointer(mp_str); }
|
|
|
|
size_type name_length() const
|
|
{ return m_len; }
|
|
};
|
|
|
|
//!The index_data stores a pointer to a buffer and the element count needed
|
|
//!to know how many destructors must be called when calling destroy
|
|
template<class VoidPointer>
|
|
struct index_data
|
|
{
|
|
typedef VoidPointer void_pointer;
|
|
void_pointer m_ptr;
|
|
index_data(void *ptr) : m_ptr(ptr){}
|
|
|
|
void *value() const
|
|
{ return static_cast<void*>(to_raw_pointer(m_ptr)); }
|
|
};
|
|
|
|
template<class MemoryAlgorithm>
|
|
struct segment_manager_base_type
|
|
{ typedef segment_manager_base<MemoryAlgorithm> type; };
|
|
|
|
template<class CharT, class MemoryAlgorithm>
|
|
struct index_config
|
|
{
|
|
typedef typename MemoryAlgorithm::void_pointer void_pointer;
|
|
typedef CharT char_type;
|
|
typedef index_key<CharT, void_pointer> key_type;
|
|
typedef index_data<void_pointer> mapped_type;
|
|
typedef typename segment_manager_base_type
|
|
<MemoryAlgorithm>::type segment_manager_base;
|
|
|
|
template<class HeaderBase>
|
|
struct intrusive_value_type
|
|
{ typedef intrusive_value_type_impl<HeaderBase, CharT, typename segment_manager_base::size_type> type; };
|
|
|
|
typedef intrusive_compare_key<CharT> intrusive_compare_key_type;
|
|
};
|
|
|
|
template<class Iterator, bool intrusive>
|
|
class segment_manager_iterator_value_adaptor
|
|
{
|
|
typedef typename Iterator::value_type iterator_val_t;
|
|
typedef typename iterator_val_t::char_type char_type;
|
|
|
|
public:
|
|
segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val)
|
|
: m_val(&val)
|
|
{}
|
|
|
|
const char_type *name() const
|
|
{ return m_val->name(); }
|
|
|
|
unsigned short name_length() const
|
|
{ return m_val->name_length(); }
|
|
|
|
const void *value() const
|
|
{ return m_val->value(); }
|
|
|
|
const typename Iterator::value_type *m_val;
|
|
};
|
|
|
|
|
|
template<class Iterator>
|
|
class segment_manager_iterator_value_adaptor<Iterator, false>
|
|
{
|
|
typedef typename Iterator::value_type iterator_val_t;
|
|
typedef typename iterator_val_t::first_type first_type;
|
|
typedef typename iterator_val_t::second_type second_type;
|
|
typedef typename first_type::char_type char_type;
|
|
typedef typename first_type::size_type size_type;
|
|
|
|
public:
|
|
segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val)
|
|
: m_val(&val)
|
|
{}
|
|
|
|
const char_type *name() const
|
|
{ return m_val->first.name(); }
|
|
|
|
size_type name_length() const
|
|
{ return m_val->first.name_length(); }
|
|
|
|
const void *value() const
|
|
{
|
|
return reinterpret_cast<block_header<size_type>*>
|
|
(to_raw_pointer(m_val->second.m_ptr))->value();
|
|
}
|
|
|
|
const typename Iterator::value_type *m_val;
|
|
};
|
|
|
|
template<class Iterator, bool intrusive>
|
|
struct segment_manager_iterator_transform
|
|
: std::unary_function< typename Iterator::value_type
|
|
, segment_manager_iterator_value_adaptor<Iterator, intrusive> >
|
|
{
|
|
typedef segment_manager_iterator_value_adaptor<Iterator, intrusive> result_type;
|
|
|
|
result_type operator()(const typename Iterator::value_type &arg) const
|
|
{ return result_type(arg); }
|
|
};
|
|
|
|
} //namespace ipcdetail {
|
|
|
|
//These pointers are the ones the user will use to
|
|
//indicate previous allocation types
|
|
static const ipcdetail::anonymous_instance_t * anonymous_instance = 0;
|
|
static const ipcdetail::unique_instance_t * unique_instance = 0;
|
|
|
|
namespace ipcdetail_really_deep_namespace {
|
|
|
|
//Otherwise, gcc issues a warning of previously defined
|
|
//anonymous_instance and unique_instance
|
|
struct dummy
|
|
{
|
|
dummy()
|
|
{
|
|
(void)anonymous_instance;
|
|
(void)unique_instance;
|
|
}
|
|
};
|
|
|
|
} //detail_really_deep_namespace
|
|
|
|
}} //namespace boost { namespace interprocess
|
|
|
|
#include <boost/interprocess/detail/config_end.hpp>
|
|
|
|
#endif //#ifndef BOOST_INTERPROCESS_SEGMENT_MANAGER_BASE_HPP
|
|
|