Imported Upstream version 1.49.0upstream/1.49.0

152 files changed, 39047 insertions, 0 deletions

diff --git a/boost/interprocess/allocators/adaptive_pool.hpp b/boost/interprocess/allocators/adaptive_pool.hpp
new file mode 100644
index 0000000000..846df5d413
--- /dev/null
+++ b/boost/interprocess/allocators/adaptive_pool.hpp
@@ -0,0 +1,468 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_ADAPTIVE_POOL_HPP
+#define BOOST_INTERPROCESS_ADAPTIVE_POOL_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/interprocess/interprocess_fwd.hpp>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/allocators/detail/adaptive_node_pool.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+
+//!\file
+//!Describes adaptive_pool pooled shared memory STL compatible allocator 
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+namespace ipcdetail{
+
+template < unsigned int Version
+         , class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         , std::size_t MaxFreeBlocks
+         , unsigned char OverheadPercent
+         >
+class adaptive_pool_base
+   : public node_pool_allocation_impl
+   < adaptive_pool_base
+      < Version, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>
+   , Version
+   , T
+   , SegmentManager
+   >
+{
+   public:
+   typedef typename SegmentManager::void_pointer         void_pointer;
+   typedef SegmentManager                                segment_manager;
+   typedef adaptive_pool_base
+      <Version, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>   self_t;
+
+   /// @cond
+
+   template <int dummy>
+   struct node_pool
+   {
+      typedef ipcdetail::shared_adaptive_node_pool
+      < SegmentManager, sizeof_value<T>::value, NodesPerBlock, MaxFreeBlocks, OverheadPercent> type;
+
+      static type *get(void *p)
+      {  return static_cast<type*>(p);  }
+   };
+   /// @endcond
+
+   BOOST_STATIC_ASSERT((Version <=2));
+
+   public:
+   //-------
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const T>::type                   const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+
+   typedef boost::interprocess::version_type<adaptive_pool_base, Version>   version;
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+
+   //!Obtains adaptive_pool_base from 
+   //!adaptive_pool_base
+   template<class T2>
+   struct rebind
+   {  
+      typedef adaptive_pool_base<Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>       other;
+   };
+
+   /// @cond
+   private:
+   //!Not assignable from related adaptive_pool_base
+   template<unsigned int Version2, class T2, class SegmentManager2, std::size_t N2, std::size_t F2, unsigned char O2>
+   adaptive_pool_base& operator=
+      (const adaptive_pool_base<Version2, T2, SegmentManager2, N2, F2, O2>&);
+
+   /// @endcond
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   adaptive_pool_base(segment_manager *segment_mngr) 
+      : mp_node_pool(ipcdetail::get_or_create_node_pool<typename node_pool<0>::type>(segment_mngr)) { }
+
+   //!Copy constructor from other adaptive_pool_base. Increments the reference 
+   //!count of the associated node pool. Never throws
+   adaptive_pool_base(const adaptive_pool_base &other) 
+      : mp_node_pool(other.get_node_pool()) 
+   {  
+      node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool))->inc_ref_count();   
+   }
+
+   //!Assignment from other adaptive_pool_base
+   adaptive_pool_base& operator=(const adaptive_pool_base &other)
+   {
+      adaptive_pool_base c(other);
+      swap(*this, c);
+      return *this;
+   }
+
+   //!Copy constructor from related adaptive_pool_base. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   adaptive_pool_base
+      (const adaptive_pool_base<Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : mp_node_pool(ipcdetail::get_or_create_node_pool<typename node_pool<0>::type>(other.get_segment_manager())) { }
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~adaptive_pool_base() 
+   {  ipcdetail::destroy_node_pool_if_last_link(node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool)));   }
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   void* get_node_pool() const
+   {  return ipcdetail::to_raw_pointer(mp_node_pool);   }
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const
+   {  return node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool))->get_segment_manager();  }
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2)
+   {  ipcdetail::do_swap(alloc1.mp_node_pool, alloc2.mp_node_pool);  }
+
+   /// @cond
+   private:
+   void_pointer   mp_node_pool;
+   /// @endcond
+};
+
+//!Equality test for same type
+//!of adaptive_pool_base
+template<unsigned int V, class T, class S, std::size_t NPC, std::size_t F, unsigned char OP> inline
+bool operator==(const adaptive_pool_base<V, T, S, NPC, F, OP> &alloc1, 
+                const adaptive_pool_base<V, T, S, NPC, F, OP> &alloc2)
+   {  return alloc1.get_node_pool() == alloc2.get_node_pool(); }
+
+//!Inequality test for same type
+//!of adaptive_pool_base
+template<unsigned int V, class T, class S, std::size_t NPC, std::size_t F, unsigned char OP> inline
+bool operator!=(const adaptive_pool_base<V, T, S, NPC, F, OP> &alloc1, 
+                const adaptive_pool_base<V, T, S, NPC, F, OP> &alloc2)
+   {  return alloc1.get_node_pool() != alloc2.get_node_pool(); }
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock = 64
+         , std::size_t MaxFreeBlocks = 2
+         , unsigned char OverheadPercent = 5
+         >
+class adaptive_pool_v1
+   :  public adaptive_pool_base
+         < 1
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         , MaxFreeBlocks
+         , OverheadPercent
+         >
+{
+   public:
+   typedef ipcdetail::adaptive_pool_base
+         < 1, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> base_t;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef adaptive_pool_v1<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>  other;
+   };
+
+   adaptive_pool_v1(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   adaptive_pool_v1
+      (const adaptive_pool_v1<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : base_t(other)
+   {}
+};
+
+}  //namespace ipcdetail{
+
+/// @endcond
+
+//!An STL node allocator that uses a segment manager as memory 
+//!source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the allocator in shared memory, memory mapped-files, etc...
+//!
+//!This node allocator shares a segregated storage between all instances 
+//!of adaptive_pool with equal sizeof(T) placed in the same segment 
+//!group. NodesPerBlock is the number of nodes allocated at once when the allocator
+//!needs runs out of nodes. MaxFreeBlocks is the maximum number of totally free blocks
+//!that the adaptive node pool will hold. The rest of the totally free blocks will be
+//!deallocated with the segment manager.
+//!
+//!OverheadPercent is the (approximated) maximum size overhead (1-20%) of the allocator:
+//!(memory usable for nodes / total memory allocated from the segment manager)
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         , std::size_t MaxFreeBlocks
+         , unsigned char OverheadPercent
+         >
+class adaptive_pool
+   /// @cond
+   :  public ipcdetail::adaptive_pool_base
+         < 2
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         , MaxFreeBlocks
+         , OverheadPercent
+         >
+   /// @endcond
+{
+
+   #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   typedef ipcdetail::adaptive_pool_base
+         < 2, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> base_t;
+   public:
+   typedef boost::interprocess::version_type<adaptive_pool, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>  other;
+   };
+
+   adaptive_pool(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   adaptive_pool
+      (const adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : base_t(other)
+   {}
+
+   #else //BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   public:
+   typedef implementation_defined::segment_manager       segment_manager;
+   typedef segment_manager::void_pointer                 void_pointer;
+   typedef implementation_defined::pointer               pointer;
+   typedef implementation_defined::const_pointer         const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+
+   //!Obtains adaptive_pool from 
+   //!adaptive_pool
+   template<class T2>
+   struct rebind
+   {  
+      typedef adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> other;
+   };
+
+   private:
+   //!Not assignable from
+   //!related adaptive_pool
+   template<class T2, class SegmentManager2, std::size_t N2, std::size_t F2, unsigned char OP2>
+   adaptive_pool& operator=
+      (const adaptive_pool<T2, SegmentManager2, N2, F2, OP2>&);
+
+   //!Not assignable from 
+   //!other adaptive_pool
+   //adaptive_pool& operator=(const adaptive_pool&);
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   adaptive_pool(segment_manager *segment_mngr);
+
+   //!Copy constructor from other adaptive_pool. Increments the reference 
+   //!count of the associated node pool. Never throws
+   adaptive_pool(const adaptive_pool &other);
+
+   //!Copy constructor from related adaptive_pool. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   adaptive_pool
+      (const adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other);
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~adaptive_pool();
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   void* get_node_pool() const;
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const;
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const;
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0);
+
+   //!Deallocate allocated memory.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type count);
+
+   //!Deallocates all free blocks
+   //!of the pool
+   void deallocate_free_blocks();
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2);
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const;
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const;
+/*
+   //!Copy construct an object. 
+   //!Throws if T's copy constructor throws
+   void construct(const pointer &ptr, const_reference v);
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr);
+*/
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const;
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain);
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one();
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements);
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p);
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain it);
+   #endif
+};
+
+#ifdef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//!Equality test for same type
+//!of adaptive_pool
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator==(const adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc2);
+
+//!Inequality test for same type
+//!of adaptive_pool
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator!=(const adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc2);
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_ADAPTIVE_POOL_HPP
+
diff --git a/boost/interprocess/allocators/allocator.hpp b/boost/interprocess/allocators/allocator.hpp
new file mode 100644
index 0000000000..aa4b22dcc9
--- /dev/null
+++ b/boost/interprocess/allocators/allocator.hpp
@@ -0,0 +1,307 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_ALLOCATOR_HPP
+#define BOOST_INTERPROCESS_ALLOCATOR_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/containers/allocation_type.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/containers/version_type.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+
+#include <memory>
+#include <new>
+#include <algorithm>
+#include <cstddef>
+#include <stdexcept>
+
+//!\file
+//!Describes an allocator that allocates portions of fixed size
+//!memory buffer (shared memory, mapped file...)
+
+namespace boost {
+namespace interprocess {
+
+
+//!An STL compatible allocator that uses a segment manager as 
+//!memory source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the allocator in shared memory, memory mapped-files, etc...
+template<class T, class SegmentManager>
+class allocator 
+{
+   public:
+   //Segment manager
+   typedef SegmentManager                                segment_manager;
+   typedef typename SegmentManager::void_pointer         void_pointer;
+
+   /// @cond
+   private:
+
+   //Self type
+   typedef allocator<T, SegmentManager>   self_t;
+
+   //Pointer to void
+   typedef typename segment_manager::void_pointer  aux_pointer_t;
+
+   //Typedef to const void pointer
+   typedef typename boost::intrusive::
+      pointer_traits<aux_pointer_t>::template
+         rebind_pointer<const void>::type          cvoid_ptr;
+
+   //Pointer to the allocator
+   typedef typename boost::intrusive::
+      pointer_traits<cvoid_ptr>::template
+         rebind_pointer<segment_manager>::type          alloc_ptr_t;
+
+   //Not assignable from related allocator
+   template<class T2, class SegmentManager2>
+   allocator& operator=(const allocator<T2, SegmentManager2>&);
+
+   //Not assignable from other allocator
+   allocator& operator=(const allocator&);
+
+   //Pointer to the allocator
+   alloc_ptr_t mp_mngr;
+   /// @endcond
+
+   public:
+   typedef T                                    value_type;
+   typedef typename boost::intrusive::
+      pointer_traits<cvoid_ptr>::template
+         rebind_pointer<T>::type                pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<pointer>::template
+         rebind_pointer<const T>::type          const_pointer;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type         reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type   const_reference;
+   typedef typename segment_manager::size_type               size_type;
+   typedef typename segment_manager::difference_type         difference_type;
+
+   typedef boost::interprocess::version_type<allocator, 2>   version;
+
+   /// @cond
+
+   //Experimental. Don't use.
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+   /// @endcond
+
+   //!Obtains an allocator that allocates
+   //!objects of type T2
+   template<class T2>
+   struct rebind
+   {   
+      typedef allocator<T2, SegmentManager>     other;
+   };
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const
+   {  return ipcdetail::to_raw_pointer(mp_mngr);   }
+
+   //!Constructor from the segment manager.
+   //!Never throws
+   allocator(segment_manager *segment_mngr) 
+      : mp_mngr(segment_mngr) { }
+
+   //!Constructor from other allocator.
+   //!Never throws
+   allocator(const allocator &other) 
+      : mp_mngr(other.get_segment_manager()){ }
+
+   //!Constructor from related allocator.
+   //!Never throws
+   template<class T2>
+   allocator(const allocator<T2, SegmentManager> &other) 
+      : mp_mngr(other.get_segment_manager()){}
+
+   //!Allocates memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_ptr hint = 0)
+   {
+      (void)hint;
+      if(count > this->max_size())
+         throw bad_alloc();
+      return pointer(static_cast<value_type*>(mp_mngr->allocate(count*sizeof(T))));
+   }
+
+   //!Deallocates memory previously allocated.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type)
+   {  mp_mngr->deallocate((void*)ipcdetail::to_raw_pointer(ptr));  }
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const
+   {  return mp_mngr->get_size()/sizeof(T);   }
+
+   //!Swap segment manager. Does not throw. If each allocator is placed in
+   //!different memory segments, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2)
+   {  ipcdetail::do_swap(alloc1.mp_mngr, alloc2.mp_mngr);   }
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const
+   {  
+      return (size_type)mp_mngr->size(ipcdetail::to_raw_pointer(p))/sizeof(T);
+   }
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0)
+   {
+      return mp_mngr->allocation_command
+         (command, limit_size, preferred_size, received_size, ipcdetail::to_raw_pointer(reuse));
+   }
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many
+      (size_type elem_size, size_type num_elements)
+   {
+      return multiallocation_chain(mp_mngr->allocate_many(sizeof(T)*elem_size, num_elements));
+   }
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many
+      (const size_type *elem_sizes, size_type n_elements)
+   {
+      multiallocation_chain(mp_mngr->allocate_many(elem_sizes, n_elements, sizeof(T)));
+   }
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain)
+   {
+      return mp_mngr->deallocate_many(chain.extract_multiallocation_chain());
+   }
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one()
+   {  return this->allocate(1);  }
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual
+      (size_type num_elements)
+   {  return this->allocate_many(1, num_elements); }
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p)
+   {  return this->deallocate(p, 1);  }
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain)
+   {  return this->deallocate_many(boost::move(chain)); }
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const
+   {  return pointer(boost::addressof(value));  }
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const
+   {  return const_pointer(boost::addressof(value));  }
+
+   //!Constructs an object
+   //!Throws if T's constructor throws
+   //!For backwards compatibility with libraries using C++03 allocators
+   template<class P>
+   void construct(const pointer &ptr, BOOST_FWD_REF(P) p)
+   {  ::new((void*)ipcdetail::to_raw_pointer(ptr)) value_type(::boost::forward<P>(p));  }
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr)
+   {  BOOST_ASSERT(ptr != 0); (*ptr).~value_type();  }
+
+};
+
+//!Equality test for same type
+//!of allocator
+template<class T, class SegmentManager> inline
+bool operator==(const allocator<T , SegmentManager>  &alloc1, 
+                const allocator<T, SegmentManager>  &alloc2)
+   {  return alloc1.get_segment_manager() == alloc2.get_segment_manager(); }
+
+//!Inequality test for same type
+//!of allocator
+template<class T, class SegmentManager> inline
+bool operator!=(const allocator<T, SegmentManager>  &alloc1, 
+                const allocator<T, SegmentManager>  &alloc2)
+   {  return alloc1.get_segment_manager() != alloc2.get_segment_manager(); }
+
+}  //namespace interprocess {
+
+/// @cond
+
+template<class T>
+struct has_trivial_destructor;
+
+template<class T, class SegmentManager>
+struct has_trivial_destructor
+   <boost::interprocess::allocator <T, SegmentManager> >
+{
+   static const bool value = true;
+};
+/// @endcond
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_ALLOCATOR_HPP
+
diff --git a/boost/interprocess/allocators/cached_adaptive_pool.hpp b/boost/interprocess/allocators/cached_adaptive_pool.hpp
new file mode 100644
index 0000000000..bec1050de5
--- /dev/null
+++ b/boost/interprocess/allocators/cached_adaptive_pool.hpp
@@ -0,0 +1,356 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_CACHED_ADAPTIVE_POOL_HPP
+#define BOOST_INTERPROCESS_CACHED_ADAPTIVE_POOL_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/allocators/detail/adaptive_node_pool.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/containers/version_type.hpp>
+#include <boost/interprocess/allocators/detail/node_tools.hpp>
+#include <cstddef>
+
+//!\file
+//!Describes cached_adaptive_pool pooled shared memory STL compatible allocator 
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+namespace ipcdetail {
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock = 64
+         , std::size_t MaxFreeBlocks = 2
+         , unsigned char OverheadPercent = 5
+         >
+class cached_adaptive_pool_v1
+   :  public ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_adaptive_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            , MaxFreeBlocks
+            , OverheadPercent
+            >
+         , 1>
+{
+   public:
+   typedef ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_adaptive_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            , MaxFreeBlocks
+            , OverheadPercent
+            >
+         , 1> base_t;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef cached_adaptive_pool_v1
+         <T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>  other;
+   };
+
+   typedef typename base_t::size_type size_type;
+
+   cached_adaptive_pool_v1(SegmentManager *segment_mngr,
+                           size_type max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES) 
+      : base_t(segment_mngr, max_cached_nodes)
+   {}
+
+   template<class T2>
+   cached_adaptive_pool_v1
+      (const cached_adaptive_pool_v1
+         <T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : base_t(other)
+   {}
+};
+
+}  //namespace ipcdetail{
+
+/// @endcond
+
+//!An STL node allocator that uses a segment manager as memory 
+//!source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the allocator in shared memory, memory mapped-files, etc...
+//!
+//!This node allocator shares a segregated storage between all instances of 
+//!cached_adaptive_pool with equal sizeof(T) placed in the same
+//!memory segment. But also caches some nodes privately to
+//!avoid some synchronization overhead.
+//!
+//!NodesPerBlock is the minimum number of nodes of nodes allocated at once when
+//!the allocator needs runs out of nodes. MaxFreeBlocks is the maximum number of totally free blocks
+//!that the adaptive node pool will hold. The rest of the totally free blocks will be
+//!deallocated with the segment manager.
+//!
+//!OverheadPercent is the (approximated) maximum size overhead (1-20%) of the allocator:
+//!(memory usable for nodes / total memory allocated from the segment manager)
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         , std::size_t MaxFreeBlocks
+         , unsigned char OverheadPercent
+         >
+class cached_adaptive_pool
+   /// @cond
+   :  public ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_adaptive_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            , MaxFreeBlocks
+            , OverheadPercent
+            >
+         , 2>
+   /// @endcond
+{
+
+   #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   public:
+   typedef ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_adaptive_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            , MaxFreeBlocks
+            , OverheadPercent
+            >
+         , 2> base_t;
+
+   public:
+   typedef boost::interprocess::version_type<cached_adaptive_pool, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef cached_adaptive_pool
+         <T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>  other;
+   };
+
+   cached_adaptive_pool(SegmentManager *segment_mngr,
+                         std::size_t max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES) 
+      : base_t(segment_mngr, max_cached_nodes)
+   {}
+
+   template<class T2>
+   cached_adaptive_pool
+      (const cached_adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : base_t(other)
+   {}
+
+   #else
+   public:
+   typedef implementation_defined::segment_manager       segment_manager;
+   typedef segment_manager::void_pointer                 void_pointer;
+   typedef implementation_defined::pointer               pointer;
+   typedef implementation_defined::const_pointer         const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+
+   //!Obtains cached_adaptive_pool from 
+   //!cached_adaptive_pool
+   template<class T2>
+   struct rebind
+   {  
+      typedef cached_adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> other;
+   };
+
+   private:
+   //!Not assignable from
+   //!related cached_adaptive_pool
+   template<class T2, class SegmentManager2, std::size_t N2, std::size_t F2, unsigned char OP2>
+   cached_adaptive_pool& operator=
+      (const cached_adaptive_pool<T2, SegmentManager2, N2, F2, OP2>&);
+
+   //!Not assignable from 
+   //!other cached_adaptive_pool
+   cached_adaptive_pool& operator=(const cached_adaptive_pool&);
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   cached_adaptive_pool(segment_manager *segment_mngr);
+
+   //!Copy constructor from other cached_adaptive_pool. Increments the reference 
+   //!count of the associated node pool. Never throws
+   cached_adaptive_pool(const cached_adaptive_pool &other);
+
+   //!Copy constructor from related cached_adaptive_pool. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   cached_adaptive_pool
+      (const cached_adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other);
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~cached_adaptive_pool();
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   node_pool_t* get_node_pool() const;
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const;
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const;
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0);
+
+   //!Deallocate allocated memory.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type count);
+
+   //!Deallocates all free blocks
+   //!of the pool
+   void deallocate_free_blocks();
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2);
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const;
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const;
+
+   //!Copy construct an object. 
+   //!Throws if T's copy constructor throws
+   void construct(const pointer &ptr, const_reference v);
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr);
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const;
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain);
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one();
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements);
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p);
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain);
+   //!Sets the new max cached nodes value. This can provoke deallocations
+   //!if "newmax" is less than current cached nodes. Never throws
+   void set_max_cached_nodes(size_type newmax);
+
+   //!Returns the max cached nodes parameter.
+   //!Never throws
+   size_type get_max_cached_nodes() const;
+   #endif
+};
+
+#ifdef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//!Equality test for same type
+//!of cached_adaptive_pool
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, std::size_t OP> inline
+bool operator==(const cached_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const cached_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc2);
+
+//!Inequality test for same type
+//!of cached_adaptive_pool
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, std::size_t OP> inline
+bool operator!=(const cached_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const cached_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc2);
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_CACHED_ADAPTIVE_POOL_HPP
+
diff --git a/boost/interprocess/allocators/cached_node_allocator.hpp b/boost/interprocess/allocators/cached_node_allocator.hpp
new file mode 100644
index 0000000000..03398156db
--- /dev/null
+++ b/boost/interprocess/allocators/cached_node_allocator.hpp
@@ -0,0 +1,327 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_CACHED_NODE_ALLOCATOR_HPP
+#define BOOST_INTERPROCESS_CACHED_NODE_ALLOCATOR_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/allocators/detail/node_pool.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/containers/version_type.hpp>
+#include <boost/interprocess/allocators/detail/node_tools.hpp>
+#include <cstddef>
+
+//!\file
+//!Describes cached_cached_node_allocator pooled shared memory STL compatible allocator 
+
+namespace boost {
+namespace interprocess {
+
+
+/// @cond
+
+namespace ipcdetail {
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock = 64
+         >
+class cached_node_allocator_v1
+   :  public ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            >
+         , 1>
+{
+   public:
+   typedef ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            >
+         , 1> base_t;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef cached_node_allocator_v1
+         <T2, SegmentManager, NodesPerBlock>  other;
+   };
+
+   typedef typename base_t::size_type size_type;
+
+   cached_node_allocator_v1(SegmentManager *segment_mngr,
+                         size_type max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES) 
+      : base_t(segment_mngr, max_cached_nodes)
+   {}
+
+   template<class T2>
+   cached_node_allocator_v1
+      (const cached_node_allocator_v1
+         <T2, SegmentManager, NodesPerBlock> &other)
+      : base_t(other)
+   {}
+};
+
+}  //namespace ipcdetail{
+
+/// @endcond
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         >
+class cached_node_allocator
+   /// @cond
+   :  public ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            >
+         , 2>
+   /// @endcond
+{
+
+   #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   public:
+   typedef ipcdetail::cached_allocator_impl
+         < T
+         , ipcdetail::shared_node_pool
+            < SegmentManager
+            , sizeof_value<T>::value
+            , NodesPerBlock
+            >
+         , 2> base_t;
+
+   public:
+   typedef boost::interprocess::version_type<cached_node_allocator, 2>   version;
+   typedef typename base_t::size_type size_type;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef cached_node_allocator<T2, SegmentManager, NodesPerBlock>  other;
+   };
+
+   cached_node_allocator(SegmentManager *segment_mngr,
+                         size_type max_cached_nodes = base_t::DEFAULT_MAX_CACHED_NODES) 
+      : base_t(segment_mngr, max_cached_nodes)
+   {}
+
+   template<class T2>
+   cached_node_allocator
+      (const cached_node_allocator<T2, SegmentManager, NodesPerBlock> &other)
+      : base_t(other)
+   {}
+
+   #else
+   public:
+   typedef implementation_defined::segment_manager       segment_manager;
+   typedef segment_manager::void_pointer                 void_pointer;
+   typedef implementation_defined::pointer               pointer;
+   typedef implementation_defined::const_pointer         const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename SegmentManager::size_type            size_type;
+   typedef typename SegmentManager::difference_type      difference_type;
+
+   //!Obtains cached_node_allocator from 
+   //!cached_node_allocator
+   template<class T2>
+   struct rebind
+   {  
+      typedef cached_node_allocator<T2, SegmentManager> other;
+   };
+
+   private:
+   //!Not assignable from
+   //!related cached_node_allocator
+   template<class T2, class SegmentManager2, std::size_t N2>
+   cached_node_allocator& operator=
+      (const cached_node_allocator<T2, SegmentManager2, N2>&);
+
+   //!Not assignable from 
+   //!other cached_node_allocator
+   cached_node_allocator& operator=(const cached_node_allocator&);
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   cached_node_allocator(segment_manager *segment_mngr);
+
+   //!Copy constructor from other cached_node_allocator. Increments the reference 
+   //!count of the associated node pool. Never throws
+   cached_node_allocator(const cached_node_allocator &other);
+
+   //!Copy constructor from related cached_node_allocator. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   cached_node_allocator
+      (const cached_node_allocator<T2, SegmentManager, NodesPerBlock> &other);
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~cached_node_allocator();
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   node_pool_t* get_node_pool() const;
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const;
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const;
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0);
+
+   //!Deallocate allocated memory.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type count);
+
+   //!Deallocates all free blocks
+   //!of the pool
+   void deallocate_free_blocks();
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2);
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const;
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const;
+
+   //!Default construct an object. 
+   //!Throws if T's default constructor throws
+   void construct(const pointer &ptr, const_reference v);
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr);
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const;
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain);
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one();
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements);
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p);
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain it);
+   //!Sets the new max cached nodes value. This can provoke deallocations
+   //!if "newmax" is less than current cached nodes. Never throws
+   void set_max_cached_nodes(size_type newmax);
+
+   //!Returns the max cached nodes parameter.
+   //!Never throws
+   size_type get_max_cached_nodes() const;
+   #endif
+};
+
+#ifdef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//!Equality test for same type
+//!of cached_node_allocator
+template<class T, class S, std::size_t NPC> inline
+bool operator==(const cached_node_allocator<T, S, NPC> &alloc1, 
+                const cached_node_allocator<T, S, NPC> &alloc2);
+
+//!Inequality test for same type
+//!of cached_node_allocator
+template<class T, class S, std::size_t NPC> inline
+bool operator!=(const cached_node_allocator<T, S, NPC> &alloc1, 
+                const cached_node_allocator<T, S, NPC> &alloc2);
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_CACHED_NODE_ALLOCATOR_HPP
+
diff --git a/boost/interprocess/allocators/detail/adaptive_node_pool.hpp b/boost/interprocess/allocators/detail/adaptive_node_pool.hpp
new file mode 100644
index 0000000000..4ccc920663
--- /dev/null
+++ b/boost/interprocess/allocators/detail/adaptive_node_pool.hpp
@@ -0,0 +1,108 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_ADAPTIVE_NODE_POOL_HPP
+#define BOOST_INTERPROCESS_DETAIL_ADAPTIVE_NODE_POOL_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/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/math_functions.hpp>
+#include <boost/intrusive/set.hpp>
+#include <boost/intrusive/slist.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/mem_algo/detail/mem_algo_common.hpp>
+#include <boost/interprocess/allocators/detail/node_tools.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <cstddef>
+#include <boost/config/no_tr1/cmath.hpp>
+#include <boost/container/detail/adaptive_node_pool_impl.hpp>
+#include <boost/assert.hpp>
+
+//!\file
+//!Describes the real adaptive pool shared by many Interprocess pool allocators
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+template< class SegmentManager
+        , std::size_t NodeSize
+        , std::size_t NodesPerBlock
+        , std::size_t MaxFreeBlocks
+        , unsigned char OverheadPercent
+        >
+class private_adaptive_node_pool
+   :  public boost::container::container_detail::private_adaptive_node_pool_impl
+         <typename SegmentManager::segment_manager_base_type>
+{
+   typedef boost::container::container_detail::private_adaptive_node_pool_impl
+      <typename SegmentManager::segment_manager_base_type> base_t;
+   //Non-copyable
+   private_adaptive_node_pool();
+   private_adaptive_node_pool(const private_adaptive_node_pool &);
+   private_adaptive_node_pool &operator=(const private_adaptive_node_pool &);
+
+   public:
+   typedef SegmentManager              segment_manager;
+   typedef typename base_t::size_type  size_type;
+
+   static const size_type nodes_per_block = NodesPerBlock;
+
+   //Deprecated, use node_per_block
+   static const size_type nodes_per_chunk = NodesPerBlock;
+
+   //!Constructor from a segment manager. Never throws
+   private_adaptive_node_pool(segment_manager *segment_mngr)
+      :  base_t(segment_mngr, NodeSize, NodesPerBlock, MaxFreeBlocks, OverheadPercent)
+   {}
+
+   //!Returns the segment manager. Never throws
+   segment_manager* get_segment_manager() const
+   {  return static_cast<segment_manager*>(base_t::get_segment_manager_base()); }
+};
+
+//!Pooled shared memory allocator using adaptive pool. Includes
+//!a reference count but the class does not delete itself, this is  
+//!responsibility of user classes. Node size (NodeSize) and the number of
+//!nodes allocated per block (NodesPerBlock) are known at compile time
+template< class SegmentManager
+        , std::size_t NodeSize
+        , std::size_t NodesPerBlock
+        , std::size_t MaxFreeBlocks
+        , unsigned char OverheadPercent
+        >
+class shared_adaptive_node_pool 
+   :  public ipcdetail::shared_pool_impl
+      < private_adaptive_node_pool
+         <SegmentManager, NodeSize, NodesPerBlock, MaxFreeBlocks, OverheadPercent>
+      >
+{
+   typedef ipcdetail::shared_pool_impl
+      < private_adaptive_node_pool
+         <SegmentManager, NodeSize, NodesPerBlock, MaxFreeBlocks, OverheadPercent>
+      > base_t;
+   public:
+   shared_adaptive_node_pool(SegmentManager *segment_mgnr)
+      : base_t(segment_mgnr)
+   {}
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_ADAPTIVE_NODE_POOL_HPP
diff --git a/boost/interprocess/allocators/detail/allocator_common.hpp b/boost/interprocess/allocators/detail/allocator_common.hpp
new file mode 100644
index 0000000000..ea660b1a90
--- /dev/null
+++ b/boost/interprocess/allocators/detail/allocator_common.hpp
@@ -0,0 +1,862 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008. 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_ALLOCATOR_DETAIL_ALLOCATOR_COMMON_HPP
+#define BOOST_INTERPROCESS_ALLOCATOR_DETAIL_ALLOCATOR_COMMON_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/intrusive/pointer_traits.hpp>
+
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/detail/utilities.hpp> //to_raw_pointer
+#include <boost/utility/addressof.hpp> //boost::addressof
+#include <boost/assert.hpp>   //BOOST_ASSERT
+#include <boost/interprocess/exceptions.hpp> //bad_alloc
+#include <boost/interprocess/sync/scoped_lock.hpp> //scoped_lock
+#include <boost/interprocess/containers/allocation_type.hpp> //boost::interprocess::allocation_type
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/mem_algo/detail/mem_algo_common.hpp>
+#include <boost/interprocess/detail/segment_manager_helper.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <algorithm> //std::swap
+#include <utility>   //std::pair
+#include <new>
+
+namespace boost {
+namespace interprocess {
+
+template <class T>
+struct sizeof_value
+{
+   static const std::size_t value = sizeof(T);
+};
+
+template <>
+struct sizeof_value<void>
+{
+   static const std::size_t value = sizeof(void*);
+};
+
+template <>
+struct sizeof_value<const void>
+{
+   static const std::size_t value = sizeof(void*);
+};
+
+template <>
+struct sizeof_value<volatile void>
+{
+   static const std::size_t value = sizeof(void*);
+};
+
+template <>
+struct sizeof_value<const volatile void>
+{
+   static const std::size_t value = sizeof(void*);
+};
+
+namespace ipcdetail {
+
+//!Object function that creates the node allocator if it is not created and
+//!increments reference count if it is already created
+template<class NodePool>
+struct get_or_create_node_pool_func
+{
+   
+   //!This connects or constructs the unique instance of node_pool_t
+   //!Can throw boost::interprocess::bad_alloc
+   void operator()()
+   {
+      //Find or create the node_pool_t
+      mp_node_pool =    mp_segment_manager->template find_or_construct
+                        <NodePool>(boost::interprocess::unique_instance)(mp_segment_manager);
+      //If valid, increment link count
+      if(mp_node_pool != 0)
+         mp_node_pool->inc_ref_count();
+   }
+
+   //!Constructor. Initializes function
+   //!object parameters
+   get_or_create_node_pool_func(typename NodePool::segment_manager *mngr)
+      : mp_segment_manager(mngr){}
+   
+   NodePool                            *mp_node_pool;
+   typename NodePool::segment_manager  *mp_segment_manager;
+};
+
+template<class NodePool>
+inline NodePool *get_or_create_node_pool(typename NodePool::segment_manager *mgnr)
+{
+   ipcdetail::get_or_create_node_pool_func<NodePool> func(mgnr);
+   mgnr->atomic_func(func);
+   return func.mp_node_pool;
+}
+
+//!Object function that decrements the reference count. If the count 
+//!reaches to zero destroys the node allocator from memory. 
+//!Never throws
+template<class NodePool>
+struct destroy_if_last_link_func
+{
+   //!Decrements reference count and destroys the object if there is no 
+   //!more attached allocators. Never throws
+   void operator()()
+   {
+      //If not the last link return
+      if(mp_node_pool->dec_ref_count() != 0) return;
+
+      //Last link, let's destroy the segment_manager
+      mp_node_pool->get_segment_manager()->template destroy<NodePool>(boost::interprocess::unique_instance); 
+   }  
+
+   //!Constructor. Initializes function
+   //!object parameters
+   destroy_if_last_link_func(NodePool *pool) 
+      : mp_node_pool(pool)
+   {}
+
+   NodePool                           *mp_node_pool;
+};
+
+//!Destruction function, initializes and executes destruction function 
+//!object. Never throws
+template<class NodePool>
+inline void destroy_node_pool_if_last_link(NodePool *pool)
+{
+   //Get segment manager
+   typename NodePool::segment_manager *mngr = pool->get_segment_manager();
+   //Execute destruction functor atomically
+   destroy_if_last_link_func<NodePool>func(pool);
+   mngr->atomic_func(func);
+}
+
+template<class NodePool>
+class cache_impl
+{
+   typedef typename NodePool::segment_manager::
+      void_pointer                                          void_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<NodePool>::type                     node_pool_ptr;
+   typedef typename NodePool::multiallocation_chain         multiallocation_chain;
+   typedef typename NodePool::segment_manager::size_type    size_type;
+   node_pool_ptr                 mp_node_pool;
+   multiallocation_chain         m_cached_nodes;
+   size_type                     m_max_cached_nodes;
+
+   public:
+   typedef typename NodePool::segment_manager            segment_manager;
+
+   cache_impl(segment_manager *segment_mngr, size_type max_cached_nodes)
+      : mp_node_pool(get_or_create_node_pool<NodePool>(segment_mngr))
+      , m_max_cached_nodes(max_cached_nodes)
+   {}
+
+   cache_impl(const cache_impl &other)
+      : mp_node_pool(other.get_node_pool())
+      , m_max_cached_nodes(other.get_max_cached_nodes())
+   {
+      mp_node_pool->inc_ref_count();
+   }
+
+   ~cache_impl()
+   {
+      this->deallocate_all_cached_nodes();
+      ipcdetail::destroy_node_pool_if_last_link(ipcdetail::to_raw_pointer(mp_node_pool));   
+   }
+
+   NodePool *get_node_pool() const
+   {  return ipcdetail::to_raw_pointer(mp_node_pool); }
+
+   segment_manager *get_segment_manager() const
+   {  return mp_node_pool->get_segment_manager(); }
+
+   size_type get_max_cached_nodes() const
+   {  return m_max_cached_nodes; }
+
+   void *cached_allocation()
+   {
+      //If don't have any cached node, we have to get a new list of free nodes from the pool
+      if(m_cached_nodes.empty()){
+         m_cached_nodes = mp_node_pool->allocate_nodes(m_max_cached_nodes/2);
+      }
+      void *ret = ipcdetail::to_raw_pointer(m_cached_nodes.front());
+      m_cached_nodes.pop_front();
+      return ret;
+   }
+
+   multiallocation_chain cached_allocation(size_type n)
+   {
+      multiallocation_chain chain;
+      size_type count = n, allocated(0);
+      BOOST_TRY{
+         //If don't have any cached node, we have to get a new list of free nodes from the pool
+         while(!m_cached_nodes.empty() && count--){
+            void *ret = ipcdetail::to_raw_pointer(m_cached_nodes.front());
+            m_cached_nodes.pop_front();
+            chain.push_back(ret);
+            ++allocated;
+         }
+
+         if(allocated != n){
+            multiallocation_chain chain2(mp_node_pool->allocate_nodes(n - allocated));
+            chain.splice_after(chain.last(), chain2, chain2.before_begin(), chain2.last(), n - allocated);
+         }
+         return boost::move(chain);
+      }
+      BOOST_CATCH(...){
+         this->cached_deallocation(boost::move(chain));
+         BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+   }
+
+   void cached_deallocation(void *ptr)
+   {
+      //Check if cache is full
+      if(m_cached_nodes.size() >= m_max_cached_nodes){
+         //This only occurs if this allocator deallocate memory allocated
+         //with other equal allocator. Since the cache is full, and more 
+         //deallocations are probably coming, we'll make some room in cache
+         //in a single, efficient multi node deallocation.
+         this->priv_deallocate_n_nodes(m_cached_nodes.size() - m_max_cached_nodes/2);
+      }
+      m_cached_nodes.push_front(ptr);
+   }
+
+   void cached_deallocation(multiallocation_chain chain)
+   {
+      m_cached_nodes.splice_after(m_cached_nodes.before_begin(), chain);
+
+      //Check if cache is full
+      if(m_cached_nodes.size() >= m_max_cached_nodes){
+         //This only occurs if this allocator deallocate memory allocated
+         //with other equal allocator. Since the cache is full, and more 
+         //deallocations are probably coming, we'll make some room in cache
+         //in a single, efficient multi node deallocation.
+         this->priv_deallocate_n_nodes(m_cached_nodes.size() - m_max_cached_nodes/2);
+      }
+   }
+
+   //!Sets the new max cached nodes value. This can provoke deallocations
+   //!if "newmax" is less than current cached nodes. Never throws
+   void set_max_cached_nodes(size_type newmax)
+   {
+      m_max_cached_nodes = newmax;
+      this->priv_deallocate_remaining_nodes();
+   }
+
+   //!Frees all cached nodes.
+   //!Never throws
+   void deallocate_all_cached_nodes()
+   {
+      if(m_cached_nodes.empty()) return;
+      mp_node_pool->deallocate_nodes(boost::move(m_cached_nodes));
+   }
+
+   private:
+   //!Frees all cached nodes at once.
+   //!Never throws
+   void priv_deallocate_remaining_nodes()
+   {
+      if(m_cached_nodes.size() > m_max_cached_nodes){
+         priv_deallocate_n_nodes(m_cached_nodes.size()-m_max_cached_nodes);
+      }
+   }
+
+   //!Frees n cached nodes at once. Never throws
+   void priv_deallocate_n_nodes(size_type n)
+   {
+      //This only occurs if this allocator deallocate memory allocated
+      //with other equal allocator. Since the cache is full, and more 
+      //deallocations are probably coming, we'll make some room in cache
+      //in a single, efficient multi node deallocation.
+      size_type count(n);
+      typename multiallocation_chain::iterator it(m_cached_nodes.before_begin());
+      while(count--){
+         ++it;
+      }
+      multiallocation_chain chain;
+      chain.splice_after(chain.before_begin(), m_cached_nodes, m_cached_nodes.before_begin(), it, n);
+      //Deallocate all new linked list at once
+      mp_node_pool->deallocate_nodes(boost::move(chain));
+   }
+
+   public:
+   void swap(cache_impl &other)
+   {
+      ipcdetail::do_swap(mp_node_pool, other.mp_node_pool); 
+      m_cached_nodes.swap(other.m_cached_nodes); 
+      ipcdetail::do_swap(m_max_cached_nodes, other.m_max_cached_nodes); 
+   } 
+};
+
+template<class Derived, class T, class SegmentManager>
+class array_allocation_impl
+{
+   const Derived *derived() const
+   {  return static_cast<const Derived*>(this); }
+   Derived *derived()
+   {  return static_cast<Derived*>(this); }
+
+   typedef typename SegmentManager::void_pointer         void_pointer;
+
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const T>::type                   const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename SegmentManager::size_type            size_type;
+   typedef typename SegmentManager::difference_type      difference_type;
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+
+
+   public:
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const
+   {  
+      return (size_type)this->derived()->get_segment_manager()->size(ipcdetail::to_raw_pointer(p))/sizeof(T);
+   }
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0)
+   {
+      return this->derived()->get_segment_manager()->allocation_command
+         (command, limit_size, preferred_size, received_size, ipcdetail::to_raw_pointer(reuse));
+   }
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements)
+   {
+      return this->derived()->get_segment_manager()->allocate_many(sizeof(T)*elem_size, num_elements);
+   }
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements)
+   {
+      return this->derived()->get_segment_manager()->allocate_many(elem_sizes, n_elements, sizeof(T));
+   }
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain)
+   {  return this->derived()->get_segment_manager()->deallocate_many(boost::move(chain)); }
+
+   //!Returns the number of elements that could be
+   //!allocated. Never throws
+   size_type max_size() const
+   {  return this->derived()->get_segment_manager()->get_size()/sizeof(T);  }
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const
+   {  return pointer(boost::addressof(value));  }
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const
+   {  return const_pointer(boost::addressof(value));  }
+
+   //!Constructs an object
+   //!Throws if T's constructor throws
+   //!For backwards compatibility with libraries using C++03 allocators
+   template<class P>
+   void construct(const pointer &ptr, BOOST_FWD_REF(P) p)
+   {  ::new((void*)ipcdetail::to_raw_pointer(ptr)) value_type(::boost::forward<P>(p));  }
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr)
+   {  BOOST_ASSERT(ptr != 0); (*ptr).~value_type();  }
+};
+
+
+template<class Derived, unsigned int Version, class T, class SegmentManager>
+class node_pool_allocation_impl
+   :  public array_allocation_impl
+      < Derived
+      , T
+      , SegmentManager>
+{
+   const Derived *derived() const
+   {  return static_cast<const Derived*>(this); }
+   Derived *derived()
+   {  return static_cast<Derived*>(this); }
+
+   typedef typename SegmentManager::void_pointer         void_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const void>::type                cvoid_pointer;
+
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const T>::type                   const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename SegmentManager::size_type            size_type;
+   typedef typename SegmentManager::difference_type      difference_type;
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+
+
+   template <int Dummy>
+   struct node_pool
+   {
+      typedef typename Derived::template node_pool<0>::type type;
+      static type *get(void *p)
+      {  return static_cast<type*>(p); }
+   };
+
+   public:
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0)
+   {
+      (void)hint;
+      typedef typename node_pool<0>::type node_pool_t;
+      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
+      if(count > this->max_size())
+         throw bad_alloc();
+      else if(Version == 1 && count == 1)
+         return pointer(static_cast<value_type*>
+         (pool->allocate_node()));
+      else
+         return pointer(static_cast<value_type*>
+            (pool->get_segment_manager()->allocate(sizeof(T)*count)));
+   }
+
+   //!Deallocate allocated memory. Never throws
+   void deallocate(const pointer &ptr, size_type count)
+   {
+      (void)count;
+      typedef typename node_pool<0>::type node_pool_t;
+      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
+      if(Version == 1 && count == 1)
+         pool->deallocate_node(ipcdetail::to_raw_pointer(ptr));
+      else
+         pool->get_segment_manager()->deallocate((void*)ipcdetail::to_raw_pointer(ptr));
+   }
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one()
+   {
+      typedef typename node_pool<0>::type node_pool_t;
+      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
+      return pointer(static_cast<value_type*>(pool->allocate_node()));
+   }
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements)
+   {
+      typedef typename node_pool<0>::type node_pool_t;
+      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
+      return multiallocation_chain(pool->allocate_nodes(num_elements));
+   }
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p)
+   {
+      typedef typename node_pool<0>::type node_pool_t;
+      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
+      pool->deallocate_node(ipcdetail::to_raw_pointer(p));
+   }
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain)
+   {
+      node_pool<0>::get(this->derived()->get_node_pool())->deallocate_nodes
+         (chain.extract_multiallocation_chain());
+   }
+
+   //!Deallocates all free blocks of the pool
+   void deallocate_free_blocks()
+   {  node_pool<0>::get(this->derived()->get_node_pool())->deallocate_free_blocks();  }
+
+   //!Deprecated, use deallocate_free_blocks.
+   //!Deallocates all free chunks of the pool.
+   void deallocate_free_chunks()
+   {  node_pool<0>::get(this->derived()->get_node_pool())->deallocate_free_blocks();  }
+};
+
+template<class T, class NodePool, unsigned int Version>
+class cached_allocator_impl
+   :  public array_allocation_impl
+         <cached_allocator_impl<T, NodePool, Version>, T, typename NodePool::segment_manager>
+{
+   cached_allocator_impl & operator=(const cached_allocator_impl& other);
+   typedef array_allocation_impl
+         < cached_allocator_impl
+            <T, NodePool, Version>
+         , T
+         , typename NodePool::segment_manager> base_t;
+
+   public:
+   typedef NodePool                                      node_pool_t;
+   typedef typename NodePool::segment_manager            segment_manager;
+   typedef typename segment_manager::void_pointer        void_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const void>::type                cvoid_pointer;
+   typedef typename base_t::pointer                      pointer;
+   typedef typename base_t::size_type                    size_type;
+   typedef typename base_t::multiallocation_chain        multiallocation_chain;
+   typedef typename base_t::value_type                   value_type;
+
+   public:
+   static const std::size_t DEFAULT_MAX_CACHED_NODES = 64;
+
+   cached_allocator_impl(segment_manager *segment_mngr, size_type max_cached_nodes)
+      : m_cache(segment_mngr, max_cached_nodes)
+   {}
+
+   cached_allocator_impl(const cached_allocator_impl &other)
+      : m_cache(other.m_cache)
+   {}
+
+   //!Copy constructor from related cached_adaptive_pool_base. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2, class NodePool2>
+   cached_allocator_impl
+      (const cached_allocator_impl
+         <T2, NodePool2, Version> &other)
+      : m_cache(other.get_segment_manager(), other.get_max_cached_nodes())
+   {}
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   node_pool_t* get_node_pool() const
+   {  return m_cache.get_node_pool();   }
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const
+   {  return m_cache.get_segment_manager();   }
+
+   //!Sets the new max cached nodes value. This can provoke deallocations
+   //!if "newmax" is less than current cached nodes. Never throws
+   void set_max_cached_nodes(size_type newmax)
+   {  m_cache.set_max_cached_nodes(newmax);   }
+
+   //!Returns the max cached nodes parameter.
+   //!Never throws
+   size_type get_max_cached_nodes() const
+   {  return m_cache.get_max_cached_nodes();   }
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0)
+   {
+      (void)hint;
+      void * ret;
+      if(count > this->max_size())
+         throw bad_alloc();
+      else if(Version == 1 && count == 1){
+         ret = m_cache.cached_allocation();
+      }
+      else{
+         ret = this->get_segment_manager()->allocate(sizeof(T)*count);
+      }   
+      return pointer(static_cast<T*>(ret));
+   }
+
+   //!Deallocate allocated memory. Never throws
+   void deallocate(const pointer &ptr, size_type count)
+   {
+      (void)count;
+      if(Version == 1 && count == 1){
+         m_cache.cached_deallocation(ipcdetail::to_raw_pointer(ptr));
+      }
+      else{
+         this->get_segment_manager()->deallocate((void*)ipcdetail::to_raw_pointer(ptr));
+      }
+   }
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one()
+   {  return pointer(static_cast<value_type*>(this->m_cache.cached_allocation()));   }
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements)
+   {  return multiallocation_chain(this->m_cache.cached_allocation(num_elements));   }
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p)
+   {  this->m_cache.cached_deallocation(ipcdetail::to_raw_pointer(p)); }
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain)
+   {
+      typename node_pool_t::multiallocation_chain mem
+         (chain.extract_multiallocation_chain());
+      m_cache.cached_deallocation(boost::move(mem));
+   }
+
+   //!Deallocates all free blocks of the pool
+   void deallocate_free_blocks()
+   {  m_cache.get_node_pool()->deallocate_free_blocks();   }
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different shared memory segments, the result is undefined.
+   friend void swap(cached_allocator_impl &alloc1, cached_allocator_impl &alloc2)
+   {  alloc1.m_cache.swap(alloc2.m_cache);   }
+
+   void deallocate_cache()
+   {  m_cache.deallocate_all_cached_nodes(); }
+
+   //!Deprecated use deallocate_free_blocks.
+   void deallocate_free_chunks()
+   {  m_cache.get_node_pool()->deallocate_free_blocks();   }
+
+   /// @cond
+   private:
+   cache_impl<node_pool_t> m_cache;
+};
+
+//!Equality test for same type of
+//!cached_allocator_impl
+template<class T, class N, unsigned int V> inline
+bool operator==(const cached_allocator_impl<T, N, V> &alloc1, 
+                const cached_allocator_impl<T, N, V> &alloc2)
+   {  return alloc1.get_node_pool() == alloc2.get_node_pool(); }
+
+//!Inequality test for same type of
+//!cached_allocator_impl
+template<class T, class N, unsigned int V> inline
+bool operator!=(const cached_allocator_impl<T, N, V> &alloc1, 
+                const cached_allocator_impl<T, N, V> &alloc2)
+   {  return alloc1.get_node_pool() != alloc2.get_node_pool(); }
+
+
+//!Pooled shared memory allocator using adaptive pool. Includes
+//!a reference count but the class does not delete itself, this is  
+//!responsibility of user classes. Node size (NodeSize) and the number of
+//!nodes allocated per block (NodesPerBlock) are known at compile time
+template<class private_node_allocator_t>
+class shared_pool_impl
+   : public private_node_allocator_t
+{
+ public:
+   //!Segment manager typedef
+   typedef typename private_node_allocator_t::
+      segment_manager                           segment_manager;
+   typedef typename private_node_allocator_t::
+      multiallocation_chain                     multiallocation_chain;
+   typedef typename private_node_allocator_t::
+     size_type                                 size_type;
+
+ private:
+   typedef typename segment_manager::mutex_family::mutex_type mutex_type;
+
+ public:
+   //!Constructor from a segment manager. Never throws
+   shared_pool_impl(segment_manager *segment_mngr)
+      : private_node_allocator_t(segment_mngr)
+   {}
+
+   //!Destructor. Deallocates all allocated blocks. Never throws
+   ~shared_pool_impl()
+   {}
+
+   //!Allocates array of count elements. Can throw boost::interprocess::bad_alloc
+   void *allocate_node()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      return private_node_allocator_t::allocate_node();
+   }
+   
+   //!Deallocates an array pointed by ptr. Never throws
+   void deallocate_node(void *ptr)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::deallocate_node(ptr);
+   }
+/*
+   //!Allocates a singly linked list of n nodes ending in null pointer.
+   //!can throw boost::interprocess::bad_alloc
+   void allocate_nodes(multiallocation_chain &nodes, size_type n)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      return private_node_allocator_t::allocate_nodes(nodes, n);
+   }
+*/
+   //!Allocates n nodes. 
+   //!Can throw boost::interprocess::bad_alloc
+   multiallocation_chain allocate_nodes(const size_type n)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      return private_node_allocator_t::allocate_nodes(n);
+   }
+
+   //!Deallocates a linked list of nodes ending in null pointer. Never throws
+   void deallocate_nodes(multiallocation_chain &nodes, size_type num)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::deallocate_nodes(nodes, num);
+   }
+
+   //!Deallocates the nodes pointed by the multiallocation iterator. Never throws
+   void deallocate_nodes(multiallocation_chain chain)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::deallocate_nodes(boost::move(chain));
+   }
+
+   //!Deallocates all the free blocks of memory. Never throws
+   void deallocate_free_blocks()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::deallocate_free_blocks();
+   }
+
+   //!Deallocates all used memory from the common pool.
+   //!Precondition: all nodes allocated from this pool should
+   //!already be deallocated. Otherwise, undefined behavior. Never throws
+   void purge_blocks()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::purge_blocks();
+   }
+
+   //!Increments internal reference count and returns new count. Never throws
+   size_type inc_ref_count()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      return ++m_header.m_usecount;
+   }
+
+   //!Decrements internal reference count and returns new count. Never throws
+   size_type dec_ref_count()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      BOOST_ASSERT(m_header.m_usecount > 0);
+      return --m_header.m_usecount;
+   }
+
+   //!Deprecated, use deallocate_free_blocks.
+   void deallocate_free_chunks()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::deallocate_free_blocks();
+   }
+
+   //!Deprecated, use purge_blocks.
+   void purge_chunks()
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      private_node_allocator_t::purge_blocks();
+   }
+
+   private:
+   //!This struct includes needed data and derives from
+   //!the mutex type to allow EBO when using null_mutex
+   struct header_t : mutex_type
+   {
+      size_type m_usecount;    //Number of attached allocators
+
+      header_t()
+      :  m_usecount(0) {}
+   } m_header;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_ALLOCATOR_DETAIL_ALLOCATOR_COMMON_HPP
diff --git a/boost/interprocess/allocators/detail/node_pool.hpp b/boost/interprocess/allocators/detail/node_pool.hpp
new file mode 100644
index 0000000000..7327ff92d5
--- /dev/null
+++ b/boost/interprocess/allocators/detail/node_pool.hpp
@@ -0,0 +1,109 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_NODE_POOL_HPP
+#define BOOST_INTERPROCESS_DETAIL_NODE_POOL_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/slist.hpp>
+#include <boost/math/common_factor_ct.hpp>
+
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <boost/container/detail/node_pool_impl.hpp>
+#include <cstddef>
+
+
+//!\file
+//!Describes the real adaptive pool shared by many Interprocess adaptive pool allocators
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+
+
+//!Pooled shared memory allocator using single segregated storage. Includes
+//!a reference count but the class does not delete itself, this is  
+//!responsibility of user classes. Node size (NodeSize) and the number of
+//!nodes allocated per block (NodesPerBlock) are known at compile time
+template< class SegmentManager, std::size_t NodeSize, std::size_t NodesPerBlock >
+class private_node_pool
+   //Inherit from the implementation to avoid template bloat
+   :  public boost::container::container_detail::
+         private_node_pool_impl<typename SegmentManager::segment_manager_base_type>
+{
+   typedef boost::container::container_detail::private_node_pool_impl
+      <typename SegmentManager::segment_manager_base_type> base_t;
+   //Non-copyable
+   private_node_pool();
+   private_node_pool(const private_node_pool &);
+   private_node_pool &operator=(const private_node_pool &);
+
+   public:
+   typedef SegmentManager              segment_manager;
+   typedef typename base_t::size_type  size_type;
+
+   static const size_type nodes_per_block = NodesPerBlock;
+   //Deprecated, use nodes_per_block
+   static const size_type nodes_per_chunk = NodesPerBlock;
+
+   //!Constructor from a segment manager. Never throws
+   private_node_pool(segment_manager *segment_mngr)
+      :  base_t(segment_mngr, NodeSize, NodesPerBlock)
+   {}
+
+   //!Returns the segment manager. Never throws
+   segment_manager* get_segment_manager() const
+   {  return static_cast<segment_manager*>(base_t::get_segment_manager_base()); }
+};
+
+
+//!Pooled shared memory allocator using single segregated storage. Includes
+//!a reference count but the class does not delete itself, this is  
+//!responsibility of user classes. Node size (NodeSize) and the number of
+//!nodes allocated per block (NodesPerBlock) are known at compile time
+//!Pooled shared memory allocator using adaptive pool. Includes
+//!a reference count but the class does not delete itself, this is  
+//!responsibility of user classes. Node size (NodeSize) and the number of
+//!nodes allocated per block (NodesPerBlock) are known at compile time
+template< class SegmentManager
+        , std::size_t NodeSize
+        , std::size_t NodesPerBlock
+        >
+class shared_node_pool 
+   :  public ipcdetail::shared_pool_impl
+      < private_node_pool
+         <SegmentManager, NodeSize, NodesPerBlock>
+      >
+{
+   typedef ipcdetail::shared_pool_impl
+      < private_node_pool
+         <SegmentManager, NodeSize, NodesPerBlock>
+      > base_t;
+   public:
+   shared_node_pool(SegmentManager *segment_mgnr)
+      : base_t(segment_mgnr)
+   {}
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_NODE_POOL_HPP
diff --git a/boost/interprocess/allocators/detail/node_tools.hpp b/boost/interprocess/allocators/detail/node_tools.hpp
new file mode 100644
index 0000000000..da7e4668e8
--- /dev/null
+++ b/boost/interprocess/allocators/detail/node_tools.hpp
@@ -0,0 +1,50 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2011. 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_DETAIL_NODE_TOOLS_HPP
+#define BOOST_INTERPROCESS_DETAIL_NODE_TOOLS_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/slist.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+
+template<class VoidPointer>
+struct node_slist
+{
+   //This hook will be used to chain the individual nodes
+    typedef typename bi::make_slist_base_hook
+      <bi::void_pointer<VoidPointer>, bi::link_mode<bi::normal_link> >::type slist_hook_t;
+
+   //A node object will hold node_t when it's not allocated
+   struct node_t
+      :  public slist_hook_t
+   {};
+
+   typedef typename bi::make_slist
+      <node_t, bi::linear<true>, bi::base_hook<slist_hook_t> >::type node_slist_t;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_NODE_TOOLS_HPP
diff --git a/boost/interprocess/allocators/node_allocator.hpp b/boost/interprocess/allocators/node_allocator.hpp
new file mode 100644
index 0000000000..f1c3259d73
--- /dev/null
+++ b/boost/interprocess/allocators/node_allocator.hpp
@@ -0,0 +1,452 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NODE_ALLOCATOR_HPP
+#define BOOST_INTERPROCESS_NODE_ALLOCATOR_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/interprocess/interprocess_fwd.hpp>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/allocators/detail/node_pool.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/allocators/detail/allocator_common.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+
+//!\file
+//!Describes node_allocator pooled shared memory STL compatible allocator 
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+namespace ipcdetail{
+
+template < unsigned int Version
+         , class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         >
+class node_allocator_base
+   : public node_pool_allocation_impl
+   < node_allocator_base
+      < Version, T, SegmentManager, NodesPerBlock>
+   , Version
+   , T
+   , SegmentManager
+   >
+{
+   public:
+   typedef typename SegmentManager::void_pointer         void_pointer;
+   typedef SegmentManager                                segment_manager;
+   typedef node_allocator_base
+      <Version, T, SegmentManager, NodesPerBlock>   self_t;
+
+   /// @cond
+
+   template <int dummy>
+   struct node_pool
+   {
+      typedef ipcdetail::shared_node_pool
+      < SegmentManager, sizeof_value<T>::value, NodesPerBlock> type;
+
+      static type *get(void *p)
+      {  return static_cast<type*>(p);  }
+   };
+   /// @endcond
+
+   BOOST_STATIC_ASSERT((Version <=2));
+
+   public:
+   //-------
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const T>::type                   const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+
+   typedef boost::interprocess::version_type<node_allocator_base, Version>   version;
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+
+   //!Obtains node_allocator_base from 
+   //!node_allocator_base
+   template<class T2>
+   struct rebind
+   {  
+      typedef node_allocator_base<Version, T2, SegmentManager, NodesPerBlock>       other;
+   };
+
+   /// @cond
+   private:
+   //!Not assignable from related node_allocator_base
+   template<unsigned int Version2, class T2, class SegmentManager2, std::size_t N2>
+   node_allocator_base& operator=
+      (const node_allocator_base<Version2, T2, SegmentManager2, N2>&);
+
+   //!Not assignable from other node_allocator_base
+   //node_allocator_base& operator=(const node_allocator_base&);
+   /// @endcond
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   node_allocator_base(segment_manager *segment_mngr) 
+      : mp_node_pool(ipcdetail::get_or_create_node_pool<typename node_pool<0>::type>(segment_mngr)) { }
+
+   //!Copy constructor from other node_allocator_base. Increments the reference 
+   //!count of the associated node pool. Never throws
+   node_allocator_base(const node_allocator_base &other) 
+      : mp_node_pool(other.get_node_pool()) 
+   {  
+      node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool))->inc_ref_count();   
+   }
+
+   //!Copy constructor from related node_allocator_base. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   node_allocator_base
+      (const node_allocator_base<Version, T2, SegmentManager, NodesPerBlock> &other)
+      : mp_node_pool(ipcdetail::get_or_create_node_pool<typename node_pool<0>::type>(other.get_segment_manager())) { }
+
+   //!Assignment from other node_allocator_base
+   node_allocator_base& operator=(const node_allocator_base &other)
+   {
+      node_allocator_base c(other);
+      swap(*this, c);
+      return *this;
+   }
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~node_allocator_base() 
+   {  ipcdetail::destroy_node_pool_if_last_link(node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool)));   }
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   void* get_node_pool() const
+   {  return ipcdetail::to_raw_pointer(mp_node_pool);   }
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const
+   {  return node_pool<0>::get(ipcdetail::to_raw_pointer(mp_node_pool))->get_segment_manager();  }
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2)
+   {  ipcdetail::do_swap(alloc1.mp_node_pool, alloc2.mp_node_pool);  }
+
+   /// @cond
+   private:
+   void_pointer   mp_node_pool;
+   /// @endcond
+};
+
+//!Equality test for same type
+//!of node_allocator_base
+template<unsigned int V, class T, class S, std::size_t NPC> inline
+bool operator==(const node_allocator_base<V, T, S, NPC> &alloc1, 
+                const node_allocator_base<V, T, S, NPC> &alloc2)
+   {  return alloc1.get_node_pool() == alloc2.get_node_pool(); }
+
+//!Inequality test for same type
+//!of node_allocator_base
+template<unsigned int V, class T, class S, std::size_t NPC> inline
+bool operator!=(const node_allocator_base<V, T, S, NPC> &alloc1, 
+                const node_allocator_base<V, T, S, NPC> &alloc2)
+   {  return alloc1.get_node_pool() != alloc2.get_node_pool(); }
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock = 64
+         >
+class node_allocator_v1
+   :  public node_allocator_base
+         < 1
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         >
+{
+   public:
+   typedef ipcdetail::node_allocator_base
+         < 1, T, SegmentManager, NodesPerBlock> base_t;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef node_allocator_v1<T2, SegmentManager, NodesPerBlock>  other;
+   };
+
+   node_allocator_v1(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   node_allocator_v1
+      (const node_allocator_v1<T2, SegmentManager, NodesPerBlock> &other)
+      : base_t(other)
+   {}
+};
+
+}  //namespace ipcdetail{
+
+/// @endcond
+
+//!An STL node allocator that uses a segment manager as memory 
+//!source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the allocator in shared memory, memory mapped-files, etc...
+//!This node allocator shares a segregated storage between all instances 
+//!of node_allocator with equal sizeof(T) placed in the same segment 
+//!group. NodesPerBlock is the number of nodes allocated at once when the allocator
+//!needs runs out of nodes
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         >
+class node_allocator
+   /// @cond
+   :  public ipcdetail::node_allocator_base
+         < 2
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         >
+   /// @endcond
+{
+
+   #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   typedef ipcdetail::node_allocator_base
+         < 2, T, SegmentManager, NodesPerBlock> base_t;
+   public:
+   typedef boost::interprocess::version_type<node_allocator, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef node_allocator<T2, SegmentManager, NodesPerBlock>  other;
+   };
+
+   node_allocator(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   node_allocator
+      (const node_allocator<T2, SegmentManager, NodesPerBlock> &other)
+      : base_t(other)
+   {}
+
+   #else //BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   public:
+   typedef implementation_defined::segment_manager       segment_manager;
+   typedef segment_manager::void_pointer                 void_pointer;
+   typedef implementation_defined::pointer               pointer;
+   typedef implementation_defined::const_pointer         const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+
+   //!Obtains node_allocator from 
+   //!node_allocator
+   template<class T2>
+   struct rebind
+   {  
+      typedef node_allocator<T2, SegmentManager, NodesPerBlock> other;
+   };
+
+   private:
+   //!Not assignable from
+   //!related node_allocator
+   template<class T2, class SegmentManager2, std::size_t N2>
+   node_allocator& operator=
+      (const node_allocator<T2, SegmentManager2, N2>&);
+
+   //!Not assignable from 
+   //!other node_allocator
+   //node_allocator& operator=(const node_allocator&);
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   node_allocator(segment_manager *segment_mngr);
+
+   //!Copy constructor from other node_allocator. Increments the reference 
+   //!count of the associated node pool. Never throws
+   node_allocator(const node_allocator &other);
+
+   //!Copy constructor from related node_allocator. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   node_allocator
+      (const node_allocator<T2, SegmentManager, NodesPerBlock> &other);
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~node_allocator();
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   void* get_node_pool() const;
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const;
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const;
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0);
+
+   //!Deallocate allocated memory.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type count);
+
+   //!Deallocates all free blocks
+   //!of the pool
+   void deallocate_free_blocks();
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2);
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const;
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const;
+
+   //!Copy construct an object. 
+   //!Throws if T's copy constructor throws
+   void construct(const pointer &ptr, const_reference v);
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr);
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const;
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain);
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one();
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements);
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p);
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain);
+   #endif
+};
+
+#ifdef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//!Equality test for same type
+//!of node_allocator
+template<class T, class S, std::size_t NPC> inline
+bool operator==(const node_allocator<T, S, NPC> &alloc1, 
+                const node_allocator<T, S, NPC> &alloc2);
+
+//!Inequality test for same type
+//!of node_allocator
+template<class T, class S, std::size_t NPC> inline
+bool operator!=(const node_allocator<T, S, NPC> &alloc1, 
+                const node_allocator<T, S, NPC> &alloc2);
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_NODE_ALLOCATOR_HPP
diff --git a/boost/interprocess/allocators/private_adaptive_pool.hpp b/boost/interprocess/allocators/private_adaptive_pool.hpp
new file mode 100644
index 0000000000..301fb92daa
--- /dev/null
+++ b/boost/interprocess/allocators/private_adaptive_pool.hpp
@@ -0,0 +1,468 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_PRIVATE_ADAPTIVE_POOL_HPP
+#define BOOST_INTERPROCESS_PRIVATE_ADAPTIVE_POOL_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/interprocess/interprocess_fwd.hpp>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/interprocess/allocators/detail/adaptive_node_pool.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+
+//!\file
+//!Describes private_adaptive_pool_base pooled shared memory STL compatible allocator 
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+namespace ipcdetail {
+
+template < unsigned int Version
+         , class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         , std::size_t MaxFreeBlocks
+         , unsigned char OverheadPercent
+         >
+class private_adaptive_pool_base
+   : public node_pool_allocation_impl
+   < private_adaptive_pool_base < Version, T, SegmentManager, NodesPerBlock
+                                , MaxFreeBlocks, OverheadPercent>
+   , Version
+   , T
+   , SegmentManager
+   >
+{
+   public:
+   //Segment manager
+   typedef SegmentManager                                segment_manager;
+   typedef typename SegmentManager::void_pointer         void_pointer;
+
+   /// @cond
+   private:
+   typedef private_adaptive_pool_base
+      < Version, T, SegmentManager, NodesPerBlock
+      , MaxFreeBlocks, OverheadPercent>                  self_t;
+   typedef ipcdetail::private_adaptive_node_pool
+      <SegmentManager
+      , sizeof_value<T>::value
+      , NodesPerBlock
+      , MaxFreeBlocks
+      , OverheadPercent
+      > node_pool_t;
+
+   BOOST_STATIC_ASSERT((Version <=2));
+
+   /// @endcond
+
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const T>::type                   const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::size_type           difference_type;
+   typedef boost::interprocess::version_type
+      <private_adaptive_pool_base, Version>              version;
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+
+   //!Obtains node_allocator from other node_allocator
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_adaptive_pool_base
+         <Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>   other;
+   };
+
+   /// @cond
+
+   template <int dummy>
+   struct node_pool
+   {
+      typedef ipcdetail::private_adaptive_node_pool
+      <SegmentManager
+      , sizeof_value<T>::value
+      , NodesPerBlock
+      , MaxFreeBlocks
+      , OverheadPercent
+      > type;
+
+      static type *get(void *p)
+      {  return static_cast<type*>(p);  }
+   };
+
+   private:
+   //!Not assignable from related private_adaptive_pool_base
+   template<unsigned int Version2, class T2, class MemoryAlgorithm2, std::size_t N2, std::size_t F2, unsigned char OP2>
+   private_adaptive_pool_base& operator=
+      (const private_adaptive_pool_base<Version2, T2, MemoryAlgorithm2, N2, F2, OP2>&);
+
+   //!Not assignable from other private_adaptive_pool_base
+   private_adaptive_pool_base& operator=(const private_adaptive_pool_base&);
+   /// @endcond
+
+   public:
+   //!Constructor from a segment manager
+   private_adaptive_pool_base(segment_manager *segment_mngr)
+      : m_node_pool(segment_mngr)
+   {}
+
+   //!Copy constructor from other private_adaptive_pool_base. Never throws
+   private_adaptive_pool_base(const private_adaptive_pool_base &other)
+      : m_node_pool(other.get_segment_manager())
+   {}
+
+   //!Copy constructor from related private_adaptive_pool_base. Never throws.
+   template<class T2>
+   private_adaptive_pool_base
+      (const private_adaptive_pool_base
+         <Version, T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : m_node_pool(other.get_segment_manager())
+   {}
+
+   //!Destructor, frees all used memory. Never throws
+   ~private_adaptive_pool_base() 
+   {}
+
+   //!Returns the segment manager. Never throws
+   segment_manager* get_segment_manager()const
+   {  return m_node_pool.get_segment_manager(); }
+
+   //!Returns the internal node pool. Never throws
+   node_pool_t* get_node_pool() const
+   {  return const_cast<node_pool_t*>(&m_node_pool); }
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different shared memory segments, the result is undefined.
+   friend void swap(self_t &alloc1,self_t &alloc2)
+   {  alloc1.m_node_pool.swap(alloc2.m_node_pool);  }
+
+   /// @cond
+   private:
+   node_pool_t m_node_pool;
+   /// @endcond
+};
+
+//!Equality test for same type of private_adaptive_pool_base
+template<unsigned int V, class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator==(const private_adaptive_pool_base<V, T, S, NodesPerBlock, F, OP> &alloc1, 
+                const private_adaptive_pool_base<V, T, S, NodesPerBlock, F, OP> &alloc2)
+{  return &alloc1 == &alloc2; }
+
+//!Inequality test for same type of private_adaptive_pool_base
+template<unsigned int V, class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator!=(const private_adaptive_pool_base<V, T, S, NodesPerBlock, F, OP> &alloc1, 
+                const private_adaptive_pool_base<V, T, S, NodesPerBlock, F, OP> &alloc2)
+{  return &alloc1 != &alloc2; }
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock = 64
+         , std::size_t MaxFreeBlocks = 2
+         , unsigned char OverheadPercent = 5
+         >
+class private_adaptive_pool_v1
+   :  public private_adaptive_pool_base
+         < 1
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         , MaxFreeBlocks
+         , OverheadPercent
+         >
+{
+   public:
+   typedef ipcdetail::private_adaptive_pool_base
+         < 1, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> base_t;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_adaptive_pool_v1<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>  other;
+   };
+
+   private_adaptive_pool_v1(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   private_adaptive_pool_v1
+      (const private_adaptive_pool_v1<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : base_t(other)
+   {}
+};
+
+}  //namespace ipcdetail {
+
+/// @endcond
+
+//!An STL node allocator that uses a segment manager as memory 
+//!source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the allocator in shared memory, memory mapped-files, etc...
+//!This allocator has its own node pool.
+//!
+//!NodesPerBlock is the minimum number of nodes of nodes allocated at once when
+//!the allocator needs runs out of nodes. MaxFreeBlocks is the maximum number of totally free blocks
+//!that the adaptive node pool will hold. The rest of the totally free blocks will be
+//!deallocated with the segment manager.
+//!
+//!OverheadPercent is the (approximated) maximum size overhead (1-20%) of the allocator:
+//!(memory usable for nodes / total memory allocated from the segment manager)
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         , std::size_t MaxFreeBlocks
+         , unsigned char OverheadPercent
+         >
+class private_adaptive_pool
+   /// @cond
+   :  public ipcdetail::private_adaptive_pool_base
+         < 2
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         , MaxFreeBlocks
+         , OverheadPercent
+         >
+   /// @endcond
+{
+
+   #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   typedef ipcdetail::private_adaptive_pool_base
+         < 2, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> base_t;
+   public:
+   typedef boost::interprocess::version_type<private_adaptive_pool, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_adaptive_pool
+         <T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent>  other;
+   };
+
+   private_adaptive_pool(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   private_adaptive_pool
+      (const private_adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
+      : base_t(other)
+   {}
+
+   #else
+   public:
+   typedef implementation_defined::segment_manager       segment_manager;
+   typedef segment_manager::void_pointer                 void_pointer;
+   typedef implementation_defined::pointer               pointer;
+   typedef implementation_defined::const_pointer         const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+
+   //!Obtains private_adaptive_pool from 
+   //!private_adaptive_pool
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_adaptive_pool
+         <T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> other;
+   };
+
+   private:
+   //!Not assignable from
+   //!related private_adaptive_pool
+   template<class T2, class SegmentManager2, std::size_t N2, std::size_t F2, unsigned char OP2>
+   private_adaptive_pool& operator=
+      (const private_adaptive_pool<T2, SegmentManager2, N2, F2>&);
+
+   //!Not assignable from 
+   //!other private_adaptive_pool
+   private_adaptive_pool& operator=(const private_adaptive_pool&);
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   private_adaptive_pool(segment_manager *segment_mngr);
+
+   //!Copy constructor from other private_adaptive_pool. Increments the reference 
+   //!count of the associated node pool. Never throws
+   private_adaptive_pool(const private_adaptive_pool &other);
+
+   //!Copy constructor from related private_adaptive_pool. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   private_adaptive_pool
+      (const private_adaptive_pool<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other);
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~private_adaptive_pool();
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   node_pool_t* get_node_pool() const;
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const;
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const;
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0);
+
+   //!Deallocate allocated memory.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type count);
+
+   //!Deallocates all free blocks
+   //!of the pool
+   void deallocate_free_blocks();
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2);
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const;
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const;
+
+   //!Copy construct an object. 
+   //!Throws if T's copy constructor throws
+   void construct(const pointer &ptr, const_reference v);
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr);
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const;
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain);
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one();
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements);
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p);
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain);
+   #endif
+};
+
+#ifdef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//!Equality test for same type
+//!of private_adaptive_pool
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator==(const private_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const private_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc2);
+
+//!Inequality test for same type
+//!of private_adaptive_pool
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator!=(const private_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const private_adaptive_pool<T, S, NodesPerBlock, F, OP> &alloc2);
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_PRIVATE_ADAPTIVE_POOL_HPP
+
diff --git a/boost/interprocess/allocators/private_node_allocator.hpp b/boost/interprocess/allocators/private_node_allocator.hpp
new file mode 100644
index 0000000000..f202e316fa
--- /dev/null
+++ b/boost/interprocess/allocators/private_node_allocator.hpp
@@ -0,0 +1,445 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_PRIVATE_NODE_ALLOCATOR_HPP
+#define BOOST_INTERPROCESS_PRIVATE_NODE_ALLOCATOR_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/interprocess/interprocess_fwd.hpp>
+#include <boost/assert.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/interprocess/allocators/detail/node_pool.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+
+//!\file
+//!Describes private_node_allocator_base pooled shared memory STL compatible allocator 
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+namespace ipcdetail {
+
+template < unsigned int Version
+         , class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         >
+class private_node_allocator_base
+   : public node_pool_allocation_impl
+   < private_node_allocator_base < Version, T, SegmentManager, NodesPerBlock>
+   , Version
+   , T
+   , SegmentManager
+   >
+{
+   public:
+   //Segment manager
+   typedef SegmentManager                                segment_manager;
+   typedef typename SegmentManager::void_pointer         void_pointer;
+
+   /// @cond
+   private:
+   typedef private_node_allocator_base
+      < Version, T, SegmentManager, NodesPerBlock>       self_t;
+   typedef ipcdetail::private_node_pool
+      <SegmentManager
+      , sizeof_value<T>::value
+      , NodesPerBlock
+      > node_pool_t;
+
+   BOOST_STATIC_ASSERT((Version <=2));
+
+   /// @endcond
+
+   public:
+
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<const T>::type                   const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manager::difference_type     difference_type;
+   typedef boost::interprocess::version_type
+      <private_node_allocator_base, Version>              version;
+   typedef boost::container::container_detail::transform_multiallocation_chain
+      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;
+
+   //!Obtains node_allocator from other node_allocator
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_node_allocator_base
+         <Version, T2, SegmentManager, NodesPerBlock>   other;
+   };
+
+   /// @cond
+   template <int dummy>
+   struct node_pool
+   {
+      typedef ipcdetail::private_node_pool
+      <SegmentManager
+      , sizeof_value<T>::value
+      , NodesPerBlock
+      > type;
+
+      static type *get(void *p)
+      {  return static_cast<type*>(p);  }
+   };
+
+   private:
+   //!Not assignable from related private_node_allocator_base
+   template<unsigned int Version2, class T2, class MemoryAlgorithm2, std::size_t N2>
+   private_node_allocator_base& operator=
+      (const private_node_allocator_base<Version2, T2, MemoryAlgorithm2, N2>&);
+
+   //!Not assignable from other private_node_allocator_base
+   private_node_allocator_base& operator=(const private_node_allocator_base&);
+   /// @endcond
+
+   public:
+   //!Constructor from a segment manager
+   private_node_allocator_base(segment_manager *segment_mngr)
+      : m_node_pool(segment_mngr)
+   {}
+
+   //!Copy constructor from other private_node_allocator_base. Never throws
+   private_node_allocator_base(const private_node_allocator_base &other)
+      : m_node_pool(other.get_segment_manager())
+   {}
+
+   //!Copy constructor from related private_node_allocator_base. Never throws.
+   template<class T2>
+   private_node_allocator_base
+      (const private_node_allocator_base
+         <Version, T2, SegmentManager, NodesPerBlock> &other)
+      : m_node_pool(other.get_segment_manager())
+   {}
+
+   //!Destructor, frees all used memory. Never throws
+   ~private_node_allocator_base() 
+   {}
+
+   //!Returns the segment manager. Never throws
+   segment_manager* get_segment_manager()const
+   {  return m_node_pool.get_segment_manager(); }
+
+   //!Returns the internal node pool. Never throws
+   node_pool_t* get_node_pool() const
+   {  return const_cast<node_pool_t*>(&m_node_pool); }
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different shared memory segments, the result is undefined.
+   friend void swap(self_t &alloc1,self_t &alloc2)
+   {  alloc1.m_node_pool.swap(alloc2.m_node_pool);  }
+
+   /// @cond
+   private:
+   node_pool_t m_node_pool;
+   /// @endcond
+};
+
+//!Equality test for same type of private_node_allocator_base
+template<unsigned int V, class T, class S, std::size_t NPC> inline
+bool operator==(const private_node_allocator_base<V, T, S, NPC> &alloc1, 
+                const private_node_allocator_base<V, T, S, NPC> &alloc2)
+{  return &alloc1 == &alloc2; }
+
+//!Inequality test for same type of private_node_allocator_base
+template<unsigned int V, class T, class S, std::size_t NPC> inline
+bool operator!=(const private_node_allocator_base<V, T, S, NPC> &alloc1, 
+                const private_node_allocator_base<V, T, S, NPC> &alloc2)
+{  return &alloc1 != &alloc2; }
+
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock = 64
+         >
+class private_node_allocator_v1
+   :  public private_node_allocator_base
+         < 1
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         >
+{
+   public:
+   typedef ipcdetail::private_node_allocator_base
+         < 1, T, SegmentManager, NodesPerBlock> base_t;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_node_allocator_v1<T2, SegmentManager, NodesPerBlock>  other;
+   };
+
+   private_node_allocator_v1(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   private_node_allocator_v1
+      (const private_node_allocator_v1<T2, SegmentManager, NodesPerBlock> &other)
+      : base_t(other)
+   {}
+};
+
+}  //namespace ipcdetail {
+
+/// @endcond
+
+//!An STL node allocator that uses a segment manager as memory 
+//!source. The internal pointer type will of the same type (raw, smart) as
+//!"typename SegmentManager::void_pointer" type. This allows
+//!placing the allocator in shared memory, memory mapped-files, etc...
+//!This allocator has its own node pool. NodesPerBlock is the number of nodes allocated 
+//!at once when the allocator needs runs out of nodes
+template < class T
+         , class SegmentManager
+         , std::size_t NodesPerBlock
+         >
+class private_node_allocator
+   /// @cond
+   :  public ipcdetail::private_node_allocator_base
+         < 2
+         , T
+         , SegmentManager
+         , NodesPerBlock
+         >
+   /// @endcond
+{
+
+   #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+   typedef ipcdetail::private_node_allocator_base
+         < 2, T, SegmentManager, NodesPerBlock> base_t;
+   public:
+   typedef boost::interprocess::version_type<private_node_allocator, 2>   version;
+
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_node_allocator
+         <T2, SegmentManager, NodesPerBlock>  other;
+   };
+
+   private_node_allocator(SegmentManager *segment_mngr) 
+      : base_t(segment_mngr)
+   {}
+
+   template<class T2>
+   private_node_allocator
+      (const private_node_allocator<T2, SegmentManager, NodesPerBlock> &other)
+      : base_t(other)
+   {}
+
+   #else
+   public:
+   typedef implementation_defined::segment_manager       segment_manager;
+   typedef segment_manager::void_pointer                 void_pointer;
+   typedef implementation_defined::pointer               pointer;
+   typedef implementation_defined::const_pointer         const_pointer;
+   typedef T                                             value_type;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                  reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type            const_reference;
+   typedef typename segment_manager::size_type           size_type;
+   typedef typename segment_manage::difference_type      difference_type;
+
+   //!Obtains private_node_allocator from 
+   //!private_node_allocator
+   template<class T2>
+   struct rebind
+   {  
+      typedef private_node_allocator
+         <T2, SegmentManager, NodesPerBlock> other;
+   };
+
+   private:
+   //!Not assignable from
+   //!related private_node_allocator
+   template<class T2, class SegmentManager2, std::size_t N2>
+   private_node_allocator& operator=
+      (const private_node_allocator<T2, SegmentManager2, N2>&);
+
+   //!Not assignable from 
+   //!other private_node_allocator
+   private_node_allocator& operator=(const private_node_allocator&);
+
+   public:
+   //!Constructor from a segment manager. If not present, constructs a node
+   //!pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   private_node_allocator(segment_manager *segment_mngr);
+
+   //!Copy constructor from other private_node_allocator. Increments the reference 
+   //!count of the associated node pool. Never throws
+   private_node_allocator(const private_node_allocator &other);
+
+   //!Copy constructor from related private_node_allocator. If not present, constructs
+   //!a node pool. Increments the reference count of the associated node pool.
+   //!Can throw boost::interprocess::bad_alloc
+   template<class T2>
+   private_node_allocator
+      (const private_node_allocator<T2, SegmentManager, NodesPerBlock> &other);
+
+   //!Destructor, removes node_pool_t from memory
+   //!if its reference count reaches to zero. Never throws
+   ~private_node_allocator();
+
+   //!Returns a pointer to the node pool.
+   //!Never throws
+   node_pool_t* get_node_pool() const;
+
+   //!Returns the segment manager.
+   //!Never throws
+   segment_manager* get_segment_manager()const;
+
+   //!Returns the number of elements that could be allocated.
+   //!Never throws
+   size_type max_size() const;
+
+   //!Allocate memory for an array of count elements. 
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate(size_type count, cvoid_pointer hint = 0);
+
+   //!Deallocate allocated memory.
+   //!Never throws
+   void deallocate(const pointer &ptr, size_type count);
+
+   //!Deallocates all free blocks
+   //!of the pool
+   void deallocate_free_blocks();
+
+   //!Swaps allocators. Does not throw. If each allocator is placed in a
+   //!different memory segment, the result is undefined.
+   friend void swap(self_t &alloc1, self_t &alloc2);
+
+   //!Returns address of mutable object.
+   //!Never throws
+   pointer address(reference value) const;
+
+   //!Returns address of non mutable object.
+   //!Never throws
+   const_pointer address(const_reference value) const;
+
+   //!Copy construct an object. 
+   //!Throws if T's copy constructor throws
+   void construct(const pointer &ptr, const_reference v);
+
+   //!Destroys object. Throws if object's
+   //!destructor throws
+   void destroy(const pointer &ptr);
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold. This size only works for memory allocated with
+   //!allocate, allocation_command and allocate_many.
+   size_type size(const pointer &p) const;
+
+   std::pair<pointer, bool>
+      allocation_command(boost::interprocess::allocation_type command,
+                         size_type limit_size, 
+                         size_type preferred_size,
+                         size_type &received_size, const pointer &reuse = 0);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
+
+   //!Allocates n_elements elements, each one of size elem_sizes[i]in a
+   //!contiguous block
+   //!of memory. The elements must be deallocated
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements);
+
+   //!Allocates many elements of size elem_size in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. The elements must be deallocated
+   //!with deallocate(...)
+   void deallocate_many(multiallocation_chain chain);
+
+   //!Allocates just one object. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   //!Throws boost::interprocess::bad_alloc if there is no enough memory
+   pointer allocate_one();
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   multiallocation_chain allocate_individual(size_type num_elements);
+
+   //!Deallocates memory previously allocated with allocate_one().
+   //!You should never use deallocate_one to deallocate memory allocated
+   //!with other functions different from allocate_one(). Never throws
+   void deallocate_one(const pointer &p);
+
+   //!Allocates many elements of size == 1 in a contiguous block
+   //!of memory. The minimum number to be allocated is min_elements,
+   //!the preferred and maximum number is
+   //!preferred_elements. The number of actually allocated elements is
+   //!will be assigned to received_size. Memory allocated with this function
+   //!must be deallocated only with deallocate_one().
+   void deallocate_individual(multiallocation_chain chain);
+   #endif
+};
+
+#ifdef BOOST_INTERPROCESS_DOXYGEN_INVOKED
+
+//!Equality test for same type
+//!of private_node_allocator
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator==(const private_node_allocator<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const private_node_allocator<T, S, NodesPerBlock, F, OP> &alloc2);
+
+//!Inequality test for same type
+//!of private_node_allocator
+template<class T, class S, std::size_t NodesPerBlock, std::size_t F, unsigned char OP> inline
+bool operator!=(const private_node_allocator<T, S, NodesPerBlock, F, OP> &alloc1, 
+                const private_node_allocator<T, S, NodesPerBlock, F, OP> &alloc2);
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_PRIVATE_NODE_ALLOCATOR_HPP
+
diff --git a/boost/interprocess/anonymous_shared_memory.hpp b/boost/interprocess/anonymous_shared_memory.hpp
new file mode 100644
index 0000000000..7184306a6d
--- /dev/null
+++ b/boost/interprocess/anonymous_shared_memory.hpp
@@ -0,0 +1,119 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_ANONYMOUS_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_ANONYMOUS_SHARED_MEMORY_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/mapped_region.hpp>
+#include <cstddef>
+
+#if (!defined(BOOST_INTERPROCESS_WINDOWS))
+#  include <fcntl.h>        //open, O_CREAT, O_*... 
+#  include <sys/mman.h>     //mmap
+#  include <sys/stat.h>     //mode_t, S_IRWXG, S_IRWXO, S_IRWXU,
+#else
+#include <boost/interprocess/windows_shared_memory.hpp>
+#endif
+
+
+//!\file
+//!Describes a function that creates anonymous shared memory that can be
+//!shared between forked processes
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+namespace ipcdetail{
+
+   class raw_mapped_region_creator
+   {
+      public:
+      static mapped_region
+         create_posix_mapped_region(void *address, offset_t offset, std::size_t size)
+      {
+         mapped_region region;
+         region.m_base = address;
+         region.m_offset = offset;
+         region.m_extra_offset = 0;
+         region.m_size = size;
+         return region;
+      }
+   };
+}
+
+/// @endcond
+
+//!A function that creates an anonymous shared memory segment of size "size".
+//!If "address" is passed the function will try to map the segment in that address.
+//!Otherwise the operating system will choose the mapping address.
+//!The function returns a mapped_region holding that segment or throws
+//!interprocess_exception if the function fails.
+//static mapped_region
+static mapped_region
+anonymous_shared_memory(std::size_t size, void *address = 0)
+#if (!defined(BOOST_INTERPROCESS_WINDOWS))
+{
+   int flags;
+   int fd = -1;
+
+   #if defined(MAP_ANONYMOUS) //Use MAP_ANONYMOUS
+   flags = MAP_ANONYMOUS | MAP_SHARED;
+   #elif !defined(MAP_ANONYMOUS) && defined(MAP_ANON) //use MAP_ANON
+   flags = MAP_ANON | MAP_SHARED;
+   #else // Use "/dev/zero"
+   fd = open("/dev/zero", O_RDWR);
+   flags = MAP_SHARED;
+   if(fd == -1){
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+   #endif
+
+
+   address = mmap( address
+                  , size
+                  , PROT_READ|PROT_WRITE
+                  , flags
+                  , fd
+                  , 0);
+
+   if(address == MAP_FAILED){
+      if(fd != -1)   
+         close(fd);
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+
+   if(fd != -1)   
+      close(fd);
+
+   return ipcdetail::raw_mapped_region_creator::create_posix_mapped_region(address, 0, size);
+}
+#else
+{
+   windows_shared_memory anonymous_mapping(create_only, 0, read_write, size);
+   return mapped_region(anonymous_mapping, read_write, 0, size, address);
+}
+
+#endif
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_ANONYMOUS_SHARED_MEMORY_HPP
diff --git a/boost/interprocess/containers/allocation_type.hpp b/boost/interprocess/containers/allocation_type.hpp
new file mode 100644
index 0000000000..660b6cbdbc
--- /dev/null
+++ b/boost/interprocess/containers/allocation_type.hpp
@@ -0,0 +1,40 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_ALLOCATION_TYPE_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_ALLOCATION_TYPE_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+typedef int allocation_type;
+/// @endcond
+static const allocation_type allocate_new       = boost::container::allocate_new;
+static const allocation_type expand_fwd         = boost::container::expand_fwd;
+static const allocation_type expand_bwd         = boost::container::expand_bwd;
+static const allocation_type shrink_in_place    = boost::container::shrink_in_place;
+static const allocation_type try_shrink_in_place= boost::container::try_shrink_in_place;
+static const allocation_type nothrow_allocation = boost::container::nothrow_allocation;
+static const allocation_type zero_memory        = boost::container::zero_memory;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_VERSION_TYPE_HPP
diff --git a/boost/interprocess/containers/containers_fwd.hpp b/boost/interprocess/containers/containers_fwd.hpp
new file mode 100644
index 0000000000..7852bbc853
--- /dev/null
+++ b/boost/interprocess/containers/containers_fwd.hpp
@@ -0,0 +1,40 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009. 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_CONTAINERS_CONTAINERS_FWD_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_CONTAINERS_FWD_HPP
+
+/// @cond
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//                        Standard predeclarations
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/container_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::ordered_range;
+using boost::container::ordered_unique_range;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+/// @endcond
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_CONTAINERS_FWD_HPP
diff --git a/boost/interprocess/containers/deque.hpp b/boost/interprocess/containers/deque.hpp
new file mode 100644
index 0000000000..30ca43203f
--- /dev/null
+++ b/boost/interprocess/containers/deque.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_DEQUE_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_DEQUE_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/deque.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::deque;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_DEQUE_HPP
+
diff --git a/boost/interprocess/containers/flat_map.hpp b/boost/interprocess/containers/flat_map.hpp
new file mode 100644
index 0000000000..f18a006c79
--- /dev/null
+++ b/boost/interprocess/containers/flat_map.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_FLAT_MAP_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_FLAT_MAP_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/flat_map.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::flat_map;
+using boost::container::flat_multimap;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_FLAT_MAP_HPP
diff --git a/boost/interprocess/containers/flat_set.hpp b/boost/interprocess/containers/flat_set.hpp
new file mode 100644
index 0000000000..1b2bf9b4d3
--- /dev/null
+++ b/boost/interprocess/containers/flat_set.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_FLAT_SET_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_FLAT_SET_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/flat_set.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::flat_set;
+using boost::container::flat_multiset;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_FLAT_SET_HPP
diff --git a/boost/interprocess/containers/list.hpp b/boost/interprocess/containers/list.hpp
new file mode 100644
index 0000000000..a75b9759b3
--- /dev/null
+++ b/boost/interprocess/containers/list.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_LIST_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_LIST_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/list.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::list;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_LIST_HPP
+
diff --git a/boost/interprocess/containers/map.hpp b/boost/interprocess/containers/map.hpp
new file mode 100644
index 0000000000..2e45ec0630
--- /dev/null
+++ b/boost/interprocess/containers/map.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_MAP_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_MAP_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/map.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::map;
+using boost::container::multimap;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_MAP_HPP
diff --git a/boost/interprocess/containers/pair.hpp b/boost/interprocess/containers/pair.hpp
new file mode 100644
index 0000000000..8ba6d047ac
--- /dev/null
+++ b/boost/interprocess/containers/pair.hpp
@@ -0,0 +1,34 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_PAIR_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_PAIR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/detail/pair.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::container_detail::pair;
+using boost::container::container_detail::piecewise_construct;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_PAIR_HPP
+
diff --git a/boost/interprocess/containers/set.hpp b/boost/interprocess/containers/set.hpp
new file mode 100644
index 0000000000..db06afea6d
--- /dev/null
+++ b/boost/interprocess/containers/set.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_SET_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_SET_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/set.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::set;
+using boost::container::multiset;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_SET_HPP
diff --git a/boost/interprocess/containers/slist.hpp b/boost/interprocess/containers/slist.hpp
new file mode 100644
index 0000000000..f93379cb7a
--- /dev/null
+++ b/boost/interprocess/containers/slist.hpp
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_SLIST_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_SLIST_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/slist.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::slist;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_SLIST_HPP
diff --git a/boost/interprocess/containers/stable_vector.hpp b/boost/interprocess/containers/stable_vector.hpp
new file mode 100644
index 0000000000..ae09e6b52f
--- /dev/null
+++ b/boost/interprocess/containers/stable_vector.hpp
@@ -0,0 +1,32 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_STABLE_VECTOR_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_STABLE_VECTOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+   namespace interprocess {
+
+      using boost::container::stable_vector;
+
+   }  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_STABLE_VECTOR_HPP
diff --git a/boost/interprocess/containers/string.hpp b/boost/interprocess/containers/string.hpp
new file mode 100644
index 0000000000..a11bb904b4
--- /dev/null
+++ b/boost/interprocess/containers/string.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_STRING_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_STRING_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/string.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::basic_string;
+using boost::container::string;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_STRING_HPP
diff --git a/boost/interprocess/containers/vector.hpp b/boost/interprocess/containers/vector.hpp
new file mode 100644
index 0000000000..3a6b411512
--- /dev/null
+++ b/boost/interprocess/containers/vector.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_VECTOR_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_VECTOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/interprocess/containers/containers_fwd.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::vector;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_VECTOR_HPP
+
diff --git a/boost/interprocess/containers/version_type.hpp b/boost/interprocess/containers/version_type.hpp
new file mode 100644
index 0000000000..247f800f4a
--- /dev/null
+++ b/boost/interprocess/containers/version_type.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_CONTAINERS_VERSION_TYPE_HPP
+#define BOOST_INTERPROCESS_CONTAINERS_VERSION_TYPE_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/container/detail/version_type.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using boost::container::container_detail::version_type;
+using boost::container::container_detail::version;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //   #ifndef  BOOST_INTERPROCESS_CONTAINERS_VERSION_TYPE_HPP
+
diff --git a/boost/interprocess/creation_tags.hpp b/boost/interprocess/creation_tags.hpp
new file mode 100644
index 0000000000..374829ac2b
--- /dev/null
+++ b/boost/interprocess/creation_tags.hpp
@@ -0,0 +1,77 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_CREATION_TAGS_HPP
+#define BOOST_INTERPROCESS_CREATION_TAGS_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+namespace boost {
+namespace interprocess {
+
+//!Tag to indicate that the resource must
+//!be only created
+struct create_only_t {};
+
+//!Tag to indicate that the resource must
+//!be only opened
+struct open_only_t {};
+
+//!Tag to indicate that the resource must
+//!be only opened for reading
+struct open_read_only_t {};
+
+//!Tag to indicate that the resource must
+//!be only opened privately for reading
+struct open_read_private_t {};
+
+//!Tag to indicate that the resource must
+//!be only opened for reading
+struct open_copy_on_write_t {};
+
+//!Tag to indicate that the resource must
+//!be created. If already created, it must be opened.
+struct open_or_create_t {};
+
+//!Value to indicate that the resource must
+//!be only created
+static const create_only_t    create_only    = create_only_t();
+
+//!Value to indicate that the resource must
+//!be only opened
+static const open_only_t      open_only      = open_only_t();
+
+//!Value to indicate that the resource must
+//!be only opened for reading
+static const open_read_only_t open_read_only = open_read_only_t();
+
+//!Value to indicate that the resource must
+//!be created. If already created, it must be opened.
+static const open_or_create_t open_or_create = open_or_create_t();
+
+//!Value to indicate that the resource must
+//!be only opened for reading
+static const open_copy_on_write_t open_copy_on_write = open_copy_on_write_t();
+
+namespace ipcdetail {
+
+enum create_enum_t
+{  DoCreate, DoOpen, DoOpenOrCreate   };
+
+}  //namespace ipcdetail {
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_CREATION_TAGS_HPP
+
diff --git a/boost/interprocess/detail/atomic.hpp b/boost/interprocess/detail/atomic.hpp
new file mode 100644
index 0000000000..f7551f3dda
--- /dev/null
+++ b/boost/interprocess/detail/atomic.hpp
@@ -0,0 +1,593 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006-2011
+// (C) Copyright Markus Schoepflin 2007
+// (C) Copyright Bryce Lelbach 2010
+//
+// 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_DETAIL_ATOMIC_HPP
+#define BOOST_INTERPROCESS_DETAIL_ATOMIC_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+//! Atomically increment an boost::uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem);
+
+//! Atomically read an boost::uint32_t from memory
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem);
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val);
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with": what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+inline boost::uint32_t atomic_cas32
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp);
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+#include <boost/interprocess/detail/win32_api.hpp>
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+//! Atomically decrement an boost::uint32_t by 1
+//! "mem": pointer to the atomic value
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
+{  return winapi::interlocked_decrement(reinterpret_cast<volatile long*>(mem)) + 1;  }
+
+//! Atomically increment an apr_uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
+{  return winapi::interlocked_increment(reinterpret_cast<volatile long*>(mem))-1;  }
+
+//! Atomically read an boost::uint32_t from memory
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
+{  return *mem;   }
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{  winapi::interlocked_exchange(reinterpret_cast<volatile long*>(mem), val);  }
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with": what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+inline boost::uint32_t atomic_cas32
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
+{  return winapi::interlocked_compare_exchange(reinterpret_cast<volatile long*>(mem), with, cmp);  }
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with" what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+inline boost::uint32_t atomic_cas32
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
+{
+   boost::uint32_t prev = cmp;
+   // This version by Mans Rullgard of Pathscale
+   __asm__ __volatile__ ( "lock\n\t"
+                          "cmpxchg %2,%0"
+                        : "+m"(*mem), "+a"(prev)
+                        : "r"(with)
+                        : "cc");
+
+   return prev;
+/*
+   asm volatile( "lock\n\t"
+                 "cmpxchg %3,%1"
+               : "=a" (prev), "=m" (*(mem))
+               : "0" (prev), "r" (with)
+               : "memory", "cc");
+*/
+/*
+   boost::uint32_t prev;
+
+   asm volatile ("lock; cmpxchgl %1, %2"             
+               : "=a" (prev)               
+               : "r" (with), "m" (*(mem)), "0"(cmp));
+   asm volatile("" : : : "memory");
+
+   return prev;
+*/
+}
+
+//! Atomically add 'val' to an boost::uint32_t
+//! "mem": pointer to the object
+//! "val": amount to add
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_add32
+   (volatile boost::uint32_t *mem, boost::uint32_t val)
+{
+   // int r = *pw;
+   // *mem += val;
+   // return r;
+   int r;
+
+   asm volatile
+   (
+      "lock\n\t"
+      "xadd %1, %0":
+      "+m"( *mem ), "=r"( r ): // outputs (%0, %1)
+      "1"( val ): // inputs (%2 == %1)
+      "memory", "cc" // clobbers
+   );
+
+   return r;
+/*
+   asm volatile( "lock\n\t; xaddl %0,%1"
+               : "=r"(val), "=m"(*mem)
+               : "0"(val), "m"(*mem));
+   asm volatile("" : : : "memory");
+
+   return val;
+*/
+}
+
+//! Atomically increment an apr_uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
+{  return atomic_add32(mem, 1);  }
+
+//! Atomically decrement an boost::uint32_t by 1
+//! "mem": pointer to the atomic value
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
+{  return atomic_add32(mem, (boost::uint32_t)-1);  }
+
+//! Atomically read an boost::uint32_t from memory
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
+{  return *mem;   }
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{  *mem = val; }
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#elif defined(__GNUC__) && (defined(__PPC__) || defined(__ppc__))
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+//! Atomically add 'val' to an boost::uint32_t
+//! "mem": pointer to the object
+//! "val": amount to add
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_add32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{
+   boost::uint32_t prev, temp;
+
+   asm volatile ("0:\n\t"                 // retry local label     
+               "lwarx  %0,0,%2\n\t"       // load prev and reserve 
+               "add    %1,%0,%3\n\t"      // temp = prev + val   
+               "stwcx. %1,0,%2\n\t"       // conditionally store   
+               "bne-   0b"                // start over if we lost
+                                          // the reservation
+               //XXX find a cleaner way to define the temp         
+               //it's not an output
+               : "=&r" (prev), "=&r" (temp)        // output, temp 
+               : "b" (mem), "r" (val)              // inputs       
+               : "memory", "cc");                  // clobbered    
+   return prev;
+}
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with" what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+inline boost::uint32_t atomic_cas32
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
+{
+   boost::uint32_t prev;
+
+   asm volatile ("0:\n\t"                 // retry local label     
+               "lwarx  %0,0,%1\n\t"       // load prev and reserve 
+               "cmpw   %0,%3\n\t"         // does it match cmp?    
+               "bne-   1f\n\t"            // ...no, bail out       
+               "stwcx. %2,0,%1\n\t"       // ...yes, conditionally
+                                          //   store with            
+               "bne-   0b\n\t"            // start over if we lost
+                                          //   the reservation       
+               "1:"                       // exit local label      
+
+               : "=&r"(prev)                        // output      
+               : "b" (mem), "r" (with), "r"(cmp)    // inputs      
+               : "memory", "cc");                   // clobbered   
+   return prev;
+}
+
+//! Atomically increment an apr_uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
+{  return atomic_add32(mem, 1);  }
+
+//! Atomically decrement an boost::uint32_t by 1
+//! "mem": pointer to the atomic value
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
+{  return atomic_add32(mem, boost::uint32_t(-1u));  }
+
+//! Atomically read an boost::uint32_t from memory
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
+{  return *mem;   }
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{  *mem = val; }
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+//! Atomically add 'val' to an boost::uint32_t
+//! "mem": pointer to the object
+//! "val": amount to add
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_add32
+   (volatile boost::uint32_t *mem, boost::uint32_t val)
+{  return __sync_fetch_and_add(const_cast<boost::uint32_t *>(mem), val);   }
+
+//! Atomically increment an apr_uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
+{  return atomic_add32(mem, 1);  }
+
+//! Atomically decrement an boost::uint32_t by 1
+//! "mem": pointer to the atomic value
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
+{  return atomic_add32(mem, (boost::uint32_t)-1);   }
+
+//! Atomically read an boost::uint32_t from memory
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
+{  return *mem;   }
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with" what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+inline boost::uint32_t atomic_cas32
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
+{  return __sync_val_compare_and_swap(const_cast<boost::uint32_t *>(mem), cmp, with);   }
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{  *mem = val; }
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#elif (defined(sun) || defined(__sun))
+
+#include <atomic.h>
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+//! Atomically add 'val' to an boost::uint32_t
+//! "mem": pointer to the object
+//! "val": amount to add
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_add32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{   return atomic_add_32_nv(reinterpret_cast<volatile ::uint32_t*>(mem), (int32_t)val) - val;   }
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with" what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+inline boost::uint32_t atomic_cas32
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
+{  return atomic_cas_32(reinterpret_cast<volatile ::uint32_t*>(mem), cmp, with);  }
+
+//! Atomically increment an apr_uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
+{  return atomic_add_32_nv(reinterpret_cast<volatile ::uint32_t*>(mem), 1) - 1; }
+
+//! Atomically decrement an boost::uint32_t by 1
+//! "mem": pointer to the atomic value
+//! Returns the old value pointed to by mem
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
+{  return atomic_add_32_nv(reinterpret_cast<volatile ::uint32_t*>(mem), (boost::uint32_t)-1) + 1; }
+
+//! Atomically read an boost::uint32_t from memory
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
+{  return *mem;   }
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{  *mem = val; }
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#elif defined(__osf__) && defined(__DECCXX)
+
+#include <machine/builtins.h>
+#include <c_asm.h>
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+//! Atomically decrement a uint32_t by 1
+//! "mem": pointer to the atomic value
+//! Returns the old value pointed to by mem
+//! Acquire, memory barrier after decrement.
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
+{  boost::uint32_t old_val = __ATOMIC_DECREMENT_LONG(mem); __MB(); return old_val; }
+
+//! Atomically increment a uint32_t by 1
+//! "mem": pointer to the object
+//! Returns the old value pointed to by mem
+//! Release, memory barrier before increment.
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
+{  __MB(); return __ATOMIC_INCREMENT_LONG(mem); }
+
+// Rational for the implementation of the atomic read and write functions.
+//
+// 1. The Alpha Architecture Handbook requires that access to a byte,
+// an aligned word, an aligned longword, or an aligned quadword is
+// atomic. (See 'Alpha Architecture Handbook', version 4, chapter 5.2.2.)
+//
+// 2. The CXX User's Guide states that volatile quantities are accessed
+// with single assembler instructions, and that a compilation error
+// occurs when declaring a quantity as volatile which is not properly
+// aligned.
+
+//! Atomically read an boost::uint32_t from memory
+//! Acquire, memory barrier after load.
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
+{  boost::uint32_t old_val = *mem; __MB(); return old_val;  }
+
+//! Atomically set an boost::uint32_t in memory
+//! "mem": pointer to the object
+//! "param": val value that the object will assume
+//! Release, memory barrier before store.
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
+{  __MB(); *mem = val; }
+
+//! Compare an boost::uint32_t's value with "cmp".
+//! If they are the same swap the value with "with"
+//! "mem": pointer to the value
+//! "with" what to swap it with
+//! "cmp": the value to compare it to
+//! Returns the old value of *mem
+//! Memory barrier between load and store.
+inline boost::uint32_t atomic_cas32(
+  volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
+{
+  // Note:
+  //
+  // Branch prediction prefers backward branches, and the Alpha Architecture
+  // Handbook explicitely states that the loop should not be implemented like
+  // it is below. (See chapter 4.2.5.) Therefore the code should probably look
+  // like this:
+  //
+  // return asm(
+  //   "10: ldl_l %v0,(%a0) ;"
+  //   "    cmpeq %v0,%a2,%t0 ;"
+  //   "    beq %t0,20f ;"
+  //   "    mb ;"
+  //   "    mov %a1,%t0 ;"
+  //   "    stl_c %t0,(%a0) ;"
+  //   "    beq %t0,30f ;"
+  //   "20: ret ;"
+  //   "30: br 10b;",
+  //   mem, with, cmp);
+  //
+  // But as the compiler always transforms this into the form where a backward
+  // branch is taken on failure, we can as well implement it in the straight
+  // forward form, as this is what it will end up in anyway.
+
+  return asm(
+    "10: ldl_l %v0,(%a0) ;"    // load prev value from mem and lock mem
+    "    cmpeq %v0,%a2,%t0 ;"  // compare with given value
+    "    beq %t0,20f ;"        // if not equal, we're done
+    "    mb ;"                 // memory barrier
+    "    mov %a1,%t0 ;"        // load new value into scratch register
+    "    stl_c %t0,(%a0) ;"    // store new value to locked mem (overwriting scratch)
+    "    beq %t0,10b ;"        // store failed because lock has been stolen, retry
+    "20: ",
+    mem, with, cmp);
+}
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#elif defined(__IBMCPP__) && (__IBMCPP__ >= 800) && defined(_AIX)  
+
+#include <builtins.h>  
+
+namespace boost {  
+namespace interprocess {  
+namespace ipcdetail{  
+
+//first define boost::uint32_t versions of __lwarx and __stwcx to avoid poluting  
+//all the functions with casts  
+
+//! From XLC documenation :  
+//! This function can be used with a subsequent stwcxu call to implement a  
+//! read-modify-write on a specified memory location. The two functions work  
+//! together to ensure that if the store is successfully performed, no other  
+//! processor or mechanism can modify the target doubleword between the time  
+//! lwarxu function is executed and the time the stwcxu functio ncompletes.  
+//! "mem" : pointer to the object  
+//! Returns the value at pointed to by mem  
+inline boost::uint32_t lwarxu(volatile boost::uint32_t *mem)  
+{  
+   return static_cast<boost::uint32_t>(__lwarx(reinterpret_cast<volatile int*>(mem)));  
+}  
+
+//! "mem" : pointer to the object  
+//! "val" : the value to store  
+//! Returns true if the update of mem is successful and false if it is  
+//!unsuccessful  
+inline bool stwcxu(volatile boost::uint32_t* mem, boost::uint32_t val)  
+{  
+   return (__stwcx(reinterpret_cast<volatile int*>(mem), static_cast<int>(val)) != 0);  
+}  
+
+//! "mem": pointer to the object  
+//! "val": amount to add  
+//! Returns the old value pointed to by mem  
+inline boost::uint32_t atomic_add32  
+   (volatile boost::uint32_t *mem, boost::uint32_t val)  
+{  
+   boost::uint32_t oldValue;  
+   do  
+   {  
+      oldValue = lwarxu(mem);  
+   }while (!stwcxu(mem, oldValue+val));  
+   return oldValue;  
+}  
+
+//! Atomically increment an apr_uint32_t by 1  
+//! "mem": pointer to the object  
+//! Returns the old value pointed to by mem  
+inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)  
+{  return atomic_add32(mem, 1);  }  
+
+//! Atomically decrement an boost::uint32_t by 1  
+//! "mem": pointer to the atomic value  
+//! Returns the old value pointed to by mem  
+inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)  
+{  return atomic_add32(mem, (boost::uint32_t)-1);   }  
+
+//! Atomically read an boost::uint32_t from memory  
+inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)  
+{  return *mem;   }  
+
+//! Compare an boost::uint32_t's value with "cmp".  
+//! If they are the same swap the value with "with"  
+//! "mem": pointer to the value  
+//! "with" what to swap it with  
+//! "cmp": the value to compare it to  
+//! Returns the old value of *mem  
+inline boost::uint32_t atomic_cas32  
+   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)  
+{  
+   boost::uint32_t oldValue;  
+   boost::uint32_t valueToStore;  
+   do  
+   {  
+      oldValue = lwarxu(mem);  
+   } while (!stwcxu(mem, (oldValue == with) ? cmp : oldValue));  
+
+   return oldValue;  
+}  
+
+//! Atomically set an boost::uint32_t in memory  
+//! "mem": pointer to the object  
+//! "param": val value that the object will assume  
+inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)  
+{  *mem = val; }  
+
+}  //namespace ipcdetail  
+}  //namespace interprocess  
+}  //namespace boost  
+
+#else
+
+#error No atomic operations implemented for this platform, sorry!
+
+#endif
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+inline bool atomic_add_unless32
+   (volatile boost::uint32_t *mem, boost::uint32_t value, boost::uint32_t unless_this)
+{
+   boost::uint32_t old, c(atomic_read32(mem));
+   while(c != unless_this && (old = atomic_cas32(mem, c + value, c)) != c){
+      c = old;
+   }
+   return c != unless_this;
+}
+
+}  //namespace ipcdetail  
+}  //namespace interprocess  
+}  //namespace boost  
+
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_ATOMIC_HPP
diff --git a/boost/interprocess/detail/cast_tags.hpp b/boost/interprocess/detail/cast_tags.hpp
new file mode 100644
index 0000000000..bd91d1b6bb
--- /dev/null
+++ b/boost/interprocess/detail/cast_tags.hpp
@@ -0,0 +1,29 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_CAST_TAGS_HPP
+#define BOOST_INTERPROCESS_CAST_TAGS_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+namespace boost { namespace interprocess { namespace ipcdetail {
+
+struct static_cast_tag {};
+struct const_cast_tag {};
+struct dynamic_cast_tag {};
+struct reinterpret_cast_tag {};
+
+}}}  //namespace boost { namespace interprocess { namespace ipcdetail {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_CAST_TAGS_HPP
+
diff --git a/boost/interprocess/detail/config_begin.hpp b/boost/interprocess/detail/config_begin.hpp
new file mode 100644
index 0000000000..559331ab32
--- /dev/null
+++ b/boost/interprocess/detail/config_begin.hpp
@@ -0,0 +1,47 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_CONFIG_INCLUDED
+#define BOOST_INTERPROCESS_CONFIG_INCLUDED
+#include <boost/config.hpp>
+#endif
+
+#ifdef BOOST_MSVC
+   #ifndef _CRT_SECURE_NO_DEPRECATE
+   #define  BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
+   #define _CRT_SECURE_NO_DEPRECATE
+   #endif
+   #pragma warning (push)
+   #pragma warning (disable : 4702) // unreachable code
+   #pragma warning (disable : 4706) // assignment within conditional expression
+   #pragma warning (disable : 4127) // conditional expression is constant
+   #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
+   #pragma warning (disable : 4284) // odd return type for operator->
+   #pragma warning (disable : 4244) // possible loss of data
+   #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
+   #pragma warning (disable : 4267) // conversion from "X" to "Y", possible loss of data
+   #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
+   #pragma warning (disable : 4355) // "this" : used in base member initializer list
+   #pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated
+   #pragma warning (disable : 4511) // copy constructor could not be generated
+   #pragma warning (disable : 4512) // assignment operator could not be generated
+   #pragma warning (disable : 4514) // unreferenced inline removed
+   #pragma warning (disable : 4521) // Disable "multiple copy constructors specified"
+   #pragma warning (disable : 4522) // "class" : multiple assignment operators specified
+   #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
+   #pragma warning (disable : 4710) // function not inlined
+   #pragma warning (disable : 4711) // function selected for automatic inline expansion
+   #pragma warning (disable : 4786) // identifier truncated in debug info
+   #pragma warning (disable : 4996) // "function": was declared deprecated
+   #pragma warning (disable : 4197) // top-level volatile in cast is ignored
+   #pragma warning (disable : 4541) // 'typeid' used on polymorphic type 'boost::exception'
+                                    //    with /GR-; unpredictable behavior may result
+   #pragma warning (disable : 4673) //  throwing '' the following types will not be considered at the catch site
+   #pragma warning (disable : 4671) //  the copy constructor is inaccessible
+#endif
diff --git a/boost/interprocess/detail/config_end.hpp b/boost/interprocess/detail/config_end.hpp
new file mode 100644
index 0000000000..422458e855
--- /dev/null
+++ b/boost/interprocess/detail/config_end.hpp
@@ -0,0 +1,17 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+#if defined BOOST_MSVC
+   #pragma warning (pop)
+   #ifdef BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
+   #undef BOOST_INTERPROCESS_CRT_SECURE_NO_DEPRECATE
+   #undef _CRT_SECURE_NO_DEPRECATE
+   #endif
+#endif
+
diff --git a/boost/interprocess/detail/file_wrapper.hpp b/boost/interprocess/detail/file_wrapper.hpp
new file mode 100644
index 0000000000..7b53f36ac8
--- /dev/null
+++ b/boost/interprocess/detail/file_wrapper.hpp
@@ -0,0 +1,202 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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_DETAIL_FILE_WRAPPER_HPP
+#define BOOST_INTERPROCESS_DETAIL_FILE_WRAPPER_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+class file_wrapper
+{
+   /// @cond
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(file_wrapper)
+   /// @endcond
+   public:
+
+   //!Default constructor.
+   //!Represents an empty file_wrapper.
+   file_wrapper();
+
+   //!Creates a file object with name "name" and mode "mode", with the access mode "mode"
+   //!If the file previously exists, throws an error.
+   file_wrapper(create_only_t, const char *name, mode_t mode, const permissions &perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoCreate, name, mode, perm);  }
+
+   //!Tries to create a file with name "name" and mode "mode", with the
+   //!access mode "mode". If the file previously exists, it tries to open it with mode "mode".
+   //!Otherwise throws an error.
+   file_wrapper(open_or_create_t, const char *name, mode_t mode, const permissions &perm  = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoOpenOrCreate, name, mode, perm);  }
+
+   //!Tries to open a file with name "name", with the access mode "mode". 
+   //!If the file does not previously exist, it throws an error.
+   file_wrapper(open_only_t, const char *name, mode_t mode)
+   {  this->priv_open_or_create(ipcdetail::DoOpen, name, mode, permissions());  }
+
+   //!Moves the ownership of "moved"'s file to *this. 
+   //!After the call, "moved" does not represent any file. 
+   //!Does not throw
+   file_wrapper(BOOST_RV_REF(file_wrapper) moved)
+      :  m_handle(file_handle_t(ipcdetail::invalid_file()))
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s file to *this.
+   //!After the call, "moved" does not represent any file.
+   //!Does not throw
+   file_wrapper &operator=(BOOST_RV_REF(file_wrapper) moved)
+   {  
+      file_wrapper tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps to file_wrappers.
+   //!Does not throw
+   void swap(file_wrapper &other);
+
+   //!Erases a file from the system.
+   //!Returns false on error. Never throws
+   static bool remove(const char *name);
+   
+   //!Sets the size of the file
+   void truncate(offset_t length);
+
+   //!Closes the
+   //!file
+   ~file_wrapper();
+
+   //!Returns the name of the file
+   //!used in the constructor
+   const char *get_name() const;
+
+   //!Returns the name of the file
+   //!used in the constructor
+   bool get_size(offset_t &size) const;
+
+   //!Returns access mode
+   //!used in the constructor
+   mode_t get_mode() const;
+
+   //!Get mapping handle
+   //!to use with mapped_region
+   mapping_handle_t get_mapping_handle() const;
+
+   private:
+   //!Closes a previously opened file mapping. Never throws.
+   void priv_close();
+   //!Closes a previously opened file mapping. Never throws.
+   bool priv_open_or_create(ipcdetail::create_enum_t type, const char *filename, mode_t mode, const permissions &perm);
+
+   file_handle_t  m_handle;
+   mode_t      m_mode;
+   std::string       m_filename;
+};
+
+inline file_wrapper::file_wrapper() 
+   :  m_handle(file_handle_t(ipcdetail::invalid_file()))
+{}
+
+inline file_wrapper::~file_wrapper() 
+{  this->priv_close(); }
+
+inline const char *file_wrapper::get_name() const
+{  return m_filename.c_str(); }
+
+inline bool file_wrapper::get_size(offset_t &size) const
+{  return get_file_size((file_handle_t)m_handle, size);  }
+
+inline void file_wrapper::swap(file_wrapper &other)
+{  
+   std::swap(m_handle,  other.m_handle);
+   std::swap(m_mode,    other.m_mode);
+   m_filename.swap(other.m_filename);   
+}
+
+inline mapping_handle_t file_wrapper::get_mapping_handle() const
+{  return mapping_handle_from_file_handle(m_handle);  }
+
+inline mode_t file_wrapper::get_mode() const
+{  return m_mode; }
+
+inline bool file_wrapper::priv_open_or_create
+   (ipcdetail::create_enum_t type, 
+    const char *filename,
+    mode_t mode,
+    const permissions &perm = permissions())
+{
+   m_filename = filename;
+
+   if(mode != read_only && mode != read_write){
+      error_info err(mode_error);
+      throw interprocess_exception(err);
+   }
+
+   //Open file existing native API to obtain the handle
+   switch(type){
+      case ipcdetail::DoOpen:
+         m_handle = open_existing_file(filename, mode);
+      break;
+      case ipcdetail::DoCreate:
+         m_handle = create_new_file(filename, mode, perm);
+      break;
+      case ipcdetail::DoOpenOrCreate:
+         m_handle = create_or_open_file(filename, mode, perm);
+      break;
+      default:
+         {
+            error_info err = other_error;
+            throw interprocess_exception(err);
+         }
+   }
+
+   //Check for error
+   if(m_handle == invalid_file()){
+      throw interprocess_exception(error_info(system_error_code()));
+   }
+
+   m_mode = mode;
+   return true;
+}
+
+inline bool file_wrapper::remove(const char *filename)
+{  return delete_file(filename); }
+
+inline void file_wrapper::truncate(offset_t length)
+{
+   if(!truncate_file(m_handle, length)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+inline void file_wrapper::priv_close()
+{
+   if(m_handle != invalid_file()){
+      close_file(m_handle);
+      m_handle = invalid_file();
+   }
+}
+
+}  //namespace ipcdetail{
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_FILE_WRAPPER_HPP
diff --git a/boost/interprocess/detail/in_place_interface.hpp b/boost/interprocess/detail/in_place_interface.hpp
new file mode 100644
index 0000000000..0e69452a40
--- /dev/null
+++ b/boost/interprocess/detail/in_place_interface.hpp
@@ -0,0 +1,73 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_IN_PLACE_INTERFACE_HPP
+#define BOOST_INTERPROCESS_IN_PLACE_INTERFACE_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/interprocess/detail/type_traits.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <typeinfo>  //typeid
+
+//!\file
+//!Describes an abstract interface for placement construction and destruction.
+
+namespace boost {
+namespace interprocess { 
+namespace ipcdetail {
+
+struct in_place_interface
+{
+   in_place_interface(std::size_t alignm, std::size_t sz, const char *tname)
+   :  alignment(alignm), size(sz), type_name(tname)
+   {}
+
+   std::size_t alignment;
+   std::size_t size;
+   const char *type_name;
+
+   virtual void construct_n(void *mem, std::size_t num, std::size_t &constructed) = 0;
+   virtual void destroy_n(void *mem, std::size_t num, std::size_t &destroyed) = 0;
+   virtual ~in_place_interface(){}
+};
+
+template<class T>
+struct placement_destroy :  public in_place_interface
+{
+   placement_destroy()
+	   :  in_place_interface(::boost::alignment_of<T>::value, sizeof(T), typeid(T).name())
+   {}
+
+   virtual void destroy_n(void *mem, std::size_t num, std::size_t &destroyed)
+   {
+      T* memory = static_cast<T*>(mem);
+      for(destroyed = 0; destroyed < num; ++destroyed)
+         (memory++)->~T();
+   }
+
+   virtual void construct_n(void *, std::size_t, std::size_t &) {}
+
+   private:
+   void destroy(void *mem)
+   {  static_cast<T*>(mem)->~T();   }
+};
+
+}
+}
+}   //namespace boost { namespace interprocess { namespace ipcdetail {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTERPROCESS_IN_PLACE_INTERFACE_HPP
diff --git a/boost/interprocess/detail/intermodule_singleton.hpp b/boost/interprocess/detail/intermodule_singleton.hpp
new file mode 100644
index 0000000000..4bffbe9d4e
--- /dev/null
+++ b/boost/interprocess/detail/intermodule_singleton.hpp
@@ -0,0 +1,1184 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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_HPP
+#define BOOST_INTERPROCESS_INTERMODULE_SINGLETON_HPP
+
+#if defined(_MSC_VER)&&(_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+#include <boost/interprocess/windows_shared_memory.hpp>
+#endif
+
+#include <boost/interprocess/shared_memory_object.hpp>
+
+#include <boost/interprocess/offset_ptr.hpp>
+#include <boost/interprocess/sync/spin/mutex.hpp>
+#include <boost/interprocess/sync/spin/recursive_mutex.hpp>
+#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/indexes/iset_index.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/assert.hpp>
+#include <cstddef>
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+#include <fcntl.h>
+#include <io.h>
+
+#include <sys/locking.h>
+#else
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+struct intermodule_singleton_mutex_family
+{
+   typedef boost::interprocess::ipcdetail::spin_mutex              mutex_type;
+   typedef boost::interprocess::ipcdetail::spin_recursive_mutex    recursive_mutex_type;
+};
+
+struct intermodule_types
+{
+   //We must use offset_ptr since a loaded DLL can map the singleton holder shared memory
+   //at a different address than other DLLs/main executables
+   typedef rbtree_best_fit<intermodule_singleton_mutex_family, offset_ptr<void> > mem_algo;
+   template<class Device, bool FileBased>
+   struct open_or_create
+   {
+      typedef managed_open_or_create_impl
+            <Device, mem_algo::Alignment, FileBased> type;
+   };
+};
+
+template<class Device, bool FileBased>
+class basic_managed_global_memory 
+   : public basic_managed_memory_impl
+      < char
+      , intermodule_types::mem_algo
+      , iset_index
+      , intermodule_types::open_or_create<Device, FileBased>::type::ManagedOpenOrCreateUserOffset
+      >
+   , private intermodule_types::open_or_create<Device, FileBased>::type
+{
+   /// @cond
+   typedef typename intermodule_types::template open_or_create<Device, FileBased>::type base2_t;
+
+   typedef basic_managed_memory_impl
+      < char
+      , intermodule_types::mem_algo
+      , iset_index
+      , base2_t::ManagedOpenOrCreateUserOffset
+      > base_t;
+
+   typedef create_open_func<base_t>        create_open_func_t;
+
+   basic_managed_global_memory *get_this_pointer()
+   {  return this;   }
+
+   public:
+   typedef typename base_t::size_type              size_type;
+
+   private:
+   typedef typename base_t::char_ptr_holder_t   char_ptr_holder_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_global_memory)
+   /// @endcond
+
+   public: //functions
+/*
+   basic_managed_global_memory()
+   {}
+
+   basic_managed_global_memory(create_only_t create_only, const char *name,
+                             size_type size, const void *addr = 0, const permissions& perm = permissions())
+      : base_t()
+      , base2_t(create_only, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), DoCreate), perm)
+   {}
+*/
+   basic_managed_global_memory (open_or_create_t open_or_create,
+                              const char *name, size_type size, 
+                              const void *addr = 0, const permissions& perm = permissions())
+      : base_t()
+      , base2_t(open_or_create, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                DoOpenOrCreate), perm)
+   {}
+
+   basic_managed_global_memory (open_only_t open_only, const char* name, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, name, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                DoOpen))
+   {}
+
+/*
+   basic_managed_global_memory (open_copy_on_write_t, const char* name, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, name, copy_on_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                DoOpen))
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!in read-only mode.
+   //!This can throw.
+   basic_managed_global_memory (open_read_only_t, const char* name, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, name, read_only, addr, 
+                create_open_func_t(get_this_pointer(), 
+                DoOpen))
+   {}
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_global_memory(BOOST_RV_REF(basic_managed_global_memory) moved)
+   {
+      basic_managed_global_memory tmp;
+      this->swap(moved);
+      tmp.swap(moved);
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_global_memory &operator=(BOOST_RV_REF(basic_managed_global_memory) moved)
+   {
+      basic_managed_global_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }*/
+};
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+typedef basic_managed_global_memory<windows_shared_memory, false>  windows_managed_global_memory;
+#endif
+
+typedef basic_managed_global_memory<shared_memory_object, true>    managed_global_memory;
+
+namespace file_locking_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 void create_tmp_subdir_and_get_pid_based_filepath(const char *subdir_name, const char *file_prefix, OS_process_id_t pid, std::string &s, bool creation_time = false)
+{
+   //Let's create a lock file for each process gmem that will mark if
+   //the process is alive or not
+   create_tmp_and_clean_old(s);
+   s += "/";
+   s += subdir_name;
+   if(!open_or_create_directory(s.c_str())){
+      throw interprocess_exception(error_info(system_error_code()));
+   }
+   s += "/";
+   s += file_prefix;
+   if(creation_time){
+      std::string sstamp;   
+      get_pid_creation_time_str(sstamp);
+      s += sstamp;
+   }
+   else{
+      pid_str_t pid_str;
+      get_pid_str(pid_str, pid);
+      s += pid_str;
+   }
+}
+
+inline bool check_if_filename_complies_with_pid
+   (const char *filename, const char *prefix, OS_process_id_t pid, std::string &file_suffix, bool creation_time = false)
+{
+   //Check if filename complies with lock file name pattern
+   std::string fname(filename);
+   std::string fprefix(prefix);
+   if(fname.size() <= fprefix.size()){
+      return false;
+   }
+   fname.resize(fprefix.size());
+   if(fname != fprefix){
+      return false;
+   }
+
+   //If not our lock file, delete it if we can lock it
+   fname = filename;
+   fname.erase(0, fprefix.size());
+   pid_str_t pid_str;
+   get_pid_str(pid_str, pid);
+   file_suffix = pid_str;
+   if(creation_time){
+      std::size_t p = fname.find('_');
+      if (p == std::string::npos){
+         return false;
+      }
+      std::string save_suffix(fname);
+      fname.erase(p);
+      fname.swap(file_suffix);
+      bool ret = (file_suffix == fname);
+      file_suffix.swap(save_suffix);
+      return ret;
+   }
+   else{
+      fname.swap(file_suffix);
+      return (file_suffix == fname);
+   }
+}
+
+}  //file_locking_helpers
+
+namespace intermodule_singleton_helpers {
+
+const int GMemMarkToBeRemoved = -1;
+const int GMemNotPresent      = -2;
+
+inline const char *get_lock_file_subdir_name()
+{  return "gmem";  }
+
+inline const char *get_lock_file_base_name()
+{  return "lck";  }
+
+inline void create_and_get_singleton_lock_file_path(std::string &s)
+{
+   file_locking_helpers::create_tmp_subdir_and_get_pid_based_filepath
+      (get_lock_file_subdir_name(), get_lock_file_base_name(), get_current_process_id(), s, true);
+}
+
+inline const char *get_shm_base_name()
+{  return "bip.gmem.shm.";  }
+
+inline void get_shm_name(std::string &shm_name)
+{
+   file_locking_helpers::get_pid_creation_time_str(shm_name);
+   shm_name.insert(0, get_shm_base_name());
+}
+
+inline std::size_t get_shm_size()
+{  return 65536;  }
+
+template<class ManagedShMem>
+struct managed_sh_dependant
+{
+   static void apply_gmem_erase_logic(const char *filepath, const char *filename);
+
+   static bool remove_old_gmem()
+   {
+      std::string refcstrRootDirectory;
+      tmp_folder(refcstrRootDirectory);
+      refcstrRootDirectory += "/";
+      refcstrRootDirectory += get_lock_file_subdir_name();
+      return for_each_file_in_dir(refcstrRootDirectory.c_str(), apply_gmem_erase_logic);
+   }
+};
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+template<>
+struct managed_sh_dependant<windows_managed_global_memory>
+{
+   static void apply_gmem_erase_logic(const char *, const char *){}
+
+   static bool remove_old_gmem()
+   { return true; }
+};
+
+
+struct locking_file_serial_id
+{
+   int fd;
+   unsigned long dwVolumeSerialNumber;
+   unsigned long nFileIndexHigh;
+   unsigned long nFileIndexLow;
+   //This reference count counts the number of modules attached
+   //to the shared memory and lock file. This serves to unlink
+   //the locking file and shared memory when all modules are
+   //done with the global memory (shared memory)
+   volatile boost::uint32_t modules_attached_to_gmem_count;
+};
+
+inline bool lock_locking_file(int fd)
+{
+   int ret = 0;
+   while(ret != 0 && errno == EDEADLK){
+      ret = _locking(fd, _LK_LOCK, 1/*lock_file_contents_length()*/);
+   }
+   return 0 == ret;
+}
+
+inline bool try_lock_locking_file(int fd)
+{
+   return 0 == _locking(fd, _LK_NBLCK , 1);
+}
+
+inline int open_or_create_and_lock_file(const char *name)
+{
+   permissions p;
+   p.set_unrestricted();
+   while(1){
+      file_handle_t handle = create_or_open_file(name, read_write, p);
+      int fd = _open_osfhandle((intptr_t)handle, _O_TEXT);
+      if(fd < 0){
+         close_file(handle);
+         return fd;
+      }
+      if(!try_lock_locking_file(fd)){
+         _close(fd);
+         return -1;
+      }
+      struct _stat s;
+      if(0 == _stat(name, &s)){
+         return fd;
+      }
+      else{
+         _close(fd);
+      }
+   }
+}
+
+inline int try_open_and_lock_file(const char *name)
+{
+   file_handle_t handle = open_existing_file(name, read_write);
+   int fd = _open_osfhandle((intptr_t)handle, _O_TEXT);
+   if(fd < 0){
+      close_file(handle);
+      return fd;
+   }
+   if(!try_lock_locking_file(fd)){
+      _close(fd);
+      return -1;
+   }
+   return fd;
+}
+
+inline void close_lock_file(int fd)
+{  _close(fd); }
+
+inline bool is_valid_fd(int fd)
+{
+   struct _stat s;
+   return EBADF != _fstat(fd, &s);
+}
+
+inline bool is_normal_file(int fd)
+{
+   if(_isatty(fd))
+      return false;
+   struct _stat s;
+   if(0 != _fstat(fd, &s))
+      return false;
+   return 0 != (s.st_mode & _S_IFREG);
+}
+
+inline std::size_t get_size(int fd)
+{
+   struct _stat s;
+   if(0 != _fstat(fd, &s))
+      return 0u;
+   return (std::size_t)s.st_size;
+}
+
+inline bool fill_file_serial_id(int fd, locking_file_serial_id &id)
+{
+   winapi::interprocess_by_handle_file_information info;
+   if(!winapi::get_file_information_by_handle((void*)_get_osfhandle(fd), &info))
+      return false;
+   id.fd = fd;
+   id.dwVolumeSerialNumber = info.dwVolumeSerialNumber;
+   id.nFileIndexHigh = info.nFileIndexHigh;
+   id.nFileIndexLow = info.nFileIndexLow;
+   id.modules_attached_to_gmem_count = 1; //Initialize attached count
+   return true;
+}
+
+inline bool compare_file_serial(int fd, const locking_file_serial_id &id)
+{
+   winapi::interprocess_by_handle_file_information info;
+   if(!winapi::get_file_information_by_handle((void*)_get_osfhandle(fd), &info))
+      return false;
+
+   return   id.dwVolumeSerialNumber == info.dwVolumeSerialNumber  &&
+            id.nFileIndexHigh       == info.nFileIndexHigh        &&
+            id.nFileIndexLow        == info.nFileIndexLow;
+}
+
+#else //UNIX
+
+struct locking_file_serial_id
+{
+   int fd;
+   dev_t st_dev;
+   ino_t st_ino;
+   //This reference count counts the number of modules attached
+   //to the shared memory and lock file. This serves to unlink
+   //the locking file and shared memory when all modules are
+   //done with the global memory (shared memory)
+   volatile boost::uint32_t modules_attached_to_gmem_count;
+};
+
+inline bool lock_locking_file(int fd)
+{
+   int ret = 0;
+   while(ret != 0 && errno != EINTR){
+      struct flock lock;
+      lock.l_type = F_WRLCK;
+      lock.l_whence = SEEK_SET;
+      lock.l_start = 0;
+      lock.l_len = 1;
+      ret = fcntl (fd, F_SETLKW, &lock);
+   }
+   return 0 == ret;
+}
+
+inline bool try_lock_locking_file(int fd)
+{
+   struct flock lock;
+   lock.l_type = F_WRLCK;
+   lock.l_whence = SEEK_SET;
+   lock.l_start = 0;
+   lock.l_len = 1;
+   return 0 == fcntl (fd, F_SETLK, &lock);
+}
+
+inline int open_or_create_and_lock_file(const char *name)
+{
+   permissions p;
+   p.set_unrestricted();
+   while(1){
+      int fd = create_or_open_file(name, read_write, p);
+      if(fd < 0){
+         return fd;
+      }
+      if(!try_lock_locking_file(fd)){
+         close(fd);
+         return -1;
+      }
+      struct stat s;
+      if(0 == stat(name, &s)){
+         return fd;
+      }
+      else{
+         close(fd);
+      }
+   }
+}
+
+inline int try_open_and_lock_file(const char *name)
+{
+   int fd = open_existing_file(name, read_write);
+   if(fd < 0){
+      return fd;
+   }
+   if(!try_lock_locking_file(fd)){
+      close(fd);
+      return -1;
+   }
+   return fd;
+}
+
+inline void close_lock_file(int fd)
+{  close(fd); }
+
+inline bool is_valid_fd(int fd)
+{
+   struct stat s;
+   return EBADF != fstat(fd, &s);
+}
+
+inline bool is_normal_file(int fd)
+{
+   struct stat s;
+   if(0 != fstat(fd, &s))
+      return false;
+   return 0 != (s.st_mode & S_IFREG);
+}
+
+inline std::size_t get_size(int fd)
+{
+   struct stat s;
+   if(0 != fstat(fd, &s))
+      return 0u;
+   return (std::size_t)s.st_size;
+}
+
+inline bool fill_file_serial_id(int fd, locking_file_serial_id &id)
+{
+   struct stat s;
+   if(0 != fstat(fd, &s))
+      return false;
+   id.fd = fd;
+   id.st_dev = s.st_dev;
+   id.st_ino = s.st_ino;
+   id.modules_attached_to_gmem_count = 1; //Initialize attached count
+   return true;
+}
+
+inline bool compare_file_serial(int fd, const locking_file_serial_id &id)
+{
+   struct stat info;
+   if(0 != fstat(fd, &info))
+      return false;
+
+   return   id.st_dev == info.st_dev  &&
+            id.st_ino == info.st_ino;
+}
+
+#endif
+
+template<class ManagedShMem>
+struct gmem_erase_func
+{
+   gmem_erase_func(const char *shm_name, const char *singleton_lock_file_path, ManagedShMem & shm)
+      :shm_name_(shm_name), singleton_lock_file_path_(singleton_lock_file_path), shm_(shm)
+   {}
+
+   void operator()()
+   {
+      locking_file_serial_id *pserial_id = shm_.template find<locking_file_serial_id>("lock_file_fd").first;
+      if(pserial_id){
+         pserial_id->fd = GMemMarkToBeRemoved;
+      }
+      delete_file(singleton_lock_file_path_);
+      shared_memory_object::remove(shm_name_);
+   }
+   
+   const char * const shm_name_;
+   const char * const singleton_lock_file_path_;
+   ManagedShMem & shm_;
+};
+
+//This function applies shared memory erasure logic based on the passed lock file.
+template<class ManagedShMem>
+void managed_sh_dependant<ManagedShMem>::
+   apply_gmem_erase_logic(const char *filepath, const char *filename)
+{
+   int fd = GMemMarkToBeRemoved;
+   try{
+      std::string str;
+      //If the filename is current process lock file, then avoid it
+      if(file_locking_helpers::check_if_filename_complies_with_pid
+         (filename, get_lock_file_base_name(), get_current_process_id(), str, true)){
+         return;
+      }
+      //Open and lock the other process' lock file
+      fd = try_open_and_lock_file(filepath);
+      if(fd < 0){
+         return;
+      }
+      //If done, then the process is dead so take global shared memory name
+      //(the name is based on the lock file name) and try to apply erasure logic
+      str.insert(0, get_shm_base_name());
+      try{
+         ManagedShMem shm(open_only, str.c_str());
+         gmem_erase_func<ManagedShMem> func(str.c_str(), filepath, shm);
+         shm.try_atomic_func(func);
+      }
+      catch(interprocess_exception &e){
+         //If shared memory is not found erase the lock file
+         if(e.get_error_code() == not_found_error){
+            delete_file(filepath);
+         }
+      }
+   }
+   catch(...){
+
+   }
+   if(fd >= 0){
+      close_lock_file(fd);
+   }
+}
+
+}  //namespace intermodule_singleton_helpers {
+
+
+
+namespace intermodule_singleton_helpers {
+
+//The lock file logic creates uses a unique instance to a file
+template <class ManagedShMem>
+struct lock_file_logic
+{
+   lock_file_logic(ManagedShMem &shm)
+      : mshm(shm)
+   {  shm.atomic_func(*this); }
+
+   void operator()(void)
+   {
+      retry_with_new_shm = false;
+
+      //First find the file locking descriptor id
+      locking_file_serial_id *pserial_id =
+         mshm.template find<locking_file_serial_id>("lock_file_fd").first;
+
+      int fd;
+      //If not found schedule a creation
+      if(!pserial_id){
+         fd = GMemNotPresent;
+      }
+      //Else get it
+      else{
+         fd = pserial_id->fd;
+      }
+      //If we need to create a new one, do it
+      if(fd == GMemNotPresent){
+         std::string lck_str;
+         //Create a unique current pid based lock file path
+         create_and_get_singleton_lock_file_path(lck_str);
+         //Open or create and lock file
+         int fd = intermodule_singleton_helpers::open_or_create_and_lock_file(lck_str.c_str());
+         //If failed, write a bad file descriptor to notify other modules that
+         //something was wrong and unlink shared memory. Mark the function object
+         //to tell caller to retry with another shared memory
+         if(fd < 0){
+            this->register_lock_file(GMemMarkToBeRemoved);
+            std::string s;
+            get_shm_name(s);
+            shared_memory_object::remove(s.c_str());
+            retry_with_new_shm = true;
+         }
+         //If successful, register the file descriptor
+         else{
+            this->register_lock_file(fd);
+         }
+      }
+      //If the fd was invalid (maybe a previous try failed) notify caller that
+      //should retry creation logic, since this shm might have been already
+      //unlinked since the shm was removed
+      else if (fd == GMemMarkToBeRemoved){
+         retry_with_new_shm = true;
+      }
+      //If the stored fd is not valid (a open fd, a normal file with the
+      //expected size, or does not have the same file id number,
+      //then it's an old shm from an old process with the same pid.
+      //If that's the case, mark it as invalid
+      else if(!is_valid_fd(fd) ||
+            !is_normal_file(fd) ||
+            0 != get_size(fd) ||
+            !compare_file_serial(fd, *pserial_id)){
+         pserial_id->fd = GMemMarkToBeRemoved;
+         std::string s;
+         get_shm_name(s);
+         shared_memory_object::remove(s.c_str());
+         retry_with_new_shm = true;
+      }
+      else{
+         //If the lock file is ok, increment reference count of
+         //attached modules to shared memory
+         atomic_inc32(&pserial_id->modules_attached_to_gmem_count);
+      }
+   }
+
+   private:
+   locking_file_serial_id * register_lock_file(int fd)
+   {
+      locking_file_serial_id *pinfo = mshm.template construct<locking_file_serial_id>("lock_file_fd")();
+      fill_file_serial_id(fd, *pinfo);
+      return pinfo;
+   }
+
+   public:
+   ManagedShMem &mshm;
+   bool retry_with_new_shm;
+};
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+template<>
+struct lock_file_logic<windows_managed_global_memory>
+{
+   lock_file_logic(windows_managed_global_memory &)
+      : retry_with_new_shm(false)
+   {}
+
+   void operator()(void){}
+   const bool retry_with_new_shm;
+};
+
+#endif
+
+}  //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 reference counted shared memory
+//to be used by all instances
+
+template<class ManagedShMem>
+class intermodule_singleton_common
+{
+   public:
+   typedef void*(singleton_constructor_t)(ManagedShMem &);
+   typedef void (singleton_destructor_t)(void *, ManagedShMem &);
+
+   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 void finalize_singleton_logic(void *ptr, singleton_destructor_t destructor)
+   {
+      if(ptr)
+         destructor(ptr, get_shm());
+      //If this is the last singleton of this module
+      //apply shm 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_shm();
+      }
+   }
+
+   static void initialize_singleton_logic
+      (void *&ptr, volatile boost::uint32_t &this_module_singleton_initialized, singleton_constructor_t ini_func);
+
+   private:
+   static ManagedShMem &get_shm()
+   {
+      return *static_cast<ManagedShMem *>(static_cast<void *>(&mem_holder.shm_mem));
+   }
+
+   static void initialize_shm();
+   static void destroy_shm();
+   //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_shm_initialized is the state of this module's shm class object
+   static volatile boost::uint32_t this_module_shm_initialized;
+   static struct mem_holder_t
+   {
+      ::boost::detail::max_align aligner;
+      char shm_mem [sizeof(ManagedShMem)];
+   } mem_holder;
+};
+
+template<class ManagedShMem>
+volatile boost::uint32_t intermodule_singleton_common<ManagedShMem>::this_module_singleton_count;
+
+template<class ManagedShMem>
+volatile boost::uint32_t intermodule_singleton_common<ManagedShMem>::this_module_shm_initialized;
+
+template<class ManagedShMem>
+typename intermodule_singleton_common<ManagedShMem>::mem_holder_t
+   intermodule_singleton_common<ManagedShMem>::mem_holder;
+
+template<class ManagedShMem>
+void intermodule_singleton_common<ManagedShMem>::initialize_shm()
+{
+   //Obtain unique shm name and size
+   std::string s;
+   while(1){
+      //Try to pass shm state to initializing
+      ::boost::uint32_t tmp = atomic_cas32(&this_module_shm_initialized, Initializing, Uninitialized);
+      if(tmp >= Initialized){
+         break;
+      }
+      //If some other thread is doing the work wait
+      else if(tmp == Initializing){
+         thread_yield();
+      }
+      else{ //(tmp == Uninitialized)
+         //If not initialized try it again?
+         try{
+            //Remove old shared memory from the system
+            intermodule_singleton_helpers::managed_sh_dependant<ManagedShMem>::remove_old_gmem();
+            //
+            if(s.empty()){
+               intermodule_singleton_helpers::get_shm_name(s);
+            }
+            const char *ShmName = s.c_str();
+            const std::size_t ShmSize = intermodule_singleton_helpers::get_shm_size();;
+
+            //in-place construction of the shared memory class
+            ::new (&get_shm())ManagedShMem(open_or_create, ShmName, ShmSize);
+            //Use shared memory internal lock to initialize the lock file
+            //that will mark this gmem as "in use".
+            intermodule_singleton_helpers::lock_file_logic<ManagedShMem> f(get_shm());
+            //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_with_new_shm){
+               get_shm().~ManagedShMem();
+               atomic_write32(&this_module_shm_initialized, Uninitialized);
+            }
+            else{
+               //Locking succeeded, so this shared memory module-instance is ready
+               atomic_write32(&this_module_shm_initialized, Initialized);
+               break;
+            }
+         }
+         catch(...){
+            //
+            throw;
+         }
+      }
+   }
+}
+
+template<class ManagedShMem>
+struct unlink_shmlogic
+{
+   unlink_shmlogic(ManagedShMem &mshm)
+      : mshm_(mshm)
+   {  mshm.atomic_func(*this);  }
+   void operator()()
+   {
+      intermodule_singleton_helpers::locking_file_serial_id *pserial_id =
+         mshm_.template find<intermodule_singleton_helpers::locking_file_serial_id>
+            ("lock_file_fd").first;
+      BOOST_ASSERT(0 != pserial_id);
+      if(1 == atomic_dec32(&pserial_id->modules_attached_to_gmem_count)){
+         int fd = pserial_id->fd;
+         if(fd > 0){
+            pserial_id->fd = intermodule_singleton_helpers::GMemMarkToBeRemoved;
+            std::string s;
+            intermodule_singleton_helpers::create_and_get_singleton_lock_file_path(s);
+            delete_file(s.c_str());
+            intermodule_singleton_helpers::close_lock_file(fd);
+            intermodule_singleton_helpers::get_shm_name(s);
+            shared_memory_object::remove(s.c_str());
+         }
+      }
+   }
+   ManagedShMem &mshm_;
+};
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+template<>
+struct unlink_shmlogic<windows_managed_global_memory>
+{
+   unlink_shmlogic(windows_managed_global_memory &)
+   {}
+   void operator()(){}
+};
+
+#endif
+
+
+template<class ManagedShMem>
+void intermodule_singleton_common<ManagedShMem>::destroy_shm()
+{
+   if(!atomic_read32(&this_module_singleton_count)){
+      //This module is being unloaded, so destroy
+      //the shared memory object of this module
+      //and unlink the shared memory if it's the last
+      unlink_shmlogic<ManagedShMem> f(get_shm());
+      (get_shm()).~ManagedShMem();
+      atomic_write32(&this_module_shm_initialized, Uninitialized);
+      //Do some cleanup for other processes old gmem instances
+      intermodule_singleton_helpers::managed_sh_dependant<ManagedShMem>::remove_old_gmem();
+   }
+}
+
+//Initialize this_module_singleton_ptr, creates the shared memory if needed and also creates an unique
+//opaque type in shared memory through a singleton_constructor_t function call,
+//initializing the passed pointer to that unique instance.
+//
+//We have two concurrency types here. a)the shared memory/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.
+template<class ManagedShMem>
+void intermodule_singleton_common<ManagedShMem>::initialize_singleton_logic
+   (void *&ptr, volatile boost::uint32_t &this_module_singleton_initialized, singleton_constructor_t constructor)
+{
+   //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 shared memory
+      if(previous_module_singleton_initialized == Uninitialized){
+         try{
+            //Now initialize shm, this function solves concurrency issues
+            //between threads of several modules
+            initialize_shm();
+            //Increment the module reference count that reflects how many
+            //singletons this module holds, so that we can safely destroy
+            //module shared memory object when no singleton is left
+            atomic_inc32(&this_module_singleton_count);
+            //Now try to create the singleton in shared memory.
+            //This function solves concurrency issues
+            //between threads of several modules
+            void *tmp = constructor(get_shm());
+            //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_inc32(&this_module_singleton_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){
+         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){
+               thread_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);
+}
+
+//Now this class is a singleton, initializing the singleton in
+//the first get() function call if LazyInit is false. If true
+//then the singleton will be initialized when loading the module.
+template<typename C, bool LazyInit, class ManagedShMem>
+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
+            intermodule_singleton_common<ManagedShMem>::initialize_singleton_logic
+               (this_module_singleton_ptr, this_module_singleton_initialized, singleton_constructor);
+      }
+      return *static_cast<C*>(this_module_singleton_ptr);
+   }
+
+   private:
+
+   struct ref_count_ptr
+   {
+      ref_count_ptr(C *p, boost::uint32_t count)
+         : ptr(p), singleton_ref_count(count)
+      {}
+      C *ptr;
+      //This reference count serves to count the number of attached
+      //modules to this singleton
+      volatile boost::uint32_t singleton_ref_count;
+   };
+
+   //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()
+      {
+         intermodule_singleton_common<ManagedShMem>::finalize_singleton_logic
+            (this_module_singleton_ptr, singleton_destructor);
+      }
+      //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()
+      {
+         intermodule_singleton_common<ManagedShMem>::initialize_singleton_logic
+            (this_module_singleton_ptr, this_module_singleton_initialized, singleton_constructor);
+      }
+   };
+
+   typedef typename if_c
+      <LazyInit, lifetime_type_lazy, lifetime_type_static>::type lifetime_type;
+
+   static lifetime_type lifetime;
+
+   //A functor to be executed inside shared memory lock that just
+   //searches for the singleton in shm and if not present creates a new one.
+   //If singleton constructor throws, the exception is propagated
+   struct init_atomic_func
+   {
+      init_atomic_func(ManagedShMem &m)
+         : mshm(m)
+      {}
+
+      void operator()()
+      {
+         ref_count_ptr *rcount = mshm.template find<ref_count_ptr>(unique_instance).first;
+         if(!rcount){
+            C *p = new C();
+            try{
+               rcount = mshm.template construct<ref_count_ptr>(unique_instance)(p, 0u);
+            }
+            catch(...){
+               delete p;
+               throw;
+            }
+         }
+         atomic_inc32(&rcount->singleton_ref_count);
+         ret_ptr = rcount->ptr;
+      }
+      ManagedShMem &mshm;
+      void *ret_ptr;
+   };
+
+   //A functor to be executed inside shared memory lock that just
+   //deletes the singleton in shm if the attached count reaches to zero
+   struct fini_atomic_func
+   {
+      fini_atomic_func(ManagedShMem &m)
+         : mshm(m)
+      {}
+
+      void operator()()
+      {
+         ref_count_ptr *rcount = mshm.template find<ref_count_ptr>(unique_instance).first;
+            //The object must exist
+         BOOST_ASSERT(rcount);
+         //Check if last reference
+         if(atomic_dec32(&rcount->singleton_ref_count) == 1){
+            //If last, destroy the object
+            BOOST_ASSERT(rcount->ptr != 0);
+            delete rcount->ptr;
+            //Now destroy shm entry
+            bool destroyed = mshm.template destroy<ref_count_ptr>(unique_instance);
+            (void)destroyed;  BOOST_ASSERT(destroyed == true);
+         }
+      }
+      ManagedShMem &mshm;
+      void *ret_ptr;
+   };
+
+   //A wrapper to execute init_atomic_func
+   static void *singleton_constructor(ManagedShMem &mshm)
+   {
+      init_atomic_func f(mshm);
+      mshm.atomic_func(f);
+      return f.ret_ptr;
+   }
+
+   //A wrapper to execute fini_atomic_func
+   static void singleton_destructor(void *p, ManagedShMem &mshm)
+   {  (void)p;
+      fini_atomic_func f(mshm);
+      mshm.atomic_func(f);
+   }
+};
+
+template <typename C, bool L, class ManagedShMem>
+volatile int intermodule_singleton_impl<C, L, ManagedShMem>::lifetime_type_lazy::m_dummy = 0;
+
+//These will be zero-initialized by the loader
+template <typename C, bool L, class ManagedShMem>
+void *intermodule_singleton_impl<C, L, ManagedShMem>::this_module_singleton_ptr = 0;
+
+template <typename C, bool L, class ManagedShMem>
+volatile boost::uint32_t intermodule_singleton_impl<C, L, ManagedShMem>::this_module_singleton_initialized = 0;
+
+template <typename C, bool L, class ManagedShMem>
+typename intermodule_singleton_impl<C, L, ManagedShMem>::lifetime_type
+   intermodule_singleton_impl<C, L, ManagedShMem>::lifetime;
+
+template<typename C, bool LazyInit = false>
+class portable_intermodule_singleton
+   : public intermodule_singleton_impl<C, LazyInit, managed_global_memory>
+{};
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+template<typename C, bool LazyInit = false>
+class windows_intermodule_singleton
+   : public intermodule_singleton_impl
+      < C
+      , LazyInit
+      , windows_managed_global_memory
+      >
+{};
+
+#endif
+
+//Now this class is a singleton, initializing the singleton in
+//the first get() function call if LazyInit is false. If true
+//then the singleton will be initialized when loading the module.
+template<typename C, bool LazyInit = false>
+class intermodule_singleton
+   #ifdef BOOST_INTERPROCESS_WINDOWS
+   : public windows_intermodule_singleton<C, LazyInit>
+   #else
+   : public portable_intermodule_singleton<C, LazyInit>
+   #endif
+{};
+
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif
diff --git a/boost/interprocess/detail/interprocess_tester.hpp b/boost/interprocess/detail/interprocess_tester.hpp
new file mode 100644
index 0000000000..2581776745
--- /dev/null
+++ b/boost/interprocess/detail/interprocess_tester.hpp
@@ -0,0 +1,31 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2011. 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_DETAIL_INTERPROCESS_TESTER_HPP
+#define BOOST_INTERPROCESS_DETAIL_INTERPROCESS_TESTER_HPP
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+class interprocess_tester
+{
+   public:
+   template<class T>
+   static void dont_close_on_destruction(T &t)
+   {  t.dont_close_on_destruction(); }
+};
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_INTERPROCESS_TESTER_HPP
+
diff --git a/boost/interprocess/detail/intersegment_ptr.hpp b/boost/interprocess/detail/intersegment_ptr.hpp
new file mode 100644
index 0000000000..92970923d0
--- /dev/null
+++ b/boost/interprocess/detail/intersegment_ptr.hpp
@@ -0,0 +1,1040 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_INTERSEGMENT_PTR_HPP
+#define BOOST_INTERPROCESS_INTERSEGMENT_PTR_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/math_functions.hpp>
+#include <boost/interprocess/detail/cast_tags.hpp>
+#include <boost/assert.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/containers/flat_map.hpp>
+#include <boost/interprocess/containers/vector.hpp>   //vector
+#include <boost/interprocess/containers/set.hpp>      //set
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <climits>
+#include <iterator>
+#include <boost/static_assert.hpp>  //BOOST_STATIC_ASSERT
+#include <climits>   //CHAR_BIT
+#include <boost/integer/static_log2.hpp>
+#include <boost/assert.hpp>   //BOOST_ASSERT
+#include <boost/interprocess/detail/multi_segment_services.hpp>
+
+//!\file
+//!
+namespace boost {
+
+//Predeclarations
+template <class T>
+struct has_trivial_constructor;
+
+template <class T>
+struct has_trivial_destructor;
+
+namespace interprocess {
+
+template <class T>
+struct is_multisegment_ptr;
+
+struct intersegment_base
+{
+   typedef intersegment_base  self_t;
+   BOOST_STATIC_ASSERT((sizeof(std::size_t) == sizeof(void*)));
+   BOOST_STATIC_ASSERT((sizeof(void*)*CHAR_BIT == 32 || sizeof(void*)*CHAR_BIT == 64));
+   static const std::size_t size_t_bits = (sizeof(void*)*CHAR_BIT == 32) ? 32 : 64;
+   static const std::size_t ctrl_bits = 2;
+   static const std::size_t align_bits = 12;
+   static const std::size_t align      = std::size_t(1) << align_bits;
+   static const std::size_t max_segment_size_bits = size_t_bits - 2;
+   static const std::size_t max_segment_size = std::size_t(1) << max_segment_size_bits;
+
+   static const std::size_t begin_bits             = max_segment_size_bits - align_bits;
+   static const std::size_t pow_size_bits_helper = static_log2<max_segment_size_bits>::value;
+   static const std::size_t pow_size_bits = 
+      (max_segment_size_bits == (std::size_t(1) << pow_size_bits_helper)) ? 
+      pow_size_bits_helper : pow_size_bits_helper + 1;
+   static const std::size_t frc_size_bits =
+      size_t_bits - ctrl_bits - begin_bits - pow_size_bits;
+
+   BOOST_STATIC_ASSERT(((size_t_bits - pow_size_bits - frc_size_bits) >= ctrl_bits ));
+
+   static const std::size_t relative_size_bits =
+      size_t_bits - max_segment_size_bits - ctrl_bits;
+
+   static const std::size_t is_pointee_outside  = 0;
+   static const std::size_t is_in_stack         = 1;
+   static const std::size_t is_relative         = 2;
+   static const std::size_t is_segmented        = 3;
+   static const std::size_t is_max_mode         = 4;
+
+   intersegment_base()
+   {
+      this->set_mode(is_pointee_outside);
+      this->set_null();
+   }
+
+   struct relative_addressing
+   {
+      std::size_t ctrl     :  2;
+      std::size_t pow      :  pow_size_bits;
+      std::size_t frc      :  frc_size_bits;
+      std::size_t beg      :  begin_bits;
+      std::ptrdiff_t off   :  sizeof(std::ptrdiff_t)*CHAR_BIT - 2;
+      std::ptrdiff_t bits  :  2;
+   };
+
+   struct direct_addressing
+   {
+      std::size_t ctrl     :  2;
+      std::size_t dummy    :  sizeof(std::size_t)*CHAR_BIT - 2;
+      void * addr;
+   };
+
+   struct segmented_addressing
+   {
+      std::size_t ctrl     :  2;
+      std::size_t segment  :  sizeof(std::size_t)*CHAR_BIT - 2;
+      std::size_t off      :  sizeof(std::size_t)*CHAR_BIT - 2;
+      std::size_t bits     :  2;
+   };
+
+   union members_t{
+      relative_addressing  relative;
+      direct_addressing    direct;
+      segmented_addressing segmented;
+   } members;
+
+   BOOST_STATIC_ASSERT(sizeof(members_t) == 2*sizeof(std::size_t));
+
+   void *relative_calculate_begin_addr() const
+   {
+      const std::size_t mask = ~(align - 1);
+      std::size_t beg = this->members.relative.beg;
+      return reinterpret_cast<void*>((((std::size_t)this) & mask) - (beg << align_bits));
+   }
+
+   void relative_set_begin_from_base(void *addr)
+   {
+      BOOST_ASSERT(addr < static_cast<void*>(this));
+      std::size_t off = reinterpret_cast<char*>(this) - reinterpret_cast<char*>(addr);
+      members.relative.beg = off >> align_bits;
+   }
+
+   //!Obtains the address pointed by the
+   //!object
+   std::size_t relative_size() const
+   {
+      std::size_t pow  = members.relative.pow;
+      std::size_t size = (std::size_t(1u) << pow);
+      BOOST_ASSERT(pow >= frc_size_bits);
+      size |= members.relative.frc << (pow - frc_size_bits);
+      return size;
+   }
+
+   static std::size_t calculate_size(std::size_t orig_size, std::size_t &pow, std::size_t &frc)
+   {
+      if(orig_size < align)
+         orig_size = align;
+      orig_size = ipcdetail::get_rounded_size_po2(orig_size, align);
+      pow = ipcdetail::floor_log2(orig_size);
+      std::size_t low_size = (std::size_t(1) << pow);
+      std::size_t diff = orig_size - low_size;
+      BOOST_ASSERT(pow >= frc_size_bits);
+      std::size_t rounded = ipcdetail::get_rounded_size_po2
+                              (diff, (std::size_t)(1u << (pow - frc_size_bits)));
+      if(rounded == low_size){
+         ++pow;
+         frc = 0;
+         rounded  = 0;
+      }
+      else{
+         frc = rounded >> (pow - frc_size_bits);
+      }
+      BOOST_ASSERT(((frc << (pow - frc_size_bits)) & (align-1))==0);
+      return low_size + rounded;
+   }
+
+   std::size_t get_mode()const
+   {  return members.direct.ctrl;   }
+
+   void set_mode(std::size_t mode)
+   {
+      BOOST_ASSERT(mode < is_max_mode);      
+      members.direct.ctrl = mode;
+   }
+
+   //!Returns true if object represents
+   //!null pointer
+   bool is_null() const
+   {
+      return   (this->get_mode() < is_relative) && 
+               !members.direct.dummy &&
+               !members.direct.addr;
+   }
+
+   //!Sets the object to represent
+   //!the null pointer
+   void set_null()
+   {
+      if(this->get_mode() >= is_relative){
+         this->set_mode(is_pointee_outside);
+      }
+      members.direct.dummy = 0;
+      members.direct.addr  = 0;
+   }
+
+   static std::size_t round_size(std::size_t orig_size)
+   {
+      std::size_t pow, frc;
+      return calculate_size(orig_size, pow, frc);
+   }
+};
+
+
+
+//!Configures intersegment_ptr with the capability to address:
+//!2^(sizeof(std::size_t)*CHAR_BIT/2) segment groups
+//!2^(sizeof(std::size_t)*CHAR_BIT/2) segments per group.
+//!2^(sizeof(std::size_t)*CHAR_BIT/2)-1 bytes maximum per segment.
+//!The mapping is implemented through flat_maps synchronized with mutexes.
+template <class Mutex>
+struct flat_map_intersegment
+   :  public intersegment_base
+{
+   typedef flat_map_intersegment<Mutex>   self_t;
+
+   void set_from_pointer(const volatile void *ptr)
+   {  this->set_from_pointer(const_cast<const void *>(ptr));  }
+
+   //!Obtains the address pointed
+   //!by the object
+   void *to_raw_pointer() const
+   {
+      if(is_null()){
+         return 0;
+      }
+      switch(this->get_mode()){
+         case is_relative:
+            return const_cast<char*>(reinterpret_cast<const char*>(this)) + members.relative.off;
+         break;
+         case is_segmented:
+            {
+            segment_info_t segment_info;
+            std::size_t offset;
+            void *this_base;
+            get_segment_info_and_offset(this, segment_info, offset, this_base);
+            char *base  = static_cast<char*>(segment_info.group->address_of(this->members.segmented.segment));
+            return base + this->members.segmented.off;
+            }
+         break;
+         case is_in_stack:
+         case is_pointee_outside:
+            return members.direct.addr;
+         break;
+         default:
+         return 0;
+         break;
+      }
+   }
+
+   //!Calculates the distance between two basic_intersegment_ptr-s.
+   //!This only works with two basic_intersegment_ptr pointing
+   //!to the same segment. Otherwise undefined
+   std::ptrdiff_t diff(const self_t &other) const
+   {  return static_cast<char*>(this->to_raw_pointer()) - static_cast<char*>(other.to_raw_pointer());   }
+
+   //!Returns true if both point to
+   //!the same object
+   bool equal(const self_t &y) const
+   {  return this->to_raw_pointer() == y.to_raw_pointer();  }
+
+   //!Returns true if *this is less than other.
+   //!This only works with two basic_intersegment_ptr pointing
+   //!to the same segment group. Otherwise undefined. Never throws
+   bool less(const self_t &y) const
+   {  return this->to_raw_pointer() < y.to_raw_pointer(); }
+
+   void swap(self_t &other)
+   {
+      void *ptr_this  = this->to_raw_pointer();
+      void *ptr_other = other.to_raw_pointer();
+      other.set_from_pointer(ptr_this);
+      this->set_from_pointer(ptr_other);
+   }
+
+   //!Sets the object internals to represent the
+   //!address pointed by ptr
+   void set_from_pointer(const void *ptr)
+   {
+      if(!ptr){
+         this->set_null();
+         return;
+      }
+
+      std::size_t mode = this->get_mode();
+      if(mode == is_in_stack){
+         members.direct.addr = const_cast<void*>(ptr);
+         return;
+      }
+      if(mode == is_relative){
+         char *beg_addr = static_cast<char*>(this->relative_calculate_begin_addr());
+         std::size_t seg_size = this->relative_size();
+         if(ptr >= beg_addr && ptr < (beg_addr + seg_size)){
+            members.relative.off = static_cast<const char*>(ptr) - reinterpret_cast<const char*>(this);
+            return;
+         }
+      }
+      std::size_t ptr_offset;
+      std::size_t this_offset;
+      segment_info_t ptr_info;
+      segment_info_t this_info;
+      void *ptr_base;
+      void *this_base;
+      get_segment_info_and_offset(this, this_info, this_offset, this_base);
+   
+      if(!this_info.group){
+         this->set_mode(is_in_stack);
+         this->members.direct.addr = const_cast<void*>(ptr);
+      }
+      else{
+         get_segment_info_and_offset(ptr, ptr_info, ptr_offset, ptr_base);      
+
+         if(ptr_info.group != this_info.group){
+            this->set_mode(is_pointee_outside);
+            this->members.direct.addr =  const_cast<void*>(ptr);
+         }
+         else if(ptr_info.id == this_info.id){
+            this->set_mode(is_relative);
+            members.relative.off = (static_cast<const char*>(ptr) - reinterpret_cast<const char*>(this));
+            this->relative_set_begin_from_base(this_base);
+            std::size_t pow, frc;
+            std::size_t s = calculate_size(this_info.size, pow, frc);
+            (void)s;
+            BOOST_ASSERT(this_info.size == s);
+            this->members.relative.pow = pow;
+            this->members.relative.frc = frc;
+         }
+         else{
+            this->set_mode(is_segmented);
+            this->members.segmented.segment = ptr_info.id;
+            this->members.segmented.off     = ptr_offset;
+         }
+      }
+   }
+
+   //!Sets the object internals to represent the address pointed 
+   //!by another flat_map_intersegment
+   void set_from_other(const self_t &other)
+   {
+      this->set_from_pointer(other.to_raw_pointer());
+   }
+
+   //!Increments internal
+   //!offset
+   void inc_offset(std::ptrdiff_t bytes)
+   {
+      this->set_from_pointer(static_cast<char*>(this->to_raw_pointer()) + bytes);
+   }
+
+   //!Decrements internal
+   //!offset
+   void dec_offset(std::ptrdiff_t bytes)
+   {
+      this->set_from_pointer(static_cast<char*>(this->to_raw_pointer()) - bytes);
+   }
+
+   //////////////////////////////////////
+   //////////////////////////////////////
+   //////////////////////////////////////
+
+   flat_map_intersegment()
+      :  intersegment_base()
+   {}
+
+   ~flat_map_intersegment()
+   {}
+
+   private:
+
+   class segment_group_t
+   {
+      struct segment_data
+      {
+         void *addr;
+         std::size_t size;
+      };
+      vector<segment_data> m_segments;
+      multi_segment_services &m_ms_services;
+      
+      public:
+      segment_group_t(multi_segment_services &ms_services)
+         :  m_ms_services(ms_services)
+      {}
+
+      void push_back(void *addr, std::size_t size)
+      {
+         segment_data d = { addr, size };
+         m_segments.push_back(d);
+      }
+
+      void pop_back()
+      {
+         BOOST_ASSERT(!m_segments.empty());
+         m_segments.erase(--m_segments.end());
+      }
+
+
+      void *address_of(std::size_t segment_id)
+      {
+         BOOST_ASSERT(segment_id < (std::size_t)m_segments.size());
+         return m_segments[segment_id].addr;
+      }
+
+      void clear_segments()
+      {  m_segments.clear();  }
+
+      std::size_t get_size() const
+      {  return m_segments.size();  }
+
+      multi_segment_services &get_multi_segment_services() const
+      {  return m_ms_services;   }
+
+      friend bool operator< (const segment_group_t&l, const segment_group_t &r)
+      {  return &l.m_ms_services < &r.m_ms_services;   }
+   };
+
+   struct segment_info_t
+   {
+      std::size_t size;
+      std::size_t id;
+      segment_group_t *group;
+      segment_info_t()
+         :  size(0), id(0), group(0)
+      {}
+   };
+
+   typedef set<segment_group_t>  segment_groups_t;
+
+   typedef boost::interprocess::flat_map
+      <const void * 
+      ,segment_info_t
+      ,std::less<const void *> >          ptr_to_segment_info_t;
+
+   struct mappings_t : Mutex
+   {
+      //!Mutex to preserve integrity in multi-threaded
+      //!enviroments
+      typedef Mutex        mutex_type;
+      //!Maps base addresses and segment information 
+      //!(size and segment group and id)*
+      
+      ptr_to_segment_info_t      m_ptr_to_segment_info;
+
+      ~mappings_t()
+      {
+         //Check that all mappings have been erased
+         BOOST_ASSERT(m_ptr_to_segment_info.empty());
+      }
+   };
+
+   //Static members
+   static mappings_t       s_map;
+   static segment_groups_t s_groups;
+   public:
+
+   typedef segment_group_t*      segment_group_id;
+
+   //!Returns the segment and offset
+   //!of an address
+   static void get_segment_info_and_offset(const void *ptr, segment_info_t &segment, std::size_t &offset, void *&base)
+   {
+      //------------------------------------------------------------------
+      boost::interprocess::scoped_lock<typename mappings_t::mutex_type> lock(s_map);
+      //------------------------------------------------------------------
+      base = 0;
+      if(s_map.m_ptr_to_segment_info.empty()){
+         segment = segment_info_t();
+         offset  = reinterpret_cast<const char*>(ptr) - static_cast<const char*>(0);
+         return;
+      }
+      //Find the first base address greater than ptr
+      typename ptr_to_segment_info_t::iterator it 
+         = s_map.m_ptr_to_segment_info.upper_bound(ptr);
+      if(it == s_map.m_ptr_to_segment_info.begin()){
+         segment = segment_info_t();
+         offset  = reinterpret_cast<const char*>(ptr) - static_cast<const char *>(0);
+      }
+      //Go to the previous one
+      --it;
+      char *      segment_base = const_cast<char*>(reinterpret_cast<const char*>(it->first));
+      std::size_t segment_size = it->second.size;
+      
+      if(segment_base <= reinterpret_cast<const char*>(ptr) &&
+         (segment_base + segment_size) >= reinterpret_cast<const char*>(ptr)){
+         segment = it->second;
+         offset  = reinterpret_cast<const char*>(ptr) - segment_base;
+         base = segment_base;
+      }
+      else{
+         segment = segment_info_t();
+         offset  = reinterpret_cast<const char*>(ptr) - static_cast<const char*>(0);
+      }
+   }
+
+   //!Associates a segment defined by group/id with a base address and size.
+   //!Returns false if the group is not found or there is an error
+   static void insert_mapping(segment_group_id group_id, void *ptr, std::size_t size)
+   {
+      //------------------------------------------------------------------
+      boost::interprocess::scoped_lock<typename mappings_t::mutex_type> lock(s_map);
+      //------------------------------------------------------------------
+
+      typedef typename ptr_to_segment_info_t::value_type value_type;
+      typedef typename ptr_to_segment_info_t::iterator   iterator;
+      typedef std::pair<iterator, bool>                  it_b_t;
+
+      segment_info_t info;
+      info.group = group_id;
+      info.size  = size;
+      info.id    = group_id->get_size();
+
+      it_b_t ret = s_map.m_ptr_to_segment_info.insert(value_type(ptr, info));
+      BOOST_ASSERT(ret.second);
+
+      value_eraser<ptr_to_segment_info_t> v_eraser(s_map.m_ptr_to_segment_info, ret.first);
+      group_id->push_back(ptr, size);
+      v_eraser.release();
+   }
+
+   static bool erase_last_mapping(segment_group_id group_id)
+   {
+      //------------------------------------------------------------------
+      boost::interprocess::scoped_lock<typename mappings_t::mutex_type> lock(s_map);
+      //------------------------------------------------------------------
+      if(!group_id->get_size()){
+         return false;
+      }
+      else{
+         void *addr = group_id->address_of(group_id->get_size()-1);
+         group_id->pop_back();
+         std::size_t erased = s_map.m_ptr_to_segment_info.erase(addr);
+         (void)erased;
+         BOOST_ASSERT(erased);
+         return true;
+      }
+   }
+
+   static segment_group_id new_segment_group(multi_segment_services *services)
+   {
+      {  //------------------------------------------------------------------
+         boost::interprocess::scoped_lock<typename mappings_t::mutex_type> lock(s_map);
+         //------------------------------------------------------------------
+         typedef typename segment_groups_t::iterator iterator;
+         std::pair<iterator, bool> ret =
+            s_groups.insert(segment_group_t(*services));
+         BOOST_ASSERT(ret.second);
+         return &*ret.first;
+      }      
+   }
+
+   static bool delete_group(segment_group_id id)
+   {
+      {  //------------------------------------------------------------------
+         boost::interprocess::scoped_lock<typename mappings_t::mutex_type> lock(s_map);
+         //------------------------------------------------------------------
+         bool success = 1u == s_groups.erase(segment_group_t(*id));
+         if(success){
+            typedef typename ptr_to_segment_info_t::iterator ptr_to_segment_info_it;
+            ptr_to_segment_info_it it(s_map.m_ptr_to_segment_info.begin());
+            while(it != s_map.m_ptr_to_segment_info.end()){
+               if(it->second.group == id){
+                  it = s_map.m_ptr_to_segment_info.erase(it);
+               }
+               else{
+                  ++it;
+               }
+            }
+         }
+         return success;
+      }      
+   }
+};
+
+//!Static map-segment_info associated with
+//!flat_map_intersegment<>
+template <class Mutex>
+typename flat_map_intersegment<Mutex>::mappings_t 
+   flat_map_intersegment<Mutex>::s_map;
+
+//!Static segment group container associated with
+//!flat_map_intersegment<>
+template <class Mutex>
+typename flat_map_intersegment<Mutex>::segment_groups_t 
+   flat_map_intersegment<Mutex>::s_groups;
+
+//!A smart pointer that can point to a pointee that resides in another memory 
+//!memory mapped or shared memory segment.
+template <class T>
+class intersegment_ptr : public flat_map_intersegment<interprocess_mutex>
+{
+   typedef flat_map_intersegment<interprocess_mutex> PT;
+   typedef intersegment_ptr<T>                  self_t;
+   typedef PT                                      base_t;
+
+   void unspecified_bool_type_func() const {}
+   typedef void (self_t::*unspecified_bool_type)() const;
+
+   public:
+   typedef T *                                     pointer;
+   typedef typename ipcdetail::add_reference<T>::type reference;
+   typedef T                                       value_type;
+   typedef std::ptrdiff_t                          difference_type;
+   typedef std::random_access_iterator_tag         iterator_category;
+
+   public:   //Public Functions
+
+   //!Constructor from raw pointer (allows "0" pointer conversion).
+   //!Never throws.
+   intersegment_ptr(pointer ptr = 0)
+   {  base_t::set_from_pointer(ptr);   }
+
+   //!Constructor from other pointer.
+   //!Never throws.
+   template <class U>
+   intersegment_ptr(U *ptr){  base_t::set_from_pointer(pointer(ptr)); }
+
+   //!Constructor from other intersegment_ptr
+   //!Never throws
+   intersegment_ptr(const intersegment_ptr& ptr) 
+   {  base_t::set_from_other(ptr);   }
+
+   //!Constructor from other intersegment_ptr. If pointers of pointee types are 
+   //!convertible, intersegment_ptrs will be convertibles. Never throws.
+   template<class T2>
+   intersegment_ptr(const intersegment_ptr<T2> &ptr) 
+   {  pointer p(ptr.get());   (void)p; base_t::set_from_other(ptr); }
+
+   //!Emulates static_cast operator.
+   //!Never throws.
+   template<class U>
+   intersegment_ptr(const intersegment_ptr<U> &r, ipcdetail::static_cast_tag)
+   {  base_t::set_from_pointer(static_cast<T*>(r.get())); }
+
+   //!Emulates const_cast operator.
+   //!Never throws.
+   template<class U>
+   intersegment_ptr(const intersegment_ptr<U> &r, ipcdetail::const_cast_tag)
+   {  base_t::set_from_pointer(const_cast<T*>(r.get())); }
+
+   //!Emulates dynamic_cast operator.
+   //!Never throws.
+   template<class U>
+   intersegment_ptr(const intersegment_ptr<U> &r, ipcdetail::dynamic_cast_tag)
+   {  base_t::set_from_pointer(dynamic_cast<T*>(r.get())); }
+
+   //!Emulates reinterpret_cast operator.
+   //!Never throws.
+   template<class U>
+   intersegment_ptr(const intersegment_ptr<U> &r, ipcdetail::reinterpret_cast_tag)
+   {  base_t::set_from_pointer(reinterpret_cast<T*>(r.get())); }
+
+   //!Obtains raw pointer from offset.
+   //!Never throws.
+   pointer get()const
+   {  return static_cast<pointer>(base_t::to_raw_pointer());   }
+
+   //!Pointer-like -> operator. It can return 0 pointer.
+   //!Never throws.
+   pointer operator->() const           
+   {  return self_t::get(); }
+
+   //!Dereferencing operator, if it is a null intersegment_ptr behavior 
+   //!is undefined. Never throws.
+   reference operator* () const           
+   {  return *(self_t::get());   }
+
+   //!Indexing operator.
+   //!Never throws.
+   reference operator[](std::ptrdiff_t idx) const   
+   {  return self_t::get()[idx];  }
+
+   //!Assignment from pointer (saves extra conversion).
+   //!Never throws.
+   intersegment_ptr& operator= (pointer from)
+   {  base_t::set_from_pointer(from); return *this;  }
+
+   //!Assignment from other intersegment_ptr.
+   //!Never throws.
+   intersegment_ptr& operator= (const intersegment_ptr &ptr)
+   {  base_t::set_from_other(ptr);  return *this;  }
+
+   //!Assignment from related intersegment_ptr. If pointers of pointee types 
+   //!are assignable, intersegment_ptrs will be assignable. Never throws.
+   template <class T2>
+   intersegment_ptr& operator= (const intersegment_ptr<T2> & ptr)
+   {  
+      pointer p(ptr.get());   (void)p; 
+      base_t::set_from_other(ptr); return *this;   
+   }
+ 
+   //!intersegment_ptr + std::ptrdiff_t.
+   //!Never throws.
+   intersegment_ptr operator+ (std::ptrdiff_t idx) const   
+   {  
+      intersegment_ptr result (*this);
+      result.inc_offset(idx*sizeof(T));
+      return result;
+   }
+
+   //!intersegment_ptr - std::ptrdiff_t.
+   //!Never throws.
+   intersegment_ptr operator- (std::ptrdiff_t idx) const   
+   {  
+      intersegment_ptr result (*this);
+      result.dec_offset(idx*sizeof(T));
+      return result;
+   }
+
+   //!intersegment_ptr += std::ptrdiff_t.
+   //!Never throws.
+   intersegment_ptr &operator+= (std::ptrdiff_t offset)
+   {  base_t::inc_offset(offset*sizeof(T));  return *this;  }
+
+   //!intersegment_ptr -= std::ptrdiff_t.
+   //!Never throws.
+   intersegment_ptr &operator-= (std::ptrdiff_t offset)
+   {  base_t::dec_offset(offset*sizeof(T));  return *this;  }
+
+   //!++intersegment_ptr.
+   //!Never throws.
+   intersegment_ptr& operator++ (void)
+   {  base_t::inc_offset(sizeof(T));   return *this;  }
+ 
+   //!intersegment_ptr++.
+   //!Never throws.
+   intersegment_ptr operator++ (int)
+   {  intersegment_ptr temp(*this); ++*this; return temp; }
+
+   //!--intersegment_ptr.
+   //!Never throws.
+   intersegment_ptr& operator-- (void)
+   {  base_t::dec_offset(sizeof(T));   return *this;  }
+
+   //!intersegment_ptr--.
+   //!Never throws.
+   intersegment_ptr operator-- (int)
+   {  intersegment_ptr temp(*this); --*this; return temp; }
+
+   //!Safe bool conversion operator.
+   //!Never throws.
+   operator unspecified_bool_type() const  
+   {  return base_t::is_null()? 0 : &self_t::unspecified_bool_type_func;   }
+
+   //!Not operator. Not needed in theory, but improves portability. 
+   //!Never throws.
+   bool operator! () const
+   {  return base_t::is_null();   }
+
+   //!Swaps two intersegment_ptr-s. More efficient than std::swap.
+   //!Never throws.
+   void swap(intersegment_ptr &other)
+   {  base_t::swap(other);   }
+
+   //!Calculates the distance between two intersegment_ptr-s.
+   //!This only works with two basic_intersegment_ptr pointing
+   //!to the same segment. Otherwise undefined
+   template <class T2>
+   std::ptrdiff_t _diff(const intersegment_ptr<T2> &other) const
+   {  return base_t::diff(other);   }
+
+   //!Returns true if both point to the
+   //!same object
+   template <class T2>
+   bool _equal(const intersegment_ptr<T2>&other) const
+   {  return base_t::equal(other);   }
+
+   //!Returns true if *this is less than other.
+   //!This only works with two basic_intersegment_ptr pointing
+   //!to the same segment group. Otherwise undefined. Never throws
+   template <class T2>
+   bool _less(const intersegment_ptr<T2> &other) const
+   {  return base_t::less(other);   }
+};
+
+//!Compares the equality of two intersegment_ptr-s.
+//!Never throws.
+template <class T1, class T2> inline
+bool operator ==(const intersegment_ptr<T1> &left,
+                 const intersegment_ptr<T2> &right)
+{  
+   //Make sure both pointers can be compared
+   bool e = typename intersegment_ptr<T1>::pointer(0) ==
+            typename intersegment_ptr<T2>::pointer(0);
+   (void)e;
+   return left._equal(right);   
+}
+
+//!Returns true if *this is less than other.
+//!This only works with two basic_intersegment_ptr pointing
+//!to the same segment group. Otherwise undefined. Never throws
+template <class T1, class T2> inline
+bool operator <(const intersegment_ptr<T1> &left,
+                const intersegment_ptr<T2> &right)
+{  
+   //Make sure both pointers can be compared
+   bool e = typename intersegment_ptr<T1>::pointer(0) <
+            typename intersegment_ptr<T2>::pointer(0);
+   (void)e;
+   return left._less(right);   
+}
+
+template<class T1, class T2> inline
+bool operator!= (const intersegment_ptr<T1> &pt1, 
+                 const intersegment_ptr<T2> &pt2)
+{  return !(pt1 ==pt2);  }
+
+//!intersegment_ptr<T1> <= intersegment_ptr<T2>.
+//!Never throws.
+template<class T1, class T2> inline
+bool operator<= (const intersegment_ptr<T1> &pt1, 
+                 const intersegment_ptr<T2> &pt2)
+{  return !(pt1 > pt2);  }
+
+//!intersegment_ptr<T1> > intersegment_ptr<T2>.
+//!Never throws.
+template<class T1, class T2> inline
+bool operator> (const intersegment_ptr<T1> &pt1, 
+                       const intersegment_ptr<T2> &pt2)
+{  return (pt2 < pt1);  }
+
+//!intersegment_ptr<T1> >= intersegment_ptr<T2>.
+//!Never throws.
+template<class T1, class T2> inline
+bool operator>= (const intersegment_ptr<T1> &pt1, 
+                 const intersegment_ptr<T2> &pt2)
+{  return !(pt1 < pt2);  }
+
+//!operator<<
+template<class E, class T, class U> inline
+std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, const intersegment_ptr<U> & p)
+{  return os << p.get();   }
+
+//!operator>>
+template<class E, class T, class U> inline
+std::basic_istream<E, T> & operator>> 
+   (std::basic_istream<E, T> & os, intersegment_ptr<U> & p)
+{  U * tmp; return os >> tmp; p = tmp;   }
+
+//!std::ptrdiff_t + intersegment_ptr. 
+//!The result is another pointer of the same segment
+template<class T> inline
+intersegment_ptr<T> operator+
+   (std::ptrdiff_t diff, const intersegment_ptr<T>& right)
+{  return right + diff;  }
+
+//!intersegment_ptr - intersegment_ptr. 
+//!This only works with two intersegment_ptr-s that point to the
+//!same segment
+template <class T, class T2> inline
+std::ptrdiff_t operator- (const intersegment_ptr<T> &pt, 
+                          const intersegment_ptr<T2> &pt2)
+{  return pt._diff(pt2)/sizeof(T);  }
+
+//! swap specialization
+template<class T> inline
+void swap (boost::interprocess::intersegment_ptr<T> &pt, 
+           boost::interprocess::intersegment_ptr<T> &pt2)
+{  pt.swap(pt2);  }
+
+//!to_raw_pointer() enables boost::mem_fn to recognize intersegment_ptr. 
+//!Never throws.
+template<class T> inline
+T * to_raw_pointer(boost::interprocess::intersegment_ptr<T> const & p)
+{  return p.get();   }
+
+//!Simulation of static_cast between pointers.
+//!Never throws.
+template<class T, class U> inline 
+boost::interprocess::intersegment_ptr<T> static_pointer_cast(const boost::interprocess::intersegment_ptr<U> &r)
+{  return boost::interprocess::intersegment_ptr<T>(r, boost::interprocess::ipcdetail::static_cast_tag());  }
+
+//!Simulation of const_cast between pointers.
+//!Never throws.
+template<class T, class U> inline 
+boost::interprocess::intersegment_ptr<T> const_pointer_cast(const boost::interprocess::intersegment_ptr<U> &r)
+{  return boost::interprocess::intersegment_ptr<T>(r, boost::interprocess::ipcdetail::const_cast_tag());  }
+
+//!Simulation of dynamic_cast between pointers.
+//!Never throws.
+template<class T, class U> inline 
+boost::interprocess::intersegment_ptr<T> dynamic_pointer_cast(const boost::interprocess::intersegment_ptr<U> &r)
+{  return boost::interprocess::intersegment_ptr<T>(r, boost::interprocess::ipcdetail::dynamic_cast_tag());  }
+
+//!Simulation of reinterpret_cast between pointers.
+//!Never throws.
+template<class T, class U> inline
+boost::interprocess::intersegment_ptr<T> reinterpret_pointer_cast(const boost::interprocess::intersegment_ptr<U> &r)
+{  return boost::interprocess::intersegment_ptr<T>(r, boost::interprocess::ipcdetail::reinterpret_cast_tag());  }
+
+//!Trait class to detect if an smart pointer has 
+//!multi-segment addressing capabilities.
+template <class T>
+struct is_multisegment_ptr
+   <boost::interprocess::intersegment_ptr<T> >
+{
+   static const bool value = true;
+};
+
+}  //namespace interprocess {
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+//!to_raw_pointer() enables boost::mem_fn to recognize intersegment_ptr. 
+//!Never throws.
+template<class T> inline
+T * to_raw_pointer(boost::interprocess::intersegment_ptr<T> const & p)
+{  return p.get();   }
+#endif
+
+//!has_trivial_constructor<> == true_type specialization
+//!for optimizations
+template <class T>
+struct has_trivial_constructor
+   < boost::interprocess::intersegment_ptr<T> > 
+   : public true_type{};
+
+//!has_trivial_destructor<> == true_type specialization
+//!for optimizations
+template <class T>
+struct has_trivial_destructor
+   < boost::interprocess::intersegment_ptr<T> > 
+   : public true_type{};
+
+}  //namespace boost {
+
+#if 0
+
+//bits
+//-> is_segmented
+//-> is_relative
+//-> is_in_stack
+//-> is_pointee_outside
+
+//Data
+
+
+
+
+//segmented:
+//
+// std::size_t ctrl    : CTRL_BITS;
+// std::size_t segment : MAX_SEGMENT_BITS;
+// std::size_t offset;
+
+//RELATIVE_SIZE_BITS =  SIZE_T_BITS -
+//                      MAX_SEGMENT_BITS - 
+//                      CTRL_BITS                  10    10
+//MAX_SEGMENT_SIZE   = SIZE_T_BITS - ALIGN_BITS    20    52
+
+//SIZE_T_BITS - 1 - ALIGN_BITS                     19    51
+//POW_SIZE_BITS = upper_log2
+// (SIZE_T_BITS - 1 - ALIGN_BITS)                  5     6
+//FRC_SIZE_BITS = SIZE_T_BITS - CTRL_BITS
+//  MAX_SEGMENT_SIZE_ALIGNBITS - POW_SIZE_BITS     6     5
+
+//relative:
+//
+// std::size_t ctrl     : CTRL_BITS;               2     2
+// std::size_t size_pow : POW_SIZE_BITS            5     6
+// std::size_t size_frc : FRC_SIZE_BITS;           6     5
+// std::size_t start    : MAX_SEGMENT_SIZE_ALIGNBITS;19    51
+// std::ptrdiff_t distance : SIZE_T_BITS;          32    64
+
+//direct:
+//
+// std::size_t ctrl     : CTRL_BITS;               2     2
+// std::size_t dummy    : SIZE_T_BITS - CTRL_BITS  30    62
+// void *addr           : SIZE_T_BITS;             32    64
+
+//32 bits systems:
+//Page alignment: 2**12
+//
+
+//!Obtains the address pointed by the
+//!object
+void *to_raw_pointer() const
+{
+   if(this->is_pointee_outside() || this->is_in_stack()){
+      return raw_address();
+   }
+   else if(this->is_relative()){
+      return (const_cast<char*>(reinterpret_cast<const char*>(this))) + this->relative_pointee_offset();
+   }
+   else{
+      group_manager *m     = get_segment_group_manager(addr);
+      char *base  = static_cast<char*>(m->get_id_address(this->segmented_id()));
+      return base + this->segmented_offset();
+   }
+}
+
+void set_from_pointer(const void *ptr)
+{
+   if(!ptr){
+      this->set_pointee_outside();
+      this->raw_address(ptr);
+   }
+   else if(this->is_in_stack()){
+      this->raw_address(ptr);
+   }
+   else if(this->is_relative() &&
+            (  (ptr >= this->relative_start())
+            &&(ptr <  this->relative_start() + this->relative_size()))
+            ){
+      this->relative_offset(ptr - this);
+   }
+   else{
+      segment_info_t ptr_info  = get_id_from_addr(ptr);
+      segment_info_t this_info = get_id_from_addr(this);
+      if(ptr_info.segment_group != this_info.segment_group){
+         if(!ptr_info.segment_group){
+            this->set_in_stack();
+         }
+         else{
+            this->set_pointee_outside();
+         }
+      }
+      else if(ptr_info.segment_id == this_info.segment_id){
+         set_relative();
+         this->relative_size  (ptr_info.size);
+         this->relative_offset(static_cast<const char*>(ptr) - reinterpret_cast<const char*>(this));
+         this->relative_start (ptr_info.base);
+      }
+   }
+}
+
+void set_from_other(const self_t &other)
+{  this->set_from_pointer(other.to_raw_pointer()); }
+
+#endif
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTERPROCESS_INTERSEGMENT_PTR_HPP
diff --git a/boost/interprocess/detail/managed_memory_impl.hpp b/boost/interprocess/detail/managed_memory_impl.hpp
new file mode 100644
index 0000000000..31c3804439
--- /dev/null
+++ b/boost/interprocess/detail/managed_memory_impl.hpp
@@ -0,0 +1,750 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_MANAGED_MEMORY_IMPL_HPP
+#define BOOST_INTERPROCESS_DETAIL_MANAGED_MEMORY_IMPL_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/segment_manager.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+//
+#include <boost/detail/no_exceptions_support.hpp>
+//
+#include <utility>
+#include <fstream>
+#include <new>
+#include <boost/assert.hpp>
+
+//!\file
+//!Describes a named shared memory allocation user class. 
+//!
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+template<class BasicManagedMemoryImpl>
+class create_open_func;
+
+template<
+         class CharType, 
+         class MemoryAlgorithm,
+         template<class IndexConfig> class IndexType
+        >
+struct segment_manager_type
+{
+   typedef segment_manager<CharType, MemoryAlgorithm, IndexType> type;
+};
+
+//!This class is designed to be a base class to classes that manage 
+//!creation of objects in a fixed size memory buffer. Apart 
+//!from allocating raw memory, the user can construct named objects. To 
+//!achieve this, this class uses the reserved space provided by the allocation
+//!algorithm to place a named_allocator_algo, who takes care of name mappings.
+//!The class can be customized with the char type used for object names
+//!and the memory allocation algorithm to be used.*/
+template <  class CharType 
+         ,  class MemoryAlgorithm
+         ,  template<class IndexConfig> class IndexType
+         ,  std::size_t Offset = 0
+         >
+class basic_managed_memory_impl
+{
+   //Non-copyable
+   basic_managed_memory_impl(const basic_managed_memory_impl &);
+   basic_managed_memory_impl &operator=(const basic_managed_memory_impl &);
+
+   template<class BasicManagedMemoryImpl>
+   friend class create_open_func;
+
+   public:
+   typedef typename segment_manager_type
+      <CharType, MemoryAlgorithm, IndexType>::type    segment_manager;
+   typedef CharType                                   char_type;
+   typedef MemoryAlgorithm                            memory_algorithm;
+   typedef typename MemoryAlgorithm::mutex_family     mutex_family;
+   typedef CharType                                   char_t;
+   typedef typename MemoryAlgorithm::size_type        size_type;
+   typedef typename MemoryAlgorithm::difference_type  difference_type;
+   typedef difference_type                            handle_t;
+   typedef typename segment_manager::
+      const_named_iterator                            const_named_iterator;
+   typedef typename segment_manager::
+      const_unique_iterator                           const_unique_iterator;
+
+   /// @cond
+
+   typedef typename 
+           segment_manager::char_ptr_holder_t         char_ptr_holder_t;
+   //Experimental. Don't use.
+
+   typedef typename segment_manager::multiallocation_chain  multiallocation_chain;
+
+   /// @endcond
+
+   static const size_type PayloadPerAllocation = segment_manager::PayloadPerAllocation;
+
+   private:
+   typedef basic_managed_memory_impl
+               <CharType, MemoryAlgorithm, IndexType, Offset> self_t;
+   protected:
+   template<class ManagedMemory>
+   static bool grow(const char *filename, size_type extra_bytes)
+   {
+      typedef typename ManagedMemory::device_type device_type;
+      //Increase file size
+      try{
+         offset_t old_size;
+         {
+            device_type f(open_or_create, filename, read_write);
+            if(!f.get_size(old_size))
+               return false;
+            f.truncate(old_size + extra_bytes);
+         }
+         ManagedMemory managed_memory(open_only, filename);
+         //Grow always works
+         managed_memory.self_t::grow(extra_bytes);
+      }
+      catch(...){
+         return false;
+      }
+      return true;
+   }
+
+   template<class ManagedMemory>
+   static bool shrink_to_fit(const char *filename)
+   {
+      typedef typename ManagedMemory::device_type device_type;
+      size_type new_size;
+      try{
+         ManagedMemory managed_memory(open_only, filename);
+         managed_memory.get_size();
+         managed_memory.self_t::shrink_to_fit();
+         new_size = managed_memory.get_size();
+      }
+      catch(...){
+         return false;
+      }
+
+      //Decrease file size
+      {
+         device_type f(open_or_create, filename, read_write);
+         f.truncate(new_size);
+      }
+      return true;
+   }
+
+   //!Constructor. Allocates basic resources. Never throws.
+   basic_managed_memory_impl() 
+      : mp_header(0){}
+
+   //!Destructor. Calls close. Never throws.
+   ~basic_managed_memory_impl()
+   {  this->close_impl(); }
+
+   //!Places segment manager in the reserved space. This can throw.
+   bool  create_impl   (void *addr, size_type size)
+   {
+      if(mp_header)  return false;
+
+      //Check if there is enough space
+      if(size < segment_manager::get_min_size())
+         return false;
+
+      //This function should not throw. The index construction can 
+      //throw if constructor allocates memory. So we must catch it.
+      BOOST_TRY{
+         //Let's construct the allocator in memory            
+         mp_header       = new(addr) segment_manager(size);
+      }
+      BOOST_CATCH(...){
+         return false;
+      }
+      BOOST_CATCH_END
+      return true;    
+   }
+ 
+   //!Connects to a segment manager in the reserved buffer. Never throws.
+   bool  open_impl     (void *addr, size_type)
+   {
+      if(mp_header)  return false;
+      mp_header = static_cast<segment_manager*>(addr);
+      return true;
+   }
+
+   //!Frees resources. Never throws.
+   bool close_impl()
+   {  
+      bool ret = mp_header != 0;
+      mp_header = 0;
+      return ret;
+   }
+
+   //!Frees resources and destroys common resources. Never throws.
+   bool destroy_impl()
+   {
+      if(mp_header == 0)
+         return false;
+      mp_header->~segment_manager();
+      this->close_impl();
+         return true;
+   }
+
+   //!
+   void grow(size_type extra_bytes)
+   {  mp_header->grow(extra_bytes); }
+
+   void shrink_to_fit()
+   {  mp_header->shrink_to_fit(); }
+
+   public:
+
+   //!Returns segment manager. Never throws.
+   segment_manager *get_segment_manager() const
+   {   return mp_header; }
+
+   //!Returns the base address of the memory in this process. Never throws.
+   void *   get_address   () const
+   {   return reinterpret_cast<char*>(mp_header) - Offset; }
+
+   //!Returns the size of memory segment. Never throws.
+   size_type   get_size   () const
+   {   return mp_header->get_size() + Offset;  }
+
+   //!Returns the number of free bytes of the memory
+   //!segment
+   size_type get_free_memory() const
+   {  return mp_header->get_free_memory();  }
+
+   //!Returns the result of "all_memory_deallocated()" function
+   //!of the used memory algorithm
+   bool all_memory_deallocated()
+   {   return mp_header->all_memory_deallocated(); }
+
+   //!Returns the result of "check_sanity()" function
+   //!of the used memory algorithm
+   bool check_sanity()
+   {   return mp_header->check_sanity(); }
+
+   //!Writes to zero free memory (memory not yet allocated) of
+   //!the memory algorithm
+   void zero_free_memory()
+   {   mp_header->zero_free_memory(); }
+
+   //!Transforms an absolute address into an offset from base address. 
+   //!The address must belong to the memory segment. Never throws.
+   handle_t get_handle_from_address   (const void *ptr) const
+   {
+      return (handle_t)(reinterpret_cast<const char*>(ptr) - 
+             reinterpret_cast<const char*>(this->get_address()));  
+   }
+
+   //!Returns true if the address belongs to the managed memory segment
+   bool belongs_to_segment (const void *ptr) const
+   {  
+      return ptr >= this->get_address() && 
+             ptr <  (reinterpret_cast<const char*>(this->get_address()) + this->get_size());
+   }
+
+   //!Transforms previously obtained offset into an absolute address in the 
+   //!process space of the current process. Never throws.*/
+   void *    get_address_from_handle (handle_t offset) const
+   {  return reinterpret_cast<char*>(this->get_address()) + offset; }
+
+   //!Searches for nbytes of free memory in the segment, marks the
+   //!memory as used and return the pointer to the memory. If no 
+   //!memory is available throws a boost::interprocess::bad_alloc exception
+   void* allocate             (size_type nbytes)
+   {   return mp_header->allocate(nbytes);   }
+
+   //!Searches for nbytes of free memory in the segment, marks the 
+   //!memory as used and return the pointer to the memory. If no memory 
+   //!is available returns 0. Never throws.
+   void* allocate             (size_type nbytes, std::nothrow_t nothrow)
+   {   return mp_header->allocate(nbytes, nothrow);  }
+
+   //!Allocates nbytes bytes aligned to "alignment" bytes. "alignment"
+   //!must be power of two. If no memory 
+   //!is available returns 0. Never throws.
+   void * allocate_aligned (size_type nbytes, size_type alignment, std::nothrow_t nothrow)
+   {   return mp_header->allocate_aligned(nbytes, alignment, nothrow);  }
+
+   template<class T>
+   std::pair<T *, bool>
+      allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                           size_type preferred_size,size_type &received_size,
+                           T *reuse_ptr = 0)
+   {  
+      return mp_header->allocation_command
+         (command, limit_size, preferred_size, received_size, reuse_ptr);
+   }
+
+   //!Allocates nbytes bytes aligned to "alignment" bytes. "alignment"
+   //!must be power of two. If no 
+   //!memory is available throws a boost::interprocess::bad_alloc exception
+   void * allocate_aligned(size_type nbytes, size_type alignment)
+   {   return mp_header->allocate_aligned(nbytes, alignment);  }
+
+   /// @cond
+
+   //Experimental. Don't use.
+
+   //!Allocates n_elements of elem_size bytes.
+   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
+   {  return mp_header->allocate_many(elem_bytes, num_elements); }
+
+   //!Allocates n_elements, each one of elem_sizes[i] bytes.
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements)
+   {  return mp_header->allocate_many(elem_sizes, n_elements); }
+
+   //!Allocates n_elements of elem_size bytes.
+   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements, std::nothrow_t nothrow)
+   {  return mp_header->allocate_many(elem_bytes, num_elements, nothrow); }
+
+   //!Allocates n_elements, each one of elem_sizes[i] bytes.
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements, std::nothrow_t nothrow)
+   {  return mp_header->allocate_many(elem_sizes, n_elements, nothrow); }
+
+   //!Allocates n_elements, each one of elem_sizes[i] bytes.
+   void deallocate_many(multiallocation_chain chain)
+   {  return mp_header->deallocate_many(boost::move(chain)); }
+
+   /// @endcond
+
+   //!Marks previously allocated memory as free. Never throws.
+   void  deallocate           (void *addr)
+   {   if (mp_header) mp_header->deallocate(addr);  }
+
+   //!Tries to find a previous named allocation address. Returns a memory
+   //!buffer and the object count. If not found returned pointer is 0.
+   //!Never throws.
+   template <class T>
+   std::pair<T*, size_type> find  (char_ptr_holder_t name)
+   {   return mp_header->template find<T>(name); }
+
+   //!Creates a named object or array in memory
+   //!
+   //!Allocates and constructs a T object or an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. If an array is being constructed all objects are
+   //!created using the same parameters given to this function.
+   //!
+   //!-> If the name was previously used, returns 0.
+   //!
+   //!-> Throws boost::interprocess::bad_alloc if there is no available memory 
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and if an 
+   //!array was being constructed, destructors of created objects are called
+   //!before freeing the memory.
+   template <class T>
+   typename segment_manager::template construct_proxy<T>::type
+      construct(char_ptr_holder_t name)
+   {   return mp_header->template construct<T>(name);  }
+
+   //!Finds or creates a named object or array in memory
+   //!
+   //!Tries to find an object with the given name in memory. If 
+   //!found, returns the pointer to this pointer. If the object is not found, 
+   //!allocates and constructs a T object or an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. If an array is being constructed all objects are
+   //!created using the same parameters given to this function.
+   //!
+   //!-> Throws boost::interprocess::bad_alloc if there is no available memory 
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and if an 
+   //!array was being constructed, destructors of created objects are called
+   //!before freeing the memory.
+   template <class T>
+   typename segment_manager::template construct_proxy<T>::type
+      find_or_construct(char_ptr_holder_t name)
+   {   return mp_header->template find_or_construct<T>(name);  }
+
+   //!Creates a named object or array in memory
+   //!
+   //!Allocates and constructs a T object or an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. If an array is being constructed all objects are
+   //!created using the same parameters given to this function.
+   //!
+   //!-> If the name was previously used, returns 0.
+   //!
+   //!-> Returns 0 if there is no available memory 
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and if an 
+   //!array was being constructed, destructors of created objects are called
+   //!before freeing the memory.
+   template <class T>
+   typename segment_manager::template construct_proxy<T>::type
+      construct(char_ptr_holder_t name, std::nothrow_t nothrow)
+   {   return mp_header->template construct<T>(name, nothrow);  }
+
+   //!Finds or creates a named object or array in memory
+   //!
+   //!Tries to find an object with the given name in memory. If 
+   //!found, returns the pointer to this pointer. If the object is not found, 
+   //!allocates and constructs a T object or an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. If an array is being constructed all objects are
+   //!created using the same parameters given to this function.
+   //!
+   //!-> Returns 0 if there is no available memory 
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and if an 
+   //!array was being constructed, destructors of created objects are called
+   //!before freeing the memory.
+   template <class T>
+   typename segment_manager::template construct_proxy<T>::type
+      find_or_construct(char_ptr_holder_t name, std::nothrow_t nothrow)
+   {   return mp_header->template find_or_construct<T>(name, nothrow);  }
+
+   //!Creates a named array from iterators in memory 
+   //!
+   //!Allocates and constructs an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. Each element in the array is created using the
+   //!objects returned when dereferencing iterators as parameters
+   //!and incrementing all iterators for each element.
+   //!
+   //!-> If the name was previously used, returns 0.
+   //!
+   //!-> Throws boost::interprocess::bad_alloc if there is no available memory 
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and 
+   //!destructors of created objects are called before freeing the memory.
+   template <class T>
+   typename segment_manager::template construct_iter_proxy<T>::type
+      construct_it(char_ptr_holder_t name)
+   {   return mp_header->template construct_it<T>(name);  }
+
+   //!Finds or creates a named array from iterators in memory 
+   //!
+   //!Tries to find an object with the given name in memory. If 
+   //!found, returns the pointer to this pointer. If the object is not found, 
+   //!allocates and constructs an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. Each element in the array is created using the
+   //!objects returned when dereferencing iterators as parameters
+   //!and incrementing all iterators for each element.
+   //!
+   //!-> If the name was previously used, returns 0.
+   //!
+   //!-> Throws boost::interprocess::bad_alloc if there is no available memory 
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and 
+   //!destructors of created objects are called before freeing the memory.
+   template <class T>
+   typename segment_manager::template construct_iter_proxy<T>::type
+      find_or_construct_it(char_ptr_holder_t name)
+   {   return mp_header->template find_or_construct_it<T>(name);  }
+
+   //!Creates a named array from iterators in memory 
+   //!
+   //!Allocates and constructs an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. Each element in the array is created using the
+   //!objects returned when dereferencing iterators as parameters
+   //!and incrementing all iterators for each element.
+   //!
+   //!-> If the name was previously used, returns 0.
+   //!
+   //!-> If there is no available memory, returns 0.
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and 
+   //!destructors of created objects are called before freeing the memory.*/
+   template <class T>
+   typename segment_manager::template construct_iter_proxy<T>::type
+      construct_it(char_ptr_holder_t name, std::nothrow_t nothrow)
+   {   return mp_header->template construct_it<T>(name, nothrow);  }
+
+   //!Finds or creates a named array from iterators in memory 
+   //!
+   //!Tries to find an object with the given name in memory. If 
+   //!found, returns the pointer to this pointer. If the object is not found, 
+   //!allocates and constructs an array of T in memory, 
+   //!associates this with the given name and returns a pointer to the 
+   //!created object. Each element in the array is created using the
+   //!objects returned when dereferencing iterators as parameters
+   //!and incrementing all iterators for each element.
+   //!
+   //!-> If the name was previously used, returns 0.
+   //!
+   //!-> If there is no available memory, returns 0.
+   //!
+   //!-> If T's constructor throws, the function throws that exception.
+   //!
+   //!Memory is freed automatically if T's constructor throws and 
+   //!destructors of created objects are called before freeing the memory.*/
+   template <class T>
+   typename segment_manager::template construct_iter_proxy<T>::type
+      find_or_construct_it(char_ptr_holder_t name, std::nothrow_t nothrow)
+   {   return mp_header->template find_or_construct_it<T>(name, nothrow);  }
+
+   //!Calls a functor and guarantees that no new construction, search or
+   //!destruction will be executed by any process while executing the object
+   //!function call. If the functor throws, this function throws.
+   template <class Func>
+   void atomic_func(Func &f)
+   {   mp_header->atomic_func(f);  }
+
+   //!Tries to call 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)
+   {   return mp_header->try_atomic_func(f); }
+
+   //!Destroys a named memory object or array.
+   //!
+   //!Finds the object with the given name, calls its destructors,
+   //!frees used memory and returns true.
+   //!
+   //!-> If the object is not found, it returns false.
+   //!
+   //!Exception Handling:
+   //!
+   //!When deleting a dynamically object or array, the Standard 
+   //!does not guarantee that dynamically allocated memory, will be released.
+   //!Also, when deleting arrays, the Standard doesn't require calling 
+   //!destructors for the rest of the objects if for one of them the destructor 
+   //!terminated with an exception. 
+   //!
+   //!Destroying an object:
+   //!
+   //!If the destructor throws, the memory will be freed and that exception
+   //!will be thrown.
+   //!
+   //!Destroying an array:
+   //!
+   //!When destroying an array, if a destructor throws, the rest of 
+   //!destructors are called. If any of these throws, the exceptions are
+   //!ignored. The name association will be erased, memory will be freed and
+   //!the first exception will be thrown. This guarantees the unlocking of
+   //!mutexes and other resources.
+   //!
+   //!For all theses reasons, classes with throwing destructors are not 
+   //!recommended.
+   template <class T>
+   bool destroy(const CharType *name)
+   {   return mp_header->template destroy<T>(name); }
+
+   //!Destroys the unique instance of type T
+   //!
+   //!Calls the destructor, frees used memory and returns true.
+   //!
+   //!Exception Handling:
+   //!
+   //!When deleting a dynamically object, the Standard does not 
+   //!guarantee that dynamically allocated memory will be released.
+   //!
+   //!Destroying an object:
+   //!
+   //!If the destructor throws, the memory will be freed and that exception
+   //!will be thrown.
+   //!
+   //!For all theses reasons, classes with throwing destructors are not 
+   //!recommended for  memory.
+   template <class T>
+   bool destroy(const unique_instance_t *const )
+   {   return mp_header->template destroy<T>(unique_instance);  }
+
+   //!Destroys the object (named, unique, or anonymous)
+   //!
+   //!Calls the destructor, frees used memory and returns true.
+   //!
+   //!Exception Handling:
+   //!
+   //!When deleting a dynamically object, the Standard does not 
+   //!guarantee that dynamically allocated memory will be released.
+   //!
+   //!Destroying an object:
+   //!
+   //!If the destructor throws, the memory will be freed and that exception
+   //!will be thrown.
+   //!
+   //!For all theses reasons, classes with throwing destructors are not 
+   //!recommended for  memory.
+   template <class T>
+   void destroy_ptr(const T *ptr)
+   {  mp_header->template destroy_ptr<T>(ptr); }
+
+   //!Returns the name of an object created with construct/find_or_construct
+   //!functions. Does not throw
+   template<class T>
+   static const char_type *get_instance_name(const T *ptr)
+   {  return segment_manager::get_instance_name(ptr);   }
+
+   //!Returns is the type 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 segment_manager::get_instance_type(ptr); }
+
+   //!Returns the length of an object created with construct/find_or_construct
+   //!functions (1 if is a single element, >=1 if it's an array). Does not throw.
+   template<class T>
+   static size_type get_instance_length(const T *ptr)
+   {  return segment_manager::get_instance_length(ptr); }
+
+   //!Preallocates needed index resources to optimize the 
+   //!creation of "num" named objects in the  memory segment.
+   //!Can throw boost::interprocess::bad_alloc if there is no enough memory.
+   void reserve_named_objects(size_type num)
+   {  mp_header->reserve_named_objects(num);  }
+
+   //!Preallocates needed index resources to optimize the 
+   //!creation of "num" unique objects in the  memory segment.
+   //!Can throw boost::interprocess::bad_alloc if there is no enough memory.
+   void reserve_unique_objects(size_type num)
+   {  mp_header->reserve_unique_objects(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()
+   {  mp_header->shrink_to_fit_indexes();  }
+
+   //!Returns the number of named objects stored
+   //!in the managed segment.
+   size_type get_num_named_objects()
+   {  return mp_header->get_num_named_objects();  }
+
+   //!Returns the number of unique objects stored
+   //!in the managed segment.
+   size_type get_num_unique_objects()
+   {  return mp_header->get_num_unique_objects();  }
+
+   //!Returns a constant iterator to the index storing the
+   //!named allocations. NOT thread-safe. Never throws.
+   const_named_iterator named_begin() const
+   {  return mp_header->named_begin(); }
+
+   //!Returns a constant iterator to the end of the index 
+   //!storing the named allocations. NOT thread-safe. Never throws.
+   const_named_iterator named_end() const
+   {  return mp_header->named_end(); }
+
+   //!Returns a constant iterator to the index storing the
+   //!unique allocations. NOT thread-safe. Never throws.
+   const_unique_iterator unique_begin() const
+   {  return mp_header->unique_begin(); }
+
+   //!Returns a constant iterator to the end of the index 
+   //!storing the unique allocations. NOT thread-safe. Never throws.
+   const_unique_iterator unique_end() const
+   {  return mp_header->unique_end(); }
+
+   //!This is the default allocator to allocate types T
+   //!from this managed segment
+   template<class T>
+   struct allocator
+   {
+      typedef typename segment_manager::template allocator<T>::type 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 mp_header->template get_allocator<T>(); }
+
+   //!This is the default deleter to delete types T
+   //!from this managed segment.
+   template<class T>
+   struct deleter
+   {
+      typedef typename segment_manager::template deleter<T>::type type;
+   };
+
+   //!Returns an instance of the default allocator for type T
+   //!initialized that allocates memory from this segment manager.
+   template<class T>
+   typename deleter<T>::type
+      get_deleter()
+   {   return mp_header->template get_deleter<T>(); }
+
+   /// @cond
+   //!Tries to find a previous named allocation address. Returns a memory
+   //!buffer and the object count. If not found returned pointer is 0.
+   //!Never throws.
+   template <class T>
+   std::pair<T*, size_type> find_no_lock  (char_ptr_holder_t name)
+   {   return mp_header->template find_no_lock<T>(name); }
+   /// @endcond
+
+   protected:
+   //!Swaps the segment manager's managed by this managed memory segment.
+   //!NOT thread-safe. Never throws.
+   void swap(basic_managed_memory_impl &other)
+   {  std::swap(mp_header, other.mp_header); }
+
+   private:
+   segment_manager *mp_header;
+};
+
+template<class BasicManagedMemoryImpl>
+class create_open_func
+{
+   public:
+   create_open_func(BasicManagedMemoryImpl * const frontend, create_enum_t type)
+      : m_frontend(frontend), m_type(type){}
+
+   bool operator()(void *addr, typename BasicManagedMemoryImpl::size_type size, bool created) const
+   {  
+      if(((m_type == DoOpen)   &&  created) || 
+         ((m_type == DoCreate) && !created))
+         return false;
+
+      if(created)
+         return m_frontend->create_impl(addr, size);
+      else
+         return m_frontend->open_impl  (addr, size);
+   }
+
+   private:
+   BasicManagedMemoryImpl *m_frontend;
+   create_enum_t           m_type;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_MANAGED_MEMORY_IMPL_HPP
+
diff --git a/boost/interprocess/detail/managed_multi_shared_memory.hpp b/boost/interprocess/detail/managed_multi_shared_memory.hpp
new file mode 100644
index 0000000000..579d1ad6ff
--- /dev/null
+++ b/boost/interprocess/detail/managed_multi_shared_memory.hpp
@@ -0,0 +1,408 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MANAGED_MULTI_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_MANAGED_MULTI_SHARED_MEMORY_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/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/interprocess/detail/multi_segment_services.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/containers/list.hpp>//list
+#include <boost/interprocess/mapped_region.hpp> //mapped_region
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp> //managed_open_or_create_impl
+#include <new>
+#include <boost/interprocess/containers/string.hpp>
+#include <boost/interprocess/streams/vectorstream.hpp>
+#include <memory>
+#include <boost/assert.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+
+//!\file
+//!Describes a named shared memory object allocation user class.
+
+namespace boost {
+
+namespace interprocess {
+
+//TODO: We must somehow obtain the permissions of the first segment
+//to apply them to subsequent segments
+//-Use GetSecurityInfo?
+//-Change everything to use only a shared memory object expanded via truncate()?
+
+//!A basic shared memory named object creation class. Initializes the 
+//!shared memory segment. Inherits all basic functionality from 
+//!basic_managed_memory_impl<CharType, MemoryAlgorithm, IndexType>
+template
+      <
+         class CharType, 
+         class MemoryAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_multi_shared_memory 
+   :  public ipcdetail::basic_managed_memory_impl
+         <CharType, MemoryAlgorithm, IndexType>
+{
+
+   typedef basic_managed_multi_shared_memory
+               <CharType, MemoryAlgorithm, IndexType>    self_t;
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, MemoryAlgorithm, IndexType>             base_t;
+   
+   typedef typename MemoryAlgorithm::void_pointer        void_pointer;
+   typedef typename ipcdetail::
+      managed_open_or_create_impl<shared_memory_object, MemoryAlgorithm::Alignment>  managed_impl;
+   typedef typename void_pointer::segment_group_id       segment_group_id;
+   typedef typename base_t::size_type                   size_type;
+
+   ////////////////////////////////////////////////////////////////////////
+   //
+   //               Some internal helper structs/functors
+   //
+   ////////////////////////////////////////////////////////////////////////
+   //!This class defines an operator() that creates a shared memory
+   //!of the requested size. The rest of the parameters are
+   //!passed in the constructor. The class a template parameter
+   //!to be used with create_from_file/create_from_istream functions
+   //!of basic_named_object classes
+
+//   class segment_creator
+//   {
+//      public:
+//      segment_creator(shared_memory &shmem,
+//                      const char *mem_name, 
+//                      const void *addr)
+//      : m_shmem(shmem), m_mem_name(mem_name), m_addr(addr){}
+//
+//      void *operator()(size_type size)
+//      {
+//         if(!m_shmem.create(m_mem_name, size, m_addr))
+//            return 0;
+//         return m_shmem.get_address(); 
+//      }      
+//      private:
+//      shared_memory &m_shmem;
+//      const char *m_mem_name;
+//      const void *m_addr;
+//   };
+
+   class group_services
+      :  public multi_segment_services
+   {
+      public:
+      typedef std::pair<void *, size_type>                  result_type;
+      typedef basic_managed_multi_shared_memory             frontend_t;
+      typedef typename 
+         basic_managed_multi_shared_memory::void_pointer    void_pointer;
+      typedef typename void_pointer::segment_group_id       segment_group_id;
+      group_services(frontend_t *const frontend)
+         :  mp_frontend(frontend), m_group(0), m_min_segment_size(0){}
+
+      virtual std::pair<void *, size_type> create_new_segment(size_type alloc_size)
+      {  (void)alloc_size;
+         /*
+         //We should allocate an extra byte so that the
+         //[base_addr + alloc_size] byte belongs to this segment
+         alloc_size += 1;
+
+         //If requested size is less than minimum, update that
+         alloc_size = (m_min_segment_size > alloc_size) ? 
+                       m_min_segment_size : alloc_size;
+         if(mp_frontend->priv_new_segment(create_open_func::DoCreate,
+                                          alloc_size, 0, permissions())){
+            typename shmem_list_t::value_type &m_impl = *mp_frontend->m_shmem_list.rbegin();
+            return result_type(m_impl.get_real_address(), m_impl.get_real_size()-1);
+         }*/
+         return result_type(static_cast<void *>(0), 0);  
+      }
+
+      virtual bool update_segments ()
+      {  return true;   }
+
+      virtual ~group_services(){}
+
+      void set_group(segment_group_id group)
+         {  m_group = group;  }
+
+      segment_group_id get_group() const
+         {  return m_group;  }
+
+      void set_min_segment_size(size_type min_segment_size)
+         {  m_min_segment_size = min_segment_size;  }
+
+      size_type get_min_segment_size() const
+         {  return m_min_segment_size;  }
+
+      private:
+
+      frontend_t * const   mp_frontend;
+      segment_group_id     m_group;
+      size_type            m_min_segment_size;
+   };
+
+   //!Functor to execute atomically when opening or creating a shared memory
+   //!segment.
+   struct create_open_func
+   {
+      enum type_t {  DoCreate, DoOpen, DoOpenOrCreate  };
+      typedef typename 
+         basic_managed_multi_shared_memory::void_pointer   void_pointer;
+
+      create_open_func(self_t * const    frontend,
+                       type_t type, size_type segment_number)
+         : mp_frontend(frontend), m_type(type), m_segment_number(segment_number){}
+
+      bool operator()(void *addr, size_type size, bool created) const
+      {  
+         if(((m_type == DoOpen)   &&  created) || 
+            ((m_type == DoCreate) && !created))
+            return false;
+         segment_group_id group = mp_frontend->m_group_services.get_group();
+         bool mapped       = false;
+         bool impl_done    = false;
+
+         //Associate this newly created segment as the
+         //segment id = 0 of this group
+         void_pointer::insert_mapping
+            ( group
+            , static_cast<char*>(addr) - managed_impl::ManagedOpenOrCreateUserOffset
+            , size + managed_impl::ManagedOpenOrCreateUserOffset);
+         //Check if this is the master segment
+         if(!m_segment_number){
+            //Create or open the Interprocess machinery
+            if((impl_done = created ? 
+               mp_frontend->create_impl(addr, size) : mp_frontend->open_impl(addr, size))){
+               return true;
+            }
+         }
+         else{
+            return true;
+         }
+
+         //This is the cleanup part
+         //---------------
+         if(impl_done){
+            mp_frontend->close_impl();
+         }
+         if(mapped){
+            bool ret = void_pointer::erase_last_mapping(group);
+            BOOST_ASSERT(ret);(void)ret;
+         }
+         return false;
+      }
+      self_t * const    mp_frontend;
+      type_t            m_type;
+      size_type       m_segment_number;
+   };
+
+   //!Functor to execute atomically when closing a shared memory segment.
+   struct close_func
+   {
+      typedef typename 
+         basic_managed_multi_shared_memory::void_pointer   void_pointer;
+
+      close_func(self_t * const frontend)
+         : mp_frontend(frontend){}
+
+      void operator()(const mapped_region &region, bool last) const
+      {  
+         if(last) mp_frontend->destroy_impl();
+         else     mp_frontend->close_impl();
+      }
+      self_t * const    mp_frontend;
+   };
+
+   //Friend declarations
+   friend struct basic_managed_multi_shared_memory::create_open_func;
+   friend struct basic_managed_multi_shared_memory::close_func;
+   friend class basic_managed_multi_shared_memory::group_services;
+
+   typedef list<managed_impl> shmem_list_t;
+
+   basic_managed_multi_shared_memory *get_this_pointer()
+      {  return this;   }
+
+ public:
+
+   basic_managed_multi_shared_memory(create_only_t,
+                                     const char *name,
+                                     size_type size,
+                                     const permissions &perm = permissions())
+      :  m_group_services(get_this_pointer())
+   {
+      priv_open_or_create(create_open_func::DoCreate,name, size, perm);  
+   }
+
+   basic_managed_multi_shared_memory(open_or_create_t,
+                                     const char *name,
+                                     size_type size,
+                                     const permissions &perm = permissions())
+      :  m_group_services(get_this_pointer())
+   {
+      priv_open_or_create(create_open_func::DoOpenOrCreate, name, size, perm);
+   }
+
+   basic_managed_multi_shared_memory(open_only_t, const char *name)
+      :  m_group_services(get_this_pointer())
+   {
+      priv_open_or_create(create_open_func::DoOpen, name, 0, permissions());
+   }
+
+   ~basic_managed_multi_shared_memory()
+      {  this->priv_close(); }
+
+   private:
+   bool  priv_open_or_create(typename create_open_func::type_t type, 
+                             const char *name,
+                             size_type size,
+                             const permissions &perm)
+   {
+      if(!m_shmem_list.empty())
+         return false;
+      typename void_pointer::segment_group_id group = 0;
+      BOOST_TRY{
+         m_root_name = name;
+         //Insert multi segment services and get a group identifier
+         group = void_pointer::new_segment_group(&m_group_services);
+         size = void_pointer::round_size(size);
+         m_group_services.set_group(group);
+         m_group_services.set_min_segment_size(size);
+
+         if(group){
+            if(this->priv_new_segment(type, size, 0, perm)){
+               return true;
+            }
+         }
+      }
+      BOOST_CATCH(const std::bad_alloc&){
+      }
+      BOOST_CATCH_END
+      if(group){
+         void_pointer::delete_group(group);
+      }
+      return false;      
+   }
+
+   bool  priv_new_segment(typename create_open_func::type_t type,
+                          size_type size,
+                          const void *addr,
+                          const permissions &perm)
+   {
+      BOOST_TRY{
+         //Get the number of groups of this multi_segment group
+         size_type segment_id  = m_shmem_list.size();
+         //Format the name of the shared memory: append segment number. 
+         boost::interprocess::basic_ovectorstream<boost::interprocess::string> formatter;
+         //Pre-reserve string size
+         size_type str_size = m_root_name.length()+10;
+         if(formatter.vector().size() < str_size){
+            //This can throw.
+            formatter.reserve(str_size);
+         }
+         //Format segment's name
+         formatter << m_root_name
+                   << static_cast<unsigned int>(segment_id) << std::ends;
+         //This functor will be executed when constructing
+         create_open_func func(this, type, segment_id);
+         const char *name = formatter.vector().c_str();
+         //This can throw.
+         managed_impl mshm;
+
+         switch(type){
+            case create_open_func::DoCreate:
+            {
+               managed_impl shm(create_only, name, size, read_write, addr, func, perm);
+               mshm = boost::move(shm);
+            }
+            break;
+
+            case create_open_func::DoOpen:
+            {
+               managed_impl shm(open_only, name,read_write, addr, func);
+               mshm = boost::move(shm);
+            }
+            break;
+
+            case create_open_func::DoOpenOrCreate:
+            {
+               managed_impl shm(open_or_create, name, size, read_write, addr, func, perm);
+               mshm = boost::move(shm);
+            }
+            break;
+
+            default:
+               return false;
+            break;
+         }
+
+         //This can throw.
+         m_shmem_list.push_back(boost::move(mshm));
+         return true;
+      }
+      BOOST_CATCH(const std::bad_alloc&){
+      }
+      BOOST_CATCH_END
+      return false;
+   }
+
+   //!Frees resources. Never throws.
+   void priv_close()
+   {  
+      if(!m_shmem_list.empty()){
+         bool ret;
+         //Obtain group identifier
+         segment_group_id group = m_group_services.get_group();
+         //Erase main segment and its resources
+         //typename shmem_list_t::iterator  itbeg = m_shmem_list.begin(),
+         //                        itend = m_shmem_list.end(),
+         //                        it    = itbeg;
+         //(*itbeg)->close_with_func(close_func(this));
+         //Delete group. All mappings are erased too.
+         ret = void_pointer::delete_group(group);
+         (void)ret;
+         BOOST_ASSERT(ret);
+         m_shmem_list.clear();
+      }
+   }
+   
+   private:
+   shmem_list_t   m_shmem_list;
+   group_services m_group_services;
+   std::string    m_root_name;
+};
+
+typedef basic_managed_multi_shared_memory
+   < char
+   , rbtree_best_fit<mutex_family, intersegment_ptr<void> >
+   , iset_index>
+   managed_multi_shared_memory;
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_MULTI_SHARED_MEMORY_HPP
+
diff --git a/boost/interprocess/detail/managed_open_or_create_impl.hpp b/boost/interprocess/detail/managed_open_or_create_impl.hpp
new file mode 100644
index 0000000000..4d6997f330
--- /dev/null
+++ b/boost/interprocess/detail/managed_open_or_create_impl.hpp
@@ -0,0 +1,483 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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_MANAGED_OPEN_OR_CREATE_IMPL
+#define BOOST_INTERPROCESS_MANAGED_OPEN_OR_CREATE_IMPL
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/mapped_region.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/move/move.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+
+
+template<class DeviceAbstraction>
+struct managed_open_or_create_impl_device_id_t
+{
+   typedef const char *type;
+};
+
+#ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+
+class xsi_shared_memory_file_wrapper;
+class xsi_key;
+
+template<>
+struct managed_open_or_create_impl_device_id_t<xsi_shared_memory_file_wrapper>
+{  
+   typedef xsi_key type;
+};
+
+#endif   //BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+   
+/// @endcond
+
+namespace ipcdetail {
+
+
+template <bool StoreDevice, class DeviceAbstraction>
+class managed_open_or_create_impl_device_holder
+{
+   public:
+   DeviceAbstraction &get_device()
+   {  static DeviceAbstraction dev; return dev; }
+
+   const DeviceAbstraction &get_device() const
+   {  static DeviceAbstraction dev; return dev; }
+};
+
+template <class DeviceAbstraction>
+class managed_open_or_create_impl_device_holder<true, DeviceAbstraction>
+{
+   public:
+   DeviceAbstraction &get_device()
+   {  return dev; }
+
+   const DeviceAbstraction &get_device() const
+   {  return dev; }
+   
+   private:
+   DeviceAbstraction dev;
+};
+
+template<class DeviceAbstraction, std::size_t MemAlignment = 0, bool FileBased = true, bool StoreDevice = true>
+class managed_open_or_create_impl
+   : public managed_open_or_create_impl_device_holder<StoreDevice, DeviceAbstraction>
+{
+   //Non-copyable
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(managed_open_or_create_impl)
+
+   typedef typename managed_open_or_create_impl_device_id_t<DeviceAbstraction>::type device_id_t;
+   typedef managed_open_or_create_impl_device_holder<StoreDevice, DeviceAbstraction> DevHolder;
+   enum
+   {  
+      UninitializedSegment,  
+      InitializingSegment,  
+      InitializedSegment,
+      CorruptedSegment
+   };
+
+   public:
+   static const std::size_t
+      ManagedOpenOrCreateUserOffset = 
+         ct_rounded_size
+            < sizeof(boost::uint32_t)
+            , MemAlignment ? (MemAlignment) :
+               (::boost::alignment_of< ::boost::detail::max_align >::value)
+            >::value;
+
+   managed_open_or_create_impl()
+   {}
+
+   managed_open_or_create_impl(create_only_t, 
+                 const device_id_t & id,
+                 std::size_t size,
+                 mode_t mode,
+                 const void *addr,
+                 const permissions &perm)
+   {
+      priv_open_or_create
+         ( DoCreate
+         , id
+         , size
+         , mode
+         , addr
+         , perm
+         , null_mapped_region_function());
+   }
+
+   managed_open_or_create_impl(open_only_t, 
+                 const device_id_t & id,
+                 mode_t mode,
+                 const void *addr)
+   {
+      priv_open_or_create
+         ( DoOpen
+         , id
+         , 0
+         , mode
+         , addr
+         , permissions()
+         , null_mapped_region_function());
+   }
+
+
+   managed_open_or_create_impl(open_or_create_t, 
+                 const device_id_t & id,
+                 std::size_t size,
+                 mode_t mode,
+                 const void *addr,
+                 const permissions &perm)
+   {
+      priv_open_or_create
+         ( DoOpenOrCreate
+         , id
+         , size
+         , mode
+         , addr
+         , perm
+         , null_mapped_region_function());
+   }
+
+   template <class ConstructFunc>
+   managed_open_or_create_impl(create_only_t, 
+                 const device_id_t & id,
+                 std::size_t size,
+                 mode_t mode,
+                 const void *addr,
+                 const ConstructFunc &construct_func,
+                 const permissions &perm)
+   {
+      priv_open_or_create
+         (DoCreate
+         , id
+         , size
+         , mode
+         , addr
+         , perm
+         , construct_func);
+   }
+
+   template <class ConstructFunc>
+   managed_open_or_create_impl(open_only_t, 
+                 const device_id_t & id,
+                 mode_t mode,
+                 const void *addr,
+                 const ConstructFunc &construct_func)
+   {
+      priv_open_or_create
+         ( DoOpen
+         , id
+         , 0
+         , mode
+         , addr
+         , permissions()
+         , construct_func);
+   }
+
+   template <class ConstructFunc>
+   managed_open_or_create_impl(open_or_create_t, 
+                 const device_id_t & id,
+                 std::size_t size,
+                 mode_t mode,
+                 const void *addr,
+                 const ConstructFunc &construct_func,
+                 const permissions &perm)
+   {
+      priv_open_or_create
+         ( DoOpenOrCreate
+         , id
+         , size
+         , mode
+         , addr
+         , perm
+         , construct_func);
+   }
+
+   managed_open_or_create_impl(BOOST_RV_REF(managed_open_or_create_impl) moved)
+   {  this->swap(moved);   }
+
+   managed_open_or_create_impl &operator=(BOOST_RV_REF(managed_open_or_create_impl) moved)
+   {  
+      managed_open_or_create_impl tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   ~managed_open_or_create_impl()
+   {}
+
+   std::size_t get_user_size()  const
+   {  return m_mapped_region.get_size() - ManagedOpenOrCreateUserOffset; }
+
+   void *get_user_address()  const
+   {  return static_cast<char*>(m_mapped_region.get_address()) + ManagedOpenOrCreateUserOffset;  }
+
+   std::size_t get_real_size()  const
+   {  return m_mapped_region.get_size(); }
+
+   void *get_real_address()  const
+   {  return m_mapped_region.get_address();  }
+
+   void swap(managed_open_or_create_impl &other)
+   {
+      this->m_mapped_region.swap(other.m_mapped_region);
+   }
+
+   bool flush()
+   {  return m_mapped_region.flush();  }
+
+   const mapped_region &get_mapped_region() const
+   {  return m_mapped_region;  }
+
+
+   DeviceAbstraction &get_device()
+   {  return this->DevHolder::get_device(); }
+
+   const DeviceAbstraction &get_device() const
+   {  return this->DevHolder::get_device(); }
+
+   private:
+
+   //These are templatized to allow explicit instantiations
+   template<bool dummy>
+   static void truncate_device(DeviceAbstraction &, offset_t, false_)
+   {} //Empty
+
+   template<bool dummy>
+   static void truncate_device(DeviceAbstraction &dev, offset_t size, true_)
+   {  dev.truncate(size);  }
+
+
+   template<bool dummy>
+   static bool check_offset_t_size(std::size_t , false_)
+   { return true; } //Empty
+
+   template<bool dummy>
+   static bool check_offset_t_size(std::size_t size, true_)
+   { return size == std::size_t(offset_t(size)); }
+
+   //These are templatized to allow explicit instantiations
+   template<bool dummy>
+   static void create_device(DeviceAbstraction &dev, const device_id_t & id, std::size_t size, const permissions &perm, false_ file_like)
+   {
+      (void)file_like;
+      DeviceAbstraction tmp(create_only, id, read_write, size, perm);
+      tmp.swap(dev);
+   }
+
+   template<bool dummy>
+   static void create_device(DeviceAbstraction &dev, const device_id_t & id, std::size_t, const permissions &perm, true_ file_like)
+   {
+      (void)file_like;
+      DeviceAbstraction tmp(create_only, id, read_write, perm);
+      tmp.swap(dev);
+   }
+
+   template <class ConstructFunc> inline 
+   void priv_open_or_create
+      (create_enum_t type, 
+       const device_id_t & id, 
+       std::size_t size,
+       mode_t mode, const void *addr,
+       const permissions &perm,
+       ConstructFunc construct_func)
+   {
+      typedef bool_<FileBased> file_like_t;
+      (void)mode;
+      error_info err;
+      bool created = false;
+      bool ronly   = false;
+      bool cow     = false;
+      DeviceAbstraction dev;
+
+      if(type != DoOpen && size < ManagedOpenOrCreateUserOffset){
+         throw interprocess_exception(error_info(size_error));
+      }
+      //Check size can be represented by offset_t (used by truncate)
+      if(type != DoOpen && !check_offset_t_size<FileBased>(size, file_like_t())){
+         throw interprocess_exception(error_info(size_error));
+      }
+      if(type == DoOpen && mode == read_write){
+         DeviceAbstraction tmp(open_only, id, read_write);
+         tmp.swap(dev);
+         created = false;
+      }
+      else if(type == DoOpen && mode == read_only){
+         DeviceAbstraction tmp(open_only, id, read_only);
+         tmp.swap(dev);
+         created = false;
+         ronly   = true;
+      }
+      else if(type == DoOpen && mode == copy_on_write){
+         DeviceAbstraction tmp(open_only, id, read_only);
+         tmp.swap(dev);
+         created = false;
+         cow     = true;
+      }
+      else if(type == DoCreate){
+         create_device<FileBased>(dev, id, size, perm, file_like_t());
+         created = true;
+      }
+      else if(type == DoOpenOrCreate){
+         //This loop is very ugly, but brute force is sometimes better
+         //than diplomacy. If someone knows how to open or create a
+         //file and know if we have really created it or just open it
+         //drop me a e-mail!
+         bool completed = false;
+         while(!completed){
+            try{
+               create_device<FileBased>(dev, id, size, perm, file_like_t());
+               created     = true;
+               completed   = true;
+            }
+            catch(interprocess_exception &ex){
+               if(ex.get_error_code() != already_exists_error){
+                  throw;
+               }
+               else{
+                  try{
+                     DeviceAbstraction tmp(open_only, id, read_write);
+                     dev.swap(tmp);
+                     created     = false;
+                     completed   = true;
+                  }
+                  catch(interprocess_exception &ex){
+                     if(ex.get_error_code() != not_found_error){
+                        throw;
+                     }
+                  }
+                  catch(...){
+                     throw;
+                  }
+               }
+            }
+            catch(...){
+               throw;
+            }
+            thread_yield();
+         }
+      }
+
+      if(created){
+         try{
+            //If this throws, we are lost
+            truncate_device<FileBased>(dev, size, file_like_t());
+
+            //If the following throws, we will truncate the file to 1
+            mapped_region        region(dev, read_write, 0, 0, addr);
+            boost::uint32_t *patomic_word = 0;  //avoid gcc warning
+            patomic_word = static_cast<boost::uint32_t*>(region.get_address());
+            boost::uint32_t previous = atomic_cas32(patomic_word, InitializingSegment, UninitializedSegment);
+
+            if(previous == UninitializedSegment){
+               try{
+                  construct_func(static_cast<char*>(region.get_address()) + ManagedOpenOrCreateUserOffset, size - ManagedOpenOrCreateUserOffset, true);
+                  //All ok, just move resources to the external mapped region
+                  m_mapped_region.swap(region);
+               }
+               catch(...){
+                  atomic_write32(patomic_word, CorruptedSegment);
+                  throw;
+               }
+               atomic_write32(patomic_word, InitializedSegment);
+            }
+            else if(previous == InitializingSegment || previous == InitializedSegment){
+               throw interprocess_exception(error_info(already_exists_error));
+            }
+            else{
+               throw interprocess_exception(error_info(corrupted_error));
+            }
+         }
+         catch(...){
+            try{
+               truncate_device<FileBased>(dev, 1u, file_like_t());
+            }
+            catch(...){
+            }
+            throw;
+         }
+      }
+      else{
+         if(FileBased){
+            offset_t filesize = 0;
+            while(filesize == 0){
+               if(!get_file_size(file_handle_from_mapping_handle(dev.get_mapping_handle()), filesize)){
+                  throw interprocess_exception(error_info(system_error_code()));
+               }
+               thread_yield();
+            }
+            if(filesize == 1){
+               throw interprocess_exception(error_info(corrupted_error));
+            }
+         }
+
+         mapped_region  region(dev, ronly ? read_only : (cow ? copy_on_write : read_write), 0, 0, addr);
+
+         boost::uint32_t *patomic_word = static_cast<boost::uint32_t*>(region.get_address());
+         boost::uint32_t value = atomic_read32(patomic_word);
+
+         while(value == InitializingSegment || value == UninitializedSegment){
+            thread_yield();
+            value = atomic_read32(patomic_word);
+         }
+
+         if(value != InitializedSegment)
+            throw interprocess_exception(error_info(corrupted_error));
+
+         construct_func( static_cast<char*>(region.get_address()) + ManagedOpenOrCreateUserOffset
+                        , region.get_size() - ManagedOpenOrCreateUserOffset
+                        , false);
+         //All ok, just move resources to the external mapped region
+         m_mapped_region.swap(region);
+      }
+      if(StoreDevice){
+         this->DevHolder::get_device() = boost::move(dev);
+      }
+   }
+
+   private:
+   friend class interprocess_tester;
+   void dont_close_on_destruction()
+   {  interprocess_tester::dont_close_on_destruction(m_mapped_region);  }
+
+   mapped_region     m_mapped_region;
+};
+
+template<class DeviceAbstraction>
+inline void swap(managed_open_or_create_impl<DeviceAbstraction> &x
+                ,managed_open_or_create_impl<DeviceAbstraction> &y)
+{  x.swap(y);  }
+
+}  //namespace ipcdetail {
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MANAGED_OPEN_OR_CREATE_IMPL
diff --git a/boost/interprocess/detail/math_functions.hpp b/boost/interprocess/detail/math_functions.hpp
new file mode 100644
index 0000000000..08274160db
--- /dev/null
+++ b/boost/interprocess/detail/math_functions.hpp
@@ -0,0 +1,110 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Stephen Cleary 2000.
+// (C) Copyright Ion Gaztanaga 2007-2011.
+//
+// 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.
+//
+// This file is a slightly modified file from Boost.Pool
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_DETAIL_MATH_FUNCTIONS_HPP
+#define BOOST_INTERPROCESS_DETAIL_MATH_FUNCTIONS_HPP
+
+#include <climits>
+#include <boost/static_assert.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+// Greatest common divisor and least common multiple
+
+//
+// gcd is an algorithm that calculates the greatest common divisor of two
+//  integers, using Euclid's algorithm.
+//
+// Pre: A > 0 && B > 0
+// Recommended: A > B
+template <typename Integer>
+inline Integer gcd(Integer A, Integer B)
+{
+   do
+   {
+      const Integer tmp(B);
+      B = A % B;
+      A = tmp;
+   } while (B != 0);
+
+   return A;
+}
+
+//
+// lcm is an algorithm that calculates the least common multiple of two
+//  integers.
+//
+// Pre: A > 0 && B > 0
+// Recommended: A > B
+template <typename Integer>
+inline Integer lcm(const Integer & A, const Integer & B)
+{
+   Integer ret = A;
+   ret /= gcd(A, B);
+   ret *= B;
+   return ret;
+}
+
+template <typename Integer>
+inline Integer log2_ceil(const Integer & A)
+{
+   Integer i = 0;
+   Integer power_of_2 = 1;
+
+   while(power_of_2 < A){
+      power_of_2 <<= 1;
+      ++i;
+   }
+   return i;
+}
+
+template <typename Integer>
+inline Integer upper_power_of_2(const Integer & A)
+{
+   Integer power_of_2 = 1;
+
+   while(power_of_2 < A){
+      power_of_2 <<= 1;
+   }
+   return power_of_2;
+}
+
+//This function uses binary search to discover the
+//highest set bit of the integer
+inline std::size_t floor_log2 (std::size_t x)
+{
+   const std::size_t Bits = sizeof(std::size_t)*CHAR_BIT;
+   const bool Size_t_Bits_Power_2= !(Bits & (Bits-1));
+   BOOST_STATIC_ASSERT(((Size_t_Bits_Power_2)== true));
+
+   std::size_t n = x;
+   std::size_t log2 = 0;
+   
+   for(std::size_t shift = Bits >> 1; shift; shift >>= 1){
+      std::size_t tmp = n >> shift;
+      if (tmp)
+         log2 += shift, n = tmp;
+   }
+
+   return log2;
+}
+
+} // namespace ipcdetail
+} // namespace interprocess
+} // namespace boost
+
+#endif
diff --git a/boost/interprocess/detail/min_max.hpp b/boost/interprocess/detail/min_max.hpp
new file mode 100644
index 0000000000..75aa00f87b
--- /dev/null
+++ b/boost/interprocess/detail/min_max.hpp
@@ -0,0 +1,40 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011.
+//
+// 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_DETAIL_MIN_MAX_HPP
+#define BOOST_INTERPROCESS_DETAIL_MIN_MAX_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+namespace boost {
+namespace interprocess { 
+
+template<class T>
+const T &max_value(const T &a, const T &b)
+{  return a > b ? a : b;   }
+
+template<class T>
+const T &min_value(const T &a, const T &b)
+{  return a < b ? a : b;   }
+
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_MIN_MAX_HPP
+
diff --git a/boost/interprocess/detail/move.hpp b/boost/interprocess/detail/move.hpp
new file mode 100644
index 0000000000..1ec43b211b
--- /dev/null
+++ b/boost/interprocess/detail/move.hpp
@@ -0,0 +1,28 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2010-2011.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_INTERPROCESS_DETAIL_MOVE_HPP
+#define BOOST_INTERPROCESS_DETAIL_MOVE_HPP
+
+#include <boost/move/move.hpp>
+
+namespace boost {
+namespace interprocess {
+
+using ::boost::move;
+using ::boost::forward;
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#endif //#ifndef BOOST_INTERPROCESS_DETAIL_MOVE_HPP
diff --git a/boost/interprocess/detail/mpl.hpp b/boost/interprocess/detail/mpl.hpp
new file mode 100644
index 0000000000..c5b6f90ef1
--- /dev/null
+++ b/boost/interprocess/detail/mpl.hpp
@@ -0,0 +1,152 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011.
+//
+// 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_DETAIL_MPL_HPP
+#define BOOST_INTERPROCESS_DETAIL_MPL_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <cstddef>
+
+namespace boost {
+namespace interprocess { 
+namespace ipcdetail {
+
+template <class T, T val>
+struct integral_constant
+{
+   static const T value = val;
+   typedef integral_constant<T,val> type;
+};
+
+template< bool C_ >
+struct bool_ : integral_constant<bool, C_>
+{
+   static const bool value = C_;
+};
+
+typedef bool_<true>        true_;
+typedef bool_<false>       false_;
+
+typedef true_  true_type;
+typedef false_ false_type;
+
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+
+template <bool B, class T = void>
+struct enable_if_c {
+  typedef T type;
+};
+
+template <class T>
+struct enable_if_c<false, T> {};
+
+template <class Cond, class T = void>
+struct enable_if : public enable_if_c<Cond::value, T> {};
+
+template <class Cond, class T = void>
+struct disable_if : public enable_if_c<!Cond::value, T> {};
+
+template <class T, class U>
+class is_convertible
+{
+   typedef char true_t;
+   class false_t { char dummy[2]; };
+   static true_t dispatch(U);
+   static false_t dispatch(...);
+   static T trigger();
+   public:
+   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
+};
+
+template<
+      bool C
+    , typename T1
+    , typename T2
+    >
+struct if_c
+{
+    typedef T1 type;
+};
+
+template<
+      typename T1
+    , typename T2
+    >
+struct if_c<false,T1,T2>
+{
+    typedef T2 type;
+};
+
+template<
+      typename T1
+    , typename T2
+    , typename T3
+    >
+struct if_
+{
+   typedef typename if_c<0 != T1::value, T2, T3>::type type;
+};
+
+
+template <class Pair>
+struct select1st 
+//   : public std::unary_function<Pair, typename Pair::first_type> 
+{
+   template<class OtherPair>
+   const typename Pair::first_type& operator()(const OtherPair& x) const 
+   {  return x.first;   }
+
+   const typename Pair::first_type& operator()(const typename Pair::first_type& x) const 
+   {  return x;   }
+};
+
+// identity is an extension: it is not part of the standard.
+template <class T>
+struct identity 
+//   : public std::unary_function<T,T> 
+{
+   typedef T type;
+   const T& operator()(const T& x) const 
+   { return x; }
+};
+
+template<std::size_t S>
+struct ls_zeros
+{
+   static const std::size_t value = (S & std::size_t(1)) ? 0 : (1u + ls_zeros<(S >> 1u)>::value);
+};
+
+template<>
+struct ls_zeros<0>
+{
+   static const std::size_t value = 0;
+};
+
+template<>
+struct ls_zeros<1>
+{
+   static const std::size_t value = 0;
+};
+
+}  //namespace ipcdetail { 
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_MPL_HPP
+
diff --git a/boost/interprocess/detail/multi_segment_services.hpp b/boost/interprocess/detail/multi_segment_services.hpp
new file mode 100644
index 0000000000..4b6cafc742
--- /dev/null
+++ b/boost/interprocess/detail/multi_segment_services.hpp
@@ -0,0 +1,46 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MULTI_SEGMENT_SERVICES_HPP
+#define BOOST_INTERPROCESS_MULTI_SEGMENT_SERVICES_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+
+/*!\file
+   Describes a named shared memory allocation user class. 
+*/
+
+namespace boost {
+
+namespace interprocess {
+
+class multi_segment_services
+{
+   public:
+   virtual std::pair<void *, std::size_t> create_new_segment(std::size_t mem) = 0;
+   virtual bool                           update_segments   () = 0;
+   virtual ~multi_segment_services() = 0;
+};
+
+inline multi_segment_services::~multi_segment_services()
+{}
+
+
+}} //namespace boost {  namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifdef BOOST_INTERPROCESS_MULTI_SEGMENT_SERVICES_HPP
diff --git a/boost/interprocess/detail/named_proxy.hpp b/boost/interprocess/detail/named_proxy.hpp
new file mode 100644
index 0000000000..604d7881ea
--- /dev/null
+++ b/boost/interprocess/detail/named_proxy.hpp
@@ -0,0 +1,349 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NAMED_PROXY_HPP
+#define BOOST_INTERPROCESS_NAMED_PROXY_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 <new>
+#include <iterator>
+#include <boost/interprocess/detail/in_place_interface.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+
+#ifndef BOOST_INTERPROCESS_PERFECT_FORWARDING
+#include <boost/interprocess/detail/preprocessor.hpp> 
+#else
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/variadic_templates_tools.hpp>
+#endif   //#ifdef BOOST_INTERPROCESS_PERFECT_FORWARDING
+
+//!\file
+//!Describes a proxy class that implements named allocation syntax.
+
+namespace boost {
+namespace interprocess { 
+namespace ipcdetail {
+
+#ifdef BOOST_INTERPROCESS_PERFECT_FORWARDING
+
+template<class T, bool is_iterator, class ...Args>
+struct CtorNArg : public placement_destroy<T>
+{
+   typedef bool_<is_iterator> IsIterator;
+   typedef CtorNArg<T, is_iterator, Args...> self_t;
+   typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
+
+   self_t& operator++()
+   {
+      this->do_increment(IsIterator(), index_tuple_t());
+      return *this;
+   }
+
+   self_t  operator++(int) {  return ++*this;   *this;  }
+
+   CtorNArg(Args && ...args)
+      :  args_(args...)
+   {}
+
+   virtual void construct_n(void *mem
+                     , std::size_t num
+                     , std::size_t &constructed)
+   {
+      T* memory      = static_cast<T*>(mem);
+      for(constructed = 0; constructed < num; ++constructed){
+         this->construct(memory++, IsIterator(), index_tuple_t());
+         this->do_increment(IsIterator(), index_tuple_t());
+      }
+   }
+
+   private:
+   template<int ...IdxPack>
+   void construct(void *mem, true_, const index_tuple<IdxPack...>&)
+   {  new((void*)mem)T(*boost::forward<Args>(get<IdxPack>(args_))...); }
+
+   template<int ...IdxPack>
+   void construct(void *mem, false_, const index_tuple<IdxPack...>&)
+   {  new((void*)mem)T(boost::forward<Args>(get<IdxPack>(args_))...); }
+
+   template<int ...IdxPack>
+   void do_increment(true_, const index_tuple<IdxPack...>&)
+   {
+      this->expansion_helper(++get<IdxPack>(args_)...);
+   }
+ 
+   template<class ...ExpansionArgs>
+   void expansion_helper(ExpansionArgs &&...)
+   {}
+
+   template<int ...IdxPack>
+   void do_increment(false_, const index_tuple<IdxPack...>&)
+   {}
+
+   tuple<Args&...> args_;
+};                                                                      
+
+//!Describes a proxy class that implements named
+//!allocation syntax.
+template 
+   < class SegmentManager  //segment manager to construct the object
+   , class T               //type of object to build
+   , bool is_iterator      //passing parameters are normal object or iterators?
+   >
+class named_proxy
+{
+   typedef typename SegmentManager::char_type char_type;
+   const char_type *    mp_name;
+   SegmentManager *     mp_mngr;
+   mutable std::size_t  m_num;
+   const bool           m_find;
+   const bool           m_dothrow;
+
+   public:
+   named_proxy(SegmentManager *mngr, const char_type *name, bool find, bool dothrow)
+      :  mp_name(name), mp_mngr(mngr), m_num(1)
+      ,  m_find(find),  m_dothrow(dothrow)
+   {}
+
+   template<class ...Args>
+   T *operator()(Args &&...args) const
+   {  
+      CtorNArg<T, is_iterator, Args...> &&ctor_obj = CtorNArg<T, is_iterator, Args...>
+         (boost::forward<Args>(args)...);
+      return mp_mngr->template 
+         generic_construct<T>(mp_name, m_num, m_find, m_dothrow, ctor_obj);
+   }
+
+   //This operator allows --> named_new("Name")[3]; <-- syntax
+   const named_proxy &operator[](std::size_t num) const
+   {  m_num *= num; return *this;  }
+};
+
+#else //#ifdef BOOST_INTERPROCESS_PERFECT_FORWARDING
+
+//!Function object that makes placement new
+//!without arguments
+template<class T>
+struct Ctor0Arg   :  public placement_destroy<T>
+{
+   typedef Ctor0Arg self_t;
+
+   Ctor0Arg(){}
+
+   self_t& operator++()       {  return *this;  }
+   self_t  operator++(int)    {  return *this;  }
+
+   void construct(void *mem)
+   {  new((void*)mem)T;  }
+
+   virtual void construct_n(void *mem, std::size_t num, std::size_t &constructed)
+   {
+      T* memory = static_cast<T*>(mem);
+      for(constructed = 0; constructed < num; ++constructed)
+         new((void*)memory++)T;
+   }
+};
+
+////////////////////////////////////////////////////////////////
+//    What the macro should generate (n == 2):
+//
+//    template<class T, bool is_iterator, class P1, class P2>
+//    struct Ctor2Arg
+//      :  public placement_destroy<T>
+//    {
+//       typedef bool_<is_iterator> IsIterator;
+//       typedef Ctor2Arg self_t;
+//
+//       void do_increment(false_)
+//       { ++m_p1; ++m_p2;  }
+//
+//       void do_increment(true_){}
+//
+//       self_t& operator++()
+//       {
+//          this->do_increment(IsIterator());
+//          return *this;
+//       }
+//
+//       self_t  operator++(int) {  return ++*this;   *this;  }
+//
+//       Ctor2Arg(const P1 &p1, const P2 &p2)
+//          : p1((P1 &)p_1), p2((P2 &)p_2) {}
+//
+//       void construct(void *mem)
+//       {  new((void*)object)T(m_p1, m_p2); }
+//
+//       virtual void construct_n(void *mem
+//                                , std::size_t num
+//                                , std::size_t &constructed)
+//       {
+//          T* memory      = static_cast<T*>(mem);
+//          for(constructed = 0; constructed < num; ++constructed){
+//             this->construct(memory++, IsIterator());
+//             this->do_increment(IsIterator());
+//          }
+//       }
+//
+//       private:
+//       void construct(void *mem, true_)
+//       {  new((void*)mem)T(*m_p1, *m_p2); }
+//                                                                           
+//       void construct(void *mem, false_)
+//       {  new((void*)mem)T(m_p1, m_p2); }
+//
+//       P1 &m_p1; P2 &m_p2;
+//    };
+////////////////////////////////////////////////////////////////
+
+//Note:
+//We define template parameters as const references to
+//be able to bind temporaries. After that we will un-const them.
+//This cast is ugly but it is necessary until "perfect forwarding"
+//is achieved in C++0x. Meanwhile, if we want to be able to
+//bind lvalues with non-const references, we have to be ugly
+#define BOOST_PP_LOCAL_MACRO(n)                                            \
+   template<class T, bool is_iterator, BOOST_PP_ENUM_PARAMS(n, class P) >  \
+   struct BOOST_PP_CAT(BOOST_PP_CAT(Ctor, n), Arg)                         \
+      :  public placement_destroy<T>                                       \
+   {                                                                       \
+      typedef bool_<is_iterator> IsIterator;                               \
+      typedef BOOST_PP_CAT(BOOST_PP_CAT(Ctor, n), Arg) self_t;             \
+                                                                           \
+      void do_increment(true_)                                             \
+         { BOOST_PP_ENUM(n, BOOST_INTERPROCESS_PP_PARAM_INC, _); }         \
+                                                                           \
+      void do_increment(false_){}                                          \
+                                                                           \
+      self_t& operator++()                                                 \
+      {                                                                    \
+         this->do_increment(IsIterator());                                 \
+         return *this;                                                     \
+      }                                                                    \
+                                                                           \
+      self_t  operator++(int) {  return ++*this;   *this;  }               \
+                                                                           \
+      BOOST_PP_CAT(BOOST_PP_CAT(Ctor, n), Arg)                             \
+         ( BOOST_PP_ENUM(n, BOOST_INTERPROCESS_PP_PARAM_LIST, _) )        \
+         : BOOST_PP_ENUM(n, BOOST_INTERPROCESS_PP_PARAM_INIT, _) {}       \
+                                                                           \
+      virtual void construct_n(void *mem                                   \
+                        , std::size_t num                                  \
+                        , std::size_t &constructed)                        \
+      {                                                                    \
+         T* memory      = static_cast<T*>(mem);                            \
+         for(constructed = 0; constructed < num; ++constructed){           \
+            this->construct(memory++, IsIterator());                       \
+            this->do_increment(IsIterator());                              \
+         }                                                                 \
+      }                                                                    \
+                                                                           \
+      private:                                                             \
+      void construct(void *mem, true_)                                     \
+      {                                                                    \
+         new((void*)mem) T                                                 \
+         (BOOST_PP_ENUM(n, BOOST_INTERPROCESS_PP_MEMBER_IT_FORWARD, _));   \
+      }                                                                    \
+                                                                           \
+      void construct(void *mem, false_)                                    \
+      {                                                                    \
+         new((void*)mem) T                                                 \
+            (BOOST_PP_ENUM(n, BOOST_INTERPROCESS_PP_MEMBER_FORWARD, _));   \
+      }                                                                    \
+                                                                           \
+      BOOST_PP_REPEAT(n, BOOST_INTERPROCESS_PP_PARAM_DEFINE, _)            \
+   };                                                                      \
+//!
+#define BOOST_PP_LOCAL_LIMITS (1, BOOST_INTERPROCESS_MAX_CONSTRUCTOR_PARAMETERS)
+#include BOOST_PP_LOCAL_ITERATE()
+
+//!Describes a proxy class that implements named
+//!allocation syntax.
+template 
+   < class SegmentManager  //segment manager to construct the object
+   , class T               //type of object to build
+   , bool is_iterator      //passing parameters are normal object or iterators?
+   >
+class named_proxy
+{
+   typedef typename SegmentManager::char_type char_type;
+   const char_type *    mp_name;
+   SegmentManager *     mp_mngr;
+   mutable std::size_t  m_num;
+   const bool           m_find;
+   const bool           m_dothrow;
+
+   public:
+   named_proxy(SegmentManager *mngr, const char_type *name, bool find, bool dothrow)
+      :  mp_name(name), mp_mngr(mngr), m_num(1)
+      ,  m_find(find),  m_dothrow(dothrow)
+   {}
+
+   //!makes a named allocation and calls the
+   //!default constructor
+   T *operator()() const
+   {  
+      Ctor0Arg<T> ctor_obj;
+      return mp_mngr->template 
+         generic_construct<T>(mp_name, m_num, m_find, m_dothrow, ctor_obj);
+   }
+   //!
+
+   #define BOOST_PP_LOCAL_MACRO(n)                                               \
+      template<BOOST_PP_ENUM_PARAMS(n, class P)>                                 \
+      T *operator()(BOOST_PP_ENUM (n, BOOST_INTERPROCESS_PP_PARAM_LIST, _)) const\
+      {                                                                          \
+         typedef BOOST_PP_CAT(BOOST_PP_CAT(Ctor, n), Arg)                        \
+            <T, is_iterator, BOOST_PP_ENUM_PARAMS(n, P)>                         \
+            ctor_obj_t;                                                          \
+         ctor_obj_t ctor_obj                                                     \
+            (BOOST_PP_ENUM(n, BOOST_INTERPROCESS_PP_PARAM_FORWARD, _));          \
+         return mp_mngr->template generic_construct<T>                           \
+            (mp_name, m_num, m_find, m_dothrow, ctor_obj);                       \
+      }                                                                          \
+   //!
+
+   #define BOOST_PP_LOCAL_LIMITS ( 1, BOOST_INTERPROCESS_MAX_CONSTRUCTOR_PARAMETERS )
+   #include BOOST_PP_LOCAL_ITERATE()
+
+   ////////////////////////////////////////////////////////////////////////
+   //             What the macro should generate (n == 2)
+   ////////////////////////////////////////////////////////////////////////
+   //
+   // template <class P1, class P2>
+   // T *operator()(P1 &p1, P2 &p2) const 
+   // {
+   //    typedef Ctor2Arg
+   //       <T, is_iterator, P1, P2>
+   //       ctor_obj_t;
+   //    ctor_obj_t ctor_obj(p1, p2);
+   //
+   //    return mp_mngr->template generic_construct<T>
+   //       (mp_name, m_num, m_find, m_dothrow, ctor_obj);
+   // }
+   //
+   //////////////////////////////////////////////////////////////////////////
+
+   //This operator allows --> named_new("Name")[3]; <-- syntax
+   const named_proxy &operator[](std::size_t num) const
+      {  m_num *= num; return *this;  }
+};
+
+#endif   //#ifdef BOOST_INTERPROCESS_PERFECT_FORWARDING
+
+}}}   //namespace boost { namespace interprocess { namespace ipcdetail {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTERPROCESS_NAMED_PROXY_HPP
diff --git a/boost/interprocess/detail/os_file_functions.hpp b/boost/interprocess/detail/os_file_functions.hpp
new file mode 100644
index 0000000000..b680c57132
--- /dev/null
+++ b/boost/interprocess/detail/os_file_functions.hpp
@@ -0,0 +1,696 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_OS_FILE_FUNCTIONS_HPP
+#define BOOST_INTERPROCESS_DETAIL_OS_FILE_FUNCTIONS_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/errors.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+#include <string>
+#include <limits>
+#include <climits>
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+#  include <boost/interprocess/detail/win32_api.hpp>
+#else
+#  ifdef BOOST_HAS_UNISTD_H
+#     include <fcntl.h>
+#     include <unistd.h>
+#     include <sys/types.h>
+#     include <sys/stat.h>
+#     include <errno.h>
+#     include <cstdio>
+#     include <dirent.h>
+#     if 0
+#        include <sys/file.h> 
+#     endif
+#  else
+#    error Unknown platform
+#  endif
+#endif
+
+#include <cstring>
+#include <cstdlib>
+
+namespace boost {
+namespace interprocess {
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+typedef void *             file_handle_t;
+typedef long long          offset_t;
+typedef struct mapping_handle_impl_t{
+   void *   handle;
+   bool     is_shm;
+}  mapping_handle_t;
+
+typedef enum { read_only      = winapi::generic_read
+             , read_write     = winapi::generic_read | winapi::generic_write
+             , copy_on_write
+             , read_private
+             , invalid_mode   = 0xffff 
+             } mode_t;
+
+typedef enum { file_begin     = winapi::file_begin
+             , file_end       = winapi::file_end
+             , file_current   = winapi::file_current
+             } file_pos_t;
+
+namespace ipcdetail{
+
+inline mapping_handle_t mapping_handle_from_file_handle(file_handle_t hnd)
+{
+   mapping_handle_t ret;
+   ret.handle = hnd;
+   ret.is_shm = false;
+   return ret;
+}
+
+inline mapping_handle_t mapping_handle_from_shm_handle(file_handle_t hnd)
+{
+   mapping_handle_t ret;
+   ret.handle = hnd;
+   ret.is_shm = true;
+   return ret;
+}
+
+inline file_handle_t file_handle_from_mapping_handle(mapping_handle_t hnd)
+{  return hnd.handle; }
+
+inline bool create_directory(const char *path)
+{  return winapi::create_directory(path); }
+
+inline const char *get_temporary_path()
+{  return std::getenv("TMP"); }
+
+
+inline file_handle_t create_new_file
+   (const char *name, mode_t mode, const permissions & perm = permissions(), bool temporary = false)
+{  
+   unsigned long attr = temporary ? winapi::file_attribute_temporary : 0;
+   return winapi::create_file
+      ( name, (unsigned int)mode, winapi::create_new, attr
+      , (winapi::interprocess_security_attributes*)perm.get_permissions());  
+}
+
+inline file_handle_t create_or_open_file
+   (const char *name, mode_t mode, const permissions & perm = permissions(), bool temporary = false)
+{  
+   unsigned long attr = temporary ? winapi::file_attribute_temporary : 0;
+   return winapi::create_file
+      ( name, (unsigned int)mode, winapi::open_always, attr
+      , (winapi::interprocess_security_attributes*)perm.get_permissions());  
+}
+
+inline file_handle_t open_existing_file
+   (const char *name, mode_t mode, bool temporary = false)
+{  
+   unsigned long attr = temporary ? winapi::file_attribute_temporary : 0;
+   return winapi::create_file
+      (name, (unsigned int)mode, winapi::open_existing, attr, 0);  
+}
+
+inline bool delete_file(const char *name)
+{  return winapi::unlink_file(name);   }
+
+inline bool truncate_file (file_handle_t hnd, std::size_t size)
+{
+   offset_t filesize;
+   if(!winapi::get_file_size(hnd, filesize))
+      return false;
+
+   const offset_t max_filesize = (std::numeric_limits<offset_t>::max)();
+   //Avoid unused variable warnings in 32 bit systems
+   (void)max_filesize;
+   if( sizeof(std::size_t) >= sizeof(offset_t) && size > std::size_t(max_filesize) ){
+      winapi::set_last_error(winapi::error_file_too_large);
+      return false;
+   }
+
+   if(offset_t(size) > filesize){
+      if(!winapi::set_file_pointer_ex(hnd, filesize, 0, winapi::file_begin)){
+         return false;
+      }      
+      //We will write zeros in the end of the file
+      //since set_end_of_file does not guarantee this
+      for(std::size_t remaining = size - filesize, write_size = 0
+         ;remaining > 0
+         ;remaining -= write_size){
+         const std::size_t DataSize = 512;
+         static char data [DataSize];
+         write_size = DataSize < remaining ? DataSize : remaining;
+         unsigned long written;
+         winapi::write_file(hnd, data, (unsigned long)write_size, &written, 0);
+         if(written != write_size){
+            return false;
+         }
+      }
+   }
+   else{
+      if(!winapi::set_file_pointer_ex(hnd, size, 0, winapi::file_begin)){
+         return false;
+      }
+      if(!winapi::set_end_of_file(hnd)){
+         return false;
+      }
+   }
+   return true;
+}
+
+inline bool get_file_size(file_handle_t hnd, offset_t &size)
+{  return winapi::get_file_size(hnd, size);  }
+
+inline bool set_file_pointer(file_handle_t hnd, offset_t off, file_pos_t pos)
+{  return winapi::set_file_pointer_ex(hnd, off, 0, (unsigned long) pos); }
+
+inline bool get_file_pointer(file_handle_t hnd, offset_t &off)
+{  return winapi::set_file_pointer_ex(hnd, 0, &off, winapi::file_current); }
+
+inline bool write_file(file_handle_t hnd, const void *data, std::size_t numdata)
+{  
+   unsigned long written;
+   return 0 != winapi::write_file(hnd, data, (unsigned long)numdata, &written, 0);
+}
+
+inline file_handle_t invalid_file()
+{  return winapi::invalid_handle_value;  }
+
+inline bool close_file(file_handle_t hnd)
+{  return 0 != winapi::close_handle(hnd);   }
+
+inline bool acquire_file_lock(file_handle_t hnd)
+{  
+   static winapi::interprocess_overlapped overlapped;
+   const unsigned long len = 0xffffffff;
+//   winapi::interprocess_overlapped overlapped;
+//   std::memset(&overlapped, 0, sizeof(overlapped));
+   return winapi::lock_file_ex
+      (hnd, winapi::lockfile_exclusive_lock, 0, len, len, &overlapped);
+}
+
+inline bool try_acquire_file_lock(file_handle_t hnd, bool &acquired)
+{  
+   const unsigned long len = 0xffffffff;
+   winapi::interprocess_overlapped overlapped;
+   std::memset(&overlapped, 0, sizeof(overlapped));
+   if(!winapi::lock_file_ex
+      (hnd, winapi::lockfile_exclusive_lock | winapi::lockfile_fail_immediately, 
+       0, len, len, &overlapped)){
+      return winapi::get_last_error() == winapi::error_lock_violation ? 
+               acquired = false, true : false;
+   
+   }
+   return (acquired = true);
+}
+
+inline bool release_file_lock(file_handle_t hnd)
+{  
+   const unsigned long len = 0xffffffff;
+   winapi::interprocess_overlapped overlapped;
+   std::memset(&overlapped, 0, sizeof(overlapped));
+   return winapi::unlock_file_ex(hnd, 0, len, len, &overlapped);
+}
+
+inline bool acquire_file_lock_sharable(file_handle_t hnd)
+{  
+   const unsigned long len = 0xffffffff;
+   winapi::interprocess_overlapped overlapped;
+   std::memset(&overlapped, 0, sizeof(overlapped));
+   return winapi::lock_file_ex(hnd, 0, 0, len, len, &overlapped);
+}
+
+inline bool try_acquire_file_lock_sharable(file_handle_t hnd, bool &acquired)
+{  
+   const unsigned long len = 0xffffffff;
+   winapi::interprocess_overlapped overlapped;
+   std::memset(&overlapped, 0, sizeof(overlapped));
+   if(!winapi::lock_file_ex
+      (hnd, winapi::lockfile_fail_immediately, 0, len, len, &overlapped)){
+      return winapi::get_last_error() == winapi::error_lock_violation ? 
+               acquired = false, true : false;
+   }
+   return (acquired = true);
+}
+
+inline bool release_file_lock_sharable(file_handle_t hnd)
+{  return release_file_lock(hnd);   }
+
+inline bool delete_subdirectories_recursive
+   (const std::string &refcstrRootDirectory, const char *dont_delete_this, unsigned int count)
+{
+   bool               bSubdirectory = false;       // Flag, indicating whether
+                                                   // subdirectories have been found
+   void *             hFile;                       // Handle to directory
+   std::string        strFilePath;                 // Filepath
+   std::string        strPattern;                  // Pattern
+   winapi::win32_find_data_t  FileInformation;     // File information
+
+   //Find all files and directories
+   strPattern = refcstrRootDirectory + "\\*.*";
+   hFile = winapi::find_first_file(strPattern.c_str(), &FileInformation);
+   if(hFile != winapi::invalid_handle_value){
+      do{
+         //If it's not "." or ".." or the pointed root_level dont_delete_this erase it
+         if(FileInformation.cFileName[0] != '.' &&
+            !(dont_delete_this && count == 0 && std::strcmp(dont_delete_this, FileInformation.cFileName) == 0)){
+            strFilePath.erase();
+            strFilePath = refcstrRootDirectory + "\\" + FileInformation.cFileName;
+
+            //If it's a directory, go recursive
+            if(FileInformation.dwFileAttributes & winapi::file_attribute_directory){
+               // Delete subdirectory
+               if(!delete_subdirectories_recursive(strFilePath, dont_delete_this, count+1))
+                  return false;
+            }
+            //If it's a file, just delete it
+            else{
+               // Set file attributes
+               //if(::SetFileAttributes(strFilePath.c_str(), winapi::file_attribute_normal) == 0)
+               //return winapi::get_last_error();
+               // Delete file
+               winapi::delete_file(strFilePath.c_str());
+            }
+         }
+      //Go to the next file
+      } while(winapi::find_next_file(hFile, &FileInformation) == 1);
+
+      // Close handle
+      winapi::find_close(hFile);
+
+      //See if the loop has ended with an error or just because we've traversed all the files
+      if(winapi::get_last_error() != winapi::error_no_more_files){
+         return false;
+      }
+      else
+      {
+         //Erase empty subdirectories or original refcstrRootDirectory
+         if(!bSubdirectory && count)
+         {
+            // Set directory attributes
+            //if(::SetFileAttributes(refcstrRootDirectory.c_str(), FILE_ATTRIBUTE_NORMAL) == 0)
+               //return ::GetLastError();
+            // Delete directory
+            if(winapi::remove_directory(refcstrRootDirectory.c_str()) == 0)
+               return false;
+         }
+      }
+   }
+   return true;
+}
+
+//This function erases all the subdirectories of a directory except the one pointed by "dont_delete_this"
+inline bool delete_subdirectories(const std::string &refcstrRootDirectory, const char *dont_delete_this)
+{
+   return delete_subdirectories_recursive(refcstrRootDirectory, dont_delete_this, 0u);
+}
+
+
+template<class Function>
+inline bool for_each_file_in_dir(const char *dir, Function f)
+{
+   void *             hFile;                       // Handle to directory
+   winapi::win32_find_data_t  FileInformation;     // File information
+
+   //Get base directory
+   std::string str(dir);
+   const std::size_t base_root_dir_len = str.size();
+
+   //Find all files and directories
+   str  +=  "\\*.*";
+   hFile = winapi::find_first_file(str.c_str(), &FileInformation);
+   if(hFile != winapi::invalid_handle_value){
+      do{   //Now loop every file
+         str.erase(base_root_dir_len);
+         //If it's not "." or ".." skip it
+         if(FileInformation.cFileName[0] != '.'){
+            str += "\\";   str += FileInformation.cFileName;
+            //If it's a file, apply erase logic
+            if(!(FileInformation.dwFileAttributes & winapi::file_attribute_directory)){
+               f(str.c_str(), FileInformation.cFileName);
+            }
+         }
+      //Go to the next file
+      } while(winapi::find_next_file(hFile, &FileInformation) == 1);
+
+      // Close handle and see if the loop has ended with an error
+      winapi::find_close(hFile);
+      if(winapi::get_last_error() != winapi::error_no_more_files){
+         return false;
+      }
+   }
+   return true;
+}
+
+
+#else    //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+typedef int       file_handle_t;
+typedef off_t     offset_t;
+
+typedef struct mapping_handle_impl_t
+{
+   file_handle_t  handle;
+   bool           is_xsi;
+}  mapping_handle_t;
+
+typedef enum { read_only      = O_RDONLY
+             , read_write     = O_RDWR
+             , copy_on_write
+             , read_private
+             , invalid_mode   = 0xffff 
+             } mode_t;
+
+typedef enum { file_begin     = SEEK_SET
+             , file_end       = SEEK_END
+             , file_current   = SEEK_CUR
+             } file_pos_t;
+
+namespace ipcdetail{
+
+inline mapping_handle_t mapping_handle_from_file_handle(file_handle_t hnd)
+{
+   mapping_handle_t ret;
+   ret.handle = hnd;
+   ret.is_xsi = false;
+   return ret;
+}
+
+inline file_handle_t file_handle_from_mapping_handle(mapping_handle_t hnd)
+{  return hnd.handle; }
+
+inline bool create_directory(const char *path)
+{  return ::mkdir(path, 0777) == 0 && ::chmod(path, 0777) == 0; }
+
+inline const char *get_temporary_path()
+{
+   const char *names[] = {"/tmp", "TMPDIR", "TMP", "TEMP" };
+   const int names_size = sizeof(names)/sizeof(names[0]);
+   struct stat data;
+   for(int i = 0; i != names_size; ++i){
+      if(::stat(names[i], &data) == 0){
+         return names[i];
+      }
+   }
+   return "/tmp";
+}
+
+inline file_handle_t create_new_file
+   (const char *name, mode_t mode, const permissions & perm = permissions(), bool temporary = false)
+{  
+   (void)temporary;
+   int ret = ::open(name, ((int)mode) | O_EXCL | O_CREAT, perm.get_permissions());
+   if(ret >= 0){
+      ::fchmod(ret, perm.get_permissions());
+   }
+   return ret;
+}
+
+inline file_handle_t create_or_open_file
+   (const char *name, mode_t mode, const permissions & perm = permissions(), bool temporary = false)
+{
+   (void)temporary;
+   int ret = -1;
+   //We need a loop to change permissions correctly using fchmod, since
+   //with "O_CREAT only" ::open we don't know if we've created or opened the file.
+   while(1){
+      ret = ::open(name, ((int)mode) | O_EXCL | O_CREAT, perm.get_permissions());
+      if(ret >= 0){
+         ::fchmod(ret, perm.get_permissions());
+         break;
+      }
+      else if(errno == EEXIST){
+         if((ret = ::open(name, (int)mode)) >= 0 || errno != ENOENT){
+            break;
+         }
+      }
+   }
+   return ret;
+}
+
+inline file_handle_t open_existing_file
+   (const char *name, mode_t mode, bool temporary = false)
+{  
+   (void)temporary;
+   return ::open(name, (int)mode);
+}
+
+inline bool delete_file(const char *name)
+{  return ::unlink(name) == 0;   }
+
+inline bool truncate_file (file_handle_t hnd, std::size_t size)
+{
+   if(sizeof(off_t) == sizeof(std::size_t)){
+      if(size > ((~std::size_t(0)) >> 1)){
+         errno = EINVAL;
+         return false;
+      }
+   }
+   return 0 == ::ftruncate(hnd, off_t(size));
+}
+
+inline bool get_file_size(file_handle_t hnd, offset_t &size)
+{  
+   struct stat data;
+   bool ret = 0 == ::fstat(hnd, &data);
+   if(ret){
+      size = data.st_size;
+   }
+   return ret;
+}
+
+inline bool set_file_pointer(file_handle_t hnd, offset_t off, file_pos_t pos)
+{  return ((off_t)(-1)) != ::lseek(hnd, off, (int)pos); }
+
+inline bool get_file_pointer(file_handle_t hnd, offset_t &off)
+{  
+   off = ::lseek(hnd, 0, SEEK_CUR);
+   return off != ((off_t)-1);
+}
+
+inline bool write_file(file_handle_t hnd, const void *data, std::size_t numdata)
+{  return (ssize_t(numdata)) == ::write(hnd, data, numdata);  }
+
+inline file_handle_t invalid_file()
+{  return -1;  }
+
+inline bool close_file(file_handle_t hnd)
+{  return ::close(hnd) == 0;   }
+
+inline bool acquire_file_lock(file_handle_t hnd)
+{
+   struct ::flock lock;
+   lock.l_type    = F_WRLCK;
+   lock.l_whence  = SEEK_SET;
+   lock.l_start   = 0;
+   lock.l_len     = 0;
+   return -1 != ::fcntl(hnd, F_SETLKW, &lock);
+}
+
+inline bool try_acquire_file_lock(file_handle_t hnd, bool &acquired)
+{
+   struct ::flock lock;
+   lock.l_type    = F_WRLCK;
+   lock.l_whence  = SEEK_SET;
+   lock.l_start   = 0;
+   lock.l_len     = 0;
+   int ret = ::fcntl(hnd, F_SETLK, &lock);
+   if(ret == -1){
+      return (errno == EAGAIN || errno == EACCES) ?
+               acquired = false, true : false;
+   }
+   return (acquired = true);
+}
+
+inline bool release_file_lock(file_handle_t hnd)
+{
+   struct ::flock lock;
+   lock.l_type    = F_UNLCK;
+   lock.l_whence  = SEEK_SET;
+   lock.l_start   = 0;
+   lock.l_len     = 0;
+   return -1 != ::fcntl(hnd, F_SETLK, &lock);
+}
+
+inline bool acquire_file_lock_sharable(file_handle_t hnd)
+{  
+   struct ::flock lock;
+   lock.l_type    = F_RDLCK;
+   lock.l_whence  = SEEK_SET;
+   lock.l_start   = 0;
+   lock.l_len     = 0;
+   return -1 != ::fcntl(hnd, F_SETLKW, &lock);
+}
+
+inline bool try_acquire_file_lock_sharable(file_handle_t hnd, bool &acquired)
+{  
+   struct flock lock;
+   lock.l_type    = F_RDLCK;
+   lock.l_whence  = SEEK_SET;
+   lock.l_start   = 0;
+   lock.l_len     = 0;
+   int ret = ::fcntl(hnd, F_SETLK, &lock);
+   if(ret == -1){
+      return (errno == EAGAIN || errno == EACCES) ? 
+               acquired = false, true : false;
+   }
+   return (acquired = true);
+}
+
+inline bool release_file_lock_sharable(file_handle_t hnd)
+{  return release_file_lock(hnd);   }
+
+#if 0
+inline bool acquire_file_lock(file_handle_t hnd)
+{  return 0 == ::flock(hnd, LOCK_EX); }
+
+inline bool try_acquire_file_lock(file_handle_t hnd, bool &acquired)
+{
+   int ret = ::flock(hnd, LOCK_EX | LOCK_NB);
+   acquired = ret == 0;
+   return (acquired || errno == EWOULDBLOCK);
+}
+
+inline bool release_file_lock(file_handle_t hnd)
+{  return 0 == ::flock(hnd, LOCK_UN); }
+
+inline bool acquire_file_lock_sharable(file_handle_t hnd)
+{  return 0 == ::flock(hnd, LOCK_SH); }
+
+inline bool try_acquire_file_lock_sharable(file_handle_t hnd, bool &acquired)
+{
+   int ret = ::flock(hnd, LOCK_SH | LOCK_NB);
+   acquired = ret == 0;
+   return (acquired || errno == EWOULDBLOCK);
+}
+
+inline bool release_file_lock_sharable(file_handle_t hnd)
+{  return 0 == ::flock(hnd, LOCK_UN); }
+#endif
+
+inline bool delete_subdirectories_recursive
+   (const std::string &refcstrRootDirectory, const char *dont_delete_this)
+{
+   DIR *d = opendir(refcstrRootDirectory.c_str());
+   if(!d) {
+      return false;
+   }
+
+   struct dir_close
+   {
+      DIR *d_;
+      dir_close(DIR *d) : d_(d) {}
+      ~dir_close() { ::closedir(d_); }
+   } dc(d); (void)dc;
+
+   struct ::dirent *de;
+   struct ::stat st;
+   std::string fn;
+
+   while((de=::readdir(d))) {
+      if( de->d_name[0] == '.' && ( de->d_name[1] == '\0'
+            || (de->d_name[1] == '.' && de->d_name[2] == '\0' )) ){
+         continue;
+      }
+      if(dont_delete_this && std::strcmp(dont_delete_this, de->d_name) == 0){  
+         continue;
+      }
+      fn = refcstrRootDirectory;
+      fn += '/';
+      fn += de->d_name;
+
+      if(std::remove(fn.c_str())) {
+         if(::stat(fn.c_str(), & st)) {
+            return false;
+         }
+         if(S_ISDIR(st.st_mode)) {
+            if(!delete_subdirectories_recursive(fn, 0) ){
+               return false;
+            }
+         } else {
+            return false;
+         }
+      }
+   }
+   return std::remove(refcstrRootDirectory.c_str()) ? false : true;
+}
+
+template<class Function>
+inline bool for_each_file_in_dir(const char *dir, Function f)
+{
+   std::string refcstrRootDirectory(dir);
+
+   DIR *d = opendir(refcstrRootDirectory.c_str());
+   if(!d) {
+      return false;
+   }
+
+   struct dir_close
+   {
+      DIR *d_;
+      dir_close(DIR *d) : d_(d) {}
+      ~dir_close() { ::closedir(d_); }
+   } dc(d); (void)dc;
+
+   struct ::dirent *de;
+   struct ::stat st;
+   std::string fn;
+
+   while((de=::readdir(d))) {
+      if( de->d_name[0] == '.' && ( de->d_name[1] == '\0'
+            || (de->d_name[1] == '.' && de->d_name[2] == '\0' )) ){
+         continue;
+      }
+      fn = refcstrRootDirectory;
+      fn += '/';
+      fn += de->d_name;
+
+      if(::stat(fn.c_str(), & st)) {
+         return false;
+      }
+      //If it's a file, apply erase logic
+      if(!S_ISDIR(st.st_mode)) {
+         f(fn.c_str(), de->d_name);
+      }
+   }
+   return true;
+}
+
+
+//This function erases all the subdirectories of a directory except the one pointed by "dont_delete_this"
+inline bool delete_subdirectories(const std::string &refcstrRootDirectory, const char *dont_delete_this)
+{
+   return delete_subdirectories_recursive(refcstrRootDirectory, dont_delete_this );
+}
+
+#endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+inline bool open_or_create_directory(const char *dir_name)
+{
+   //If fails, check that it's because it already exists
+   if(!create_directory(dir_name)){
+      error_info info(system_error_code());
+      if(info.get_error_code() != already_exists_error){
+         return false;
+      }
+   }
+   return true;
+}
+
+
+}  //namespace ipcdetail{
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_OS_FILE_FUNCTIONS_HPP
diff --git a/boost/interprocess/detail/os_thread_functions.hpp b/boost/interprocess/detail/os_thread_functions.hpp
new file mode 100644
index 0000000000..e49e82c8e0
--- /dev/null
+++ b/boost/interprocess/detail/os_thread_functions.hpp
@@ -0,0 +1,211 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_OS_THREAD_FUNCTIONS_HPP
+#define BOOST_INTERPROCESS_DETAIL_OS_THREAD_FUNCTIONS_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/streams/bufferstream.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+#  include <boost/interprocess/detail/win32_api.hpp>
+#else
+#  ifdef BOOST_HAS_UNISTD_H
+#     include <pthread.h>
+#     include <unistd.h>
+#     include <sched.h>
+#     include <time.h>
+#  else
+#     error Unknown platform
+#  endif
+#endif
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+typedef unsigned long OS_process_id_t;
+typedef unsigned long OS_thread_id_t;
+typedef OS_thread_id_t OS_systemwide_thread_id_t;
+
+//process
+inline OS_process_id_t get_current_process_id()
+{  return winapi::get_current_process_id();  }
+
+inline OS_process_id_t get_invalid_process_id()
+{  return OS_process_id_t(0);  }
+
+//thread
+inline OS_thread_id_t get_current_thread_id()
+{  return winapi::get_current_thread_id();  }
+
+inline OS_thread_id_t get_invalid_thread_id()
+{  return OS_thread_id_t(0xffffffff);  }
+
+inline bool equal_thread_id(OS_thread_id_t id1, OS_thread_id_t id2)
+{  return id1 == id2;  }
+
+inline void thread_yield()
+{  winapi::sched_yield();  }
+
+inline void thread_sleep(unsigned int ms)
+{  winapi::Sleep(ms);  }
+
+//systemwide thread
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{
+   return get_current_thread_id();
+}
+
+inline void systemwide_thread_id_copy
+   (const volatile OS_systemwide_thread_id_t &from, volatile OS_systemwide_thread_id_t &to)
+{
+   to = from;
+}
+
+inline bool equal_systemwide_thread_id(const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
+{
+   return equal_thread_id(id1, id2);
+}
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{
+   return get_invalid_thread_id();
+}
+
+inline long double get_current_process_creation_time()
+{
+   winapi::interprocess_filetime CreationTime, ExitTime, KernelTime, UserTime;
+
+   get_process_times
+      ( winapi::get_current_process(), &CreationTime, &ExitTime, &KernelTime, &UserTime);
+
+   typedef long double ldouble_t;
+   const ldouble_t resolution = (100.0l/1000000000.0l);
+   return CreationTime.dwHighDateTime*(ldouble_t(1u<<31u)*2.0l*resolution) +
+              CreationTime.dwLowDateTime*resolution;
+}
+
+
+#else    //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+typedef pthread_t OS_thread_id_t;
+typedef pid_t     OS_process_id_t;
+
+struct OS_systemwide_thread_id_t
+{  
+   OS_systemwide_thread_id_t()
+      :  pid(), tid()
+   {}
+
+   OS_systemwide_thread_id_t(pid_t p, pthread_t t)
+      :  pid(p), tid(t)
+   {}
+
+   OS_systemwide_thread_id_t(const OS_systemwide_thread_id_t &x)
+      :  pid(x.pid), tid(x.tid)
+   {}
+
+   OS_systemwide_thread_id_t(const volatile OS_systemwide_thread_id_t &x)
+      :  pid(x.pid), tid(x.tid)
+   {}
+
+   OS_systemwide_thread_id_t & operator=(const OS_systemwide_thread_id_t &x)
+   {  pid = x.pid;   tid = x.tid;   return *this;   }
+
+   OS_systemwide_thread_id_t & operator=(const volatile OS_systemwide_thread_id_t &x)
+   {  pid = x.pid;   tid = x.tid;   return *this;  }
+
+   void operator=(const OS_systemwide_thread_id_t &x) volatile
+   {  pid = x.pid;   tid = x.tid;   }
+
+   pid_t       pid;
+   pthread_t   tid;
+};
+
+inline void systemwide_thread_id_copy
+   (const volatile OS_systemwide_thread_id_t &from, volatile OS_systemwide_thread_id_t &to)
+{
+   to.pid = from.pid;
+   to.tid = from.tid;
+}
+
+//process
+inline OS_process_id_t get_current_process_id()
+{  return ::getpid();  }
+
+inline OS_process_id_t get_invalid_process_id()
+{  return pid_t(0);  }
+
+//thread
+inline OS_thread_id_t get_current_thread_id()
+{  return ::pthread_self();  }
+
+inline OS_thread_id_t get_invalid_thread_id()
+{ 
+   static pthread_t invalid_id;
+   return invalid_id;
+}
+
+inline bool equal_thread_id(OS_thread_id_t id1, OS_thread_id_t id2)
+{  return 0 != pthread_equal(id1, id2);  }
+
+inline void thread_yield()
+{  ::sched_yield();  }
+
+inline void thread_sleep(unsigned int ms)
+{
+   const struct timespec rqt = { ms/1000u, (ms%1000u)*1000000u  };
+   ::nanosleep(&rqt, 0);
+}
+
+//systemwide thread
+inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
+{
+   return OS_systemwide_thread_id_t(::getpid(), ::pthread_self());
+}
+
+inline bool equal_systemwide_thread_id(const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
+{
+   return (0 != pthread_equal(id1.tid, id2.tid)) && (id1.pid == id2.pid);
+}
+
+inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
+{
+   return OS_systemwide_thread_id_t(get_invalid_process_id(), get_invalid_thread_id());
+}
+
+inline long double get_current_process_creation_time()
+{ return 0.0L; }
+
+#endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+typedef char pid_str_t[sizeof(OS_process_id_t)*3+1];
+
+inline void get_pid_str(pid_str_t &pid_str, OS_process_id_t pid)
+{
+   bufferstream bstream(pid_str, sizeof(pid_str));
+   bstream << pid << std::ends;
+}
+
+inline void get_pid_str(pid_str_t &pid_str)
+{  get_pid_str(pid_str, get_current_process_id());  }
+
+}  //namespace ipcdetail{
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_OS_THREAD_FUNCTIONS_HPP
diff --git a/boost/interprocess/detail/pointer_type.hpp b/boost/interprocess/detail/pointer_type.hpp
new file mode 100644
index 0000000000..7c45be085e
--- /dev/null
+++ b/boost/interprocess/detail/pointer_type.hpp
@@ -0,0 +1,74 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011.
+// (C) Copyright Gennaro Prota 2003 - 2004.
+//
+// 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_DETAIL_POINTER_TYPE_HPP
+#define BOOST_INTERPROCESS_DETAIL_POINTER_TYPE_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/interprocess/detail/type_traits.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+struct two {char _[2];};
+
+namespace pointer_type_imp {
+
+template <class U> static two  test(...);
+template <class U> static char test(typename U::pointer* = 0);
+
+}  //namespace pointer_type_imp {
+
+template <class T>
+struct has_pointer_type
+{
+    static const bool value = sizeof(pointer_type_imp::test<T>(0)) == 1;
+};
+
+namespace pointer_type_imp {
+
+template <class T, class D, bool = has_pointer_type<D>::value>
+struct pointer_type
+{
+    typedef typename D::pointer type;
+};
+
+template <class T, class D>
+struct pointer_type<T, D, false>
+{
+    typedef T* type;
+};
+
+}  //namespace pointer_type_imp {
+
+template <class T, class D>
+struct pointer_type
+{
+    typedef typename pointer_type_imp::pointer_type<T,
+        typename ipcdetail::remove_reference<D>::type>::type type;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_POINTER_TYPE_HPP
+
diff --git a/boost/interprocess/detail/posix_time_types_wrk.hpp b/boost/interprocess/detail/posix_time_types_wrk.hpp
new file mode 100644
index 0000000000..c1276f0f26
--- /dev/null
+++ b/boost/interprocess/detail/posix_time_types_wrk.hpp
@@ -0,0 +1,42 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_POSIX_TIMES_WRK_HPP
+#define BOOST_INTERPROCESS_POSIX_TIMES_WRK_HPP
+
+//workaround to avoid winsock redefines when using date-time
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 
+#define BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#endif   //#ifndef WIN32_LEAN_AND_MEAN
+#endif   //#ifdef _WIN32
+
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+
+namespace boost {
+namespace interprocess {
+
+typedef boost::date_time::microsec_clock<boost::posix_time::ptime> microsec_clock;
+
+}
+}
+
+#ifdef _WIN32
+#ifdef BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#undef BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#endif   //#ifdef BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#endif   //#ifdef _WIN32
+
+#endif   //#ifndef BOOST_INTERPROCESS_POSIX_TIMES_WRK_HPP
+
diff --git a/boost/interprocess/detail/preprocessor.hpp b/boost/interprocess/detail/preprocessor.hpp
new file mode 100644
index 0000000000..4af2686452
--- /dev/null
+++ b/boost/interprocess/detail/preprocessor.hpp
@@ -0,0 +1,137 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_DETAIL_PREPROCESSOR_HPP
+#define BOOST_INTERPROCESS_DETAIL_PREPROCESSOR_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+
+#ifdef BOOST_INTERPROCESS_PERFECT_FORWARDING
+#error "This file is not needed when perfect forwarding is available"
+#endif
+
+#include <boost/preprocessor/iteration/local.hpp> 
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+
+#define BOOST_INTERPROCESS_MAX_CONSTRUCTOR_PARAMETERS 10
+
+//Note:
+//We define template parameters as const references to
+//be able to bind temporaries. After that we will un-const them.
+//This cast is ugly but it is necessary until "perfect forwarding"
+//is achieved in C++0x. Meanwhile, if we want to be able to
+//bind rvalues with non-const references, we have to be ugly
+#ifndef BOOST_NO_RVALUE_REFERENCES
+   #define BOOST_INTERPROCESS_PP_PARAM_LIST(z, n, data) \
+   BOOST_PP_CAT(P, n) && BOOST_PP_CAT(p, n) \
+   //!
+#else
+   #define BOOST_INTERPROCESS_PP_PARAM_LIST(z, n, data) \
+   const BOOST_PP_CAT(P, n) & BOOST_PP_CAT(p, n) \
+   //!
+#endif
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+   #define BOOST_INTERPROCESS_PP_PARAM(U, u) \
+   U && u \
+   //!
+#else
+   #define BOOST_INTERPROCESS_PP_PARAM(U, u) \
+   const U & u \
+   //!
+#endif
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+
+#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+
+#define BOOST_INTERPROCESS_PP_PARAM_INIT(z, n, data) \
+  BOOST_PP_CAT(m_p, n) (BOOST_INTERPROCESS_MOVE_NAMESPACE::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ))           \
+//!
+
+#else
+
+#define BOOST_INTERPROCESS_PP_PARAM_INIT(z, n, data) \
+  BOOST_PP_CAT(m_p, n) (BOOST_PP_CAT(p, n))           \
+//!
+
+#endif
+
+#else
+#define BOOST_INTERPROCESS_PP_PARAM_INIT(z, n, data) \
+  BOOST_PP_CAT(m_p, n) (const_cast<BOOST_PP_CAT(P, n) &>(BOOST_PP_CAT(p, n))) \
+//!
+#endif
+
+#define BOOST_INTERPROCESS_PP_PARAM_INC(z, n, data)   \
+  BOOST_PP_CAT(++m_p, n)                        \
+//!
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+
+#if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+#define BOOST_INTERPROCESS_PP_PARAM_DEFINE(z, n, data)  \
+  BOOST_PP_CAT(P, n) & BOOST_PP_CAT(m_p, n);            \
+//!
+
+#else
+
+#define BOOST_INTERPROCESS_PP_PARAM_DEFINE(z, n, data)  \
+  BOOST_PP_CAT(P, n) && BOOST_PP_CAT(m_p, n);            \
+//!
+
+#endif //defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+
+#else
+#define BOOST_INTERPROCESS_PP_PARAM_DEFINE(z, n, data)  \
+  BOOST_PP_CAT(P, n) & BOOST_PP_CAT(m_p, n);             \
+//!
+#endif
+
+#define BOOST_INTERPROCESS_PP_PARAM_FORWARD(z, n, data) \
+::boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ) \
+//!
+
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+#include <boost/container/detail/stored_ref.hpp>
+
+#define BOOST_INTERPROCESS_PP_MEMBER_FORWARD(z, n, data) \
+::boost::container::container_detail::stored_ref< BOOST_PP_CAT(P, n) >::forward( BOOST_PP_CAT(m_p, n) ) \
+//!
+
+#else
+
+#define BOOST_INTERPROCESS_PP_MEMBER_FORWARD(z, n, data) \
+::boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(m_p, n) ) \
+//!
+
+#endif   //!defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
+
+#define BOOST_INTERPROCESS_PP_MEMBER_IT_FORWARD(z, n, data) \
+BOOST_PP_CAT(*m_p, n) \
+//!
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#else
+#ifdef BOOST_INTERPROCESS_PERFECT_FORWARDING
+#error "This file is not needed when perfect forwarding is available"
+#endif
+#endif //#ifndef BOOST_INTERPROCESS_DETAIL_PREPROCESSOR_HPP
diff --git a/boost/interprocess/detail/ptime_wrk.hpp b/boost/interprocess/detail/ptime_wrk.hpp
new file mode 100644
index 0000000000..4a4709e3a8
--- /dev/null
+++ b/boost/interprocess/detail/ptime_wrk.hpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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_PTIME_WRK_HPP
+#define BOOST_INTERPROCESS_PTIME_WRK_HPP
+
+//workaround to avoid winsock redefines when using date-time
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 
+#define BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#endif   //#ifndef WIN32_LEAN_AND_MEAN
+#endif   //#ifdef _WIN32
+
+#include <boost/date_time/posix_time/ptime.hpp>
+
+#ifdef _WIN32
+#ifdef BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#undef WIN32_LEAN_AND_MEAN
+#undef BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#endif   //#ifdef BOOST_INTERPROCESS_WIN32_LEAN_AND_MEAN
+#endif   //#ifdef _WIN32
+
+#endif   //#ifndef BOOST_INTERPROCESS_PTIME_WRK_HPP
+
diff --git a/boost/interprocess/detail/robust_emulation.hpp b/boost/interprocess/detail/robust_emulation.hpp
new file mode 100644
index 0000000000..b2097d0ad7
--- /dev/null
+++ b/boost/interprocess/detail/robust_emulation.hpp
@@ -0,0 +1,439 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2010-2011. 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_ROBUST_EMULATION_HPP
+#define BOOST_INTERPROCESS_ROBUST_EMULATION_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/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
+#include <boost/interprocess/detail/intermodule_singleton.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <string>
+
+namespace boost{
+namespace interprocess{
+namespace ipcdetail{
+
+namespace robust_emulation_helpers {
+
+template<class T>
+class mutex_traits
+{
+   public:
+   static void take_ownership(T &t)
+   {  t.take_ownership(); }
+};
+
+inline void remove_if_can_lock_file(const char *file_path)
+{
+   file_handle_t fhnd = open_existing_file(file_path, read_write);
+
+   if(fhnd != invalid_file()){
+      bool acquired;
+      if(try_acquire_file_lock(fhnd, acquired) && acquired){
+         delete_file(file_path);
+      }
+      close_file(fhnd);
+   }
+}
+
+inline const char *robust_lock_subdir_path()
+{  return "robust"; }
+
+inline const char *robust_lock_prefix()
+{  return "lck"; }
+
+inline void robust_lock_path(std::string &s)
+{
+   tmp_folder(s);
+   s += "/";
+   s += robust_lock_subdir_path();
+}
+
+inline void create_and_get_robust_lock_file_path(std::string &s, OS_process_id_t pid)
+{
+   file_locking_helpers::create_tmp_subdir_and_get_pid_based_filepath
+      (robust_lock_subdir_path(), robust_lock_prefix(), pid, s);
+}
+
+//This class will be a intermodule_singleton. The constructor will create
+//a lock file, the destructor will erase it.
+//
+//We should take in care that another process might be erasing unlocked
+//files while creating this one, so there are some race conditions we must
+//take in care to guarantee some robustness.
+class robust_mutex_lock_file
+{
+   file_handle_t fd;
+   std::string fname;
+   public:
+   robust_mutex_lock_file()
+   {
+      permissions p;
+      p.set_unrestricted();
+      //Remove old lock files of other processes
+      remove_old_robust_lock_files();
+      //Create path and obtain lock file path for this process
+      create_and_get_robust_lock_file_path(fname, get_current_process_id());
+
+      //Now try to open or create the lock file
+      fd = create_or_open_file(fname.c_str(), read_write, p);
+      //If we can't open or create it, then something unrecoverable has happened
+      if(fd == invalid_file()){
+         throw interprocess_exception(other_error, "Robust emulation robust_mutex_lock_file constructor failed: could not open or create file");
+      }
+
+      //Now we must take in care a race condition with another process
+      //calling "remove_old_robust_lock_files()". No other threads from this
+      //process will be creating the lock file because intermodule_singleton
+      //guarantees this. So let's loop acquiring the lock and checking if we
+      //can't exclusively create the file (if the file is erased by another process
+      //then this exclusive open would fail). If the file can't be exclusively created
+      //then we have correctly open/create and lock the file. If the file can
+      //be exclusively created, then close previous locked file and try again.
+      while(1){
+         bool acquired;
+         if(!try_acquire_file_lock(fd, acquired) || !acquired ){
+            throw interprocess_exception(other_error, "Robust emulation robust_mutex_lock_file constructor failed: try_acquire_file_lock");
+         }
+         //Creating exclusively must fail with already_exists_error
+         //to make sure we've locked the file and no one has
+         //deleted it between creation and locking
+         file_handle_t fd2 = create_new_file(fname.c_str(), read_write, p);
+         if(fd2 != invalid_file()){
+            close_file(fd);
+            fd = fd2;
+            continue;
+         }
+         //If exclusive creation fails with expected error go ahead
+         else if(error_info(system_error_code()).get_error_code() == already_exists_error){ //must already exist
+            //Leak descriptor to mantain the file locked until the process dies
+            break;
+         }
+         //If exclusive creation fails with unexpected error throw an unrecoverable error
+         else{
+            close_file(fd);
+            throw interprocess_exception(other_error, "Robust emulation robust_mutex_lock_file constructor failed: create_file filed with unexpected error");
+         }
+      }
+   }   
+
+   ~robust_mutex_lock_file()
+   {
+      //The destructor is guaranteed by intermodule_singleton to be
+      //executed serialized between all threads from current process,
+      //so we just need to close and unlink the file.
+      close_file(fd);
+      //If some other process deletes the file before us after
+      //closing it there should not be any problem.
+      delete_file(fname.c_str());
+   }
+
+   private:
+   //This functor is execute for all files in the lock file directory
+   class other_process_lock_remover
+   {
+      public:
+      void operator()(const char *filepath, const char *filename)
+      {
+         std::string pid_str;
+         //If the lock file is not our own lock file, then try to do the cleanup
+         if(!file_locking_helpers::check_if_filename_complies_with_pid
+            (filename, robust_lock_prefix(), get_current_process_id(), pid_str)){
+            remove_if_can_lock_file(filepath);
+         }
+      }
+   };
+
+   bool remove_old_robust_lock_files()
+   {
+      std::string refcstrRootDirectory;
+      robust_lock_path(refcstrRootDirectory);
+      return for_each_file_in_dir(refcstrRootDirectory.c_str(), other_process_lock_remover());
+   }
+};
+
+}  //namespace robust_emulation_helpers {
+
+//This is the mutex class. Mutex should follow mutex concept
+//with an additonal "take_ownership()" function to take ownership of the
+//mutex when robust_spin_mutex determines the previous owner was dead.
+template<class Mutex>
+class robust_spin_mutex
+{
+   public:
+   static const boost::uint32_t correct_state = 0;
+   static const boost::uint32_t fixing_state  = 1;
+   static const boost::uint32_t broken_state  = 2;
+
+   typedef robust_emulation_helpers::mutex_traits<Mutex> mutex_traits_t;
+
+   robust_spin_mutex();
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   void unlock();
+   void consistent();
+   bool previous_owner_dead();
+
+   private:
+   static const unsigned int spin_threshold = 100u;
+   bool lock_own_unique_file();
+   bool robust_check();
+   bool check_if_owner_dead_and_take_ownership_atomically();
+   bool is_owner_dead(boost::uint32_t owner);
+   void owner_to_filename(boost::uint32_t owner, std::string &s);
+   //The real mutex
+   Mutex mtx;
+   //The pid of the owner
+   volatile boost::uint32_t owner;
+   //The state of the mutex (correct, fixing, broken)
+   volatile boost::uint32_t state;
+};
+
+template<class Mutex>
+inline robust_spin_mutex<Mutex>::robust_spin_mutex()
+   : mtx(), owner(get_invalid_process_id()), state(correct_state)
+{}
+
+template<class Mutex>
+inline void robust_spin_mutex<Mutex>::lock()
+{
+   //If the mutex is broken (recovery didn't call consistent()),
+   //then throw an exception
+   if(atomic_read32(&this->state) == broken_state){
+      throw interprocess_exception(lock_error, "Broken id");
+   }
+
+   //This function provokes intermodule_singleton instantiation
+   if(!this->lock_own_unique_file()){
+      throw interprocess_exception(lock_error, "Broken id");
+   }
+
+   //Now the logic. Try to lock, if successful mark the owner
+   //if it fails, start recovery logic
+   unsigned int spin_count = 0;
+   while(1){
+      if (mtx.try_lock()){
+         atomic_write32(&this->owner, get_current_process_id());
+         break;
+      }
+      else{
+         //Do the dead owner checking each spin_threshold lock tries
+         ipcdetail::thread_yield();
+         ++spin_count;
+         if(spin_count > spin_threshold){
+            //Check if owner dead and take ownership if possible
+            if(!this->robust_check()){
+               spin_count = 0;
+            }
+            else{
+               break;
+            }
+         }
+      }
+   }
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::try_lock()
+{
+   //Same as lock() but without spinning
+   if(atomic_read32(&this->state) == broken_state){
+      throw interprocess_exception(lock_error, "Broken id");
+   }
+
+   if(!this->lock_own_unique_file()){
+      throw interprocess_exception(lock_error, "Broken id");
+   }
+
+   if (mtx.try_lock()){
+      atomic_write32(&this->owner, get_current_process_id());
+      return true;
+   }
+   else{
+      if(!this->robust_check()){
+         return false;
+      }
+      else{
+         return true;
+      }
+   }
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::timed_lock
+   (const boost::posix_time::ptime &abs_time)
+{
+   //Same as lock() but with an additional timeout
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   //Obtain current count and target time
+   boost::posix_time::ptime now = microsec_clock::universal_time();
+
+   if(now >= abs_time)
+      return this->try_lock();
+
+   do{
+      if(this->try_lock()){
+         break;
+      }
+      now = microsec_clock::universal_time();
+
+      if(now >= abs_time){
+         return this->try_lock();
+      }
+      // relinquish current time slice
+      ipcdetail::thread_yield();
+   }while (true);
+
+   return true;
+}
+
+template<class Mutex>
+inline void robust_spin_mutex<Mutex>::owner_to_filename(boost::uint32_t owner, std::string &s)
+{
+   robust_emulation_helpers::create_and_get_robust_lock_file_path(s, owner);
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::robust_check()
+{
+   //If the old owner was dead, and we've acquired ownership, mark
+   //the mutex as 'fixing'. This means that a "consistent()" is needed
+   //to avoid marking the mutex as "broken" when the mutex is unlocked.
+   if(!this->check_if_owner_dead_and_take_ownership_atomically()){
+      return false;
+   }
+   atomic_write32(&this->state, fixing_state);
+   return true;   
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::check_if_owner_dead_and_take_ownership_atomically()
+{
+   boost::uint32_t cur_owner = get_current_process_id();
+   boost::uint32_t old_owner = atomic_read32(&this->owner), old_owner2;
+   //The cas loop guarantees that only one thread from this or another process
+   //will succeed taking ownership
+   do{
+      //Check if owner is dead
+      if(!this->is_owner_dead(old_owner)){
+         return false;
+      }
+      //If it's dead, try to mark this process as the owner in the owner field
+      old_owner2 = old_owner;
+      old_owner = atomic_cas32(&this->owner, cur_owner, old_owner);
+   }while(old_owner2 != old_owner);
+   //If success, we fix mutex internals to assure our ownership
+   mutex_traits_t::take_ownership(mtx);
+   return true;
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::is_owner_dead(boost::uint32_t owner)
+{
+   //If owner is an invalid id, then it's clear it's dead
+   if(owner == (boost::uint32_t)get_invalid_process_id()){
+      return true;
+   }
+
+   //Obtain the lock filename of the owner field
+   std::string file;
+   this->owner_to_filename(owner, file);
+
+   //Now the logic is to open and lock it
+   file_handle_t fhnd = open_existing_file(file.c_str(), read_write);
+
+   if(fhnd != invalid_file()){
+      //If we can open the file, lock it.
+      bool acquired;
+      if(try_acquire_file_lock(fhnd, acquired) && acquired){
+         //If locked, just delete the file
+         delete_file(file.c_str());
+         close_file(fhnd);
+         return true;
+      }
+      //If not locked, the owner is suppossed to be still alive
+      close_file(fhnd);
+   }
+   else{
+      //If the lock file does not exist then the owner is dead (a previous cleanup)
+      //function has deleted the file. If there is another reason, then this is
+      //an unrecoverable error
+      if(error_info(system_error_code()).get_error_code() == not_found_error){
+         return true;
+      }
+   }
+   return false;
+}
+
+template<class Mutex>
+inline void robust_spin_mutex<Mutex>::consistent()
+{
+   //This function supposes the previous state was "fixing"
+   //and the current process holds the mutex
+   if(atomic_read32(&this->state) != fixing_state &&
+      atomic_read32(&this->owner) != (boost::uint32_t)get_current_process_id()){
+      throw interprocess_exception(lock_error, "Broken id");
+   }
+   //If that's the case, just update mutex state
+   atomic_write32(&this->state, correct_state);
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::previous_owner_dead()
+{
+   //Notifies if a owner recovery has been performed in the last lock()
+   return atomic_read32(&this->state) == fixing_state;
+};
+
+template<class Mutex>
+inline void robust_spin_mutex<Mutex>::unlock()
+{
+   //If in "fixing" state, unlock and mark the mutex as unrecoverable
+   //so next locks will fail and all threads will be notified that the
+   //data protected by the mutex was not recoverable.
+   if(atomic_read32(&this->state) == fixing_state){
+      atomic_write32(&this->state, broken_state);
+   }
+   //Write an invalid owner to minimize pid reuse possibility
+   atomic_write32(&this->owner, get_invalid_process_id());
+   mtx.unlock();
+}
+
+template<class Mutex>
+inline bool robust_spin_mutex<Mutex>::lock_own_unique_file()
+{
+   //This function forces instantiation of the singleton
+   robust_emulation_helpers::robust_mutex_lock_file* dummy = 
+      &ipcdetail::intermodule_singleton
+         <robust_emulation_helpers::robust_mutex_lock_file>::get();
+   return dummy != 0;
+}
+
+}  //namespace ipcdetail{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif
diff --git a/boost/interprocess/detail/segment_manager_helper.hpp b/boost/interprocess/detail/segment_manager_helper.hpp
new file mode 100644
index 0000000000..ea820b3881
--- /dev/null
+++ b/boost/interprocess/detail/segment_manager_helper.hpp
@@ -0,0 +1,513 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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 value_bytes
+               ,size_type value_alignment
+               ,unsigned char alloc_type
+               ,std::size_t sizeof_char
+               ,std::size_t num_char
+               )
+      :  m_value_bytes(value_bytes)
+      ,  m_num_char((unsigned short)num_char)
+      ,  m_value_alignment((unsigned char)value_alignment)
+      ,  m_alloc_type_sizeof_char
+         ( (alloc_type << 5u) | 
+           ((unsigned char)sizeof_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 *name, size_type length)
+      : mp_str(name), 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 *name)
+   {  mp_str = name; }
+
+   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
+
diff --git a/boost/interprocess/detail/tmp_dir_helpers.hpp b/boost/interprocess/detail/tmp_dir_helpers.hpp
new file mode 100644
index 0000000000..38aafb2beb
--- /dev/null
+++ b/boost/interprocess/detail/tmp_dir_helpers.hpp
@@ -0,0 +1,174 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2011. 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_DETAIL_TMP_DIR_HELPERS_HPP
+#define BOOST_INTERPROCESS_DETAIL_TMP_DIR_HELPERS_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/errors.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <string>
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+   //#define BOOST_INTERPROCESS_HAS_WINDOWS_KERNEL_BOOTTIME
+   //#define BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
+   //#include <boost/interprocess/detail/win32_api.hpp>
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
+   //#include <sys/sysctl.h>
+   //#if defined(CTL_KERN) && defined (KERN_BOOTTIME)
+      //#define BOOST_INTERPROCESS_HAS_BSD_KERNEL_BOOTTIME
+      //#define BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
+   //#endif
+#endif
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+#if defined (BOOST_INTERPROCESS_HAS_WINDOWS_KERNEL_BOOTTIME)
+inline void get_bootstamp(std::string &s, bool add = false)
+{
+   std::string bootstamp;
+   winapi::get_last_bootup_time(bootstamp);
+   if(add){
+      s += bootstamp;
+   }
+   else{
+      s.swap(bootstamp);
+   }
+}
+#elif defined(BOOST_INTERPROCESS_HAS_BSD_KERNEL_BOOTTIME)
+inline void get_bootstamp(std::string &s, bool add = false)
+{
+   // FreeBSD specific: sysctl "kern.boottime"
+   int request[2] = { CTL_KERN, KERN_BOOTTIME };
+   struct ::timeval result;
+   std::size_t result_len = sizeof result;
+
+   if (::sysctl (request, 2, &result, &result_len, NULL, 0) < 0)
+      return;
+
+   char bootstamp_str[256];
+
+   const char Characters [] =
+      { '0', '1', '2', '3', '4', '5', '6', '7'
+      , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+   std::size_t char_counter = 0;
+   //32 bit values to allow 32 and 64 bit process IPC
+   boost::uint32_t fields[2] = { boost::uint32_t(result.tv_sec), boost::uint32_t(result.tv_usec) };
+   for(std::size_t field = 0; field != 2; ++field){
+      for(std::size_t i = 0; i != sizeof(fields[0]); ++i){
+         const char *ptr = (const char *)&fields[field];
+         bootstamp_str[char_counter++] = Characters[(ptr[i]&0xF0)>>4];
+         bootstamp_str[char_counter++] = Characters[(ptr[i]&0x0F)];
+      }
+   }
+   bootstamp_str[char_counter] = 0;
+   if(add){
+      s += bootstamp_str;
+   }
+   else{
+      s = bootstamp_str;
+   }
+}
+#endif
+
+inline void get_tmp_base_dir(std::string &tmp_name)
+{
+   #if defined (BOOST_INTERPROCESS_WINDOWS)
+   winapi::get_shared_documents_folder(tmp_name);
+   if(tmp_name.empty() || !winapi::is_directory(tmp_name.c_str())){
+      tmp_name = get_temporary_path();
+   }
+   #else
+   tmp_name = get_temporary_path();
+   #endif
+   if(tmp_name.empty()){
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+   //Remove final null.
+   tmp_name += "/boost_interprocess";
+}
+
+inline void tmp_folder(std::string &tmp_name)
+{
+   get_tmp_base_dir(tmp_name);
+   #ifdef BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
+   tmp_name += "/";
+   get_bootstamp(tmp_name, true);
+   #endif
+}
+
+inline void tmp_filename(const char *filename, std::string &tmp_name)
+{
+   tmp_folder(tmp_name);
+   tmp_name += "/";
+   tmp_name += filename;
+}
+
+inline void create_tmp_and_clean_old(std::string &tmp_name)
+{
+   //First get the temp directory
+   std::string root_tmp_name;
+   get_tmp_base_dir(root_tmp_name);
+
+   //If fails, check that it's because already exists
+   if(!create_directory(root_tmp_name.c_str())){
+      error_info info(system_error_code());
+      if(info.get_error_code() != already_exists_error){
+         throw interprocess_exception(info);
+      }
+   }
+
+   #ifdef BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
+   tmp_folder(tmp_name);
+
+   //If fails, check that it's because already exists
+   if(!create_directory(tmp_name.c_str())){
+      error_info info(system_error_code());
+      if(info.get_error_code() != already_exists_error){
+         throw interprocess_exception(info);
+      }
+   }
+   //Now erase all old directories created in the previous boot sessions
+   std::string subdir = tmp_name;
+   subdir.erase(0, root_tmp_name.size()+1);
+   delete_subdirectories(root_tmp_name, subdir.c_str());
+   #else
+   tmp_name = root_tmp_name;
+   #endif
+}
+
+inline void create_tmp_and_clean_old_and_get_filename(const char *filename, std::string &tmp_name)
+{
+   create_tmp_and_clean_old(tmp_name);
+   tmp_name += "/";
+   tmp_name += filename;
+}
+
+inline void add_leading_slash(const char *name, std::string &new_name)
+{
+   if(name[0] != '/'){
+      new_name = '/';
+   }
+   new_name += name;
+}
+
+}  //namespace boost{
+}  //namespace interprocess {
+}  //namespace ipcdetail {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //ifndef BOOST_INTERPROCESS_DETAIL_TMP_DIR_HELPERS_HPP
diff --git a/boost/interprocess/detail/transform_iterator.hpp b/boost/interprocess/detail/transform_iterator.hpp
new file mode 100644
index 0000000000..ef646fbefe
--- /dev/null
+++ b/boost/interprocess/detail/transform_iterator.hpp
@@ -0,0 +1,195 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011.
+// (C) Copyright Gennaro Prota 2003 - 2004.
+//
+// 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_DETAIL_TRANSFORM_ITERATORS_HPP
+#define BOOST_INTERPROCESS_DETAIL_TRANSFORM_ITERATORS_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/interprocess/interprocess_fwd.hpp>
+
+#include <iterator>
+#include <boost/interprocess/detail/type_traits.hpp>
+
+namespace boost {
+namespace interprocess { 
+
+template <class PseudoReference>
+struct operator_arrow_proxy
+{
+   operator_arrow_proxy(const PseudoReference &px)
+      :  m_value(px)
+   {}
+
+   PseudoReference* operator->() const { return &m_value; }
+   // This function is needed for MWCW and BCC, which won't call operator->
+   // again automatically per 13.3.1.2 para 8
+//   operator T*() const { return &m_value; }
+   mutable PseudoReference m_value;
+};
+
+template <class T>
+struct operator_arrow_proxy<T&>
+{
+   operator_arrow_proxy(T &px)
+      :  m_value(px)
+   {}
+
+   T* operator->() const { return const_cast<T*>(&m_value); }
+   // This function is needed for MWCW and BCC, which won't call operator->
+   // again automatically per 13.3.1.2 para 8
+//   operator T*() const { return &m_value; }
+   T &m_value;
+};
+
+template <class Iterator, class UnaryFunction>
+class transform_iterator
+   : public UnaryFunction
+   , public std::iterator
+      < typename Iterator::iterator_category
+      , typename ipcdetail::remove_reference<typename UnaryFunction::result_type>::type
+      , typename Iterator::difference_type
+      , operator_arrow_proxy<typename UnaryFunction::result_type>
+      , typename UnaryFunction::result_type>
+{
+   public:
+   explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
+      :  UnaryFunction(f), m_it(it)
+   {}
+
+   explicit transform_iterator()
+      :  UnaryFunction(), m_it()
+   {}
+
+   //Constructors
+   transform_iterator& operator++() 
+   { increment();   return *this;   }
+
+   transform_iterator operator++(int)
+   {
+      transform_iterator result (*this);
+      increment();
+      return result;
+   }
+
+   transform_iterator& operator--() 
+   { decrement();   return *this;   }
+
+   transform_iterator operator--(int)
+   {
+      transform_iterator result (*this);
+      decrement();
+      return result;
+   }
+
+   friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
+   { return i.equal(i2); }
+
+   friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
+   { return !(i == i2); }
+
+   friend bool operator< (const transform_iterator& i, const transform_iterator& i2)
+   { return i < i2; }
+
+   friend bool operator> (const transform_iterator& i, const transform_iterator& i2)
+   { return i2 < i; }
+
+   friend bool operator<= (const transform_iterator& i, const transform_iterator& i2)
+   { return !(i > i2); }
+
+   friend bool operator>= (const transform_iterator& i, const transform_iterator& i2)
+   { return !(i < i2); }
+
+   friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
+   { return i2.distance_to(i); }
+
+   //Arithmetic
+   transform_iterator& operator+=(typename Iterator::difference_type off)
+   {  this->advance(off); return *this;   }
+
+   transform_iterator operator+(typename Iterator::difference_type off) const
+   {
+      transform_iterator other(*this);
+      other.advance(off);
+      return other;
+   }
+
+   friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
+   {  return right + off; }
+
+   transform_iterator& operator-=(typename Iterator::difference_type off)
+   {  this->advance(-off); return *this;   }
+
+   transform_iterator operator-(typename Iterator::difference_type off) const
+   {  return *this + (-off);  }
+
+   typename UnaryFunction::result_type operator*() const
+   { return dereference(); }
+
+   typename UnaryFunction::result_type operator[](typename Iterator::difference_type off) const
+   { return UnaryFunction::operator()(m_it[off]); }
+
+   operator_arrow_proxy<typename UnaryFunction::result_type>
+      operator->() const
+   { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
+
+   Iterator & base()
+   {  return m_it;   }
+
+   const Iterator & base() const
+   {  return m_it;   }
+
+   private:
+   Iterator m_it;
+
+   void increment()
+   { ++m_it; }
+
+   void decrement()
+   { --m_it; }
+
+   bool equal(const transform_iterator &other) const
+   {  return m_it == other.m_it;   }
+
+   bool less(const transform_iterator &other) const
+   {  return other.m_it < m_it;   }
+
+   typename UnaryFunction::result_type dereference() const
+   { return UnaryFunction::operator()(*m_it); }
+
+   void advance(typename Iterator::difference_type n)
+   {  std::advance(m_it, n); }
+
+   typename Iterator::difference_type distance_to(const transform_iterator &other)const
+   {  return std::distance(other.m_it, m_it); }
+};
+
+template <class Iterator, class UnaryFunc>
+transform_iterator<Iterator, UnaryFunc>
+make_transform_iterator(Iterator it, UnaryFunc fun)
+{
+   return transform_iterator<Iterator, UnaryFunc>(it, fun);
+}
+
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_TRANSFORM_ITERATORS_HPP
+
diff --git a/boost/interprocess/detail/type_traits.hpp b/boost/interprocess/detail/type_traits.hpp
new file mode 100644
index 0000000000..2cfa0be291
--- /dev/null
+++ b/boost/interprocess/detail/type_traits.hpp
@@ -0,0 +1,145 @@
+//////////////////////////////////////////////////////////////////////////////
+// (C) Copyright John Maddock 2000.
+// (C) Copyright Ion Gaztanaga 2005-2011.
+//
+// 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_DETAIL_TYPE_TRAITS_HPP
+#define BOOST_INTERPROCESS_DETAIL_TYPE_TRAITS_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+
+namespace boost {
+namespace interprocess { 
+namespace ipcdetail {
+
+struct nat{};
+
+template<class T>
+struct remove_reference
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&>
+{
+   typedef T type;
+};
+
+template<class T>
+struct is_reference
+{
+   static const bool value = false;
+};
+
+template<class T>
+struct is_reference<T&>
+{
+   static const bool value = true;
+};
+
+template<class T>
+struct is_pointer
+{
+   static const bool value = false;
+};
+
+template<class T>
+struct is_pointer<T*>
+{
+   static const bool value = true;
+};
+
+template <typename T>
+struct add_reference
+{
+    typedef T& type;
+};
+
+template<class T>
+struct add_reference<T&>
+{
+    typedef T& type;
+};
+
+template<>
+struct add_reference<void>
+{
+    typedef nat &type;
+};
+
+template<>
+struct add_reference<const void>
+{
+    typedef const nat &type;
+};
+
+template <class T>
+struct add_const_reference
+{  typedef const T &type;   };
+
+template <class T>
+struct add_const_reference<T&>
+{  typedef T& type;   };
+
+template<class T>
+struct remove_const
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_const<const T>
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_volatile
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_volatile<volatile T>
+{
+   typedef T type;
+};
+
+template <typename T, typename U>
+struct is_same
+{
+   typedef char yes_type;
+   struct no_type
+   {
+      char padding[8];
+   };
+
+   template <typename V>
+   static yes_type is_same_tester(V*, V*);
+   static no_type is_same_tester(...);
+
+   static T *t;
+   static U *u;
+
+   static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u));
+};
+
+} // namespace ipcdetail
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_TYPE_TRAITS_HPP
diff --git a/boost/interprocess/detail/utilities.hpp b/boost/interprocess/detail/utilities.hpp
new file mode 100644
index 0000000000..625a9159d3
--- /dev/null
+++ b/boost/interprocess/detail/utilities.hpp
@@ -0,0 +1,160 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011.
+// (C) Copyright Gennaro Prota 2003 - 2004.
+//
+// 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_DETAIL_UTILITIES_HPP
+#define BOOST_INTERPROCESS_DETAIL_UTILITIES_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/interprocess/interprocess_fwd.hpp>
+#include <boost/move/move.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/interprocess/detail/min_max.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/detail/transform_iterator.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/interprocess/containers/version_type.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/move/move.hpp>
+#include <utility>
+#include <algorithm>
+
+namespace boost {
+namespace interprocess { 
+namespace ipcdetail {
+
+template <class T>
+inline T* to_raw_pointer(T* p)
+{  return p; }
+
+template <class Pointer>
+inline typename boost::intrusive::pointer_traits<Pointer>::element_type*
+to_raw_pointer(const Pointer &p)
+{  return boost::interprocess::ipcdetail::to_raw_pointer(p.operator->());  }
+
+//!To avoid ADL problems with swap
+template <class T>
+inline void do_swap(T& x, T& y)
+{
+   using std::swap;
+   swap(x, y);
+}
+
+//Rounds "orig_size" by excess to round_to bytes
+template<class SizeType>
+inline SizeType get_rounded_size(SizeType orig_size, SizeType round_to)
+{
+   return ((orig_size-1)/round_to+1)*round_to;
+}
+
+//Truncates "orig_size" to a multiple of "multiple" bytes.
+template<class SizeType>
+inline SizeType get_truncated_size(SizeType orig_size, SizeType multiple)
+{
+   return orig_size/multiple*multiple;
+}
+
+//Rounds "orig_size" by excess to round_to bytes. round_to must be power of two
+template<class SizeType>
+inline SizeType get_rounded_size_po2(SizeType orig_size, SizeType round_to)
+{
+   return ((orig_size-1)&(~(round_to-1))) + round_to;
+}
+
+//Truncates "orig_size" to a multiple of "multiple" bytes. multiple must be power of two
+template<class SizeType>
+inline SizeType get_truncated_size_po2(SizeType orig_size, SizeType multiple)
+{
+   return (orig_size & (~(multiple-1)));
+}
+
+template <std::size_t OrigSize, std::size_t RoundTo>
+struct ct_rounded_size
+{
+   static const std::size_t value = ((OrigSize-1)/RoundTo+1)*RoundTo;
+};
+
+// Gennaro Prota wrote this. Thanks!
+template <int p, int n = 4>
+struct ct_max_pow2_less
+{
+   static const std::size_t c = 2*n < p;
+
+   static const std::size_t value =
+         c ? (ct_max_pow2_less< c*p, 2*c*n>::value) : n;
+};
+
+template <>
+struct ct_max_pow2_less<0, 0>
+{
+   static const std::size_t value = 0;
+};
+
+}  //namespace ipcdetail {
+
+//!Trait class to detect if an index is a node
+//!index. This allows more efficient operations
+//!when deallocating named objects.
+template <class Index>
+struct is_node_index
+{
+   static const bool value = false;
+};
+
+//!Trait class to detect if an index is an intrusive
+//!index. This will embed the derivation hook in each
+//!allocation header, to provide memory for the intrusive
+//!container.
+template <class Index>
+struct is_intrusive_index
+{
+   static const bool value = false;
+};
+
+template <typename T> T*
+addressof(T& v)
+{
+  return reinterpret_cast<T*>(
+       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+}
+
+//Anti-exception node eraser
+template<class Cont>
+class value_eraser
+{
+   public:
+   value_eraser(Cont & cont, typename Cont::iterator it) 
+      : m_cont(cont), m_index_it(it), m_erase(true){}
+   ~value_eraser()  
+   {  if(m_erase) m_cont.erase(m_index_it);  }
+
+   void release() {  m_erase = false;  }
+
+   private:
+   Cont                   &m_cont;
+   typename Cont::iterator m_index_it;
+   bool                    m_erase;
+};
+
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_UTILITIES_HPP
+
diff --git a/boost/interprocess/detail/variadic_templates_tools.hpp b/boost/interprocess/detail/variadic_templates_tools.hpp
new file mode 100644
index 0000000000..1e6c4216e3
--- /dev/null
+++ b/boost/interprocess/detail/variadic_templates_tools.hpp
@@ -0,0 +1,153 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
+#define BOOST_INTERPROCESS_DETAIL_VARIADIC_TEMPLATES_TOOLS_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/interprocess/detail/type_traits.hpp>
+#include <cstddef>   //std::size_t
+
+namespace boost {
+namespace interprocess { 
+namespace ipcdetail {
+
+template<typename... Values>
+class tuple;
+
+template<> class tuple<>
+{};
+
+template<typename Head, typename... Tail>
+class tuple<Head, Tail...>
+   : private tuple<Tail...>
+{
+   typedef tuple<Tail...> inherited;
+
+   public:
+   tuple() { }
+
+   // implicit copy-constructor is okay
+   // Construct tuple from separate arguments.
+   tuple(typename add_const_reference<Head>::type v,
+         typename add_const_reference<Tail>::type... vtail)
+   : inherited(vtail...), m_head(v)
+   {}
+
+   // Construct tuple from another tuple.
+   template<typename... VValues>
+   tuple(const tuple<VValues...>& other)
+      : m_head(other.head()), inherited(other.tail())
+   {}
+
+   template<typename... VValues>
+   tuple& operator=(const tuple<VValues...>& other)
+   {
+      m_head = other.head();
+      tail() = other.tail();
+      return this;
+   }
+
+   typename add_reference<Head>::type head()             {  return m_head; }
+   typename add_reference<const Head>::type head() const {  return m_head; }
+
+   inherited& tail()             { return *this; }
+   const inherited& tail() const { return *this; }
+
+   protected:
+   Head m_head;
+};
+
+
+template<typename... Values>
+tuple<Values&&...> tie_forward(Values&&... values)
+{ return tuple<Values&&...>(values...); }
+
+template<int I, typename Tuple>
+struct tuple_element;
+
+template<int I, typename Head, typename... Tail>
+struct tuple_element<I, tuple<Head, Tail...> >
+{
+   typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
+};
+
+template<typename Head, typename... Tail>
+struct tuple_element<0, tuple<Head, Tail...> >
+{
+   typedef Head type;
+};
+
+template<int I, typename Tuple>
+class get_impl;
+
+template<int I, typename Head, typename... Values>
+class get_impl<I, tuple<Head, Values...> >
+{
+   typedef typename tuple_element<I-1, tuple<Values...> >::type   Element;
+   typedef get_impl<I-1, tuple<Values...> >                       Next;
+
+   public:
+   typedef typename add_reference<Element>::type                  type;
+   typedef typename add_const_reference<Element>::type            const_type;
+   static type get(tuple<Head, Values...>& t)              { return Next::get(t.tail()); }
+   static const_type get(const tuple<Head, Values...>& t)  { return Next::get(t.tail()); }
+};
+
+template<typename Head, typename... Values>
+class get_impl<0, tuple<Head, Values...> >
+{
+   public:
+   typedef typename add_reference<Head>::type         type;
+   typedef typename add_const_reference<Head>::type   const_type;
+   static type       get(tuple<Head, Values...>& t)      { return t.head(); }
+   static const_type get(const tuple<Head, Values...>& t){ return t.head(); }
+};
+
+template<int I, typename... Values>
+typename get_impl<I, tuple<Values...> >::type get(tuple<Values...>& t)
+{  return get_impl<I, tuple<Values...> >::get(t);  }
+
+template<int I, typename... Values>
+typename get_impl<I, tuple<Values...> >::const_type get(const tuple<Values...>& t)
+{  return get_impl<I, tuple<Values...> >::get(t);  }
+
+////////////////////////////////////////////////////
+// Builds an index_tuple<0, 1, 2, ..., Num-1>, that will
+// be used to "unpack" into comma-separated values
+// in a function call.
+////////////////////////////////////////////////////
+
+template<int... Indexes>
+struct index_tuple{};
+
+template<std::size_t Num, typename Tuple = index_tuple<> >
+struct build_number_seq;
+
+template<std::size_t Num, int... Indexes> 
+struct build_number_seq<Num, index_tuple<Indexes...> >
+   : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
+{};
+
+template<int... Indexes>
+struct build_number_seq<0, index_tuple<Indexes...> >
+{  typedef index_tuple<Indexes...> type;  };
+
+
+}}}   //namespace boost { namespace interprocess { namespace ipcdetail {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
diff --git a/boost/interprocess/detail/win32_api.hpp b/boost/interprocess/detail/win32_api.hpp
new file mode 100644
index 0000000000..b420c3d67b
--- /dev/null
+++ b/boost/interprocess/detail/win32_api.hpp
@@ -0,0 +1,1766 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_WIN32_PRIMITIVES_HPP
+#define BOOST_INTERPROCESS_WIN32_PRIMITIVES_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/date_time/filetime_functions.hpp>
+#include <cstddef>
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <vector>
+#include <memory>
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#  pragma comment( lib, "advapi32.lib" )
+#  pragma comment( lib, "oleaut32.lib" )
+#  pragma comment( lib, "Ole32.lib" )
+#  pragma comment( lib, "Psapi.lib" )
+#endif
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+#  include <cstdarg>
+#  include <boost/detail/interlocked.hpp>
+#else
+# error "This file can only be included in Windows OS"
+#endif
+
+
+//The structures used in Interprocess with the
+//same binary interface as windows ones
+namespace boost {
+namespace interprocess {
+namespace winapi {
+
+//Some used constants
+static const unsigned long infinite_time        = 0xFFFFFFFF;
+static const unsigned long error_already_exists = 183L;
+static const unsigned long error_sharing_violation = 32L;
+static const unsigned long error_file_not_found = 2u;
+static const unsigned long error_no_more_files  = 18u;
+//Retries in CreateFile, see http://support.microsoft.com/kb/316609
+static const unsigned int  error_sharing_violation_tries = 3u;
+static const unsigned int  error_sharing_violation_sleep_ms = 250u;
+static const unsigned int  error_file_too_large = 223u;
+
+static const unsigned long semaphore_all_access = (0x000F0000L)|(0x00100000L)|0x3;
+static const unsigned long mutex_all_access     = (0x000F0000L)|(0x00100000L)|0x0001;
+
+static const unsigned long page_readonly        = 0x02;
+static const unsigned long page_readwrite       = 0x04;
+static const unsigned long page_writecopy       = 0x08;
+
+static const unsigned long standard_rights_required   = 0x000F0000L;
+static const unsigned long section_query              = 0x0001;
+static const unsigned long section_map_write          = 0x0002;
+static const unsigned long section_map_read           = 0x0004;
+static const unsigned long section_map_execute        = 0x0008;
+static const unsigned long section_extend_size        = 0x0010;
+static const unsigned long section_all_access         = standard_rights_required |
+                                                        section_query            |
+                                                        section_map_write        |
+                                                        section_map_read         |
+                                                        section_map_execute      |
+                                                        section_extend_size;
+
+static const unsigned long file_map_copy        = section_query;
+static const unsigned long file_map_write       = section_map_write;
+static const unsigned long file_map_read        = section_map_read;
+static const unsigned long file_map_all_access  = section_all_access;
+static const unsigned long delete_access = 0x00010000L;
+static const unsigned long file_flag_backup_semantics = 0x02000000;
+static const long file_flag_delete_on_close = 0x04000000;
+
+//Native API constants
+static const unsigned long file_open_for_backup_intent = 0x00004000;
+static const int file_share_valid_flags = 0x00000007;
+static const long file_delete_on_close = 0x00001000L;
+static const long obj_case_insensitive = 0x00000040L;
+
+static const unsigned long movefile_copy_allowed            = 0x02;
+static const unsigned long movefile_delay_until_reboot      = 0x04;
+static const unsigned long movefile_replace_existing        = 0x01;
+static const unsigned long movefile_write_through           = 0x08;
+static const unsigned long movefile_create_hardlink         = 0x10;
+static const unsigned long movefile_fail_if_not_trackable   = 0x20;
+
+static const unsigned long file_share_read      = 0x00000001;
+static const unsigned long file_share_write     = 0x00000002;
+static const unsigned long file_share_delete    = 0x00000004;
+
+static const unsigned long file_attribute_readonly    = 0x00000001;
+static const unsigned long file_attribute_hidden      = 0x00000002;
+static const unsigned long file_attribute_system      = 0x00000004;
+static const unsigned long file_attribute_directory   = 0x00000010;
+static const unsigned long file_attribute_archive     = 0x00000020;
+static const unsigned long file_attribute_device      = 0x00000040;
+static const unsigned long file_attribute_normal      = 0x00000080;
+static const unsigned long file_attribute_temporary   = 0x00000100;
+
+static const unsigned long generic_read         = 0x80000000L;
+static const unsigned long generic_write        = 0x40000000L;
+
+static const unsigned long wait_object_0        = 0;
+static const unsigned long wait_abandoned       = 0x00000080L;
+static const unsigned long wait_timeout         = 258L;
+static const unsigned long wait_failed          = (unsigned long)0xFFFFFFFF;
+
+static const unsigned long duplicate_close_source  = (unsigned long)0x00000001;
+static const unsigned long duplicate_same_access   = (unsigned long)0x00000002;
+
+static const unsigned long format_message_allocate_buffer
+   = (unsigned long)0x00000100;
+static const unsigned long format_message_ignore_inserts
+   = (unsigned long)0x00000200;
+static const unsigned long format_message_from_string
+   = (unsigned long)0x00000400;
+static const unsigned long format_message_from_hmodule
+   = (unsigned long)0x00000800;
+static const unsigned long format_message_from_system
+   = (unsigned long)0x00001000;
+static const unsigned long format_message_argument_array
+   = (unsigned long)0x00002000;
+static const unsigned long format_message_max_width_mask
+   = (unsigned long)0x000000FF;
+static const unsigned long lang_neutral         = (unsigned long)0x00;
+static const unsigned long sublang_default      = (unsigned long)0x01;
+static const unsigned long invalid_file_size    = (unsigned long)0xFFFFFFFF;
+static const unsigned long invalid_file_attributes =  ((unsigned long)-1);
+static       void * const  invalid_handle_value = (void*)(long)(-1);
+static const unsigned long create_new        = 1;
+static const unsigned long create_always     = 2;
+static const unsigned long open_existing     = 3;
+static const unsigned long open_always       = 4;
+static const unsigned long truncate_existing = 5;
+
+static const unsigned long file_begin     = 0;
+static const unsigned long file_current   = 1;
+static const unsigned long file_end       = 2;
+
+static const unsigned long lockfile_fail_immediately  = 1;
+static const unsigned long lockfile_exclusive_lock    = 2;
+static const unsigned long error_lock_violation       = 33;
+static const unsigned long security_descriptor_revision = 1;
+
+//Own defines
+static const long SystemTimeOfDayInfoLength  = 48;
+static const long BootAndSystemstampLength   = 16;
+static const long BootstampLength            = 8;
+static const unsigned long MaxPath           = 260;
+
+
+//Keys
+static void * const  hkey_local_machine = (void*)(unsigned long*)(long)(0x80000002);
+static unsigned long key_query_value    = 0x0001;
+
+//COM API
+const unsigned long RPC_C_AUTHN_LEVEL_PKT_BIPC = 4;
+const unsigned long RPC_C_AUTHN_DEFAULT_BIPC = 0xffffffffL;
+const unsigned long RPC_C_AUTHZ_DEFAULT_BIPC = 0xffffffffL;
+const unsigned long RPC_C_IMP_LEVEL_IMPERSONATE_BIPC = 3;
+const   signed long EOAC_NONE_BIPC = 0;
+const   signed long CLSCTX_INPROC_SERVER_BIPC   = 0x1;
+const   signed long CLSCTX_LOCAL_SERVER_BIPC   = 0x4;
+const   signed long WBEM_FLAG_RETURN_IMMEDIATELY_BIPC = 0x10;
+const   signed long WBEM_FLAG_RETURN_WHEN_COMPLETE_BIPC = 0x0;
+const   signed long WBEM_FLAG_FORWARD_ONLY_BIPC = 0x20;
+const   signed long WBEM_INFINITE_BIPC = 0xffffffffL;
+const   signed long RPC_E_TOO_LATE_BIPC = 0x80010119L;
+const   signed long S_OK_BIPC = 0L;
+const   signed long S_FALSE_BIPC = 1;
+
+}  //namespace winapi {
+}  //namespace interprocess  {
+}  //namespace boost  {
+
+
+namespace boost  {
+namespace interprocess  {
+namespace winapi {
+
+struct GUID_BIPC
+{
+   unsigned long  Data1;
+   unsigned short Data2;
+   unsigned short Data3;
+   unsigned char  Data4[8];
+};
+
+const GUID_BIPC CLSID_WbemAdministrativeLocator =
+   { 0xcb8555cc, 0x9128, 0x11d1, {0xad, 0x9b, 0x00, 0xc0, 0x4f, 0xd8, 0xfd, 0xff}};
+
+const GUID_BIPC IID_IUnknown = { 0x00000000, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
+
+struct wchar_variant
+{
+   unsigned long  long dummy;
+   union value_t{
+      wchar_t *pbstrVal;
+      unsigned long  long dummy;
+   } value;
+};
+
+   struct IUnknown_BIPC
+   {
+      public:
+      virtual long __stdcall QueryInterface( 
+            /* [in] */ const GUID_BIPC &riid,
+            /* [iid_is][out] */ void **ppvObject) = 0;
+      
+      virtual unsigned long __stdcall AddRef( void) = 0;
+      
+      virtual unsigned long __stdcall Release( void) = 0;
+   };
+
+struct IWbemClassObject_BIPC : public IUnknown_BIPC
+{
+   public:
+   virtual long __stdcall GetQualifierSet( 
+      /* [out] */ void **ppQualSet) = 0;
+   
+   virtual long __stdcall Get( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags,
+      /* [unique][in][out] */ wchar_variant *pVal,
+      /* [unique][in][out] */ long *pType,
+      /* [unique][in][out] */ long *plFlavor) = 0;
+   
+   virtual long __stdcall Put( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags,
+      /* [in] */ wchar_variant *pVal,
+      /* [in] */ long Type) = 0;
+   
+   virtual long __stdcall Delete( 
+      /* [string][in] */ const wchar_t * wszName) = 0;
+   
+   virtual long __stdcall GetNames( 
+      /* [string][in] */ const wchar_t * wszQualifierName,
+      /* [in] */ long lFlags,
+      /* [in] */ wchar_variant *pQualifierVal,
+      /* [out] */ void * *pNames) = 0;
+   
+   virtual long __stdcall BeginEnumeration( 
+      /* [in] */ long lEnumFlags) = 0;
+   
+   virtual long __stdcall Next( 
+      /* [in] */ long lFlags,
+      /* [unique][in][out] */ wchar_t * *strName,
+      /* [unique][in][out] */ wchar_variant *pVal,
+      /* [unique][in][out] */ long *pType,
+      /* [unique][in][out] */ long *plFlavor) = 0;
+   
+   virtual long __stdcall EndEnumeration( void) = 0;
+   
+   virtual long __stdcall GetPropertyQualifierSet( 
+      /* [string][in] */ const wchar_t * wszProperty,
+      /* [out] */ void **ppQualSet) = 0;
+   
+   virtual long __stdcall Clone( 
+      /* [out] */ IWbemClassObject_BIPC **ppCopy) = 0;
+   
+   virtual long __stdcall GetObjectText( 
+      /* [in] */ long lFlags,
+      /* [out] */ wchar_t * *pstrObjectText) = 0;
+   
+   virtual long __stdcall SpawnDerivedClass( 
+      /* [in] */ long lFlags,
+      /* [out] */ IWbemClassObject_BIPC **ppNewClass) = 0;
+   
+   virtual long __stdcall SpawnInstance( 
+      /* [in] */ long lFlags,
+      /* [out] */ IWbemClassObject_BIPC **ppNewInstance) = 0;
+   
+   virtual long __stdcall CompareTo( 
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemClassObject_BIPC *pCompareTo) = 0;
+   
+   virtual long __stdcall GetPropertyOrigin( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [out] */ wchar_t * *pstrClassName) = 0;
+   
+   virtual long __stdcall InheritsFrom( 
+      /* [in] */ const wchar_t * strAncestor) = 0;
+   
+   virtual long __stdcall GetMethod( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags,
+      /* [out] */ IWbemClassObject_BIPC **ppInSignature,
+      /* [out] */ IWbemClassObject_BIPC **ppOutSignature) = 0;
+   
+   virtual long __stdcall PutMethod( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemClassObject_BIPC *pInSignature,
+      /* [in] */ IWbemClassObject_BIPC *pOutSignature) = 0;
+   
+   virtual long __stdcall DeleteMethod( 
+      /* [string][in] */ const wchar_t * wszName) = 0;
+   
+   virtual long __stdcall BeginMethodEnumeration( 
+      /* [in] */ long lEnumFlags) = 0;
+   
+   virtual long __stdcall NextMethod( 
+      /* [in] */ long lFlags,
+      /* [unique][in][out] */ wchar_t * *pstrName,
+      /* [unique][in][out] */ IWbemClassObject_BIPC **ppInSignature,
+      /* [unique][in][out] */ IWbemClassObject_BIPC **ppOutSignature) = 0;
+   
+   virtual long __stdcall EndMethodEnumeration( void) = 0;
+   
+   virtual long __stdcall GetMethodQualifierSet( 
+      /* [string][in] */ const wchar_t * wszMethod,
+      /* [out] */ void **ppQualSet) = 0;
+   
+   virtual long __stdcall GetMethodOrigin( 
+      /* [string][in] */ const wchar_t * wszMethodName,
+      /* [out] */ wchar_t * *pstrClassName) = 0;
+   
+};
+
+
+struct IWbemContext_BIPC : public IUnknown_BIPC
+{
+public:
+   virtual long __stdcall Clone( 
+      /* [out] */ IWbemContext_BIPC **ppNewCopy) = 0;
+   
+   virtual long __stdcall GetNames( 
+      /* [in] */ long lFlags,
+      /* [out] */ void * *pNames) = 0;
+   
+   virtual long __stdcall BeginEnumeration( 
+      /* [in] */ long lFlags) = 0;
+   
+   virtual long __stdcall Next( 
+      /* [in] */ long lFlags,
+      /* [out] */ wchar_t * *pstrName,
+      /* [out] */ wchar_variant *pValue) = 0;
+   
+   virtual long __stdcall EndEnumeration( void) = 0;
+   
+   virtual long __stdcall SetValue( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags,
+      /* [in] */ wchar_variant *pValue) = 0;
+   
+   virtual long __stdcall GetValue( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags,
+      /* [out] */ wchar_variant *pValue) = 0;
+   
+   virtual long __stdcall DeleteValue( 
+      /* [string][in] */ const wchar_t * wszName,
+      /* [in] */ long lFlags) = 0;
+   
+   virtual long __stdcall DeleteAll( void) = 0;
+   
+};
+
+
+struct IEnumWbemClassObject_BIPC : public IUnknown_BIPC
+{
+public:
+   virtual long __stdcall Reset( void) = 0;
+   
+   virtual long __stdcall Next( 
+      /* [in] */ long lTimeout,
+      /* [in] */ unsigned long uCount,
+      /* [length_is][size_is][out] */ IWbemClassObject_BIPC **apObjects,
+      /* [out] */ unsigned long *puReturned) = 0;
+   
+   virtual long __stdcall NextAsync( 
+      /* [in] */ unsigned long uCount,
+      /* [in] */ void *pSink) = 0;
+   
+   virtual long __stdcall Clone( 
+      /* [out] */ void **ppEnum) = 0;
+   
+   virtual long __stdcall Skip( 
+      /* [in] */ long lTimeout,
+      /* [in] */ unsigned long nCount) = 0;
+   
+};
+
+struct IWbemServices_BIPC : public IUnknown_BIPC
+{
+public:
+   virtual long __stdcall OpenNamespace( 
+      /* [in] */ const wchar_t * strNamespace,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [unique][in][out] */ void **ppWorkingNamespace,
+      /* [unique][in][out] */ void **ppResult) = 0;
+   
+   virtual long __stdcall CancelAsyncCall( 
+      /* [in] */ void *pSink) = 0;
+   
+   virtual long __stdcall QueryObjectSink( 
+      /* [in] */ long lFlags,
+      /* [out] */ void **ppResponseHandler) = 0;
+   
+   virtual long __stdcall GetObject( 
+      /* [in] */ const wchar_t * strObjectPath,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [unique][in][out] */ void **ppObject,
+      /* [unique][in][out] */ void **ppCallResult) = 0;
+   
+   virtual long __stdcall GetObjectAsync( 
+      /* [in] */ const wchar_t * strObjectPath,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall PutClass( 
+      /* [in] */ IWbemClassObject_BIPC *pObject,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [unique][in][out] */ void **ppCallResult) = 0;
+   
+   virtual long __stdcall PutClassAsync( 
+      /* [in] */ IWbemClassObject_BIPC *pObject,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall DeleteClass( 
+      /* [in] */ const wchar_t * strClass,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [unique][in][out] */ void **ppCallResult) = 0;
+   
+   virtual long __stdcall DeleteClassAsync( 
+      /* [in] */ const wchar_t * strClass,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall CreateClassEnum( 
+      /* [in] */ const wchar_t * strSuperclass,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [out] */ void **ppEnum) = 0;
+   
+   virtual long __stdcall CreateClassEnumAsync( 
+      /* [in] */ const wchar_t * strSuperclass,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall PutInstance( 
+      /* [in] */ void *pInst,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [unique][in][out] */ void **ppCallResult) = 0;
+   
+   virtual long __stdcall PutInstanceAsync( 
+      /* [in] */ void *pInst,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall DeleteInstance( 
+      /* [in] */ const wchar_t * strObjectPath,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [unique][in][out] */ void **ppCallResult) = 0;
+   
+   virtual long __stdcall DeleteInstanceAsync( 
+      /* [in] */ const wchar_t * strObjectPath,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall CreateInstanceEnum( 
+      /* [in] */ const wchar_t * strFilter,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [out] */ void **ppEnum) = 0;
+   
+   virtual long __stdcall CreateInstanceEnumAsync( 
+      /* [in] */ const wchar_t * strFilter,
+      /* [in] */ long lFlags,
+      /* [in] */ void *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall ExecQuery( 
+      /* [in] */ const wchar_t * strQueryLanguage,
+      /* [in] */ const wchar_t * strQuery,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemContext_BIPC *pCtx,
+      /* [out] */ IEnumWbemClassObject_BIPC **ppEnum) = 0;
+
+   virtual long __stdcall ExecQueryAsync( 
+      /* [in] */ const wchar_t * strQueryLanguage,
+      /* [in] */ const wchar_t * strQuery,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemContext_BIPC *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall ExecNotificationQuery( 
+      /* [in] */ const wchar_t * strQueryLanguage,
+      /* [in] */ const wchar_t * strQuery,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemContext_BIPC *pCtx,
+      /* [out] */ void **ppEnum) = 0;
+   
+   virtual long __stdcall ExecNotificationQueryAsync( 
+      /* [in] */ const wchar_t * strQueryLanguage,
+      /* [in] */ const wchar_t * strQuery,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemContext_BIPC *pCtx,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+   virtual long __stdcall ExecMethod( 
+      /* [in] */ const wchar_t * strObjectPath,
+      /* [in] */ const wchar_t * strMethodName,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemContext_BIPC *pCtx,
+      /* [in] */ IWbemClassObject_BIPC *pInParams,
+      /* [unique][in][out] */ IWbemClassObject_BIPC **ppOutParams,
+      /* [unique][in][out] */ void **ppCallResult) = 0;
+   
+   virtual long __stdcall ExecMethodAsync( 
+      /* [in] */ const wchar_t * strObjectPath,
+      /* [in] */ const wchar_t * strMethodName,
+      /* [in] */ long lFlags,
+      /* [in] */ IWbemContext_BIPC *pCtx,
+      /* [in] */ IWbemClassObject_BIPC *pInParams,
+      /* [in] */ void *pResponseHandler) = 0;
+   
+};
+
+struct IWbemLocator_BIPC : public IUnknown_BIPC
+{
+public:
+   virtual long __stdcall ConnectServer( 
+      /* [in] */ const wchar_t * strNetworkResource,
+      /* [in] */ const wchar_t * strUser,
+      /* [in] */ const wchar_t * strPassword,
+      /* [in] */ const wchar_t * strLocale,
+      /* [in] */ long lSecurityFlags,
+      /* [in] */ const wchar_t * strAuthority,
+      /* [in] */ void *pCtx,
+      /* [out] */ IWbemServices_BIPC **ppNamespace) = 0;
+   
+};
+ 
+
+
+struct interprocess_overlapped 
+{
+   unsigned long *internal;
+   unsigned long *internal_high;
+   union {
+      struct {
+         unsigned long offset;
+         unsigned long offset_high;
+      }dummy;
+      void *pointer;
+   };
+
+   void *h_event;
+};
+
+struct interprocess_filetime
+{  
+   unsigned long  dwLowDateTime;  
+   unsigned long  dwHighDateTime;
+};
+
+struct win32_find_data_t
+{
+   unsigned long dwFileAttributes;
+   interprocess_filetime ftCreationTime;
+   interprocess_filetime ftLastAccessTime;
+   interprocess_filetime ftLastWriteTime;
+   unsigned long nFileSizeHigh;
+   unsigned long nFileSizeLow;
+   unsigned long dwReserved0;
+   unsigned long dwReserved1;
+   char cFileName[MaxPath];
+   char cAlternateFileName[14];
+};
+
+struct interprocess_security_attributes
+{
+   unsigned long nLength;
+   void *lpSecurityDescriptor;
+   int bInheritHandle;
+};
+
+struct system_info {
+    union {
+        unsigned long dwOemId;          // Obsolete field...do not use
+        struct {
+            unsigned short wProcessorArchitecture;
+            unsigned short wReserved;
+        } dummy;
+    };
+    unsigned long dwPageSize;
+    void * lpMinimumApplicationAddress;
+    void * lpMaximumApplicationAddress;
+    unsigned long * dwActiveProcessorMask;
+    unsigned long dwNumberOfProcessors;
+    unsigned long dwProcessorType;
+    unsigned long dwAllocationGranularity;
+    unsigned short wProcessorLevel;
+    unsigned short wProcessorRevision;
+};
+
+struct interprocess_memory_basic_information
+{
+   void *         BaseAddress;  
+   void *         AllocationBase;
+   unsigned long  AllocationProtect;
+   unsigned long  RegionSize;
+   unsigned long  State;
+   unsigned long  Protect;
+   unsigned long  Type;
+};
+
+typedef struct _interprocess_acl
+{
+   unsigned char  AclRevision;
+   unsigned char  Sbz1;
+   unsigned short AclSize;
+   unsigned short AceCount;
+   unsigned short Sbz2;
+} interprocess_acl;
+
+typedef struct _interprocess_security_descriptor
+{
+   unsigned char Revision;
+   unsigned char Sbz1;
+   unsigned short Control;
+   void *Owner;
+   void *Group;
+   interprocess_acl *Sacl;
+   interprocess_acl *Dacl;
+} interprocess_security_descriptor;
+
+enum file_information_class_t {
+   file_directory_information = 1,
+   file_full_directory_information,
+   file_both_directory_information,
+   file_basic_information,
+   file_standard_information,
+   file_internal_information,
+   file_ea_information,
+   file_access_information,
+   file_name_information,
+   file_rename_information,
+   file_link_information,
+   file_names_information,
+   file_disposition_information,
+   file_position_information,
+   file_full_ea_information,
+   file_mode_information,
+   file_alignment_information,
+   file_all_information,
+   file_allocation_information,
+   file_end_of_file_information,
+   file_alternate_name_information,
+   file_stream_information,
+   file_pipe_information,
+   file_pipe_local_information,
+   file_pipe_remote_information,
+   file_mailslot_query_information,
+   file_mailslot_set_information,
+   file_compression_information,
+   file_copy_on_write_information,
+   file_completion_information,
+   file_move_cluster_information,
+   file_quota_information,
+   file_reparse_point_information,
+   file_network_open_information,
+   file_object_id_information,
+   file_tracking_information,
+   file_ole_directory_information,
+   file_content_index_information,
+   file_inherit_content_index_information,
+   file_ole_information,
+   file_maximum_information
+};
+
+struct file_name_information_t {
+   unsigned long FileNameLength;
+   wchar_t FileName[1];
+};
+
+struct file_rename_information_t {
+   int Replace;
+   void *RootDir;
+   unsigned long FileNameLength;
+   wchar_t FileName[1];
+};
+
+struct unicode_string_t {
+   unsigned short Length;
+   unsigned short MaximumLength;
+   wchar_t *Buffer;
+};
+
+struct object_attributes_t {
+   unsigned long Length;
+   void * RootDirectory;
+   unicode_string_t *ObjectName;
+   unsigned long Attributes;
+   void *SecurityDescriptor;
+   void *SecurityQualityOfService;
+};
+
+struct io_status_block_t {
+   union {
+      long Status;
+      void *Pointer;
+   };
+
+   unsigned long *Information;
+};
+
+union system_timeofday_information
+{
+   struct data_t
+   {
+      __int64 liKeBootTime;
+      __int64 liKeSystemTime;
+      __int64 liExpTimeZoneBias;
+      unsigned long uCurrentTimeZoneId;
+      unsigned long dwReserved;
+   } data;
+   unsigned char Reserved1[SystemTimeOfDayInfoLength];
+};
+
+struct interprocess_by_handle_file_information
+{
+    unsigned long dwFileAttributes;
+    interprocess_filetime ftCreationTime;
+    interprocess_filetime ftLastAccessTime;
+    interprocess_filetime ftLastWriteTime;
+    unsigned long dwVolumeSerialNumber;
+    unsigned long nFileSizeHigh;
+    unsigned long nFileSizeLow;
+    unsigned long nNumberOfLinks;
+    unsigned long nFileIndexHigh;
+    unsigned long nFileIndexLow;
+};
+
+enum system_information_class {
+   system_basic_information = 0,
+   system_performance_information = 2,
+   system_time_of_day_information = 3,
+   system_process_information = 5,
+   system_processor_performance_information = 8,
+   system_interrupt_information = 23,
+   system_exception_information = 33,
+   system_registry_quota_information = 37,
+   system_lookaside_information = 45
+};
+
+enum object_information_class
+{
+   object_basic_information,
+   object_name_information,
+   object_type_information,
+   object_all_information,
+   object_data_information
+};
+
+struct object_name_information_t
+{
+   unicode_string_t Name;
+   wchar_t NameBuffer[1];
+};
+
+//Some windows API declarations
+extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
+extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+extern "C" __declspec(dllimport) int __stdcall GetProcessTimes
+   ( void *hProcess, interprocess_filetime* lpCreationTime
+   , interprocess_filetime *lpExitTime,interprocess_filetime *lpKernelTime
+   , interprocess_filetime *lpUserTime );
+extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long);
+extern "C" __declspec(dllimport) int __stdcall SwitchToThread();
+extern "C" __declspec(dllimport) unsigned long __stdcall GetLastError();
+extern "C" __declspec(dllimport) void __stdcall SetLastError(unsigned long);
+extern "C" __declspec(dllimport) void * __stdcall GetCurrentProcess();
+extern "C" __declspec(dllimport) int __stdcall CloseHandle(void*);
+extern "C" __declspec(dllimport) int __stdcall DuplicateHandle
+   ( void *hSourceProcessHandle,    void *hSourceHandle
+   , void *hTargetProcessHandle,    void **lpTargetHandle
+   , unsigned long dwDesiredAccess, int bInheritHandle
+   , unsigned long dwOptions);
+extern "C" __declspec(dllimport) void *__stdcall FindFirstFileA(const char *lpFileName, win32_find_data_t *lpFindFileData);
+extern "C" __declspec(dllimport) int   __stdcall FindNextFileA(void *hFindFile, win32_find_data_t *lpFindFileData);
+extern "C" __declspec(dllimport) int   __stdcall FindClose(void *hFindFile);
+//extern "C" __declspec(dllimport) void __stdcall GetSystemTimeAsFileTime(interprocess_filetime*);
+//extern "C" __declspec(dllimport) int  __stdcall FileTimeToLocalFileTime(const interprocess_filetime *in, const interprocess_filetime *out);
+extern "C" __declspec(dllimport) void * __stdcall CreateMutexA(interprocess_security_attributes*, int, const char *);
+extern "C" __declspec(dllimport) void * __stdcall OpenMutexA(unsigned long, int, const char *);
+extern "C" __declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void *, unsigned long);
+extern "C" __declspec(dllimport) int __stdcall ReleaseMutex(void *);
+extern "C" __declspec(dllimport) int __stdcall UnmapViewOfFile(void *);
+extern "C" __declspec(dllimport) void * __stdcall CreateSemaphoreA(interprocess_security_attributes*, long, long, const char *);
+extern "C" __declspec(dllimport) int __stdcall ReleaseSemaphore(void *, long, long *);
+extern "C" __declspec(dllimport) void * __stdcall OpenSemaphoreA(unsigned long, int, const char *);
+extern "C" __declspec(dllimport) void * __stdcall CreateFileMappingA (void *, interprocess_security_attributes*, unsigned long, unsigned long, unsigned long, const char *);
+extern "C" __declspec(dllimport) void * __stdcall MapViewOfFileEx (void *, unsigned long, unsigned long, unsigned long, std::size_t, void*);
+extern "C" __declspec(dllimport) void * __stdcall OpenFileMappingA (unsigned long, int, const char *);
+extern "C" __declspec(dllimport) void * __stdcall CreateFileA (const char *, unsigned long, unsigned long, struct interprocess_security_attributes*, unsigned long, unsigned long, void *);
+extern "C" __declspec(dllimport) int __stdcall    DeleteFileA (const char *);
+extern "C" __declspec(dllimport) int __stdcall    MoveFileExA (const char *, const char *, unsigned long);
+extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *);
+extern "C" __declspec(dllimport) int __stdcall FlushViewOfFile (void *, std::size_t);
+extern "C" __declspec(dllimport) int __stdcall FlushFileBuffers (void *);
+extern "C" __declspec(dllimport) int __stdcall GetFileSizeEx (void *, __int64 *size);
+extern "C" __declspec(dllimport) unsigned long __stdcall FormatMessageA
+   (unsigned long dwFlags,       const void *lpSource,   unsigned long dwMessageId, 
+   unsigned long dwLanguageId,   char *lpBuffer,         unsigned long nSize, 
+   std::va_list *Arguments);
+extern "C" __declspec(dllimport) void *__stdcall LocalFree (void *);
+extern "C" __declspec(dllimport) unsigned long __stdcall GetFileAttributesA(const char *);
+extern "C" __declspec(dllimport) int __stdcall CreateDirectoryA(const char *, interprocess_security_attributes*);
+extern "C" __declspec(dllimport) int __stdcall RemoveDirectoryA(const char *lpPathName);
+extern "C" __declspec(dllimport) int __stdcall GetTempPathA(unsigned long length, char *buffer);
+extern "C" __declspec(dllimport) int __stdcall CreateDirectory(const char *, interprocess_security_attributes*);
+extern "C" __declspec(dllimport) int __stdcall SetFileValidData(void *, __int64 size);
+extern "C" __declspec(dllimport) int __stdcall SetEndOfFile(void *);
+extern "C" __declspec(dllimport) int __stdcall SetFilePointerEx(void *, __int64 distance, __int64 *new_file_pointer, unsigned long move_method);
+extern "C" __declspec(dllimport) int __stdcall LockFile  (void *hnd, unsigned long offset_low, unsigned long offset_high, unsigned long size_low, unsigned long size_high);
+extern "C" __declspec(dllimport) int __stdcall UnlockFile(void *hnd, unsigned long offset_low, unsigned long offset_high, unsigned long size_low, unsigned long size_high);
+extern "C" __declspec(dllimport) int __stdcall LockFileEx(void *hnd, unsigned long flags, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped* overlapped);
+extern "C" __declspec(dllimport) int __stdcall UnlockFileEx(void *hnd, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped* overlapped);
+extern "C" __declspec(dllimport) int __stdcall WriteFile(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped);
+extern "C" __declspec(dllimport) int __stdcall InitializeSecurityDescriptor(interprocess_security_descriptor *pSecurityDescriptor, unsigned long dwRevision);
+extern "C" __declspec(dllimport) int __stdcall SetSecurityDescriptorDacl(interprocess_security_descriptor *pSecurityDescriptor, int bDaclPresent, interprocess_acl *pDacl, int bDaclDefaulted);
+extern "C" __declspec(dllimport) void *__stdcall LoadLibraryA(const char *);
+extern "C" __declspec(dllimport) int   __stdcall FreeLibrary(void *);
+extern "C" __declspec(dllimport) void *__stdcall GetProcAddress(void *, const char*);
+extern "C" __declspec(dllimport) void *__stdcall GetModuleHandleA(const char*);
+extern "C" __declspec(dllimport) void *__stdcall GetFileInformationByHandle(void *, interprocess_by_handle_file_information*);
+extern "C" __declspec(dllimport) unsigned long __stdcall GetMappedFileNameW(void *, void *, wchar_t *, unsigned long);
+extern "C" __declspec(dllimport) long __stdcall RegOpenKeyExA(void *, const char *, unsigned long, unsigned long, void **);
+extern "C" __declspec(dllimport) long __stdcall RegQueryValueExA(void *, const char *, unsigned long*, unsigned long*, unsigned char *, unsigned long*);
+extern "C" __declspec(dllimport) long __stdcall RegCloseKey(void *);
+extern "C" __declspec(dllimport) int  __stdcall QueryPerformanceCounter(__int64 *lpPerformanceCount);
+
+//COM API
+extern "C" __declspec(dllimport) long __stdcall CoInitialize(void *pvReserved);
+extern "C" __declspec(dllimport) long __stdcall CoInitializeSecurity(
+                    void*         pSecDesc,
+                    long                         cAuthSvc,
+                    void *asAuthSvc,
+                    void                        *pReserved1,
+                    unsigned long                        dwAuthnLevel,
+                    unsigned long                        dwImpLevel,
+                    void                        *pAuthList,
+                    unsigned long                        dwCapabilities,
+                    void                        *pReserved3 );
+
+ extern "C" __declspec(dllimport) long __stdcall CoSetProxyBlanket(
+                     IUnknown_BIPC *pProxy,
+                     unsigned long dwAuthnSvc,
+                     unsigned long dwAuthzSvc,
+                     wchar_t *pServerPrincName,
+                     unsigned long dwAuthnLevel,
+                     unsigned long dwImpLevel,
+                     void *pAuthInfo,
+                     unsigned long dwCapabilities);
+
+extern "C" __declspec(dllimport) long __stdcall VariantClear(wchar_variant * pvarg);
+extern "C" __declspec(dllimport) long __stdcall CoCreateInstance(const GUID_BIPC & rclsid, IUnknown_BIPC *pUnkOuter,
+                    unsigned long dwClsContext, const GUID_BIPC & riid, void** ppv);
+extern "C" __declspec(dllimport) void __stdcall CoUninitialize(void);
+
+
+
+//API function typedefs
+//Pointer to functions
+typedef long (__stdcall *NtDeleteFile_t)(object_attributes_t *ObjectAttributes); 
+typedef long (__stdcall *NtSetInformationFile_t)(void *FileHandle, io_status_block_t *IoStatusBlock, void *FileInformation, unsigned long Length, int FileInformationClass ); 
+typedef long (__stdcall * NtQuerySystemInformation_t)(int, void*, unsigned long, unsigned long *); 
+typedef long (__stdcall * NtQueryObject_t)(void*, object_information_class, void *, unsigned long, unsigned long *); 
+typedef long (__stdcall *NtQueryInformationFile_t)(void *,io_status_block_t *,void *, long, int);
+typedef long (__stdcall *NtOpenFile_t)(void*,unsigned long ,object_attributes_t*,io_status_block_t*,unsigned long,unsigned long);
+typedef long (__stdcall *NtClose_t) (void*);
+typedef long (__stdcall *RtlCreateUnicodeStringFromAsciiz_t)(unicode_string_t *, const char *);
+typedef void (__stdcall *RtlFreeUnicodeString_t)(unicode_string_t *);
+typedef void (__stdcall *RtlInitUnicodeString_t)( unicode_string_t *, const wchar_t * );
+typedef long (__stdcall *RtlAppendUnicodeToString_t)(unicode_string_t *Destination, const wchar_t *Source);
+typedef unsigned long (__stdcall * GetMappedFileName_t)(void *, void *, wchar_t *, unsigned long);
+typedef long          (__stdcall * RegOpenKeyEx_t)(void *, const char *, unsigned long, unsigned long, void **);
+typedef long          (__stdcall * RegQueryValueEx_t)(void *, const char *, unsigned long*, unsigned long*, unsigned char *, unsigned long*);
+typedef long          (__stdcall * RegCloseKey_t)(void *);
+
+}  //namespace winapi {
+}  //namespace interprocess  {
+}  //namespace boost  {
+
+namespace boost {
+namespace interprocess {
+namespace winapi {
+
+inline unsigned long get_last_error()
+{  return GetLastError();  }
+
+inline void set_last_error(unsigned long err)
+{  return SetLastError(err);  }
+
+inline unsigned long format_message
+   (unsigned long dwFlags, const void *lpSource,
+    unsigned long dwMessageId, unsigned long dwLanguageId,
+    char *lpBuffer, unsigned long nSize, std::va_list *Arguments)
+{
+   return FormatMessageA
+      (dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments);
+}
+
+//And now, wrapper functions
+inline void * local_free(void *hmem)
+{  return LocalFree(hmem); }
+
+inline unsigned long make_lang_id(unsigned long p, unsigned long s)
+{  return ((((unsigned short)(s)) << 10) | (unsigned short)(p));   }
+
+inline void sched_yield()
+{
+   if(!SwitchToThread()){
+      Sleep(1);
+   }
+}
+
+inline void sleep(unsigned long ms)
+{  Sleep(ms);  }
+
+inline unsigned long get_current_thread_id()
+{  return GetCurrentThreadId();  }
+
+inline bool get_process_times
+   ( void *hProcess, interprocess_filetime* lpCreationTime
+   , interprocess_filetime *lpExitTime, interprocess_filetime *lpKernelTime
+   , interprocess_filetime *lpUserTime )
+{  return 0 != GetProcessTimes(hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime); }
+
+inline unsigned long get_current_process_id()
+{  return GetCurrentProcessId();  }
+
+inline unsigned int close_handle(void* handle)
+{  return CloseHandle(handle);   }
+
+inline void * find_first_file(const char *lpFileName, win32_find_data_t *lpFindFileData)
+{  return FindFirstFileA(lpFileName, lpFindFileData);   }
+
+inline bool find_next_file(void *hFindFile, win32_find_data_t *lpFindFileData)
+{  return FindNextFileA(hFindFile, lpFindFileData) != 0;   }
+
+inline bool find_close(void *handle)
+{  return FindClose(handle) != 0;   }
+
+inline bool duplicate_current_process_handle
+   (void *hSourceHandle, void **lpTargetHandle)
+{
+   return 0 != DuplicateHandle
+      ( GetCurrentProcess(),  hSourceHandle,    GetCurrentProcess()
+      , lpTargetHandle,       0,                0
+      , duplicate_same_access);
+}
+/*
+inline void get_system_time_as_file_time(interprocess_filetime *filetime)
+{  GetSystemTimeAsFileTime(filetime);  }
+
+inline bool file_time_to_local_file_time
+   (const interprocess_filetime *in, const interprocess_filetime *out)
+{  return 0 != FileTimeToLocalFileTime(in, out);  }
+*/
+inline void *open_or_create_mutex(const char *name, bool initial_owner, interprocess_security_attributes *attr)
+{  return CreateMutexA(attr, (int)initial_owner, name);  }
+
+inline unsigned long wait_for_single_object(void *handle, unsigned long time)
+{  return WaitForSingleObject(handle, time); }
+
+inline int release_mutex(void *handle)
+{  return ReleaseMutex(handle);  }
+
+inline int unmap_view_of_file(void *address)
+{  return UnmapViewOfFile(address); }
+
+inline void *open_or_create_semaphore(const char *name, long initial_count, long maximum_count, interprocess_security_attributes *attr)
+{  return CreateSemaphoreA(attr, initial_count, maximum_count, name);  }
+
+inline int release_semaphore(void *handle, long release_count, long *prev_count)
+{  return ReleaseSemaphore(handle, release_count, prev_count); }
+
+class interprocess_all_access_security
+{
+   interprocess_security_attributes sa;
+   interprocess_security_descriptor sd; 
+   bool initialized;
+
+   public:
+   interprocess_all_access_security()
+      : initialized(false)
+   {
+      if(!InitializeSecurityDescriptor(&sd, security_descriptor_revision))
+         return;
+      if(!SetSecurityDescriptorDacl(&sd, true, 0, false))
+         return;
+      sa.lpSecurityDescriptor = &sd;
+      sa.nLength = sizeof(interprocess_security_attributes);
+      sa.bInheritHandle = false;
+      initialized = false;
+   }
+
+   interprocess_security_attributes *get_attributes()
+   {  return &sa; }
+};
+
+inline void * create_file_mapping (void * handle, unsigned long access, unsigned long high_size, unsigned long low_size, const char * name, interprocess_security_attributes *psec)
+{
+   return CreateFileMappingA (handle, psec, access, high_size, low_size, name); 
+}
+
+inline void * open_file_mapping (unsigned long access, const char *name)
+{  return OpenFileMappingA (access, 0, name);   }
+
+inline void *map_view_of_file_ex(void *handle, unsigned long file_access, unsigned long highoffset, unsigned long lowoffset, std::size_t numbytes, void *base_addr)
+{  return MapViewOfFileEx(handle, file_access, highoffset, lowoffset, numbytes, base_addr);  }
+
+inline void *create_file(const char *name, unsigned long access, unsigned long creation_flags, unsigned long attributes, interprocess_security_attributes *psec)
+{
+   for (unsigned int attempt(0); attempt < error_sharing_violation_tries; ++attempt){
+      void * const handle = CreateFileA(name, access,
+                                        file_share_read | file_share_write | file_share_delete,
+                                        psec, creation_flags, attributes, 0);
+      bool const invalid(invalid_handle_value == handle);
+      if (!invalid){
+         return handle;
+      }
+      if (error_sharing_violation != get_last_error()){
+         return handle;
+      }
+      Sleep(error_sharing_violation_sleep_ms);
+   }
+   return invalid_handle_value;
+}
+
+inline bool delete_file(const char *name)
+{  return 0 != DeleteFileA(name);  }
+
+inline bool move_file_ex(const char *source_filename, const char *destination_filename, unsigned long flags)
+{  return 0 != MoveFileExA(source_filename, destination_filename, flags);  }
+
+inline void get_system_info(system_info *info)
+{  GetSystemInfo(info); }
+
+inline bool flush_view_of_file(void *base_addr, std::size_t numbytes)
+{  return 0 != FlushViewOfFile(base_addr, numbytes); }
+
+inline bool flush_file_buffers(void *handle)
+{  return 0 != FlushFileBuffers(handle); }
+
+inline bool get_file_size(void *handle, __int64 &size)
+{  return 0 != GetFileSizeEx(handle, &size);  }
+
+inline bool create_directory(const char *name)
+{  
+   interprocess_all_access_security sec;
+   return 0 != CreateDirectoryA(name, sec.get_attributes());   
+}
+
+inline bool remove_directory(const char *lpPathName)
+{  return 0 != RemoveDirectoryA(lpPathName);   }
+
+inline unsigned long get_temp_path(unsigned long length, char *buffer)
+{  return GetTempPathA(length, buffer);   }
+
+inline int set_end_of_file(void *handle)
+{  return 0 != SetEndOfFile(handle);   }
+
+inline bool set_file_pointer_ex(void *handle, __int64 distance, __int64 *new_file_pointer, unsigned long move_method)
+{  return 0 != SetFilePointerEx(handle, distance, new_file_pointer, move_method);   }
+
+inline bool lock_file_ex(void *hnd, unsigned long flags, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped *overlapped)
+{  return 0 != LockFileEx(hnd, flags, reserved, size_low, size_high, overlapped); }
+
+inline bool unlock_file_ex(void *hnd, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped *overlapped)
+{  return 0 != UnlockFileEx(hnd, reserved, size_low, size_high, overlapped);  }
+
+inline bool write_file(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped)
+{  return 0 != WriteFile(hnd, buffer, bytes_to_write, bytes_written, overlapped);  }
+
+inline bool get_file_information_by_handle(void *hnd, interprocess_by_handle_file_information *info)
+{  return 0 != GetFileInformationByHandle(hnd, info);  }
+
+inline long interlocked_increment(long volatile *addr)
+{  return BOOST_INTERLOCKED_INCREMENT(addr);  }
+
+inline long interlocked_decrement(long volatile *addr)
+{  return BOOST_INTERLOCKED_DECREMENT(addr);  }
+
+inline long interlocked_compare_exchange(long volatile *addr, long val1, long val2)
+{  return BOOST_INTERLOCKED_COMPARE_EXCHANGE(addr, val1, val2);  }
+
+inline long interlocked_exchange_add(long volatile* addend, long value)
+{  return BOOST_INTERLOCKED_EXCHANGE_ADD(const_cast<long*>(addend), value);  }
+
+inline long interlocked_exchange(long volatile* addend, long value)
+{  return BOOST_INTERLOCKED_EXCHANGE(const_cast<long*>(addend), value);  }
+
+//Forward functions
+inline void *load_library(const char *name)
+{  return LoadLibraryA(name); }
+
+inline bool free_library(void *module)
+{  return 0 != FreeLibrary(module); }
+
+inline void *get_proc_address(void *module, const char *name)
+{  return GetProcAddress(module, name); }
+
+inline void *get_current_process()
+{  return GetCurrentProcess();  }
+
+inline void *get_module_handle(const char *name)
+{  return GetModuleHandleA(name); }
+
+inline unsigned long get_mapped_file_name(void *process, void *lpv, wchar_t *lpfilename, unsigned long nSize)
+{  return GetMappedFileNameW(process, lpv, lpfilename, nSize); }
+
+inline long reg_open_key_ex(void *hKey, const char *lpSubKey, unsigned long ulOptions, unsigned long samDesired, void **phkResult)
+{  return RegOpenKeyExA(hKey, lpSubKey, ulOptions, samDesired, phkResult); }
+
+inline long reg_query_value_ex(void *hKey, const char *lpValueName, unsigned long*lpReserved, unsigned long*lpType, unsigned char *lpData, unsigned long*lpcbData)
+{  return RegQueryValueExA(hKey, lpValueName, lpReserved, lpType, lpData, lpcbData); }
+
+inline long reg_close_key(void *hKey)
+{  return RegCloseKey(hKey); }
+
+inline bool query_performance_counter(__int64 *lpPerformanceCount)
+{
+   return 0 != QueryPerformanceCounter(lpPerformanceCount);
+}
+
+inline void initialize_object_attributes
+( object_attributes_t *pobject_attr, unicode_string_t *name
+ , unsigned long attr, void *rootdir, void *security_descr)
+
+{
+   pobject_attr->Length = sizeof(object_attributes_t);
+   pobject_attr->RootDirectory = rootdir;
+   pobject_attr->Attributes = attr;
+   pobject_attr->ObjectName = name;
+   pobject_attr->SecurityDescriptor = security_descr;
+   pobject_attr->SecurityQualityOfService = 0;
+}
+
+inline void rtl_init_empty_unicode_string(unicode_string_t *ucStr, wchar_t *buf, unsigned short bufSize)
+{
+   ucStr->Buffer = buf;
+   ucStr->Length = 0;
+   ucStr->MaximumLength = bufSize;
+}
+
+//A class that locates and caches loaded DLL function addresses.
+template<int Dummy>
+struct function_address_holder
+{
+   enum { NtSetInformationFile, NtQuerySystemInformation, NtQueryObject, NumFunction };
+   enum { NtDll_dll, NumModule };
+
+   private:
+   static void *FunctionAddresses[NumFunction];
+   static volatile long FunctionStates[NumFunction];
+   static void *ModuleAddresses[NumModule];
+   static volatile long ModuleStates[NumModule];
+
+   static void *get_module_from_id(unsigned int id)
+   {
+      assert(id < (unsigned int)NumModule);
+      const char *module[] = { "ntdll.dll" };
+      bool compile_check[sizeof(module)/sizeof(module[0]) == NumModule];
+      (void)compile_check;
+      return get_module_handle(module[id]);
+   }
+
+   static void *get_module(const unsigned int id)
+   {
+      assert(id < (unsigned int)NumModule);
+      while(ModuleStates[id] < 2){
+         if(interlocked_compare_exchange(&ModuleStates[id], 1, 0) == 0){
+            ModuleAddresses[id] = get_module_from_id(id);
+            interlocked_increment(&ModuleStates[id]);
+            break;
+         }
+         else{
+            sched_yield();
+         }
+      }
+      return ModuleAddresses[id];
+   }
+
+   static void *get_address_from_dll(const unsigned int id)
+   {
+      assert(id < (unsigned int)NumFunction);
+      const char *function[] = { "NtSetInformationFile", "NtQuerySystemInformation", "NtQueryObject" };
+      bool compile_check[sizeof(function)/sizeof(function[0]) == NumFunction];
+      (void)compile_check;
+      return get_proc_address(get_module(NtDll_dll), function[id]);
+   }
+
+   public:
+   static void *get(const unsigned int id)
+   {
+      assert(id < (unsigned int)NumFunction);
+      while(FunctionStates[id] < 2){
+         if(interlocked_compare_exchange(&FunctionStates[id], 1, 0) == 0){
+            FunctionAddresses[id] = get_address_from_dll(id);
+            interlocked_increment(&FunctionStates[id]);
+            break;
+         }
+         else{
+            sched_yield();
+         }
+      }
+      return FunctionAddresses[id];
+   }
+};
+
+template<int Dummy>
+void *function_address_holder<Dummy>::FunctionAddresses[function_address_holder<Dummy>::NumFunction];
+
+template<int Dummy>
+volatile long function_address_holder<Dummy>::FunctionStates[function_address_holder<Dummy>::NumFunction];
+
+template<int Dummy>
+void *function_address_holder<Dummy>::ModuleAddresses[function_address_holder<Dummy>::NumModule];
+
+template<int Dummy>
+volatile long function_address_holder<Dummy>::ModuleStates[function_address_holder<Dummy>::NumModule];
+
+
+struct dll_func
+   : public function_address_holder<0>
+{};
+
+//Complex winapi based functions...
+struct library_unloader
+{
+   void *lib_;
+   library_unloader(void *module) : lib_(module){}
+   ~library_unloader(){ free_library(lib_);  }
+};
+
+//pszFilename must have room for at least MaxPath+1 characters
+inline bool get_file_name_from_handle_function
+   (void * hFile, wchar_t *pszFilename, std::size_t length, std::size_t &out_length) 
+{
+   if(length <= MaxPath){
+      return false;
+   }
+
+//   void *hiPSAPI = load_library("PSAPI.DLL");
+//   if (0 == hiPSAPI)
+//      return 0;
+//   library_unloader unloader(hiPSAPI);
+
+//  Pointer to function getMappedFileName() in PSAPI.DLL
+//   GetMappedFileName_t pfGMFN =
+//      (GetMappedFileName_t)get_proc_address(hiPSAPI, "GetMappedFileNameW");
+//   if (! pfGMFN){
+//      return 0;      //  Failed: unexpected error
+//   }
+
+   bool bSuccess = false;
+
+   // Create a file mapping object.
+   void * hFileMap = create_file_mapping(hFile, page_readonly, 0, 1, 0, 0);
+   if(hFileMap){
+      // Create a file mapping to get the file name.
+      void* pMem = map_view_of_file_ex(hFileMap, file_map_read, 0, 0, 1, 0);
+
+      if (pMem){
+         //out_length = pfGMFN(get_current_process(), pMem, pszFilename, MaxPath);
+         out_length = get_mapped_file_name(get_current_process(), pMem, pszFilename, MaxPath);
+         if(out_length){
+            bSuccess = true;
+         } 
+         unmap_view_of_file(pMem);
+      }
+      close_handle(hFileMap);
+   }
+
+   return(bSuccess);
+}
+
+inline bool get_system_time_of_day_information(system_timeofday_information &info)
+{
+   NtQuerySystemInformation_t pNtQuerySystemInformation = (NtQuerySystemInformation_t)
+      //get_proc_address(get_module_handle("ntdll.dll"), "NtQuerySystemInformation");
+         dll_func::get(dll_func::NtQuerySystemInformation);
+   unsigned long res;
+   long status = pNtQuerySystemInformation(system_time_of_day_information, &info, sizeof(info), &res);
+   if(status){
+      return false;
+   }
+   return true;
+}
+
+inline bool get_boot_time(unsigned char (&bootstamp) [BootstampLength])
+{
+   system_timeofday_information info;
+   bool ret = get_system_time_of_day_information(info);
+   if(!ret){
+      return false;
+   }
+   std::memcpy(&bootstamp[0], &info.Reserved1, sizeof(bootstamp));
+   return true;
+}
+
+inline bool get_boot_and_system_time(unsigned char (&bootsystemstamp) [BootAndSystemstampLength])
+{
+   system_timeofday_information info;
+   bool ret = get_system_time_of_day_information(info);
+   if(!ret){
+      return false;
+   }
+   std::memcpy(&bootsystemstamp[0], &info.Reserved1, sizeof(bootsystemstamp));
+   return true;
+}
+
+inline bool get_boot_time_str(char *bootstamp_str, std::size_t &s) //will write BootstampLength chars
+{
+   if(s < (BootstampLength*2))
+      return false;
+   system_timeofday_information info;
+   bool ret = get_system_time_of_day_information(info);
+   if(!ret){
+      return false;
+   }
+   const char Characters [] =
+      { '0', '1', '2', '3', '4', '5', '6', '7'
+      , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+   std::size_t char_counter = 0;
+   for(std::size_t i = 0; i != static_cast<std::size_t>(BootstampLength); ++i){
+      bootstamp_str[char_counter++] = Characters[(info.Reserved1[i]&0xF0)>>4];
+      bootstamp_str[char_counter++] = Characters[(info.Reserved1[i]&0x0F)];
+   }
+   s = BootstampLength*2;
+   return true;
+}
+
+inline bool get_boot_and_system_time_wstr(wchar_t *bootsystemstamp, std::size_t &s)  //will write BootAndSystemstampLength chars
+{
+   if(s < (BootAndSystemstampLength*2))
+      return false;
+   system_timeofday_information info;
+   bool ret = get_system_time_of_day_information(info);
+   if(!ret){
+      return false;
+   }
+   const wchar_t Characters [] =
+      { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7'
+      , L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F' };
+   std::size_t char_counter = 0;
+   for(std::size_t i = 0; i != static_cast<std::size_t>(BootAndSystemstampLength); ++i){
+      bootsystemstamp[char_counter++] = Characters[(info.Reserved1[i]&0xF0)>>4];
+      bootsystemstamp[char_counter++] = Characters[(info.Reserved1[i]&0x0F)];
+   }
+   s = BootAndSystemstampLength*2;
+   return true;
+}
+
+class handle_closer
+{
+   void *handle_;
+   public:
+   handle_closer(void *handle) : handle_(handle){}
+   ~handle_closer(){ close_handle(handle_);  }
+};
+
+union ntquery_mem_t
+{
+   object_name_information_t name;
+   struct ren_t
+   {
+      file_rename_information_t info;
+      wchar_t buf[32767];
+   } ren;
+};
+
+inline bool unlink_file(const char *filename)
+{
+   if(!delete_file(filename)){
+      try{
+         NtSetInformationFile_t pNtSetInformationFile =
+            //(NtSetInformationFile_t)get_proc_address(get_module_handle("ntdll.dll"), "NtSetInformationFile"); 
+            (NtSetInformationFile_t)dll_func::get(dll_func::NtSetInformationFile);
+         if(!pNtSetInformationFile){
+            return false;
+         }
+
+         NtQueryObject_t pNtQueryObject =
+            //(NtQueryObject_t)get_proc_address(get_module_handle("ntdll.dll"), "NtQueryObject"); 
+            (NtQueryObject_t)dll_func::get(dll_func::NtQueryObject);
+
+         //First step: Obtain a handle to the file using Win32 rules. This resolves relative paths
+         void *fh = create_file(filename, generic_read | delete_access, open_existing,
+            file_flag_backup_semantics | file_flag_delete_on_close, 0); 
+         if(fh == invalid_handle_value){
+            return false;
+         }
+
+         handle_closer h_closer(fh);
+
+         std::auto_ptr<ntquery_mem_t> pmem(new ntquery_mem_t);
+         file_rename_information_t *pfri = &pmem->ren.info;
+         const std::size_t RenMaxNumChars =
+            ((char*)pmem.get() - (char*)&pmem->ren.info.FileName[0])/sizeof(wchar_t);
+
+         //Obtain file name
+         unsigned long size;
+         if(pNtQueryObject(fh, object_name_information, pmem.get(), sizeof(ntquery_mem_t), &size)){
+            return false;
+         }
+
+         //Copy filename to the rename member
+         std::memmove(pmem->ren.info.FileName, pmem->name.Name.Buffer, pmem->name.Name.Length);
+         std::size_t filename_string_length = pmem->name.Name.Length/sizeof(wchar_t);
+
+         //Second step: obtain the complete native-nt filename
+         //if(!get_file_name_from_handle_function(fh, pfri->FileName, RenMaxNumChars, filename_string_length)){
+         //return 0;
+         //}
+
+         //Add trailing mark
+         if((RenMaxNumChars-filename_string_length) < (SystemTimeOfDayInfoLength*2)){
+            return false;
+         }
+
+         //Search '\\' character to replace it
+         for(std::size_t i = filename_string_length; i != 0; --filename_string_length){
+            if(pmem->ren.info.FileName[--i] == L'\\')
+               break;
+         }
+
+         //Add random number
+         std::size_t s = RenMaxNumChars - filename_string_length;
+         if(!get_boot_and_system_time_wstr(&pfri->FileName[filename_string_length], s)){
+            return false;
+         }
+         filename_string_length += s;
+
+         //Fill rename information (FileNameLength is in bytes)
+         pfri->FileNameLength = static_cast<unsigned long>(sizeof(wchar_t)*(filename_string_length));
+         pfri->Replace = 1;
+         pfri->RootDir = 0;
+
+         //Final step: change the name of the in-use file:
+         io_status_block_t io;
+         if(0 != pNtSetInformationFile(fh, &io, pfri, sizeof(ntquery_mem_t::ren_t), file_rename_information)){
+            return false;
+         }
+         return true;
+      }
+      catch(...){
+         return false;
+      }
+   }
+   return true;
+}
+
+struct reg_closer
+{
+   //reg_closer(RegCloseKey_t func, void *key) : func_(func), key_(key){}
+   //~reg_closer(){ (*func_)(key_);  }
+   //RegCloseKey_t func_;
+   void *key_;
+   reg_closer(void *key) : key_(key){}
+   ~reg_closer(){ reg_close_key(key_);  }
+};
+
+inline void get_shared_documents_folder(std::string &s)
+{
+   s.clear();
+   //void *hAdvapi = load_library("Advapi32.dll");
+   //if (hAdvapi){
+      //library_unloader unloader(hAdvapi);
+      //  Pointer to function RegOpenKeyA
+      //RegOpenKeyEx_t pRegOpenKey =
+         //(RegOpenKeyEx_t)get_proc_address(hAdvapi, "RegOpenKeyExA");
+      //if (pRegOpenKey){
+         //  Pointer to function RegCloseKey
+         //RegCloseKey_t pRegCloseKey =
+            //(RegCloseKey_t)get_proc_address(hAdvapi, "RegCloseKey");
+         //if (pRegCloseKey){
+            //  Pointer to function RegQueryValueA
+            //RegQueryValueEx_t pRegQueryValue =
+               //(RegQueryValueEx_t)get_proc_address(hAdvapi, "RegQueryValueExA");
+            //if (pRegQueryValue){
+               //Open the key
+               void *key;
+               //if ((*pRegOpenKey)( hkey_local_machine
+                                 //, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"
+                                 //, 0
+                                 //, key_query_value
+                                 //, &key) == 0){
+                  //reg_closer key_closer(pRegCloseKey, key);
+               if (reg_open_key_ex( hkey_local_machine
+                                 , "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"
+                                 , 0
+                                 , key_query_value
+                                 , &key) == 0){
+                  reg_closer key_closer(key);
+
+                  //Obtain the value
+                  unsigned long size;
+                  unsigned long type;
+                  const char *const reg_value = "Common AppData";
+                  //long err = (*pRegQueryValue)( key, reg_value, 0, &type, 0, &size);
+                  long err = reg_query_value_ex( key, reg_value, 0, &type, 0, &size);
+                  if(!err){
+                     //Size includes terminating NULL
+                     s.resize(size);
+                     //err = (*pRegQueryValue)( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
+                     err = reg_query_value_ex( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
+                     if(!err)
+                        s.erase(s.end()-1);
+                     (void)err;
+                  }
+               }
+            //}
+         //}
+      //}
+   //}
+}
+
+
+inline void get_registry_value(const char *folder, const char *value_key, std::vector<unsigned char> &s)
+{
+   s.clear();
+   //void *hAdvapi = load_library("Advapi32.dll");
+   //if (hAdvapi){
+      //library_unloader unloader(hAdvapi);
+      //  Pointer to function RegOpenKeyA
+      //RegOpenKeyEx_t pRegOpenKey =
+         //(RegOpenKeyEx_t)get_proc_address(hAdvapi, "RegOpenKeyExA");
+      //if (pRegOpenKey){
+         //  Pointer to function RegCloseKey
+         //RegCloseKey_t pRegCloseKey =
+            //(RegCloseKey_t)get_proc_address(hAdvapi, "RegCloseKey");
+         //if (pRegCloseKey){
+            //  Pointer to function RegQueryValueA
+            //RegQueryValueEx_t pRegQueryValue =
+               //(RegQueryValueEx_t)get_proc_address(hAdvapi, "RegQueryValueExA");
+            //if (pRegQueryValue){
+               //Open the key
+               void *key;
+               //if ((*pRegOpenKey)( hkey_local_machine
+                                 //, folder
+                                 //, 0
+                                 //, key_query_value
+                                 //, &key) == 0){
+                  //reg_closer key_closer(pRegCloseKey, key);
+               if (reg_open_key_ex( hkey_local_machine
+                                 , folder
+                                 , 0
+                                 , key_query_value
+                                 , &key) == 0){
+                  reg_closer key_closer(key);
+
+                  //Obtain the value
+                  unsigned long size;
+                  unsigned long type;
+                  const char *const reg_value = value_key;
+                  //long err = (*pRegQueryValue)( key, reg_value, 0, &type, 0, &size);
+                  long err = reg_query_value_ex( key, reg_value, 0, &type, 0, &size);
+                  if(!err){
+                     //Size includes terminating NULL
+                     s.resize(size);
+                     //err = (*pRegQueryValue)( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
+                     err = reg_query_value_ex( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
+                     if(!err)
+                        s.erase(s.end()-1);
+                     (void)err;
+                  }
+               }
+            //}
+         //}
+      //}
+   //}
+}
+
+struct co_uninitializer
+{  ~co_uninitializer()  {  CoUninitialize(); }  };
+
+template<class Object>
+struct com_releaser
+{
+   Object *&object_;
+   com_releaser(Object *&object) : object_(object) {}
+   ~com_releaser()  {  object_->Release();    object_ = 0;  }
+};
+
+inline bool get_wmi_class_attribute( std::wstring& strValue, const wchar_t *wmi_class, const wchar_t *wmi_class_var)
+{
+   //See example http://msdn.microsoft.com/en-us/library/aa390423%28v=VS.85%29.aspx
+   long co_init_ret = CoInitialize(0);
+   if(co_init_ret != S_OK_BIPC && co_init_ret != S_FALSE_BIPC)
+      return false;
+   co_uninitializer co_initialize_end;
+   (void)co_initialize_end;
+
+   bool bRet = false;
+   long sec_init_ret = CoInitializeSecurity
+      ( 0   //pVoid 
+      ,-1   //cAuthSvc 
+      , 0   //asAuthSvc 
+      , 0   //pReserved1 
+      , RPC_C_AUTHN_LEVEL_PKT_BIPC //dwAuthnLevel 
+      , RPC_C_IMP_LEVEL_IMPERSONATE_BIPC //dwImpLevel 
+      , 0   //pAuthList 
+      , EOAC_NONE_BIPC //dwCapabilities 
+      , 0   //pReserved3 
+      );
+   if( 0 == sec_init_ret || RPC_E_TOO_LATE_BIPC == sec_init_ret)
+   {
+      IWbemLocator_BIPC * pIWbemLocator = 0;
+      const wchar_t * bstrNamespace = L"root\\cimv2";
+ 
+      if( 0 != CoCreateInstance(
+            CLSID_WbemAdministrativeLocator,
+            0,
+            CLSCTX_INPROC_SERVER_BIPC | CLSCTX_LOCAL_SERVER_BIPC,
+            IID_IUnknown, (void **)&pIWbemLocator)){
+         return false;
+      }
+ 
+      com_releaser<IWbemLocator_BIPC> IWbemLocator_releaser(pIWbemLocator);
+
+      IWbemServices_BIPC *pWbemServices = 0;
+
+      if( 0 != pIWbemLocator->ConnectServer(
+            bstrNamespace,  // Namespace
+            0,          // Userid
+            0,           // PW
+            0,           // Locale
+            0,              // flags
+            0,           // Authority
+            0,           // Context
+            &pWbemServices
+            )
+         ){
+         return false;
+      }
+
+      if( S_OK_BIPC != CoSetProxyBlanket(
+            pWbemServices,
+            RPC_C_AUTHN_DEFAULT_BIPC,
+            RPC_C_AUTHZ_DEFAULT_BIPC,
+            0,
+            RPC_C_AUTHN_LEVEL_PKT_BIPC,
+            RPC_C_IMP_LEVEL_IMPERSONATE_BIPC,
+            0,
+            EOAC_NONE_BIPC
+            )
+         ){
+         return false;
+      }
+ 
+      com_releaser<IWbemServices_BIPC> IWbemServices_releaser(pWbemServices);
+
+      strValue.clear();
+      strValue += L"Select ";
+      strValue += wmi_class_var;
+      strValue += L" from ";
+      strValue += wmi_class;
+
+      IEnumWbemClassObject_BIPC * pEnumObject  = 0;
+
+      if ( 0 != pWbemServices->ExecQuery(
+            L"WQL",
+            strValue.c_str(),
+            //WBEM_FLAG_RETURN_IMMEDIATELY_BIPC,
+            WBEM_FLAG_RETURN_WHEN_COMPLETE_BIPC | WBEM_FLAG_FORWARD_ONLY_BIPC,
+            0,
+            &pEnumObject
+            )
+         ){
+         return false;
+      }
+
+      com_releaser<IEnumWbemClassObject_BIPC> IEnumWbemClassObject_releaser(pEnumObject);
+
+      //WBEM_FLAG_FORWARD_ONLY_BIPC incompatible with Reset
+      //if ( 0 != pEnumObject->Reset() ){
+         //return false;
+      //}
+
+      wchar_variant vwchar;
+      unsigned long uCount = 1, uReturned;
+      IWbemClassObject_BIPC * pClassObject = 0;
+      while( 0 == pEnumObject->Next( WBEM_INFINITE_BIPC, uCount, &pClassObject, &uReturned ) )
+      {
+         com_releaser<IWbemClassObject_BIPC> IWbemClassObject_releaser(pClassObject);
+         if ( 0 == pClassObject->Get( L"LastBootUpTime", 0, &vwchar, 0, 0 ) ){
+            bRet = true;
+            strValue = vwchar.value.pbstrVal;
+            VariantClear(&vwchar );
+            break;
+         }
+      }
+   }
+   return bRet;
+}
+
+inline bool get_last_bootup_time( std::wstring& strValue )
+{
+   bool ret = get_wmi_class_attribute(strValue, L"Win32_OperatingSystem", L"LastBootUpTime");
+   std::size_t timezone = strValue.find(L'+');
+   if(timezone != std::wstring::npos){
+      strValue.erase(timezone);
+   }
+   timezone = strValue.find(L'-');
+   if(timezone != std::wstring::npos){
+      strValue.erase(timezone);
+   }
+   return ret;
+}
+
+inline bool get_last_bootup_time( std::string& str )
+{
+   std::wstring wstr;
+   bool ret = get_last_bootup_time(wstr);
+   str.resize(wstr.size());
+   for(std::size_t i = 0, max = str.size(); i != max; ++i){
+      str[i] = '0' + (wstr[i]-L'0');
+   }
+   return ret;
+}
+
+inline bool is_directory(const char *path)
+{
+	unsigned long attrib = GetFileAttributesA(path);
+
+	return (attrib != invalid_file_attributes &&
+	        (attrib & file_attribute_directory));
+}
+
+}  //namespace winapi 
+}  //namespace interprocess
+}  //namespace boost 
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifdef BOOST_INTERPROCESS_WIN32_PRIMITIVES_HPP
diff --git a/boost/interprocess/detail/workaround.hpp b/boost/interprocess/detail/workaround.hpp
new file mode 100644
index 0000000000..896a2208a2
--- /dev/null
+++ b/boost/interprocess/detail/workaround.hpp
@@ -0,0 +1,148 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_WORKAROUND_HPP
+#define BOOST_INTERPROCESS_DETAIL_WORKAROUND_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+
+#if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
+
+#define BOOST_INTERPROCESS_WINDOWS
+
+/*
+#if !defined(_MSC_EXTENSIONS)
+#error "Turn on Microsoft language extensions (_MSC_EXTENSIONS) to be able to call Windows API functions"
+#endif
+*/
+
+#endif
+
+#if !defined(BOOST_INTERPROCESS_WINDOWS)
+
+   #include <unistd.h>
+
+   #if ((_POSIX_THREAD_PROCESS_SHARED - 0) > 0)
+   //Cygwin defines _POSIX_THREAD_PROCESS_SHARED but does not implement it.
+   //Mac Os X >= Leopard defines _POSIX_THREAD_PROCESS_SHARED but does not seems to work.
+   #  if !defined(__CYGWIN__) && !defined(__APPLE__)
+   #  define BOOST_INTERPROCESS_POSIX_PROCESS_SHARED
+   #  endif
+   #endif
+   
+   #if ((_POSIX_BARRIERS - 0) > 0)
+   # define BOOST_INTERPROCESS_POSIX_BARRIERS
+   # endif
+
+   #if ((_POSIX_SEMAPHORES - 0) > 0)
+   # define BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES
+   #  if defined(__CYGWIN__)
+      #define BOOST_INTERPROCESS_POSIX_SEMAPHORES_NO_UNLINK
+   #  endif
+   //Some platforms have a limited (name length) named semaphore support
+   #elif (defined(__FreeBSD__) && (__FreeBSD__ >= 4)) || defined(__APPLE__)
+     # define BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES   
+   #endif 
+
+   #if ((defined _V6_ILP32_OFFBIG)  &&(_V6_ILP32_OFFBIG   - 0 > 0)) ||\
+       ((defined _V6_LP64_OFF64)    &&(_V6_LP64_OFF64     - 0 > 0)) ||\
+       ((defined _V6_LPBIG_OFFBIG)  &&(_V6_LPBIG_OFFBIG   - 0 > 0)) ||\
+       ((defined _XBS5_ILP32_OFFBIG)&&(_XBS5_ILP32_OFFBIG - 0 > 0)) ||\
+       ((defined _XBS5_LP64_OFF64)  &&(_XBS5_LP64_OFF64   - 0 > 0)) ||\
+       ((defined _XBS5_LPBIG_OFFBIG)&&(_XBS5_LPBIG_OFFBIG - 0 > 0)) ||\
+       ((defined _FILE_OFFSET_BITS) &&(_FILE_OFFSET_BITS  - 0 >= 64))||\
+       ((defined _FILE_OFFSET_BITS) &&(_FILE_OFFSET_BITS  - 0 >= 64))
+      #define BOOST_INTERPROCESS_UNIX_64_BIT_OR_BIGGER_OFF_T
+   #else
+   #endif
+
+   //Check for XSI shared memory objects. They are available in nearly all UNIX platforms
+   #if !defined(__QNXNTO__)
+   # define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+   #endif
+
+   #if ((_POSIX_SHARED_MEMORY_OBJECTS - 0) > 0)
+   # define BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS
+   #else
+   //VMS and MACOS don't define it but the have shm_open/close interface
+   # if defined(__vms)
+   #  if __CRTL_VER >= 70200000
+   #  define BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS
+   #  endif
+   //Mac OS has some non-conformant features like names limited to SHM_NAME_MAX
+   # elif defined (__APPLE__)
+//   #  define BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS
+//   #  define BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS_NO_GROW
+   # endif 
+   #endif
+
+   //Now check if we have only XSI shared memory
+   #if defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS) &&\
+      !defined(BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS)
+   //#  define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS_ONLY
+   #endif
+
+   #if ((_POSIX_TIMEOUTS - 0) > 0)
+   # define BOOST_INTERPROCESS_POSIX_TIMEOUTS
+   #endif 
+
+
+   #ifdef BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS
+      //Some systems have filesystem-based resources, so the
+      //portable "/shmname" format does not work due to permission issues
+      //For those systems we need to form a path to a temporary directory:
+      //          hp-ux               tru64               vms               freebsd
+      #if defined(__hpux) || defined(__osf__) || defined(__vms) || (defined(__FreeBSD__) && (__FreeBSD__ < 7)) 
+      #define BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SHARED_MEMORY
+      #elif defined(__FreeBSD__)
+      #define BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY
+      #endif
+   #endif
+
+   #ifdef BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES
+      #if defined(__osf__) || defined(__vms)
+      #define BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SEMAPHORES
+      #endif
+   #endif
+
+   #if ((_POSIX_VERSION + 0)>= 200112L || (_XOPEN_VERSION + 0)>= 500)
+   #define BOOST_INTERPROCESS_POSIX_RECURSIVE_MUTEXES
+   #endif
+
+#endif
+
+#if    !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)\
+    && !defined(BOOST_INTERPROCESS_DISABLE_VARIADIC_TMPL)
+#define BOOST_INTERPROCESS_PERFECT_FORWARDING
+#endif
+
+//Now declare some Boost.Interprocess features depending on the implementation
+
+#if defined(BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES) && !defined(BOOST_INTERPROCESS_POSIX_SEMAPHORES_NO_UNLINK)
+
+#define BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES
+
+#endif
+
+#if defined(BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES) && !defined(BOOST_INTERPROCESS_POSIX_SEMAPHORES_NO_UNLINK)
+
+#define BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES
+#define BOOST_INTERPROCESS_NAMED_SEMAPHORE_USES_POSIX_SEMAPHORES
+
+#endif
+
+// Timeout duration use if BOOST_INTERPROCESS_ENABLE_TIMEOUT_WHEN_LOCKING is set
+#ifndef BOOST_INTERPROCESS_TIMEOUT_WHEN_LOCKING_DURATION_MS
+#define BOOST_INTERPROCESS_TIMEOUT_WHEN_LOCKING_DURATION_MS 10000
+#endif
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_WORKAROUND_HPP
diff --git a/boost/interprocess/detail/xsi_shared_memory_device.hpp b/boost/interprocess/detail/xsi_shared_memory_device.hpp
new file mode 100644
index 0000000000..d2e2bf2ce6
--- /dev/null
+++ b/boost/interprocess/detail/xsi_shared_memory_device.hpp
@@ -0,0 +1,392 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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_XSI_SHARED_MEMORY_DEVICE_HPP
+#define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_DEVICE_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+#error "This header can't be used in Windows operating systems"
+#endif
+
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+
+#include <boost/interprocess/xsi_shared_memory.hpp>
+#include <boost/interprocess/sync/xsi/xsi_named_mutex.hpp>
+#include <boost/interprocess/mapped_region.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <cstddef>
+#include <boost/cstdint.hpp>
+#include <string>
+#include <cstring>
+
+//!\file
+//!Describes a class representing a native xsi shared memory.
+
+namespace boost {
+namespace interprocess {
+
+class xsi_shared_memory_device
+{
+   /// @cond
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper)
+   /// @endcond 
+
+   public:
+
+   xsi_shared_memory_device();
+
+   xsi_shared_memory_device(create_only_t, const char *name, mode_t mode, std::size_t size)
+   {  this->priv_open_or_create_name_only(ipcdetail::DoCreate, name, mode, size);  }
+
+   xsi_shared_memory_device(open_or_create_t, const char *name, mode_t mode, std::size_t size)
+   {  this->priv_open_or_create_name_only(ipcdetail::DoOpenOrCreate, name, mode, size);  }
+
+   xsi_shared_memory_device(open_only_t, const char *name, mode_t mode)
+   {  this->priv_open_or_create_name_only(ipcdetail::DoOpen, name, mode, 0);  }
+
+   xsi_shared_memory_device(create_only_t, const char *filepath, boost::uint8_t id, mode_t mode, std::size_t size)
+   {  this->priv_open_or_create_name_id(ipcdetail::DoCreate, name, id, mode, size);  }
+
+   xsi_shared_memory_device(open_or_create_t, const char *filepath, boost::uint8_t id, mode_t mode, std::size_t size)
+   {  this->priv_open_or_create_name_id(ipcdetail::DoOpenOrCreate, id, name, mode, size);  }
+
+   xsi_shared_memory_device(open_only_t, const char *filepath, boost::uint8_t id, mode_t mode)
+   {  this->priv_open_or_create_name_id(ipcdetail::DoOpen, name, id, mode, 0);  }
+
+   xsi_shared_memory_device(BOOST_RV_REF(xsi_shared_memory_device) moved)
+   {  this->swap(moved);   }
+
+   xsi_shared_memory_device &operator=(BOOST_RV_REF(xsi_shared_memory_device) moved)
+   {  
+      xsi_shared_memory_device tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps two xsi_shared_memory_device. Does not throw
+   void swap(xsi_shared_memory_device &other);
+
+   //!Destroys *this. The shared memory won't be destroyed, just
+   //!this connection to it. Use remove() to destroy the shared memory.
+   ~xsi_shared_memory_device();
+
+   //!Returns the name of the
+   //!shared memory.
+   const char *get_name() const;
+
+   //!Returns the shared memory ID that
+   //!identifies the shared memory
+   int get_shmid() const;
+
+   //!Returns access
+   //!permissions
+   mode_t get_mode() const;
+
+   //!Returns the mapping handle.
+   //!Never throws
+   mapping_handle_t get_mapping_handle() const;
+
+   //!Erases a XSI shared memory object identified by shmname
+   //!from the system.
+   //!Returns false on error. Never throws
+   static bool remove(const char *shmname);
+
+   //!Erases the XSI shared memory object identified by shmid
+   //!from the system.
+   //!Returns false on error. Never throws
+   static bool remove(int shmid);
+
+   /// @cond
+   private:
+   template<int Dummy>
+   struct info_constants_t
+   {
+      static const std::size_t MaxName = 32;
+      static const std::size_t FirstID = 2;
+      static const std::size_t LastID  = 256;
+      static const std::size_t NumID   = LastID - FirstID;
+   };
+
+   struct info_t
+   {
+      struct names_t
+      {
+         char buf[info_constants_t<0>::MaxName];
+      } names[info_constants_t<0>::NumID];
+   };
+
+   static void priv_obtain_index(mapped_region &m, xsi_named_mutex &m, std::string &path);
+   static bool priv_remove_dead_memory(info_t *info, const char *path);
+
+   bool priv_open_or_create_name_only( ipcdetail::create_enum_t type
+                           , const char *shmname
+                           , mode_t mode
+                           , std::size_t size);
+   bool priv_open_or_create_name_id( ipcdetail::create_enum_t type
+                           , const char *shmname
+                           , boost::uint8_t id
+                           , mode_t mode
+                           , std::size_t size);
+   xsi_shared_memory m_shm;
+   mode_t            m_mode;
+   std::string       m_name;
+   /// @endcond
+};
+
+template<int Dummy>
+const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::MaxName;
+
+template<int Dummy>
+const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::FirstID;
+
+template<int Dummy>
+const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::LastID;
+
+template<int Dummy>
+const std::size_t xsi_shared_memory_device::info_constants_t<Dummy>::NumID;
+
+/// @cond
+
+inline xsi_shared_memory_device::xsi_shared_memory_device()
+   : m_shm(), m_mode(invalid_mode), m_name()
+{}
+
+inline xsi_shared_memory_device::~xsi_shared_memory_device() 
+{}
+
+inline const char *xsi_shared_memory_device::get_name() const
+{  return m_name.c_str(); }
+
+inline void xsi_shared_memory_device::swap(xsi_shared_memory_device &other)
+{
+   m_shm.swap(other.m_shm);
+   std::swap(m_mode,  other.m_mode);
+   m_name.swap(other.m_name);   
+}
+
+inline mapping_handle_t xsi_shared_memory_device::get_mapping_handle() const
+{  return m_shm.get_mapping_handle();   }
+
+inline mode_t xsi_shared_memory_device::get_mode() const
+{  return m_mode; }
+
+inline int xsi_shared_memory::get_shmid() const
+{  return m_shm.get_shmid(); }
+
+inline void xsi_shared_memory_device::priv_obtain_index
+   (mapped_region &reg, xsi_named_mutex &mut, std::string &path)
+{
+   const char *const filename = "xsi_shm_emulation_file";
+   permissions p;
+   p.set_unrestricted();
+   std::string xsi_shm_emulation_file_path;
+   ipcdetail::create_tmp_and_clean_old_and_get_filename(filename, xsi_shm_emulation_file_path);
+   ipcdetail::create_or_open_file(xsi_shm_emulation_file_path.c_str(), read_write, p);
+   const std::size_t MemSize = sizeof(info_t);
+
+   xsi_shared_memory index_shm(open_or_create, xsi_shm_emulation_file_path.c_str(), 1, MemSize, 0666);
+   mapped_region r(index_shm, read_write, 0, MemSize, 0);
+   xsi_named_mutex m(open_or_create, xsi_shm_emulation_file_path.c_str(), 2, 0666);
+   reg = boost::move(r);
+   mut = boost::move(m);
+   path.swap(xsi_shm_emulation_file_path);
+}
+
+inline bool xsi_shared_memory_device::priv_remove_dead_memory
+   (xsi_shared_memory_device::info_t *info, const char *path)
+{
+   bool removed = false;
+   for(std::size_t i = 0; i != info_constants_t<0>::NumID; ++i){
+      if(info->names[i].buf[0]){
+         try{
+            xsi_shared_memory temp( open_only, path, i+info_constants_t<0>::FirstID, 0600);
+         }
+         catch(interprocess_exception &e){
+               if(e.get_error_code() == not_found_error){
+                  std::memset(info->names[i].buf, 0, info_constants_t<0>::MaxName);
+                  removed = true;
+               }
+         }
+      }
+   }
+   return removed;
+}
+
+inline bool xsi_shared_memory_device::priv_open_or_create_name_id
+   (ipcdetail::create_enum_t type, const char *filepath, mode_t mode, std::size_t size)
+{
+   //Set accesses
+   if (mode != read_write && mode != read_only){
+      error_info err = other_error;
+      throw interprocess_exception(err);
+   }
+
+   int perm = (mode == read_only) ? (0444) : (0666);
+
+   if(type == ipcdetail::DoOpen){
+      if(!found){
+         error_info err = not_found_error;
+         throw interprocess_exception(err);
+      }
+      xsi_shared_memory temp(open_only, filepath, id, perm);
+      m_shm = boost::move(temp);
+   }
+   else if(type == ipcdetail::DoCreate){
+      //Try to reuse slot
+      xsi_shared_memory temp(create_only, filepath, id, size, perm);
+      std::strcpy(info->names[target_entry].buf, shmname);
+      m_shm = boost::move(temp);
+   }
+   else{ // if(type == ipcdetail::DoOpenOrCreate){
+      xsi_shared_memory temp(open_or_create, filepath, id, size, perm);
+      m_shm = boost::move(temp);
+   }
+
+   m_mode = mode;
+   m_name.clear();
+   return true;
+}
+
+inline bool xsi_shared_memory_device::priv_open_or_create_name_only
+   (ipcdetail::create_enum_t type, const char *shmname, mode_t mode, std::size_t size)
+{
+   //Set accesses
+   if (mode != read_write && mode != read_only){
+      error_info err = other_error;
+      throw interprocess_exception(err);
+   }
+
+   if (std::strlen(shmname) >= (info_constants_t<0>::MaxName)){
+      error_info err = other_error;
+      throw interprocess_exception(err);
+   }
+
+   {
+      //Obtain index and index lock
+      mapped_region region;
+      xsi_named_mutex mut;
+      std::string xsi_shm_emulation_file_path;
+      priv_obtain_index(region, mut, xsi_shm_emulation_file_path);
+      info_t *info = static_cast<info_t *>(region.get_address());
+      scoped_lock<xsi_named_mutex> lock(mut);
+
+      //Find the correct entry or the first empty index
+      bool found = false;
+      int target_entry = -1;
+      int tries = 2;
+      while(tries--){
+         for(std::size_t i = 0; i != info_constants_t<0>::NumID; ++i){
+            if(target_entry < 0 && !info->names[i].buf[0]){
+               target_entry = static_cast<int>(i);
+            }
+            else if(0 == std::strcmp(info->names[i].buf, shmname)){
+               found = true;
+               target_entry = static_cast<int>(i);
+               break;
+            }
+         }
+         if(target_entry < 0){
+            if(!tries || !priv_remove_dead_memory(info, xsi_shm_emulation_file_path.c_str())){
+               error_info err = out_of_resource_error;
+               throw interprocess_exception(err);
+            }
+         }
+      }
+      //Now handle the result
+      int perm = (mode == read_only) ? (0444) : (0666);
+      if(type == ipcdetail::DoOpen){
+         if(!found){
+            error_info err = not_found_error;
+            throw interprocess_exception(err);
+         }
+         xsi_shared_memory temp( open_only, xsi_shm_emulation_file_path.c_str()
+                               , target_entry+info_constants_t<0>::FirstID, perm);
+         m_shm = boost::move(temp);
+      }
+      else{
+
+         if(type == ipcdetail::DoCreate){
+            //Try to reuse slot
+            xsi_shared_memory temp( create_only, xsi_shm_emulation_file_path.c_str()
+                                  , target_entry+info_constants_t<0>::FirstID, size, perm);
+            std::strcpy(info->names[target_entry].buf, shmname);
+            m_shm = boost::move(temp);
+         }
+         else{ // if(type == ipcdetail::DoOpenOrCreate){
+            xsi_shared_memory temp( open_or_create, xsi_shm_emulation_file_path.c_str()
+                                  , target_entry+info_constants_t<0>::FirstID, size, perm);
+            if(!found){
+               std::memset(info->names[target_entry].buf, 0, info_constants_t<0>::MaxName);
+               std::strcpy(info->names[target_entry].buf, shmname);
+            }
+            m_shm = boost::move(temp);
+         }
+      }
+   }
+
+   m_mode = mode;
+   m_name = shmname;
+   return true;
+}
+
+inline bool xsi_shared_memory_device::remove(const char *shmname)
+{
+   try{
+      //Obtain index and index lockss
+      mapped_region region;
+      xsi_named_mutex mut;
+      std::string xsi_shm_emulation_file_path;
+      priv_obtain_index(region, mut, xsi_shm_emulation_file_path);
+      scoped_lock<xsi_named_mutex> lock(mut);
+      info_t *info = static_cast<info_t *>(region.get_address());
+
+      //Now check and remove
+      bool removed = false;
+
+      for(std::size_t i = 0; i != info_constants_t<0>::NumID; ++i){
+         if(0 == std::strcmp(info->names[i].buf, name)){
+            xsi_shared_memory temp( open_only, xsi_shm_emulation_file_path.c_str()
+                                  , i+info_constants_t<0>::FirstID);
+            if(!xsi_shared_memory::remove(temp.get_shmid()) && (system_error_code() != invalid_argument)){
+               return false;
+            }
+            std::memset(info->names[i].buf, 0, info_constants_t<0>::MaxName);
+            removed = true;
+            break;
+         }
+      }
+      return removed;
+   }
+   catch(...){
+      return false;
+   }
+}
+
+inline bool xsi_shared_memory_device::remove(int shmid)
+{  return xsi_shared_memory::remove(shmid);  }
+
+///@endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_XSI_SHARED_MEMORY_DEVICE_HPP
diff --git a/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp b/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp
new file mode 100644
index 0000000000..d74d9664a5
--- /dev/null
+++ b/boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp
@@ -0,0 +1,80 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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_XSI_SHARED_MEMORY_FILE_WRAPPER_HPP
+#define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_FILE_WRAPPER_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS)
+#error "This header can't be used in operating systems without XSI (System V) shared memory support"
+#endif
+
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+
+#include <boost/interprocess/xsi_shared_memory.hpp>
+
+//!\file
+//!Describes a class representing a pseudo-file implemented on top of xsi shared memory.
+
+namespace boost {
+namespace interprocess {
+
+class xsi_shared_memory_file_wrapper
+   : public xsi_shared_memory
+{
+   /// @cond
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory_file_wrapper)
+   /// @endcond   
+   public:
+
+   xsi_shared_memory_file_wrapper() : xsi_shared_memory() {}
+
+   xsi_shared_memory_file_wrapper(create_only_t, const xsi_key &key, mode_t mode, std::size_t size, const permissions& perm = permissions())
+      : xsi_shared_memory(create_only_t(), key, size, perm.get_permissions())
+   {}
+
+   xsi_shared_memory_file_wrapper(open_or_create_t, const xsi_key &key, mode_t mode, std::size_t size, const permissions& perm = permissions())
+      : xsi_shared_memory(open_or_create_t(), key, size, perm.get_permissions())
+   {}
+
+   xsi_shared_memory_file_wrapper(open_only_t, const xsi_key &key, mode_t mode, const permissions& perm = permissions())
+      : xsi_shared_memory(open_only_t(), key)
+   {}
+
+   xsi_shared_memory_file_wrapper(BOOST_RV_REF(xsi_shared_memory_file_wrapper) moved)
+   {  this->swap(moved);   }
+
+   xsi_shared_memory_file_wrapper &operator=(BOOST_RV_REF(xsi_shared_memory_file_wrapper) moved)
+   {  
+      xsi_shared_memory_file_wrapper tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps two xsi_shared_memory_file_wrapper. Does not throw
+   void swap(xsi_shared_memory_file_wrapper &other)
+   {  this->xsi_shared_memory::swap(other);  }
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_XSI_SHARED_MEMORY_FILE_WRAPPER_HPP
diff --git a/boost/interprocess/errors.hpp b/boost/interprocess/errors.hpp
new file mode 100644
index 0000000000..e36b8e4e66
--- /dev/null
+++ b/boost/interprocess/errors.hpp
@@ -0,0 +1,236 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+// Parts of this code are taken from boost::filesystem library
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2002 Beman Dawes
+//  Copyright (C) 2001 Dietmar Kuehl 
+//  Use, modification, and distribution is subject to the Boost Software
+//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
+//  at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  See library home page at http://www.boost.org/libs/filesystem
+//
+//////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef BOOST_INTERPROCESS_ERRORS_HPP
+#define BOOST_INTERPROCESS_ERRORS_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 <stdarg.h>
+#include <string>
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+#  include <boost/interprocess/detail/win32_api.hpp>
+#else
+#  ifdef BOOST_HAS_UNISTD_H
+#    include <errno.h>        //Errors
+#    include <cstring>        //strerror
+#  else  //ifdef BOOST_HAS_UNISTD_H
+#    error Unknown platform
+#  endif //ifdef BOOST_HAS_UNISTD_H
+#endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+//!\file
+//!Describes the error numbering of interprocess classes
+
+namespace boost {
+namespace interprocess {
+/// @cond
+inline int system_error_code() // artifact of POSIX and WINDOWS error reporting
+{
+   #if (defined BOOST_INTERPROCESS_WINDOWS)
+   return winapi::get_last_error();
+   #else
+   return errno; // GCC 3.1 won't accept ::errno
+   #endif
+}
+
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+inline void fill_system_message(int sys_err_code, std::string &str)
+{
+   void *lpMsgBuf;
+   winapi::format_message( 
+      winapi::format_message_allocate_buffer | 
+      winapi::format_message_from_system | 
+      winapi::format_message_ignore_inserts,
+      0,
+      sys_err_code,
+      winapi::make_lang_id(winapi::lang_neutral, winapi::sublang_default), // Default language
+      reinterpret_cast<char *>(&lpMsgBuf),
+      0,
+      0 
+   );
+   str += static_cast<const char*>(lpMsgBuf);
+   winapi::local_free( lpMsgBuf ); // free the buffer
+   while ( str.size()
+      && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
+      str.erase( str.size()-1 );
+}
+# else
+inline void fill_system_message( int system_error, std::string &str)
+{  str = std::strerror(system_error);  }
+# endif
+/// @endcond
+
+enum error_code_t
+{
+   no_error = 0,
+   system_error,     // system generated error; if possible, is translated
+                     // to one of the more specific errors below.
+   other_error,      // library generated error
+   security_error,   // includes access rights, permissions failures
+   read_only_error,
+   io_error,
+   path_error,
+   not_found_error,
+//   not_directory_error,
+   busy_error,       // implies trying again might succeed
+   already_exists_error,
+   not_empty_error,
+   is_directory_error,
+   out_of_space_error,
+   out_of_memory_error,
+   out_of_resource_error,
+   lock_error,
+   sem_error,
+   mode_error,
+   size_error,
+   corrupted_error,
+   not_such_file_or_directory,
+   invalid_argument,
+   timeout_when_locking_error,
+   timeout_when_waiting_error,
+};
+
+typedef int    native_error_t;
+
+/// @cond
+struct ec_xlate
+{
+   native_error_t sys_ec;
+   error_code_t   ec; 
+};
+
+static const ec_xlate ec_table[] =
+{
+   #if (defined BOOST_INTERPROCESS_WINDOWS)
+   { /*ERROR_ACCESS_DENIED*/5L, security_error },
+   { /*ERROR_INVALID_ACCESS*/12L, security_error },
+   { /*ERROR_SHARING_VIOLATION*/32L, security_error },
+   { /*ERROR_LOCK_VIOLATION*/33L, security_error },
+   { /*ERROR_LOCKED*/212L, security_error },
+   { /*ERROR_NOACCESS*/998L, security_error },
+   { /*ERROR_WRITE_PROTECT*/19L, read_only_error },
+   { /*ERROR_NOT_READY*/21L, io_error },
+   { /*ERROR_SEEK*/25L, io_error },
+   { /*ERROR_READ_FAULT*/30L, io_error },
+   { /*ERROR_WRITE_FAULT*/29L, io_error },
+   { /*ERROR_CANTOPEN*/1011L, io_error },
+   { /*ERROR_CANTREAD*/1012L, io_error },
+   { /*ERROR_CANTWRITE*/1013L, io_error },
+   { /*ERROR_DIRECTORY*/267L, path_error },
+   { /*ERROR_INVALID_NAME*/123L, path_error },
+   { /*ERROR_FILE_NOT_FOUND*/2L, not_found_error },
+   { /*ERROR_PATH_NOT_FOUND*/3L, not_found_error },
+   { /*ERROR_DEV_NOT_EXIST*/55L, not_found_error },
+   { /*ERROR_DEVICE_IN_USE*/2404L, busy_error },
+   { /*ERROR_OPEN_FILES*/2401L, busy_error },
+   { /*ERROR_BUSY_DRIVE*/142L, busy_error },
+   { /*ERROR_BUSY*/170L, busy_error },
+   { /*ERROR_FILE_EXISTS*/80L, already_exists_error },
+   { /*ERROR_ALREADY_EXISTS*/183L, already_exists_error },
+   { /*ERROR_DIR_NOT_EMPTY*/145L, not_empty_error },
+   { /*ERROR_HANDLE_DISK_FULL*/39L, out_of_space_error },
+   { /*ERROR_DISK_FULL*/112L, out_of_space_error },
+   { /*ERROR_OUTOFMEMORY*/14L, out_of_memory_error },
+   { /*ERROR_NOT_ENOUGH_MEMORY*/8L, out_of_memory_error },
+   { /*ERROR_TOO_MANY_OPEN_FILES*/4L, out_of_resource_error },
+   { /*ERROR_INVALID_ADDRESS*/487L, busy_error }
+   #else    //#if (defined BOOST_INTERPROCESS_WINDOWS)
+   { EACCES, security_error },
+   { EROFS, read_only_error },
+   { EIO, io_error },
+   { ENAMETOOLONG, path_error },
+   { ENOENT, not_found_error },
+   //    { ENOTDIR, not_directory_error },
+   { EAGAIN, busy_error },
+   { EBUSY, busy_error },
+   { ETXTBSY, busy_error },
+   { EEXIST, already_exists_error },
+   { ENOTEMPTY, not_empty_error },
+   { EISDIR, is_directory_error },
+   { ENOSPC, out_of_space_error },
+   { ENOMEM, out_of_memory_error },
+   { EMFILE, out_of_resource_error },
+   { ENOENT, not_such_file_or_directory },
+   { EINVAL, invalid_argument }
+   #endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
+};
+
+inline error_code_t lookup_error(native_error_t err)
+{  
+   const ec_xlate *cur  = &ec_table[0],
+                  *end  = cur + sizeof(ec_table)/sizeof(ec_xlate); 
+   for  (;cur != end; ++cur ){
+      if ( err == cur->sys_ec ) return cur->ec;
+   }
+   return system_error; // general system error code
+}
+
+struct error_info
+{
+   error_info(error_code_t ec = other_error )
+      :  m_nat(0), m_ec(ec)
+   {}
+
+   error_info(native_error_t sys_err_code)
+      :  m_nat(sys_err_code), m_ec(lookup_error(sys_err_code))
+   {}
+
+   error_info & operator =(error_code_t ec)
+   {
+      m_nat = 0;
+      m_ec = ec;
+      return *this;
+   }
+
+   error_info & operator =(native_error_t sys_err_code)
+   {
+      m_nat = sys_err_code;
+      m_ec = lookup_error(sys_err_code);
+      return *this;
+   }
+
+   native_error_t get_native_error()const
+   {  return m_nat;  }
+
+   error_code_t   get_error_code()const
+   {  return m_ec;  }
+
+   private:
+   native_error_t m_nat;
+   error_code_t   m_ec;
+};
+/// @endcond
+
+}  // namespace interprocess {
+}  // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_ERRORS_HPP
diff --git a/boost/interprocess/exceptions.hpp b/boost/interprocess/exceptions.hpp
new file mode 100644
index 0000000000..a4f196f0be
--- /dev/null
+++ b/boost/interprocess/exceptions.hpp
@@ -0,0 +1,150 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_EXCEPTIONS_HPP
+#define BOOST_INTERPROCESS_EXCEPTIONS_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/interprocess/errors.hpp>
+#include <stdexcept>
+#include <new>
+
+//!\file
+//!Describes exceptions thrown by interprocess classes
+
+namespace boost {
+
+namespace interprocess {
+
+//!This class is the base class of all exceptions
+//!thrown by boost::interprocess
+class interprocess_exception : public std::exception
+{
+   public:
+   interprocess_exception(const char *err/*error_code_t ec = other_error*/)
+      :  m_err(other_error)
+   {
+//      try   {  m_str = "boost::interprocess_exception::library_error"; }
+      try   {  m_str = err; }
+      catch (...) {}
+   }
+/*
+   interprocess_exception(native_error_t sys_err_code)
+      :  m_err(sys_err_code)
+   {
+      try   {  fill_system_message(m_err.get_native_error(), m_str); }
+      catch (...) {}
+   }*/
+
+   interprocess_exception(const error_info &err_info, const char *str = 0)
+      :  m_err(err_info)
+   {
+      try{
+         if(m_err.get_native_error() != 0){
+            fill_system_message(m_err.get_native_error(), m_str);
+         }
+         else if(str){
+            m_str = str;
+         }
+         else{
+            m_str = "boost::interprocess_exception::library_error";
+         }
+      }
+      catch(...){}
+   }
+
+   virtual ~interprocess_exception() throw(){}
+
+   virtual const char * what() const throw()
+   {  return m_str.c_str();  }
+
+   native_error_t get_native_error()const { return m_err.get_native_error(); }
+
+   // Note: a value of other_error implies a library (rather than system) error
+   error_code_t   get_error_code()  const { return m_err.get_error_code(); }
+
+   /// @cond
+   private:
+   error_info        m_err;
+   std::string       m_str;
+   /// @endcond
+};
+
+//!This is the exception thrown by shared interprocess_mutex family when a deadlock situation
+//!is detected or when using a interprocess_condition the interprocess_mutex is not locked
+class lock_exception : public interprocess_exception
+{
+   public:
+   lock_exception()
+      :  interprocess_exception(lock_error)
+   {}
+
+   virtual const char* what() const throw()
+   {  return "boost::interprocess::lock_exception";  }
+};
+
+//!This is the exception thrown by named interprocess_semaphore when a deadlock situation
+//!is detected or when an error is detected in the post/wait operation
+/*
+class sem_exception : public interprocess_exception
+{
+   public:
+   sem_exception()
+      :  interprocess_exception(lock_error)
+   {}
+
+   virtual const char* what() const throw()
+   {  return "boost::interprocess::sem_exception";  }
+};
+*/
+//!This is the exception thrown by synchronization objects when there is
+//!an error in a wait() function
+/*
+class wait_exception : public interprocess_exception
+{
+   public:
+   virtual const char* what() const throw()
+   {  return "boost::interprocess::wait_exception";  }
+};
+*/
+
+//!This exception is thrown when a named object is created
+//!in "open_only" mode and the resource was not already created
+/*
+class not_previously_created : public interprocess_exception
+{
+ public:
+    virtual const char* what() const throw()
+      {  return "boost::interprocess::not_previously_created";  }
+};
+*/
+
+//!This exception is thrown when a memory request can't be
+//!fulfilled.
+class bad_alloc : public interprocess_exception
+{
+ public:
+   bad_alloc() : interprocess_exception("::boost::interprocess::bad_alloc"){}
+   virtual const char* what() const throw()
+      {  return "boost::interprocess::bad_alloc";  }
+};
+
+}  // namespace interprocess {
+
+}  // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_EXCEPTIONS_HPP
diff --git a/boost/interprocess/file_mapping.hpp b/boost/interprocess/file_mapping.hpp
new file mode 100644
index 0000000000..3bad98fca1
--- /dev/null
+++ b/boost/interprocess/file_mapping.hpp
@@ -0,0 +1,184 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_FILE_MAPPING_HPP
+#define BOOST_INTERPROCESS_FILE_MAPPING_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/move/move.hpp>
+#include <string>    //std::string
+
+//!\file
+//!Describes file_mapping and mapped region classes
+
+namespace boost {
+namespace interprocess {
+
+//!A class that wraps a file-mapping that can be used to
+//!create mapped regions from the mapped files
+class file_mapping
+{
+   /// @cond
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(file_mapping)
+   /// @endcond
+
+   public:
+   //!Constructs an empty file mapping.
+   //!Does not throw
+   file_mapping();
+
+   //!Opens a file mapping of file "filename", starting in offset 
+   //!"file_offset", and the mapping's size will be "size". The mapping 
+   //!can be opened for read-only "read_only" or read-write "read_write"
+   //!modes. Throws interprocess_exception on error.
+   file_mapping(const char *filename, mode_t mode);
+
+   //!Moves the ownership of "moved"'s file mapping object to *this. 
+   //!After the call, "moved" does not represent any file mapping object. 
+   //!Does not throw
+   file_mapping(BOOST_RV_REF(file_mapping) moved)
+      :  m_handle(file_handle_t(ipcdetail::invalid_file()))
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s file mapping to *this.
+   //!After the call, "moved" does not represent any file mapping. 
+   //!Does not throw
+   file_mapping &operator=(BOOST_RV_REF(file_mapping) moved)
+   {
+      file_mapping tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps to file_mappings.
+   //!Does not throw.
+   void swap(file_mapping &other);
+
+   //!Returns access mode
+   //!used in the constructor
+   mode_t get_mode() const;
+
+   //!Obtains the mapping handle
+   //!to be used with mapped_region
+   mapping_handle_t get_mapping_handle() const;
+
+   //!Destroys the file mapping. All mapped regions created from this are still
+   //!valid. Does not throw
+   ~file_mapping();
+
+   //!Returns the name of the file
+   //!used in the constructor.
+   const char *get_name() const;
+
+   //!Removes the file named "filename" even if it's been memory mapped.
+   //!Returns true on success.
+   //!The function might fail in some operating systems if the file is
+   //!being used other processes and no deletion permission was shared.
+   static bool remove(const char *filename);
+
+   /// @cond
+   private:
+   //!Closes a previously opened file mapping. Never throws.
+   void priv_close();
+   file_handle_t  m_handle;
+   mode_t    m_mode;
+   std::string       m_filename;
+   /// @endcond
+};
+
+inline file_mapping::file_mapping() 
+   :  m_handle(file_handle_t(ipcdetail::invalid_file()))
+{}
+
+inline file_mapping::~file_mapping() 
+{  this->priv_close(); }
+
+inline const char *file_mapping::get_name() const
+{  return m_filename.c_str(); }
+
+inline void file_mapping::swap(file_mapping &other)
+{  
+   std::swap(m_handle, other.m_handle);
+   std::swap(m_mode, other.m_mode);
+   m_filename.swap(other.m_filename);   
+}
+
+inline mapping_handle_t file_mapping::get_mapping_handle() const
+{  return ipcdetail::mapping_handle_from_file_handle(m_handle);  }
+
+inline mode_t file_mapping::get_mode() const
+{  return m_mode; }
+
+inline file_mapping::file_mapping
+   (const char *filename, mode_t mode)
+   :  m_filename(filename)
+{
+   //Check accesses
+   if (mode != read_write && mode != read_only){
+      error_info err = other_error;
+      throw interprocess_exception(err);
+   }
+
+   //Open file
+   m_handle = ipcdetail::open_existing_file(filename, mode);
+
+   //Check for error
+   if(m_handle == ipcdetail::invalid_file()){
+      error_info err = system_error_code();
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+   m_mode = mode;
+}
+
+inline bool file_mapping::remove(const char *filename)
+{  return ipcdetail::delete_file(filename);  }
+
+///@cond
+
+inline void file_mapping::priv_close()
+{
+   if(m_handle != ipcdetail::invalid_file()){
+      ipcdetail::close_file(m_handle);
+      m_handle = ipcdetail::invalid_file();
+   }
+}
+
+///@endcond
+
+//!A class that stores the name of a file
+//!and tries to remove it in its destructor
+//!Useful to remove temporary files in the presence
+//!of exceptions
+class remove_file_on_destroy
+{
+   const char * m_name;
+   public:
+   remove_file_on_destroy(const char *name)
+      :  m_name(name)
+   {}
+
+   ~remove_file_on_destroy()
+   {  ipcdetail::delete_file(m_name);  }
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_FILE_MAPPING_HPP
diff --git a/boost/interprocess/indexes/flat_map_index.hpp b/boost/interprocess/indexes/flat_map_index.hpp
new file mode 100644
index 0000000000..bac387e268
--- /dev/null
+++ b/boost/interprocess/indexes/flat_map_index.hpp
@@ -0,0 +1,78 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_FLAT_MAP_INDEX_HPP
+#define BOOST_INTERPROCESS_FLAT_MAP_INDEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <functional>
+#include <utility>
+#include <boost/interprocess/containers/flat_map.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+//!\file
+//!Describes index adaptor of boost::map container, to use it
+//!as name/shared memory index
+
+//[flat_map_index
+namespace boost { namespace interprocess {
+
+//!Helper class to define typedefs from IndexTraits
+template <class MapConfig>
+struct flat_map_index_aux
+{
+   typedef typename MapConfig::key_type            key_type;
+   typedef typename MapConfig::mapped_type         mapped_type;
+   typedef typename MapConfig::
+      segment_manager_base                   segment_manager_base;
+   typedef std::less<key_type>                     key_less;
+   typedef std::pair<key_type, mapped_type>        value_type;
+   typedef allocator<value_type
+                    ,segment_manager_base>   allocator_type;
+   typedef flat_map<key_type,  mapped_type,
+                    key_less, allocator_type>      index_t;
+};
+
+//!Index type based in flat_map. Just derives from flat_map and
+//!defines the interface needed by managed memory segments.
+template <class MapConfig>
+class flat_map_index
+   //Derive class from flat_map specialization
+   : public flat_map_index_aux<MapConfig>::index_t
+{
+   /// @cond
+   typedef flat_map_index_aux<MapConfig>  index_aux;
+   typedef typename index_aux::index_t    base_type;
+   typedef typename index_aux::
+      segment_manager_base          segment_manager_base;
+   /// @endcond
+
+   public:
+   //!Constructor. Takes a pointer to the segment manager. Can throw
+   flat_map_index(segment_manager_base *segment_mngr)
+      : base_type(typename index_aux::key_less(),
+                  typename index_aux::allocator_type(segment_mngr))
+   {}
+
+   //!This reserves memory to optimize the insertion of n elements in the index
+   void reserve(typename segment_manager_base::size_type n)
+   {  base_type::reserve(n);  }
+
+   //!This frees all unnecessary memory
+   void shrink_to_fit()
+   {  base_type::shrink_to_fit();   }
+};
+
+}}   //namespace boost { namespace interprocess
+//]
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_FLAT_MAP_INDEX_HPP
diff --git a/boost/interprocess/indexes/iset_index.hpp b/boost/interprocess/indexes/iset_index.hpp
new file mode 100644
index 0000000000..966239290a
--- /dev/null
+++ b/boost/interprocess/indexes/iset_index.hpp
@@ -0,0 +1,150 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_ISET_INDEX_HPP
+#define BOOST_INTERPROCESS_ISET_INDEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <string>
+#include <functional>
+#include <utility>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/intrusive/set.hpp>
+
+
+//!\file
+//!Describes index adaptor of boost::intrusive::set container, to use it
+//!as name/shared memory index
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+//!Helper class to define typedefs from IndexTraits
+template <class MapConfig>
+struct iset_index_aux
+{
+   typedef typename 
+      MapConfig::segment_manager_base                          segment_manager_base;
+
+   typedef typename 
+      segment_manager_base::void_pointer                       void_pointer;
+   typedef typename bi::make_set_base_hook
+      < bi::void_pointer<void_pointer>
+      , bi::optimize_size<true>
+      >::type                                                  derivation_hook;
+
+   typedef typename MapConfig::template 
+      intrusive_value_type<derivation_hook>::type              value_type;
+   typedef std::less<value_type>                               value_compare;
+   typedef typename bi::make_set
+      < value_type
+      , bi::base_hook<derivation_hook>
+      >::type                                                  index_t;
+};
+/// @endcond
+
+//!Index type based in boost::intrusive::set.
+//!Just derives from boost::intrusive::set
+//!and defines the interface needed by managed memory segments*/
+template <class MapConfig>
+class iset_index
+   //Derive class from map specialization
+   :  public iset_index_aux<MapConfig>::index_t
+{
+   /// @cond
+   typedef iset_index_aux<MapConfig>                     index_aux;
+   typedef typename index_aux::index_t                   index_type;
+   typedef typename MapConfig::
+      intrusive_compare_key_type                         intrusive_compare_key_type;
+   typedef typename MapConfig::char_type                 char_type;
+   /// @endcond
+
+   public:
+   typedef typename index_type::iterator                 iterator;
+   typedef typename index_type::const_iterator           const_iterator;
+   typedef typename index_type::insert_commit_data       insert_commit_data;
+   typedef typename index_type::value_type               value_type;
+
+   /// @cond
+   private:
+
+   struct intrusive_key_value_less
+   {
+      bool operator()(const intrusive_compare_key_type &i, const value_type &b) const
+      {  
+         std::size_t blen = b.name_length();
+         return (i.m_len < blen) || 
+                  (i.m_len == blen && 
+                  std::char_traits<char_type>::compare 
+                     (i.mp_str, b.name(), i.m_len) < 0);
+      }
+
+      bool operator()(const value_type &b, const intrusive_compare_key_type &i) const
+      {  
+         std::size_t blen = b.name_length();
+         return (blen < i.m_len) || 
+                  (blen == i.m_len &&
+                  std::char_traits<char_type>::compare 
+                     (b.name(), i.mp_str, i.m_len) < 0);
+      }
+   };
+
+   /// @endcond
+
+   public:
+
+   //!Constructor. Takes a pointer to the
+   //!segment manager. Can throw
+   iset_index(typename MapConfig::segment_manager_base *)
+      : index_type(/*typename index_aux::value_compare()*/)
+   {}
+
+   //!This reserves memory to optimize the insertion of n
+   //!elements in the index
+   void reserve(typename MapConfig::segment_manager_base::size_type)
+   {  /*Does nothing, map has not reserve or rehash*/  }
+
+   //!This frees all unnecessary memory
+   void shrink_to_fit()
+   {  /*Does nothing, this intrusive index does not allocate memory;*/   }
+
+   iterator find(const intrusive_compare_key_type &key)
+   {  return index_type::find(key, intrusive_key_value_less());  }
+
+   const_iterator find(const intrusive_compare_key_type &key) const
+   {  return index_type::find(key, intrusive_key_value_less());  }
+
+   std::pair<iterator, bool>insert_check
+      (const intrusive_compare_key_type &key, insert_commit_data &commit_data)
+   {  return index_type::insert_check(key, intrusive_key_value_less(), commit_data); }
+};
+
+/// @cond
+
+//!Trait class to detect if an index is an intrusive
+//!index.
+template<class MapConfig>
+struct is_intrusive_index
+   <boost::interprocess::iset_index<MapConfig> >
+{
+   static const bool value = true;
+};
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost 
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_ISET_INDEX_HPP
diff --git a/boost/interprocess/indexes/iunordered_set_index.hpp b/boost/interprocess/indexes/iunordered_set_index.hpp
new file mode 100644
index 0000000000..ef1ae79d3b
--- /dev/null
+++ b/boost/interprocess/indexes/iunordered_set_index.hpp
@@ -0,0 +1,368 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_IUNORDERED_SET_INDEX_HPP
+#define BOOST_INTERPROCESS_IUNORDERED_SET_INDEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <functional>
+#include <utility>
+
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/containers/vector.hpp>
+#include <boost/intrusive/unordered_set.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+
+//!\file
+//!Describes index adaptor of boost::intrusive::unordered_set container, to use it
+//!as name/shared memory index
+
+namespace boost { namespace interprocess {
+
+/// @cond
+
+//!Helper class to define typedefs
+//!from IndexTraits
+template <class MapConfig>
+struct iunordered_set_index_aux
+{
+   typedef typename 
+      MapConfig::segment_manager_base                 segment_manager_base;
+
+   typedef typename 
+      segment_manager_base::void_pointer              void_pointer;
+
+   typedef typename bi::make_unordered_set_base_hook
+      < bi::void_pointer<void_pointer>
+      >::type        derivation_hook;
+
+   typedef typename MapConfig::template 
+      intrusive_value_type<derivation_hook>::type     value_type;
+
+   typedef typename MapConfig::
+      intrusive_compare_key_type                      intrusive_compare_key_type;
+
+   typedef std::equal_to<value_type>                  value_equal;
+
+   typedef typename MapConfig::char_type              char_type;
+
+   struct equal_function
+   {
+      bool operator()(const intrusive_compare_key_type &i, const value_type &b) const
+      {  
+         return (i.m_len == b.name_length()) &&
+                  (std::char_traits<char_type>::compare 
+                     (i.mp_str, b.name(), i.m_len) == 0);
+      }
+
+      bool operator()(const value_type &b, const intrusive_compare_key_type &i) const
+      {  
+         return (i.m_len == b.name_length()) &&
+                  (std::char_traits<char_type>::compare 
+                     (i.mp_str, b.name(), i.m_len) == 0);
+      }
+
+      bool operator()(const value_type &b1, const value_type &b2) const
+      {  
+         return (b1.name_length() == b2.name_length()) &&
+                  (std::char_traits<char_type>::compare 
+                     (b1.name(), b2.name(), b1.name_length()) == 0);
+      }
+   };
+
+    struct hash_function
+      : std::unary_function<value_type, std::size_t>
+    {
+        std::size_t operator()(const value_type &val) const
+        {
+            const char_type *beg = ipcdetail::to_raw_pointer(val.name()),
+                            *end = beg + val.name_length();
+            return boost::hash_range(beg, end);
+        }
+
+        std::size_t operator()(const intrusive_compare_key_type &i) const
+        {
+            const char_type *beg = i.mp_str,
+                            *end = beg + i.m_len;
+            return boost::hash_range(beg, end);
+        }
+    };
+
+   typedef typename bi::make_unordered_set
+      < value_type
+      , bi::hash<hash_function>
+      , bi::equal<equal_function>
+     , bi::size_type<typename segment_manager_base::size_type>
+      >::type                                         index_t;
+   typedef typename index_t::bucket_type              bucket_type;
+   typedef allocator
+      <bucket_type, segment_manager_base>             allocator_type;
+
+   struct allocator_holder
+   {
+      allocator_holder(segment_manager_base *mngr)
+         :  alloc(mngr)
+      {}
+      allocator_type alloc;
+      bucket_type init_bucket;
+   };
+};
+/// @endcond
+
+//!Index type based in boost::intrusive::set.
+//!Just derives from boost::intrusive::set 
+//!and defines the interface needed by managed memory segments
+template <class MapConfig>
+class iunordered_set_index
+      //Derive class from map specialization
+   :  private iunordered_set_index_aux<MapConfig>::allocator_holder
+   ,  public iunordered_set_index_aux<MapConfig>::index_t
+{
+   /// @cond
+   typedef iunordered_set_index_aux<MapConfig>           index_aux;
+   typedef typename index_aux::index_t                   index_type;
+   typedef typename MapConfig::
+      intrusive_compare_key_type                         intrusive_compare_key_type;
+   typedef typename index_aux::equal_function            equal_function;
+   typedef typename index_aux::hash_function             hash_function;
+   typedef typename MapConfig::char_type                 char_type;
+   typedef typename 
+      iunordered_set_index_aux<MapConfig>::allocator_type      allocator_type;
+   typedef typename 
+      iunordered_set_index_aux<MapConfig>::allocator_holder    allocator_holder;
+   /// @endcond
+
+   public:
+   typedef typename index_type::iterator                 iterator;
+   typedef typename index_type::const_iterator           const_iterator;
+   typedef typename index_type::insert_commit_data       insert_commit_data;
+   typedef typename index_type::value_type               value_type;
+   typedef typename index_type::bucket_ptr               bucket_ptr;
+   typedef typename index_type::bucket_type              bucket_type;
+   typedef typename index_type::bucket_traits            bucket_traits;
+   typedef typename index_type::size_type                size_type;
+
+   /// @cond
+   private:
+   typedef typename index_aux::
+      segment_manager_base             segment_manager_base;
+
+   static const std::size_t InitBufferSize = 64;
+
+   static bucket_ptr create_buckets(allocator_type &alloc, size_type num)
+   {
+      num = index_type::suggested_upper_bucket_count(num);
+      bucket_ptr buckets = alloc.allocate(num);
+      bucket_ptr buckets_init = buckets;
+      for(size_type i = 0; i < num; ++i){
+         new(to_raw_pointer(buckets_init++))bucket_type();
+      }
+      return buckets;
+   }
+
+   static size_type shrink_buckets
+      ( bucket_ptr buckets, size_type old_size
+      , allocator_type &alloc, size_type new_size)
+   {
+      if(old_size <= new_size )
+         return old_size;
+      size_type received_size;
+      if(!alloc.allocation_command
+         (boost::interprocess::try_shrink_in_place | boost::interprocess::nothrow_allocation, old_size, new_size, received_size, buckets).first){
+         return old_size;
+      }
+
+      for( bucket_type *p = ipcdetail::to_raw_pointer(buckets) + received_size
+         , *pend = ipcdetail::to_raw_pointer(buckets) + old_size
+         ; p != pend
+         ; ++p){
+         p->~bucket_type();
+      }
+
+      bucket_ptr shunk_p = alloc.allocation_command
+         (boost::interprocess::shrink_in_place | boost::interprocess::nothrow_allocation, received_size, received_size, received_size, buckets).first;
+      BOOST_ASSERT(buckets == shunk_p);
+
+      bucket_ptr buckets_init = buckets + received_size;
+      for(size_type i = 0; i < (old_size - received_size); ++i){
+         to_raw_pointer(buckets_init++)->~bucket_type();
+      }
+      return received_size;
+   }
+
+   static bucket_ptr expand_or_create_buckets
+      ( bucket_ptr old_buckets, const size_type old_num
+      , allocator_type &alloc,  const size_type new_num)
+   {
+      size_type received_size;
+      std::pair<bucket_ptr, bool> ret =
+         alloc.allocation_command
+            (boost::interprocess::expand_fwd | boost::interprocess::allocate_new, new_num, new_num, received_size, old_buckets);
+      if(ret.first == old_buckets){
+         bucket_ptr buckets_init = old_buckets + old_num;
+         for(size_type i = 0; i < (new_num - old_num); ++i){
+            new(to_raw_pointer(buckets_init++))bucket_type();
+         }
+      }
+      else{
+         bucket_ptr buckets_init = ret.first;
+         for(size_type i = 0; i < new_num; ++i){
+            new(to_raw_pointer(buckets_init++))bucket_type();
+         }
+      }
+
+      return ret.first;
+   }
+
+   static void destroy_buckets
+      (allocator_type &alloc, bucket_ptr buckets, size_type num)
+   {
+      bucket_ptr buckets_destroy = buckets;
+      for(size_type i = 0; i < num; ++i){
+         to_raw_pointer(buckets_destroy++)->~bucket_type();
+      }
+      alloc.deallocate(buckets, num);
+   }
+
+   iunordered_set_index<MapConfig>* get_this_pointer()
+   {  return this;   }
+
+   /// @endcond
+
+   public:
+   //!Constructor. Takes a pointer to the
+   //!segment manager. Can throw
+   iunordered_set_index(segment_manager_base *mngr)
+      :  allocator_holder(mngr)
+      ,  index_type(bucket_traits(&get_this_pointer()->init_bucket, 1))
+   {}
+
+   ~iunordered_set_index()
+   {
+      index_type::clear();
+      if(index_type::bucket_pointer() != bucket_ptr(&this->init_bucket)){
+         destroy_buckets(this->alloc, index_type::bucket_pointer(), index_type::bucket_count());
+      }
+   }
+
+   //!This reserves memory to optimize the insertion of n
+   //!elements in the index
+   void reserve(size_type new_n)
+   {
+      //Let's maintain a 1.0f load factor
+      size_type old_n  = this->bucket_count();
+      if(new_n <= old_n)
+         return;
+      bucket_ptr old_p = this->bucket_pointer();
+      new_n = index_type::suggested_upper_bucket_count(new_n);
+      bucket_ptr new_p;
+      //This can throw
+      try{
+         if(old_p != bucket_ptr(&this->init_bucket))
+            new_p = expand_or_create_buckets(old_p, old_n, this->alloc, new_n);
+         else
+            new_p = create_buckets(this->alloc, new_n);
+      }
+      catch(...){
+         return;
+      }
+      //Rehashing does not throw, since neither the hash nor the
+      //comparison function can throw
+      this->rehash(bucket_traits(new_p, new_n));
+      if(new_p != old_p && old_p != bucket_ptr(&this->init_bucket)){
+         destroy_buckets(this->alloc, old_p, old_n);
+      }
+   }
+
+   //!This tries to free unused memory
+   //!previously allocated.
+   void shrink_to_fit()
+   {
+      size_type cur_size   = this->size();
+      size_type cur_count  = this->bucket_count();
+      bucket_ptr old_p = this->bucket_pointer();
+      
+      if(!this->size() && old_p != bucket_ptr(&this->init_bucket)){
+         this->rehash(bucket_traits(bucket_ptr(&this->init_bucket), 1));
+         destroy_buckets(this->alloc, old_p, cur_count);
+      }
+      else{
+         size_type sug_count = 0; //gcc warning
+         sug_count = index_type::suggested_upper_bucket_count(cur_size);
+
+         if(sug_count >= cur_count)
+            return;
+
+         try{
+            shrink_buckets(old_p, cur_count, this->alloc, sug_count);
+         }
+         catch(...){
+            return;
+         }
+
+         //Rehashing does not throw, since neither the hash nor the
+         //comparison function can throw
+         this->rehash(bucket_traits(old_p, sug_count));
+      }
+   }
+
+   iterator find(const intrusive_compare_key_type &key)
+   {  return index_type::find(key, hash_function(), equal_function());  }
+
+   const_iterator find(const intrusive_compare_key_type &key) const
+   {  return index_type::find(key, hash_function(), equal_function());  }
+
+   std::pair<iterator, bool>insert_check
+      (const intrusive_compare_key_type &key, insert_commit_data &commit_data)
+   {  return index_type::insert_check(key, hash_function(), equal_function(), commit_data); }
+
+   iterator insert_commit(value_type &val, insert_commit_data &commit_data)
+   {
+      iterator it = index_type::insert_commit(val, commit_data);
+      size_type cur_size      = this->size();
+      if(cur_size > this->bucket_count()){
+         try{
+            this->reserve(cur_size);
+         }
+         catch(...){
+            //Strong guarantee: if something goes wrong
+            //we should remove the insertion.
+            //
+            //We can use the iterator because the hash function   
+            //can't throw and this means that "reserve" will
+            //throw only because of the memory allocation:
+            //the iterator has not been invalidated.
+            index_type::erase(it);
+            throw;
+         }
+      }
+      return it;
+   }
+};
+
+/// @cond
+
+//!Trait class to detect if an index is an intrusive
+//!index
+template<class MapConfig>
+struct is_intrusive_index
+   <boost::interprocess::iunordered_set_index<MapConfig> >
+{
+   static const bool value = true;
+};
+/// @endcond
+
+}}   //namespace boost { namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_IUNORDERED_SET_INDEX_HPP
diff --git a/boost/interprocess/indexes/map_index.hpp b/boost/interprocess/indexes/map_index.hpp
new file mode 100644
index 0000000000..ffea73e8d9
--- /dev/null
+++ b/boost/interprocess/indexes/map_index.hpp
@@ -0,0 +1,100 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MAP_INDEX_HPP
+#define BOOST_INTERPROCESS_MAP_INDEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <functional>
+#include <utility>
+#include <boost/interprocess/containers/map.hpp>
+#include <boost/interprocess/allocators/private_adaptive_pool.hpp>
+
+//!\file
+//!Describes index adaptor of boost::map container, to use it
+//!as name/shared memory index
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+//!Helper class to define typedefs from IndexTraits
+template <class MapConfig>
+struct map_index_aux
+{
+   typedef typename MapConfig::key_type            key_type;
+   typedef typename MapConfig::mapped_type         mapped_type;
+   typedef std::less<key_type>                     key_less;
+   typedef std::pair<const key_type, mapped_type>  value_type;
+
+   typedef private_adaptive_pool
+            <value_type,
+               typename MapConfig::
+         segment_manager_base>                     allocator_type;
+
+   typedef boost::interprocess::map
+      <key_type,  mapped_type,
+       key_less, allocator_type>                   index_t;
+};
+
+}  //namespace ipcdetail {
+
+//!Index type based in boost::interprocess::map. Just derives from boost::interprocess::map 
+//!and defines the interface needed by managed memory segments
+template <class MapConfig>
+class map_index
+   //Derive class from map specialization
+   : public ipcdetail::map_index_aux<MapConfig>::index_t
+{
+   /// @cond
+   typedef ipcdetail::map_index_aux<MapConfig>  index_aux;
+   typedef typename index_aux::index_t       base_type;
+   typedef typename MapConfig::
+      segment_manager_base          segment_manager_base;
+   /// @endcond
+
+   public:
+   //!Constructor. Takes a pointer to the
+   //!segment manager. Can throw
+   map_index(segment_manager_base *segment_mngr)
+      : base_type(typename index_aux::key_less(),
+                  segment_mngr){}
+
+   //!This reserves memory to optimize the insertion of n
+   //!elements in the index
+   void reserve(typename segment_manager_base::size_type)
+      {  /*Does nothing, map has not reserve or rehash*/  }
+
+   //!This tries to free previously allocate
+   //!unused memory.
+   void shrink_to_fit()
+   {  base_type::get_stored_allocator().deallocate_free_blocks(); }
+};
+
+/// @cond
+
+//!Trait class to detect if an index is a node
+//!index. This allows more efficient operations
+//!when deallocating named objects.
+template<class MapConfig>
+struct is_node_index
+   <boost::interprocess::map_index<MapConfig> >
+{
+   static const bool value = true;
+};
+/// @endcond
+
+}}   //namespace boost { namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MAP_INDEX_HPP
diff --git a/boost/interprocess/indexes/null_index.hpp b/boost/interprocess/indexes/null_index.hpp
new file mode 100644
index 0000000000..81c88be79b
--- /dev/null
+++ b/boost/interprocess/indexes/null_index.hpp
@@ -0,0 +1,68 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NULL_INDEX_HPP
+#define BOOST_INTERPROCESS_NULL_INDEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/offset_ptr.hpp>
+
+//!\file
+//!Describes a null index adaptor, so that if we don't want to construct 
+//!named objects, we can use this null index type to save resources.
+
+namespace boost {
+namespace interprocess {
+
+//!Null index type
+//!used to save compilation time when
+//!named indexes are not needed.
+template <class MapConfig>
+class null_index
+{
+   /// @cond
+   typedef typename MapConfig::
+      segment_manager_base    segment_manager_base;
+   /// @endcond
+
+   public:
+   typedef void * iterator;
+   typedef const void * const_iterator;
+
+   //!begin() is equal
+   //!to end()
+   const_iterator begin() const
+   {  return const_iterator(0);  }
+
+   //!begin() is equal
+   //!to end()
+   iterator begin()
+   {  return iterator(0);  }
+
+   //!begin() is equal
+   //!to end()
+   const_iterator end() const
+   {  return const_iterator(0);  }
+
+   //!begin() is equal
+   //!to end()
+   iterator end()
+   {  return iterator(0);  }
+
+   //!Empty constructor
+   null_index(segment_manager_base *){}
+};
+
+}}   //namespace boost { namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_NULL_INDEX_HPP
diff --git a/boost/interprocess/indexes/unordered_map_index.hpp b/boost/interprocess/indexes/unordered_map_index.hpp
new file mode 100644
index 0000000000..a14fa1d4a7
--- /dev/null
+++ b/boost/interprocess/indexes/unordered_map_index.hpp
@@ -0,0 +1,113 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_UNORDERED_MAP_INDEX_HPP
+#define BOOST_INTERPROCESS_UNORDERED_MAP_INDEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <functional>
+#include <utility>
+#include <boost/unordered_map.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/allocators/private_adaptive_pool.hpp>
+
+//!\file
+//!Describes index adaptor of boost::unordered_map container, to use it
+//!as name/shared memory index
+
+namespace boost {
+namespace interprocess {
+
+///@cond
+
+//!Helper class to define typedefs from
+//!IndexTraits
+template <class MapConfig>
+struct unordered_map_index_aux
+{
+   typedef typename MapConfig::key_type            key_type;
+   typedef typename MapConfig::mapped_type         mapped_type;
+   typedef std::equal_to<key_type>                 key_equal;
+   typedef std::pair<const key_type, mapped_type>  value_type;
+   typedef private_adaptive_pool
+            <value_type,
+               typename MapConfig::
+                  segment_manager_base>      allocator_type;
+    struct hasher
+      : std::unary_function<key_type, std::size_t>
+    {
+        std::size_t operator()(const key_type &val) const
+        {
+            typedef typename key_type::char_type    char_type;
+            const char_type *beg = ipcdetail::to_raw_pointer(val.mp_str),
+                            *end = beg + val.m_len;
+            return boost::hash_range(beg, end);
+        }
+    };
+   typedef unordered_map<key_type,  mapped_type, hasher,
+                         key_equal, allocator_type>      index_t;
+};
+
+///@endcond
+
+//!Index type based in unordered_map. Just derives from unordered_map and
+//!defines the interface needed by managed memory segments
+template <class MapConfig>
+class unordered_map_index
+   //Derive class from unordered_map specialization
+   : public unordered_map_index_aux<MapConfig>::index_t
+{
+   /// @cond
+   typedef unordered_map_index_aux<MapConfig>   index_aux;
+   typedef typename index_aux::index_t          base_type;
+   typedef typename 
+      MapConfig::segment_manager_base     segment_manager_base;
+   /// @endcond
+
+   public:
+   //!Constructor. Takes a pointer to the
+   //!segment manager. Can throw
+   unordered_map_index(segment_manager_base *segment_mngr)
+      : base_type(0,
+                  typename index_aux::hasher(),
+                  typename index_aux::key_equal(),
+                  segment_mngr){}
+
+   //!This reserves memory to optimize the insertion of n
+   //!elements in the index
+   void reserve(typename segment_manager_base::size_type n)
+   {  base_type::rehash(n);  }
+
+   //!This tries to free previously allocate
+   //!unused memory.
+   void shrink_to_fit()
+   {  base_type::rehash(base_type::size()); }
+};
+
+/// @cond
+
+//!Trait class to detect if an index is a node
+//!index. This allows more efficient operations
+//!when deallocating named objects.
+template<class MapConfig>
+struct is_node_index
+   <boost::interprocess::unordered_map_index<MapConfig> >
+{
+   static const bool value = true;
+};
+/// @endcond
+
+}}   //namespace boost { namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_UNORDERED_MAP_INDEX_HPP
diff --git a/boost/interprocess/interprocess_fwd.hpp b/boost/interprocess/interprocess_fwd.hpp
new file mode 100644
index 0000000000..2b3e3eba07
--- /dev/null
+++ b/boost/interprocess/interprocess_fwd.hpp
@@ -0,0 +1,418 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_FWD_HPP
+#define BOOST_INTERPROCESS_FWD_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 <cstddef>
+
+//////////////////////////////////////////////////////////////////////////////
+//                        Standard predeclarations
+//////////////////////////////////////////////////////////////////////////////
+
+/// @cond
+
+namespace boost{
+namespace intrusive{
+}}
+
+namespace boost{
+namespace interprocess{
+namespace bi = boost::intrusive;
+}}
+
+#include <utility>
+#include <memory>
+#include <functional>
+#include <iosfwd>
+#include <string>
+
+/// @endcond
+
+namespace boost { namespace interprocess {
+
+//////////////////////////////////////////////////////////////////////////////
+//                            permissions
+//////////////////////////////////////////////////////////////////////////////
+
+class permissions;
+
+//////////////////////////////////////////////////////////////////////////////
+//                            shared_memory
+//////////////////////////////////////////////////////////////////////////////
+
+class shared_memory_object;
+
+#if defined (BOOST_INTERPROCESS_WINDOWS) || defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+class windows_shared_memory;
+#endif   //#if defined (BOOST_INTERPROCESS_WINDOWS)
+
+//////////////////////////////////////////////////////////////////////////////
+//              mapped file/mapped region/mapped_file
+//////////////////////////////////////////////////////////////////////////////
+
+class file_mapping;
+class mapped_region;
+class mapped_file;
+
+//////////////////////////////////////////////////////////////////////////////
+//                               Mutexes
+//////////////////////////////////////////////////////////////////////////////
+
+class null_mutex;
+
+class interprocess_mutex;
+class interprocess_recursive_mutex;
+
+class named_mutex;
+class named_recursive_mutex;
+
+class interprocess_semaphore;
+class named_semaphore;
+
+//////////////////////////////////////////////////////////////////////////////
+//                         Mutex families
+//////////////////////////////////////////////////////////////////////////////
+
+struct mutex_family;
+struct null_mutex_family;
+
+//////////////////////////////////////////////////////////////////////////////
+//                   Other synchronization classes
+//////////////////////////////////////////////////////////////////////////////
+
+class barrier;
+class interprocess_sharable_mutex;
+class interprocess_condition;
+
+//////////////////////////////////////////////////////////////////////////////
+//                              Locks
+//////////////////////////////////////////////////////////////////////////////
+
+template <class Mutex>
+class scoped_lock;
+
+template <class SharableMutex>
+class sharable_lock;
+
+template <class UpgradableMutex>
+class upgradable_lock;
+
+//////////////////////////////////////////////////////////////////////////////
+//                      STL compatible allocators
+//////////////////////////////////////////////////////////////////////////////
+
+template<class T, class SegmentManager>
+class allocator;
+
+template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
+class node_allocator;
+
+template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
+class private_node_allocator;
+
+template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
+class cached_node_allocator;
+
+template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
+         , unsigned char OverheadPercent = 5
+>
+class adaptive_pool;
+
+template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
+         , unsigned char OverheadPercent = 5
+>
+class private_adaptive_pool;
+
+template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
+         , unsigned char OverheadPercent = 5
+>
+class cached_adaptive_pool;
+
+
+//////////////////////////////////////////////////////////////////////////////
+//                            offset_ptr
+//////////////////////////////////////////////////////////////////////////////
+
+static const std::size_t offset_type_alignment = 0;
+
+template <class T, class DifferenceType = std::ptrdiff_t, class OffsetType = std::size_t, std::size_t Alignment = offset_type_alignment>
+class offset_ptr;
+
+//////////////////////////////////////////////////////////////////////////////
+//                    Memory allocation algorithms
+//////////////////////////////////////////////////////////////////////////////
+
+//Single segment memory allocation algorithms
+template<class MutexFamily, class VoidMutex = offset_ptr<void> >
+class simple_seq_fit;
+
+template<class MutexFamily, class VoidMutex = offset_ptr<void>, std::size_t MemAlignment = 0>
+class rbtree_best_fit;
+
+//////////////////////////////////////////////////////////////////////////////
+//                         Index Types
+//////////////////////////////////////////////////////////////////////////////
+
+template<class IndexConfig> class flat_map_index;
+template<class IndexConfig> class iset_index;
+template<class IndexConfig> class iunordered_set_index;
+template<class IndexConfig> class map_index;
+template<class IndexConfig> class null_index;
+template<class IndexConfig> class unordered_map_index;
+
+//////////////////////////////////////////////////////////////////////////////
+//                         Segment manager
+//////////////////////////////////////////////////////////////////////////////
+
+template <class CharType
+         ,class MemoryAlgorithm
+         ,template<class IndexConfig> class IndexType>
+class segment_manager;
+
+//////////////////////////////////////////////////////////////////////////////
+//                  External buffer managed memory classes
+//////////////////////////////////////////////////////////////////////////////
+
+template <class CharType
+         ,class MemoryAlgorithm
+         ,template<class IndexConfig> class IndexType>
+class basic_managed_external_buffer;
+
+typedef basic_managed_external_buffer
+   <char
+   ,rbtree_best_fit<null_mutex_family>
+   ,iset_index>
+managed_external_buffer;
+
+typedef basic_managed_external_buffer
+   <wchar_t
+   ,rbtree_best_fit<null_mutex_family>
+   ,iset_index>
+wmanaged_external_buffer;
+
+//////////////////////////////////////////////////////////////////////////////
+//                      managed memory classes
+//////////////////////////////////////////////////////////////////////////////
+
+template <class CharType
+         ,class MemoryAlgorithm
+         ,template<class IndexConfig> class IndexType>
+class basic_managed_shared_memory;
+
+typedef basic_managed_shared_memory 
+   <char
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+managed_shared_memory;
+
+typedef basic_managed_shared_memory
+   <wchar_t
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+wmanaged_shared_memory;
+
+
+//////////////////////////////////////////////////////////////////////////////
+//                      Windows shared memory managed memory classes
+//////////////////////////////////////////////////////////////////////////////
+
+#if defined (BOOST_INTERPROCESS_WINDOWS) || defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+
+template <class CharType
+         ,class MemoryAlgorithm
+         ,template<class IndexConfig> class IndexType>
+class basic_managed_windows_shared_memory;
+
+typedef basic_managed_windows_shared_memory 
+   <char
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+managed_windows_shared_memory;
+
+typedef basic_managed_windows_shared_memory
+   <wchar_t
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+wmanaged_windows_shared_memory;
+
+#endif   //#if defined (BOOST_INTERPROCESS_WINDOWS)
+
+#if defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS) || defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+
+template <class CharType
+         ,class MemoryAlgorithm
+         ,template<class IndexConfig> class IndexType>
+class basic_managed_xsi_shared_memory;
+
+typedef basic_managed_xsi_shared_memory 
+   <char
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+managed_xsi_shared_memory;
+
+typedef basic_managed_xsi_shared_memory
+   <wchar_t
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+wmanaged_xsi_shared_memory;
+
+#endif //#if defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS)
+
+//////////////////////////////////////////////////////////////////////////////
+//                      Fixed address shared memory
+//////////////////////////////////////////////////////////////////////////////
+
+typedef basic_managed_shared_memory
+   <char
+   ,rbtree_best_fit<mutex_family, void*>
+   ,iset_index>
+fixed_managed_shared_memory;
+
+typedef basic_managed_shared_memory
+   <wchar_t
+   ,rbtree_best_fit<mutex_family, void*>
+   ,iset_index>
+wfixed_managed_shared_memory;
+
+//////////////////////////////////////////////////////////////////////////////
+//                      Heap memory managed memory classes
+//////////////////////////////////////////////////////////////////////////////
+
+template
+   <class CharType
+   ,class MemoryAlgorithm
+   ,template<class IndexConfig> class IndexType>
+class basic_managed_heap_memory;
+
+typedef basic_managed_heap_memory
+   <char
+   ,rbtree_best_fit<null_mutex_family>
+   ,iset_index>
+managed_heap_memory;
+
+typedef basic_managed_heap_memory
+   <wchar_t
+   ,rbtree_best_fit<null_mutex_family>
+   ,iset_index>
+wmanaged_heap_memory;
+
+//////////////////////////////////////////////////////////////////////////////
+//                         Mapped file managed memory classes
+//////////////////////////////////////////////////////////////////////////////
+
+template
+   <class CharType
+   ,class MemoryAlgorithm
+   ,template<class IndexConfig> class IndexType>
+class basic_managed_mapped_file;
+
+typedef basic_managed_mapped_file
+   <char
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+managed_mapped_file;
+
+typedef basic_managed_mapped_file
+   <wchar_t
+   ,rbtree_best_fit<mutex_family>
+   ,iset_index>
+wmanaged_mapped_file;
+
+//////////////////////////////////////////////////////////////////////////////
+//                            Exceptions
+//////////////////////////////////////////////////////////////////////////////
+
+class interprocess_exception;
+class lock_exception;
+class bad_alloc;
+
+//////////////////////////////////////////////////////////////////////////////
+//                            Bufferstream
+//////////////////////////////////////////////////////////////////////////////
+
+//bufferstream
+template <class CharT
+         ,class CharTraits = std::char_traits<CharT> >
+class basic_bufferbuf;
+
+template <class CharT
+         ,class CharTraits = std::char_traits<CharT> >
+class basic_ibufferstream;
+
+template <class CharT
+         ,class CharTraits = std::char_traits<CharT> >
+class basic_obufferstream;
+
+template <class CharT
+         ,class CharTraits = std::char_traits<CharT> >
+class basic_bufferstream;
+
+//////////////////////////////////////////////////////////////////////////////
+//                            Vectorstream
+//////////////////////////////////////////////////////////////////////////////
+
+template <class CharVector
+         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
+class basic_vectorbuf;
+
+template <class CharVector
+         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
+class basic_ivectorstream;
+
+template <class CharVector
+         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
+class basic_ovectorstream;
+
+template <class CharVector
+         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
+class basic_vectorstream;
+
+//////////////////////////////////////////////////////////////////////////////
+//                             Smart pointers
+//////////////////////////////////////////////////////////////////////////////
+
+template<class T, class Deleter>
+class scoped_ptr;
+
+template<class T, class VoidPointer>
+class intrusive_ptr;
+
+template<class T, class VoidAllocator, class Deleter>
+class shared_ptr;
+
+template<class T, class VoidAllocator, class Deleter>
+class weak_ptr;
+
+//////////////////////////////////////////////////////////////////////////////
+//                                  IPC
+//////////////////////////////////////////////////////////////////////////////
+
+template<class VoidPointer>
+class message_queue_t;
+
+typedef message_queue_t<offset_ptr<void> > message_queue;
+
+}}  //namespace boost { namespace interprocess {
+
+//////////////////////////////////////////////////////////////////////////////
+//                                  CONTAINERS
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTERPROCESS_FWD_HPP
diff --git a/boost/interprocess/ipc/message_queue.hpp b/boost/interprocess/ipc/message_queue.hpp
new file mode 100644
index 0000000000..d3846afb7c
--- /dev/null
+++ b/boost/interprocess/ipc/message_queue.hpp
@@ -0,0 +1,704 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MESSAGE_QUEUE_HPP
+#define BOOST_INTERPROCESS_MESSAGE_QUEUE_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/sync/interprocess_condition.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/offset_ptr.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <algorithm> //std::lower_bound
+#include <cstddef>   //std::size_t
+#include <cstring>   //memcpy
+
+
+//!\file
+//!Describes an inter-process message queue. This class allows sending
+//!messages between processes and allows blocking, non-blocking and timed
+//!sending and receiving.
+
+namespace boost{  namespace interprocess{
+
+//!A class that allows sending messages
+//!between processes.
+template<class VoidPointer>
+class message_queue_t
+{
+   /// @cond
+   //Blocking modes
+   enum block_t   {  blocking,   timed,   non_blocking   };
+
+   message_queue_t();
+   /// @endcond
+
+   public:
+   typedef VoidPointer                                                 void_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<char>::type                                    char_ptr;
+   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type        size_type;
+
+   //!Creates a process shared message queue with name "name". For this message queue,
+   //!the maximum number of messages will be "max_num_msg" and the maximum message size
+   //!will be "max_msg_size". Throws on error and if the queue was previously created.
+   message_queue_t(create_only_t create_only,
+                 const char *name, 
+                 size_type max_num_msg, 
+                 size_type max_msg_size,
+                 const permissions &perm = permissions());
+
+   //!Opens or creates a process shared message queue with name "name". 
+   //!If the queue is created, the maximum number of messages will be "max_num_msg" 
+   //!and the maximum message size will be "max_msg_size". If queue was previously 
+   //!created the queue will be opened and "max_num_msg" and "max_msg_size" parameters
+   //!are ignored. Throws on error.
+   message_queue_t(open_or_create_t open_or_create,
+                 const char *name, 
+                 size_type max_num_msg, 
+                 size_type max_msg_size,
+                 const permissions &perm = permissions());
+
+   //!Opens a previously created process shared message queue with name "name". 
+   //!If the queue was not previously created or there are no free resources, 
+   //!throws an error.
+   message_queue_t(open_only_t open_only,
+                 const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. All opened message queues are still
+   //!valid after destruction. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the message queue from the system
+   //!use remove().
+   ~message_queue_t(); 
+
+   //!Sends a message stored in buffer "buffer" with size "buffer_size" in the 
+   //!message queue with priority "priority". If the message queue is full
+   //!the sender is blocked. Throws interprocess_error on error.*/
+   void send (const void *buffer,     size_type buffer_size, 
+              unsigned int priority);
+
+   //!Sends a message stored in buffer "buffer" with size "buffer_size" through the 
+   //!message queue with priority "priority". If the message queue is full
+   //!the sender is not blocked and returns false, otherwise returns true.
+   //!Throws interprocess_error on error.
+   bool try_send    (const void *buffer,     size_type buffer_size, 
+                         unsigned int priority);
+
+   //!Sends a message stored in buffer "buffer" with size "buffer_size" in the 
+   //!message queue with priority "priority". If the message queue is full
+   //!the sender retries until time "abs_time" is reached. Returns true if
+   //!the message has been successfully sent. Returns false if timeout is reached.
+   //!Throws interprocess_error on error.
+   bool timed_send    (const void *buffer,     size_type buffer_size, 
+                           unsigned int priority,  const boost::posix_time::ptime& abs_time);
+
+   //!Receives a message from the message queue. The message is stored in buffer 
+   //!"buffer", which has size "buffer_size". The received message has size 
+   //!"recvd_size" and priority "priority". If the message queue is empty
+   //!the receiver is blocked. Throws interprocess_error on error.
+   void receive (void *buffer,           size_type buffer_size, 
+                 size_type &recvd_size,unsigned int &priority);
+
+   //!Receives a message from the message queue. The message is stored in buffer 
+   //!"buffer", which has size "buffer_size". The received message has size 
+   //!"recvd_size" and priority "priority". If the message queue is empty
+   //!the receiver is not blocked and returns false, otherwise returns true.
+   //!Throws interprocess_error on error.
+   bool try_receive (void *buffer,           size_type buffer_size, 
+                     size_type &recvd_size,unsigned int &priority);
+
+   //!Receives a message from the message queue. The message is stored in buffer 
+   //!"buffer", which has size "buffer_size". The received message has size 
+   //!"recvd_size" and priority "priority". If the message queue is empty
+   //!the receiver retries until time "abs_time" is reached. Returns true if
+   //!the message has been successfully sent. Returns false if timeout is reached.
+   //!Throws interprocess_error on error.
+   bool timed_receive (void *buffer,           size_type buffer_size, 
+                       size_type &recvd_size,unsigned int &priority,
+                       const boost::posix_time::ptime &abs_time);
+
+   //!Returns the maximum number of messages allowed by the queue. The message
+   //!queue must be opened or created previously. Otherwise, returns 0. 
+   //!Never throws
+   size_type get_max_msg() const;
+
+   //!Returns the maximum size of message allowed by the queue. The message
+   //!queue must be opened or created previously. Otherwise, returns 0. 
+   //!Never throws
+   size_type get_max_msg_size() const;
+
+   //!Returns the number of messages currently stored. 
+   //!Never throws
+   size_type get_num_msg();
+
+   //!Removes the message queue from the system.
+   //!Returns false on error. Never throws
+   static bool remove(const char *name);
+
+   /// @cond   
+   private:
+   typedef boost::posix_time::ptime ptime;
+   bool do_receive(block_t block,
+                   void *buffer,         size_type buffer_size, 
+                   size_type &recvd_size, unsigned int &priority,
+                   const ptime &abs_time);
+
+   bool do_send(block_t block,
+                const void *buffer,      size_type buffer_size, 
+                unsigned int priority,   const ptime &abs_time);
+
+   //!Returns the needed memory size for the shared message queue.
+   //!Never throws
+   static size_type get_mem_size(size_type max_msg_size, size_type max_num_msg);
+
+   ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
+   /// @endcond
+};
+
+/// @cond
+
+namespace ipcdetail {
+
+//!This header is the prefix of each message in the queue
+template<class VoidPointer>
+class msg_hdr_t 
+{
+   typedef VoidPointer                                                           void_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<char>::type                                              char_ptr;
+   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type  difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type                  size_type;
+
+   public:
+   size_type               len;     // Message length
+   unsigned int            priority;// Message priority
+   //!Returns the data buffer associated with this this message
+   void * data(){ return this+1; }  //
+};
+
+//!This functor is the predicate to order stored messages by priority
+template<class VoidPointer>
+class priority_functor
+{
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<msg_hdr_t<VoidPointer> >::type                  msg_hdr_ptr_t;
+
+   public:
+   bool operator()(const msg_hdr_ptr_t &msg1, 
+                   const msg_hdr_ptr_t &msg2) const
+      {  return msg1->priority < msg2->priority;  }
+};
+
+//!This header is placed in the beginning of the shared memory and contains 
+//!the data to control the queue. This class initializes the shared memory 
+//!in the following way: in ascending memory address with proper alignment
+//!fillings:
+//!
+//!-> mq_hdr_t: 
+//!   Main control block that controls the rest of the elements
+//!
+//!-> offset_ptr<msg_hdr_t> index [max_num_msg]
+//!   An array of pointers with size "max_num_msg" called index. Each pointer 
+//!   points to a preallocated message. The elements of this array are 
+//!   reordered in runtime in the following way:
+//!
+//!   When the current number of messages is "cur_num_msg", the first 
+//!   "cur_num_msg" pointers point to inserted messages and the rest
+//!   point to free messages. The first "cur_num_msg" pointers are
+//!   ordered by the priority of the pointed message and by insertion order 
+//!   if two messages have the same priority. So the next message to be 
+//!   used in a "receive" is pointed by index [cur_num_msg-1] and the first free
+//!   message ready to be used in a "send" operation is index [cur_num_msg].
+//!   This transforms index in a fixed size priority queue with an embedded free
+//!   message queue.
+//!
+//!-> struct message_t
+//!   {  
+//!      msg_hdr_t            header;
+//!      char[max_msg_size]   data;
+//!   } messages [max_num_msg];
+//!
+//!   An array of buffers of preallocated messages, each one prefixed with the
+//!   msg_hdr_t structure. Each of this message is pointed by one pointer of
+//!   the index structure.
+template<class VoidPointer>
+class mq_hdr_t
+   : public ipcdetail::priority_functor<VoidPointer>
+{   
+   typedef VoidPointer                                                     void_pointer;
+   typedef msg_hdr_t<void_pointer>                                         msg_header;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<msg_header>::type                                  msg_hdr_ptr_t;
+   typedef typename boost::intrusive::pointer_traits
+      <msg_hdr_ptr_t>::difference_type                                     difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type            size_type;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<msg_hdr_ptr_t>::type                              msg_hdr_ptr_ptr_t;
+
+   public:
+   //!Constructor. This object must be constructed in the beginning of the 
+   //!shared memory of the size returned by the function "get_mem_size".
+   //!This constructor initializes the needed resources and creates
+   //!the internal structures like the priority index. This can throw.*/
+   mq_hdr_t(size_type max_num_msg, size_type max_msg_size)
+      : m_max_num_msg(max_num_msg), 
+         m_max_msg_size(max_msg_size),
+         m_cur_num_msg(0)
+      {  this->initialize_memory();  }
+
+   //!Returns the inserted message with top priority
+   msg_header * top_msg()
+      {  return mp_index[m_cur_num_msg-1].get();   }
+
+   //!Returns true if the message queue is full
+   bool is_full() const
+      {  return m_cur_num_msg == m_max_num_msg;  }
+
+   //!Returns true if the message queue is empty
+   bool is_empty() const
+      {  return !m_cur_num_msg;  }
+
+   //!Frees the top priority message and saves it in the free message list
+   void free_top_msg()
+      {  --m_cur_num_msg;  }
+
+   //!Returns the first free msg of the free message queue
+   msg_header * free_msg()
+      {  return mp_index[m_cur_num_msg].get();  }
+
+   //!Inserts the first free message in the priority queue
+   void queue_free_msg()
+   {  
+      //Get free msg
+      msg_hdr_ptr_t free = mp_index[m_cur_num_msg];
+      //Get priority queue's range
+      msg_hdr_ptr_t *it  = &mp_index[0], *it_end = &mp_index[m_cur_num_msg];
+      //Check where the free message should be placed
+      it = std::lower_bound(it, it_end, free, static_cast<priority_functor<VoidPointer>&>(*this));
+      //Make room in that position
+      std::copy_backward(it, it_end, it_end+1);
+      //Insert the free message in the correct position
+      *it = free;
+      ++m_cur_num_msg;
+   }
+
+   //!Returns the number of bytes needed to construct a message queue with 
+   //!"max_num_size" maximum number of messages and "max_msg_size" maximum 
+   //!message size. Never throws.
+   static size_type get_mem_size
+      (size_type max_msg_size, size_type max_num_msg)
+   {
+      const size_type 
+		 msg_hdr_align  = ::boost::alignment_of<msg_header>::value,
+		 index_align    = ::boost::alignment_of<msg_hdr_ptr_t>::value,
+         r_hdr_size     = ipcdetail::ct_rounded_size<sizeof(mq_hdr_t), index_align>::value,
+         r_index_size   = ipcdetail::get_rounded_size(sizeof(msg_hdr_ptr_t)*max_num_msg, msg_hdr_align),
+         r_max_msg_size = ipcdetail::get_rounded_size(max_msg_size, msg_hdr_align) + sizeof(msg_header);
+      return r_hdr_size + r_index_size + (max_num_msg*r_max_msg_size) + 
+         ipcdetail::managed_open_or_create_impl<shared_memory_object>::ManagedOpenOrCreateUserOffset;
+   }
+
+   //!Initializes the memory structures to preallocate messages and constructs the
+   //!message index. Never throws.
+   void initialize_memory()
+   {
+      const size_type 
+		  msg_hdr_align  = ::boost::alignment_of<msg_header>::value,
+		  index_align    = ::boost::alignment_of<msg_hdr_ptr_t>::value,
+         r_hdr_size     = ipcdetail::ct_rounded_size<sizeof(mq_hdr_t), index_align>::value,
+         r_index_size   = ipcdetail::get_rounded_size(sizeof(msg_hdr_ptr_t)*m_max_num_msg, msg_hdr_align),
+         r_max_msg_size = ipcdetail::get_rounded_size(m_max_msg_size, msg_hdr_align) + sizeof(msg_header);
+
+      //Pointer to the index
+      msg_hdr_ptr_t *index =  reinterpret_cast<msg_hdr_ptr_t*>
+                                 (reinterpret_cast<char*>(this)+r_hdr_size);
+
+      //Pointer to the first message header
+      msg_header *msg_hdr   =  reinterpret_cast<msg_header*>
+                                 (reinterpret_cast<char*>(this)+r_hdr_size+r_index_size);  
+
+      //Initialize the pointer to the index
+      mp_index             = index;
+
+      //Initialize the index so each slot points to a preallocated message
+      for(size_type i = 0; i < m_max_num_msg; ++i){
+         index[i] = msg_hdr;
+         msg_hdr  = reinterpret_cast<msg_header*>
+                        (reinterpret_cast<char*>(msg_hdr)+r_max_msg_size);
+      }
+   }
+
+   public:
+   //Pointer to the index
+   msg_hdr_ptr_ptr_t          mp_index;
+   //Maximum number of messages of the queue
+   const size_type            m_max_num_msg;
+   //Maximum size of messages of the queue
+   const size_type            m_max_msg_size;
+   //Current number of messages
+   size_type                  m_cur_num_msg;
+   //Mutex to protect data structures
+   interprocess_mutex         m_mutex;
+   //Condition block receivers when there are no messages
+   interprocess_condition     m_cond_recv;
+   //Condition block senders when the queue is full
+   interprocess_condition     m_cond_send;
+};
+
+
+//!This is the atomic functor to be executed when creating or opening 
+//!shared memory. Never throws
+template<class VoidPointer>
+class initialization_func_t
+{
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<char>::type                                    char_ptr;
+   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type        size_type;
+
+   initialization_func_t(size_type maxmsg = 0, 
+                         size_type maxmsgsize = 0)
+      : m_maxmsg (maxmsg), m_maxmsgsize(maxmsgsize) {}
+
+   bool operator()(void *address, size_type, bool created)
+   {
+      char      *mptr;
+
+      if(created){
+         mptr     = reinterpret_cast<char*>(address);
+         //Construct the message queue header at the beginning
+         BOOST_TRY{
+            new (mptr) mq_hdr_t<VoidPointer>(m_maxmsg, m_maxmsgsize);
+         }
+         BOOST_CATCH(...){
+            return false;   
+         }
+         BOOST_CATCH_END
+      }
+      return true;
+   }
+   const size_type m_maxmsg;
+   const size_type m_maxmsgsize;
+};
+
+}  //namespace ipcdetail {
+
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::~message_queue_t()
+{}
+
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_mem_size
+   (size_type max_msg_size, size_type max_num_msg)
+{  return ipcdetail::mq_hdr_t<VoidPointer>::get_mem_size(max_msg_size, max_num_msg);   }
+
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::message_queue_t(create_only_t create_only,
+                                    const char *name, 
+                                    size_type max_num_msg, 
+                                    size_type max_msg_size,
+                                    const permissions &perm)
+      //Create shared memory and execute functor atomically
+   :  m_shmem(create_only, 
+              name, 
+           get_mem_size(max_msg_size, max_num_msg),
+              read_write,
+              static_cast<void*>(0),
+              //Prepare initialization functor
+              ipcdetail::initialization_func_t<VoidPointer> (max_num_msg, max_msg_size),
+              perm)
+{}
+
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::message_queue_t(open_or_create_t open_or_create,
+                                    const char *name, 
+                                    size_type max_num_msg, 
+                                    size_type max_msg_size,
+                                    const permissions &perm)
+      //Create shared memory and execute functor atomically
+   :  m_shmem(open_or_create, 
+              name, 
+              get_mem_size(max_msg_size, max_num_msg),
+              read_write,
+              static_cast<void*>(0),
+              //Prepare initialization functor
+              ipcdetail::initialization_func_t<VoidPointer> (max_num_msg, max_msg_size),
+              perm)
+{}
+
+template<class VoidPointer>
+inline message_queue_t<VoidPointer>::message_queue_t(open_only_t open_only,
+                                    const char *name)
+   //Create shared memory and execute functor atomically
+   :  m_shmem(open_only, 
+              name,
+              read_write,
+              static_cast<void*>(0),
+              //Prepare initialization functor
+              ipcdetail::initialization_func_t<VoidPointer> ())
+{}
+
+template<class VoidPointer>
+inline void message_queue_t<VoidPointer>::send
+   (const void *buffer, size_type buffer_size, unsigned int priority)
+{  this->do_send(blocking, buffer, buffer_size, priority, ptime()); }
+
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::try_send
+   (const void *buffer, size_type buffer_size, unsigned int priority)
+{  return this->do_send(non_blocking, buffer, buffer_size, priority, ptime()); }
+
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::timed_send
+   (const void *buffer, size_type buffer_size
+   ,unsigned int priority, const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->send(buffer, buffer_size, priority);
+      return true;
+   }
+   return this->do_send(timed, buffer, buffer_size, priority, abs_time);
+}
+
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::do_send(block_t block,
+                                const void *buffer,      size_type buffer_size, 
+                                unsigned int priority,   const boost::posix_time::ptime &abs_time)
+{
+   ipcdetail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<ipcdetail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
+   //Check if buffer is smaller than maximum allowed
+   if (buffer_size > p_hdr->m_max_msg_size) {
+      throw interprocess_exception(size_error);
+   }
+
+   //---------------------------------------------
+   scoped_lock<interprocess_mutex> lock(p_hdr->m_mutex);
+   //---------------------------------------------
+   {
+      //If the queue is full execute blocking logic
+      if (p_hdr->is_full()) {
+
+         switch(block){
+            case non_blocking :
+               return false;
+            break;
+
+            case blocking :
+               do{
+                  p_hdr->m_cond_send.wait(lock);
+               }
+               while (p_hdr->is_full());
+            break;
+
+            case timed :
+               do{
+                  if(!p_hdr->m_cond_send.timed_wait(lock, abs_time)){
+                     if(p_hdr->is_full())
+                        return false;
+                     break;
+                  }
+               }
+               while (p_hdr->is_full());
+            break;
+            default:
+            break;
+         }
+      }
+      
+      //Get the first free message from free message queue
+      ipcdetail::msg_hdr_t<VoidPointer> *free_msg = p_hdr->free_msg();
+      if (free_msg == 0) {
+         throw interprocess_exception("boost::interprocess::message_queue corrupted");
+      }
+
+      //Copy control data to the free message
+      free_msg->priority = priority;
+      free_msg->len      = buffer_size;
+
+      //Copy user buffer to the message
+      std::memcpy(free_msg->data(), buffer, buffer_size);
+
+//      bool was_empty = p_hdr->is_empty();
+      //Insert the first free message in the priority queue
+      p_hdr->queue_free_msg();
+      
+      //If this message changes the queue empty state, notify it to receivers
+//      if (was_empty){
+         p_hdr->m_cond_recv.notify_one();
+//      }
+   }  // Lock end
+
+   return true;
+}
+
+template<class VoidPointer>
+inline void message_queue_t<VoidPointer>::receive(void *buffer,        size_type buffer_size, 
+                        size_type &recvd_size,   unsigned int &priority)
+{  this->do_receive(blocking, buffer, buffer_size, recvd_size, priority, ptime()); }
+
+template<class VoidPointer>
+inline bool
+   message_queue_t<VoidPointer>::try_receive(void *buffer,              size_type buffer_size, 
+                              size_type &recvd_size,   unsigned int &priority)
+{  return this->do_receive(non_blocking, buffer, buffer_size, recvd_size, priority, ptime()); }
+
+template<class VoidPointer>
+inline bool
+   message_queue_t<VoidPointer>::timed_receive(void *buffer,            size_type buffer_size, 
+                                size_type &recvd_size,   unsigned int &priority,
+                                const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->receive(buffer, buffer_size, recvd_size, priority);
+      return true;
+   }
+   return this->do_receive(timed, buffer, buffer_size, recvd_size, priority, abs_time);
+}
+
+template<class VoidPointer>
+inline bool
+   message_queue_t<VoidPointer>::do_receive(block_t block,
+                          void *buffer,            size_type buffer_size, 
+                          size_type &recvd_size,   unsigned int &priority,
+                          const boost::posix_time::ptime &abs_time)
+{
+   ipcdetail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<ipcdetail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
+   //Check if buffer is big enough for any message
+   if (buffer_size < p_hdr->m_max_msg_size) {
+      throw interprocess_exception(size_error);
+   }
+
+   //---------------------------------------------
+   scoped_lock<interprocess_mutex> lock(p_hdr->m_mutex);
+   //---------------------------------------------
+   {
+      //If there are no messages execute blocking logic
+      if (p_hdr->is_empty()) {
+         switch(block){
+            case non_blocking :
+               return false;
+            break;
+
+            case blocking :
+               do{
+                  p_hdr->m_cond_recv.wait(lock);
+               }
+               while (p_hdr->is_empty());
+            break;
+
+            case timed :
+               do{
+                  if(!p_hdr->m_cond_recv.timed_wait(lock, abs_time)){
+                     if(p_hdr->is_empty())
+                        return false;
+                     break;
+                  }
+               }
+               while (p_hdr->is_empty());
+            break;
+
+            //Paranoia check
+            default:
+            break;
+         }
+      }
+
+      //Thre is at least message ready to pick, get the top one
+     ipcdetail::msg_hdr_t<VoidPointer> *top_msg = p_hdr->top_msg();
+
+      //Paranoia check
+      if (top_msg == 0) {
+         throw interprocess_exception("boost::interprocess::message_queue corrupted");
+      }
+
+      //Get data from the message
+      recvd_size     = top_msg->len;
+      priority       = top_msg->priority;
+
+      //Copy data to receiver's bufers
+     std::memcpy(buffer, top_msg->data(), recvd_size);
+
+//      bool was_full = p_hdr->is_full();
+
+      //Free top message and put it in the free message list
+      p_hdr->free_top_msg();
+
+      //If this reception changes the queue full state, notify senders
+//      if (was_full){
+         p_hdr->m_cond_send.notify_one();
+//      }
+   }  //Lock end
+
+   return true;
+}
+
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_max_msg() const
+{  
+   ipcdetail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<ipcdetail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
+   return p_hdr ? p_hdr->m_max_num_msg : 0;  }
+
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_max_msg_size() const
+{  
+   ipcdetail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<ipcdetail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
+   return p_hdr ? p_hdr->m_max_msg_size : 0;  
+}
+
+template<class VoidPointer>
+inline typename message_queue_t<VoidPointer>::size_type message_queue_t<VoidPointer>::get_num_msg()
+{  
+   ipcdetail::mq_hdr_t<VoidPointer> *p_hdr = static_cast<ipcdetail::mq_hdr_t<VoidPointer>*>(m_shmem.get_user_address());
+   if(p_hdr){
+      //---------------------------------------------
+      scoped_lock<interprocess_mutex> lock(p_hdr->m_mutex);
+      //---------------------------------------------
+      return p_hdr->m_cur_num_msg;
+   }
+
+   return 0;  
+}
+
+template<class VoidPointer>
+inline bool message_queue_t<VoidPointer>::remove(const char *name)
+{  return shared_memory_object::remove(name);  }
+
+/// @endcond
+
+}} //namespace boost{  namespace interprocess{
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MESSAGE_QUEUE_HPP
diff --git a/boost/interprocess/managed_external_buffer.hpp b/boost/interprocess/managed_external_buffer.hpp
new file mode 100644
index 0000000000..a2cf47f4e6
--- /dev/null
+++ b/boost/interprocess/managed_external_buffer.hpp
@@ -0,0 +1,113 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MANAGED_EXTERNAL_BUFFER_HPP
+#define BOOST_INTERPROCESS_MANAGED_EXTERNAL_BUFFER_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/move/move.hpp>
+#include <boost/assert.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+#include <boost/interprocess/indexes/iset_index.hpp>
+
+//!\file
+//!Describes a named user memory allocation user class. 
+
+namespace boost {
+namespace interprocess {
+
+//!A basic user memory named object creation class. Inherits all 
+//!basic functionality from 
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+template
+      <
+         class CharType, 
+         class AllocationAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_external_buffer 
+   : public ipcdetail::basic_managed_memory_impl <CharType, AllocationAlgorithm, IndexType>
+{
+   /// @cond
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, AllocationAlgorithm, IndexType>    base_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_external_buffer)
+   /// @endcond
+   
+   public:
+   typedef typename base_t::size_type              size_type;
+
+   //!Default constructor. Does nothing.
+   //!Useful in combination with move semantics
+   basic_managed_external_buffer()
+   {}
+
+   //!Creates and places the segment manager. This can throw
+   basic_managed_external_buffer
+      (create_only_t, void *addr, size_type size)
+   {
+      //Check if alignment is correct
+      BOOST_ASSERT((0 == (((std::size_t)addr) & (AllocationAlgorithm::Alignment - size_type(1u)))));
+      if(!base_t::create_impl(addr, size)){
+         throw interprocess_exception("Could not initialize buffer in basic_managed_external_buffer constructor");
+      }
+   }
+
+   //!Creates and places the segment manager. This can throw
+   basic_managed_external_buffer
+      (open_only_t, void *addr, size_type size)
+   {
+      //Check if alignment is correct
+      BOOST_ASSERT((0 == (((std::size_t)addr) & (AllocationAlgorithm::Alignment - size_type(1u)))));
+      if(!base_t::open_impl(addr, size)){
+         throw interprocess_exception("Could not initialize buffer in basic_managed_external_buffer constructor");
+      }
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this. Does not throw
+   basic_managed_external_buffer(BOOST_RV_REF(basic_managed_external_buffer) moved)
+   {
+      this->swap(moved);
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this. Does not throw
+   basic_managed_external_buffer &operator=(BOOST_RV_REF(basic_managed_external_buffer) moved)
+   {
+      basic_managed_external_buffer tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }
+
+   void grow(size_type extra_bytes)
+   {  base_t::grow(extra_bytes);   }
+
+   //!Swaps the ownership of the managed heap memories managed by *this and other.
+   //!Never throws.
+   void swap(basic_managed_external_buffer &other)
+   {  base_t::swap(other); }
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_EXTERNAL_BUFFER_HPP
+
diff --git a/boost/interprocess/managed_heap_memory.hpp b/boost/interprocess/managed_heap_memory.hpp
new file mode 100644
index 0000000000..74869bb1f5
--- /dev/null
+++ b/boost/interprocess/managed_heap_memory.hpp
@@ -0,0 +1,148 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MANAGED_HEAP_MEMORY_HPP
+#define BOOST_INTERPROCESS_MANAGED_HEAP_MEMORY_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/interprocess/creation_tags.hpp>
+#include <boost/move/move.hpp>
+#include <vector>
+#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+#include <boost/interprocess/indexes/iset_index.hpp>
+
+//!\file
+//!Describes a named heap memory allocation user class. 
+
+namespace boost {
+namespace interprocess {
+
+//!A basic heap memory named object creation class. Initializes the 
+//!heap memory segment. Inherits all basic functionality from 
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+template
+      <
+         class CharType, 
+         class AllocationAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_heap_memory 
+   : public ipcdetail::basic_managed_memory_impl <CharType, AllocationAlgorithm, IndexType>
+{
+   /// @cond
+   private:
+
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, AllocationAlgorithm, IndexType>             base_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_heap_memory)
+   /// @endcond
+
+   public: //functions
+   typedef typename base_t::size_type              size_type;
+
+   //!Default constructor. Does nothing.
+   //!Useful in combination with move semantics
+   basic_managed_heap_memory(){}
+
+   //!Destructor. Liberates the heap memory holding the managed data.
+   //!Never throws.
+   ~basic_managed_heap_memory()
+   {  this->priv_close();  }
+
+   //!Creates heap memory and initializes the segment manager.
+   //!This can throw.
+   basic_managed_heap_memory(size_type size)
+      :  m_heapmem(size, char(0))
+   {
+      if(!base_t::create_impl(&m_heapmem[0], size)){
+         this->priv_close();
+         throw interprocess_exception("Could not initialize heap in basic_managed_heap_memory constructor");
+      }
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this. Does not throw
+   basic_managed_heap_memory(BOOST_RV_REF(basic_managed_heap_memory) moved)
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this. Does not throw
+   basic_managed_heap_memory &operator=(BOOST_RV_REF(basic_managed_heap_memory) moved)
+   {
+      basic_managed_heap_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }
+
+   //!Tries to resize internal heap memory so that
+   //!we have room for more objects. 
+   //!WARNING: If memory is reallocated, all the objects will 
+   //!be binary-copied to the new buffer. To be able to use
+   //!this function, all pointers constructed in this buffer
+   //!must be offset pointers. Otherwise, the result is undefined.
+   //!Returns true if the growth has been successful, so you will
+   //!have some extra bytes to allocate new objects. If returns 
+   //!false, the heap allocation has failed.
+   bool grow(size_type extra_bytes)
+   {  
+      //If memory is reallocated, data will
+      //be automatically copied
+      BOOST_TRY{
+        m_heapmem.resize(m_heapmem.size()+extra_bytes);
+      }
+      BOOST_CATCH(...){
+         return false;
+      }
+      BOOST_CATCH_END
+
+      //Grow always works
+      base_t::close_impl();
+      base_t::open_impl(&m_heapmem[0], m_heapmem.size());
+      base_t::grow(extra_bytes);
+      return true;
+   }
+
+   //!Swaps the ownership of the managed heap memories managed by *this and other.
+   //!Never throws.
+   void swap(basic_managed_heap_memory &other)
+   {
+      base_t::swap(other);
+      m_heapmem.swap(other.m_heapmem);
+   }
+
+   /// @cond
+   private:
+   //!Frees resources. Never throws.
+   void priv_close()
+   {  
+      base_t::destroy_impl();
+      std::vector<char>().swap(m_heapmem);
+   }
+
+   std::vector<char>  m_heapmem;
+   /// @endcond
+};
+
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_HEAP_MEMORY_HPP
+
diff --git a/boost/interprocess/managed_mapped_file.hpp b/boost/interprocess/managed_mapped_file.hpp
new file mode 100644
index 0000000000..218fa9783c
--- /dev/null
+++ b/boost/interprocess/managed_mapped_file.hpp
@@ -0,0 +1,217 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MANAGED_MAPPED_FILE_HPP
+#define BOOST_INTERPROCESS_MANAGED_MAPPED_FILE_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/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/file_wrapper.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/file_mapping.hpp>
+#include <boost/interprocess/permissions.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+#include <boost/interprocess/indexes/iset_index.hpp>
+
+namespace boost {
+namespace interprocess {
+
+//!A basic mapped file named object creation class. Initializes the 
+//!mapped file. Inherits all basic functionality from 
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>
+template
+      <
+         class CharType, 
+         class AllocationAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_mapped_file 
+   : public ipcdetail::basic_managed_memory_impl
+      <CharType, AllocationAlgorithm, IndexType
+      ,ipcdetail::managed_open_or_create_impl< ipcdetail::file_wrapper
+                                             , AllocationAlgorithm::Alignment>::ManagedOpenOrCreateUserOffset
+      >
+{
+   /// @cond
+   public:
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, AllocationAlgorithm, IndexType,
+      ipcdetail::managed_open_or_create_impl
+         <ipcdetail::file_wrapper, AllocationAlgorithm::Alignment>::ManagedOpenOrCreateUserOffset
+      >   base_t;
+   typedef ipcdetail::file_wrapper device_type;
+   typedef typename base_t::size_type              size_type;
+
+   private:
+
+   typedef ipcdetail::create_open_func<base_t>        create_open_func_t;   
+   typedef ipcdetail::managed_open_or_create_impl< ipcdetail::file_wrapper
+                                                 , AllocationAlgorithm::Alignment> managed_open_or_create_type;
+
+   basic_managed_mapped_file *get_this_pointer()
+   {  return this;   }
+
+   private:
+   typedef typename base_t::char_ptr_holder_t   char_ptr_holder_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_mapped_file)
+   /// @endcond
+
+   public: //functions
+
+   //!Creates mapped file and creates and places the segment manager. 
+   //!This can throw.
+   basic_managed_mapped_file()
+   {}
+
+   //!Creates mapped file and creates and places the segment manager. 
+   //!This can throw.
+   basic_managed_mapped_file(create_only_t create_only, const char *name,
+                             size_type size, const void *addr = 0, const permissions &perm = permissions())
+      : m_mfile(create_only, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), ipcdetail::DoCreate), perm)
+   {}
+
+   //!Creates mapped file and creates and places the segment manager if
+   //!segment was not created. If segment was created it connects to the
+   //!segment.
+   //!This can throw.
+   basic_managed_mapped_file (open_or_create_t open_or_create,
+                              const char *name, size_type size, 
+                              const void *addr = 0, const permissions &perm = permissions())
+      : m_mfile(open_or_create, name, size, read_write, addr,
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpenOrCreate), perm)
+   {}
+
+   //!Connects to a created mapped file and its segment manager.
+   //!This can throw.
+   basic_managed_mapped_file (open_only_t open_only, const char* name, 
+                              const void *addr = 0)
+      : m_mfile(open_only, name, read_write, addr,
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created mapped file and its segment manager
+   //!in copy_on_write mode.
+   //!This can throw.
+   basic_managed_mapped_file (open_copy_on_write_t, const char* name, 
+                              const void *addr = 0)
+      : m_mfile(open_only, name, copy_on_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created mapped file and its segment manager
+   //!in read-only mode.
+   //!This can throw.
+   basic_managed_mapped_file (open_read_only_t, const char* name, 
+                              const void *addr = 0)
+      : m_mfile(open_only, name, read_only, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_mapped_file(BOOST_RV_REF(basic_managed_mapped_file) moved)
+   {
+      this->swap(moved);
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_mapped_file &operator=(BOOST_RV_REF(basic_managed_mapped_file) moved)
+   {
+      basic_managed_mapped_file tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~basic_managed_mapped_file()
+   {}
+
+   //!Swaps the ownership of the managed mapped memories managed by *this and other.
+   //!Never throws.
+   void swap(basic_managed_mapped_file &other)
+   {
+      base_t::swap(other);
+      m_mfile.swap(other.m_mfile);
+   }
+
+   //!Flushes cached data to file.
+   //!Never throws
+   bool flush()
+   {  return m_mfile.flush();  }
+
+   //!Tries to resize mapped file so that we have room for 
+   //!more objects. 
+   //!
+   //!This function is not synchronized so no other thread or process should
+   //!be reading or writing the file
+   static bool grow(const char *filename, size_type extra_bytes)
+   {
+      return base_t::template grow
+         <basic_managed_mapped_file>(filename, extra_bytes);
+   }
+
+   //!Tries to resize mapped file to minimized the size of the file.
+   //!
+   //!This function is not synchronized so no other thread or process should
+   //!be reading or writing the file
+   static bool shrink_to_fit(const char *filename)
+   {
+      return base_t::template shrink_to_fit
+         <basic_managed_mapped_file>(filename);
+   }
+
+   /// @cond
+
+   //!Tries to find a previous named allocation address. Returns a memory
+   //!buffer and the object count. If not found returned pointer is 0.
+   //!Never throws.
+   template <class T>
+   std::pair<T*, size_type> find  (char_ptr_holder_t name)
+   {
+      if(m_mfile.get_mapped_region().get_mode() == read_only){
+         return base_t::template find_no_lock<T>(name);
+      }
+      else{
+         return base_t::template find<T>(name);
+      }
+   }
+
+   private:
+   managed_open_or_create_type m_mfile;
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_MAPPED_FILE_HPP
diff --git a/boost/interprocess/managed_shared_memory.hpp b/boost/interprocess/managed_shared_memory.hpp
new file mode 100644
index 0000000000..cec9591be4
--- /dev/null
+++ b/boost/interprocess/managed_shared_memory.hpp
@@ -0,0 +1,221 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MANAGED_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_MANAGED_SHARED_MEMORY_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/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/permissions.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+
+namespace boost {
+
+namespace interprocess {
+
+//!A basic shared memory named object creation class. Initializes the 
+//!shared memory segment. Inherits all basic functionality from 
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+template
+      <
+         class CharType, 
+         class AllocationAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_shared_memory 
+   : public ipcdetail::basic_managed_memory_impl
+      <CharType, AllocationAlgorithm, IndexType
+      ,ipcdetail::managed_open_or_create_impl<shared_memory_object
+                                             , AllocationAlgorithm::Alignment>::ManagedOpenOrCreateUserOffset>
+   , private ipcdetail::managed_open_or_create_impl<shared_memory_object
+                                                   , AllocationAlgorithm::Alignment>
+{
+   /// @cond
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, AllocationAlgorithm, IndexType,
+      ipcdetail::managed_open_or_create_impl
+         < shared_memory_object, AllocationAlgorithm::Alignment>::ManagedOpenOrCreateUserOffset>   base_t;
+   typedef ipcdetail::managed_open_or_create_impl
+      <shared_memory_object, AllocationAlgorithm::Alignment>                       base2_t;
+
+   typedef ipcdetail::create_open_func<base_t>        create_open_func_t;
+
+   basic_managed_shared_memory *get_this_pointer()
+   {  return this;   }
+
+   public:
+   typedef shared_memory_object                    device_type;
+   typedef typename base_t::size_type              size_type;
+
+   private:
+   typedef typename base_t::char_ptr_holder_t   char_ptr_holder_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_shared_memory)
+   /// @endcond
+
+   public: //functions
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~basic_managed_shared_memory()
+   {}
+
+   //!Default constructor. Does nothing.
+   //!Useful in combination with move semantics
+   basic_managed_shared_memory()
+   {}
+
+   //!Creates shared memory and creates and places the segment manager. 
+   //!This can throw.
+   basic_managed_shared_memory(create_only_t create_only, const char *name,
+                             size_type size, const void *addr = 0, const permissions& perm = permissions())
+      : base_t()
+      , base2_t(create_only, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), ipcdetail::DoCreate), perm)
+   {}
+
+   //!Creates shared memory and creates and places the segment manager if
+   //!segment was not created. If segment was created it connects to the
+   //!segment.
+   //!This can throw.
+   basic_managed_shared_memory (open_or_create_t open_or_create,
+                              const char *name, size_type size, 
+                              const void *addr = 0, const permissions& perm = permissions())
+      : base_t()
+      , base2_t(open_or_create, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpenOrCreate), perm)
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!in copy_on_write mode.
+   //!This can throw.
+   basic_managed_shared_memory (open_copy_on_write_t, const char* name, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, name, copy_on_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!in read-only mode.
+   //!This can throw.
+   basic_managed_shared_memory (open_read_only_t, const char* name, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, name, read_only, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!This can throw.
+   basic_managed_shared_memory (open_only_t open_only, const char* name, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, name, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_shared_memory(BOOST_RV_REF(basic_managed_shared_memory) moved)
+   {
+      basic_managed_shared_memory tmp;
+      this->swap(moved);
+      tmp.swap(moved);
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_shared_memory &operator=(BOOST_RV_REF(basic_managed_shared_memory) moved)
+   {
+      basic_managed_shared_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }
+
+   //!Swaps the ownership of the managed shared memories managed by *this and other.
+   //!Never throws.
+   void swap(basic_managed_shared_memory &other)
+   {
+      base_t::swap(other);
+      base2_t::swap(other);
+   }
+
+   //!Tries to resize the managed shared memory object so that we have
+   //!room for more objects. 
+   //!
+   //!This function is not synchronized so no other thread or process should
+   //!be reading or writing the file
+   static bool grow(const char *shmname, size_type extra_bytes)
+   {
+      return base_t::template grow
+         <basic_managed_shared_memory>(shmname, extra_bytes);
+   }
+
+   //!Tries to resize the managed shared memory to minimized the size of the file.
+   //!
+   //!This function is not synchronized so no other thread or process should
+   //!be reading or writing the file
+   static bool shrink_to_fit(const char *shmname)
+   {
+      return base_t::template shrink_to_fit
+         <basic_managed_shared_memory>(shmname);
+   }
+
+   bool flush()
+   {
+      return this->base2_t::flush();
+   }
+
+   /// @cond
+
+   //!Tries to find a previous named allocation address. Returns a memory
+   //!buffer and the object count. If not found returned pointer is 0.
+   //!Never throws.
+   template <class T>
+   std::pair<T*, size_type> find  (char_ptr_holder_t name)
+   {
+      if(base2_t::get_mapped_region().get_mode() == read_only){
+         return base_t::template find_no_lock<T>(name);
+      }
+      else{
+         return base_t::template find<T>(name);
+      }
+   }
+
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_SHARED_MEMORY_HPP
+
diff --git a/boost/interprocess/managed_windows_shared_memory.hpp b/boost/interprocess/managed_windows_shared_memory.hpp
new file mode 100644
index 0000000000..959194cc19
--- /dev/null
+++ b/boost/interprocess/managed_windows_shared_memory.hpp
@@ -0,0 +1,194 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MANAGED_WINDOWS_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_MANAGED_WINDOWS_SHARED_MEMORY_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/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/windows_shared_memory.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/move/move.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+#include <boost/interprocess/indexes/iset_index.hpp>
+
+namespace boost {
+namespace interprocess {
+
+//!A basic managed windows shared memory creation class. Initializes the 
+//!shared memory segment. Inherits all basic functionality from 
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>
+//!Unlike basic_managed_shared_memory, it has
+//!no kernel persistence and the shared memory is destroyed
+//!when all processes destroy all their windows_shared_memory
+//!objects and mapped regions for the same shared memory
+//!or the processes end/crash.
+//!
+//!Warning: basic_managed_windows_shared_memory and
+//!basic_managed_shared_memory can't communicate between them.
+template
+      <
+         class CharType, 
+         class AllocationAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_windows_shared_memory 
+   : public ipcdetail::basic_managed_memory_impl
+      < CharType, AllocationAlgorithm, IndexType
+      , ipcdetail::managed_open_or_create_impl
+         < windows_shared_memory
+         , AllocationAlgorithm::Alignment
+         , false>::ManagedOpenOrCreateUserOffset
+      >
+{
+   /// @cond
+   private:
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, AllocationAlgorithm, IndexType,
+      ipcdetail::managed_open_or_create_impl
+         <windows_shared_memory, AllocationAlgorithm::Alignment, false>::ManagedOpenOrCreateUserOffset>   base_t;
+   typedef ipcdetail::create_open_func<base_t>        create_open_func_t;
+
+   basic_managed_windows_shared_memory *get_this_pointer()
+   {  return this;   }
+
+   private:
+   typedef typename base_t::char_ptr_holder_t   char_ptr_holder_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_windows_shared_memory)
+   /// @endcond
+
+   public: //functions
+   typedef typename base_t::size_type              size_type;
+
+   //!Default constructor. Does nothing.
+   //!Useful in combination with move semantics
+   basic_managed_windows_shared_memory()
+   {}
+
+   //!Creates shared memory and creates and places the segment manager. 
+   //!This can throw.
+   basic_managed_windows_shared_memory
+      (create_only_t create_only, const char *name,
+     size_type size, const void *addr = 0, const permissions &perm = permissions())
+      : m_wshm(create_only, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), ipcdetail::DoCreate), perm)
+   {}
+
+   //!Creates shared memory and creates and places the segment manager if
+   //!segment was not created. If segment was created it connects to the
+   //!segment.
+   //!This can throw.
+   basic_managed_windows_shared_memory
+      (open_or_create_t open_or_create,
+      const char *name, size_type size, 
+      const void *addr = 0,
+      const permissions &perm = permissions())
+      : m_wshm(open_or_create, name, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpenOrCreate), perm)
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!This can throw.
+   basic_managed_windows_shared_memory
+      (open_only_t open_only, const char* name, const void *addr = 0)
+      : m_wshm(open_only, name, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created shared memory and its segment manager
+   //!in copy_on_write mode.
+   //!This can throw.
+   basic_managed_windows_shared_memory
+      (open_copy_on_write_t, const char* name, const void *addr = 0)
+      : m_wshm(open_only, name, copy_on_write, addr, 
+                create_open_func_t(get_this_pointer(), ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created shared memory and its segment manager
+   //!in read-only mode.
+   //!This can throw.
+   basic_managed_windows_shared_memory
+      (open_read_only_t, const char* name, const void *addr = 0)
+      : base_t()
+      , m_wshm(open_only, name, read_only, addr, 
+                create_open_func_t(get_this_pointer(), ipcdetail::DoOpen))
+   {}
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_windows_shared_memory
+      (BOOST_RV_REF(basic_managed_windows_shared_memory) moved)
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_windows_shared_memory &operator=(BOOST_RV_REF(basic_managed_windows_shared_memory) moved)
+   {
+      basic_managed_windows_shared_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. All mapped regions are still valid after
+   //!destruction. When all mapped regions and basic_managed_windows_shared_memory
+   //!objects referring the shared memory are destroyed, the
+   //!operating system will destroy the shared memory.
+   ~basic_managed_windows_shared_memory()
+   {}
+
+   //!Swaps the ownership of the managed mapped memories managed by *this and other.
+   //!Never throws.
+   void swap(basic_managed_windows_shared_memory &other)
+   {
+      base_t::swap(other);
+      m_wshm.swap(other.m_wshm);
+   }
+
+   /// @cond
+
+   //!Tries to find a previous named allocation address. Returns a memory
+   //!buffer and the object count. If not found returned pointer is 0.
+   //!Never throws.
+   template <class T>
+   std::pair<T*, size_type> find  (char_ptr_holder_t name)
+   {
+      if(m_wshm.get_mapped_region().get_mode() == read_only){
+         return base_t::template find_no_lock<T>(name);
+      }
+      else{
+         return base_t::template find<T>(name);
+      }
+   }
+
+   private:
+   ipcdetail::managed_open_or_create_impl< windows_shared_memory
+                                         , AllocationAlgorithm::Alignment, false> m_wshm;
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_WINDOWS_SHARED_MEMORY_HPP
diff --git a/boost/interprocess/managed_xsi_shared_memory.hpp b/boost/interprocess/managed_xsi_shared_memory.hpp
new file mode 100644
index 0000000000..9601920254
--- /dev/null
+++ b/boost/interprocess/managed_xsi_shared_memory.hpp
@@ -0,0 +1,198 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008-2011. 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_MANAGED_XSI_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_MANAGED_XSI_SHARED_MEMORY_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#if !defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS)
+#error "This header can't be used in operating systems without XSI (System V) shared memory support"
+#endif
+
+#include <boost/interprocess/detail/managed_memory_impl.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/detail/xsi_shared_memory_file_wrapper.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+//These includes needed to fulfill default template parameters of
+//predeclarations in interprocess_fwd.hpp
+#include <boost/interprocess/mem_algo/rbtree_best_fit.hpp>  
+#include <boost/interprocess/sync/mutex_family.hpp>
+#include <boost/interprocess/indexes/iset_index.hpp>
+
+namespace boost {
+
+namespace interprocess {
+
+//!A basic X/Open System Interface (XSI) shared memory named object creation class. Initializes the 
+//!shared memory segment. Inherits all basic functionality from 
+//!basic_managed_memory_impl<CharType, AllocationAlgorithm, IndexType>*/
+template
+      <
+         class CharType, 
+         class AllocationAlgorithm, 
+         template<class IndexConfig> class IndexType
+      >
+class basic_managed_xsi_shared_memory 
+   : public ipcdetail::basic_managed_memory_impl
+      <CharType, AllocationAlgorithm, IndexType
+      ,ipcdetail::managed_open_or_create_impl
+         < xsi_shared_memory_file_wrapper, AllocationAlgorithm::Alignment
+         , false, true>::ManagedOpenOrCreateUserOffset>
+   , private ipcdetail::managed_open_or_create_impl
+      <xsi_shared_memory_file_wrapper, AllocationAlgorithm::Alignment, false, true>
+{
+   /// @cond
+   public:
+   typedef xsi_shared_memory_file_wrapper device_type;
+
+   public:
+   typedef ipcdetail::managed_open_or_create_impl
+      <xsi_shared_memory_file_wrapper, AllocationAlgorithm::Alignment, false, true>            base2_t;
+   typedef ipcdetail::basic_managed_memory_impl 
+      <CharType, AllocationAlgorithm, IndexType,
+      base2_t::ManagedOpenOrCreateUserOffset>   base_t;
+
+   typedef ipcdetail::create_open_func<base_t>        create_open_func_t;
+
+   basic_managed_xsi_shared_memory *get_this_pointer()
+   {  return this;   }
+
+   private:
+   typedef typename base_t::char_ptr_holder_t   char_ptr_holder_t;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_managed_xsi_shared_memory)
+   /// @endcond
+
+   public: //functions
+   typedef typename base_t::size_type              size_type;
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~basic_managed_xsi_shared_memory()
+   {}
+
+   //!Default constructor. Does nothing.
+   //!Useful in combination with move semantics
+   basic_managed_xsi_shared_memory()
+   {}
+
+   //!Creates shared memory and creates and places the segment manager. 
+   //!This can throw.
+   basic_managed_xsi_shared_memory(create_only_t create_only, const xsi_key &key,
+                             std::size_t size, const void *addr = 0, const permissions& perm = permissions())
+      : base_t()
+      , base2_t(create_only, key, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), ipcdetail::DoCreate), perm)
+   {}
+
+   //!Creates shared memory and creates and places the segment manager if
+   //!segment was not created. If segment was created it connects to the
+   //!segment.
+   //!This can throw.
+   basic_managed_xsi_shared_memory (open_or_create_t open_or_create,
+                              const xsi_key &key, std::size_t size, 
+                              const void *addr = 0, const permissions& perm = permissions())
+      : base_t()
+      , base2_t(open_or_create, key, size, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpenOrCreate), perm)
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!in read-only mode.
+   //!This can throw.
+   basic_managed_xsi_shared_memory (open_read_only_t, const xsi_key &key, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, key, read_only, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Connects to a created shared memory and its segment manager.
+   //!This can throw.
+   basic_managed_xsi_shared_memory (open_only_t open_only, const xsi_key &key, 
+                                const void *addr = 0)
+      : base_t()
+      , base2_t(open_only, key, read_write, addr, 
+                create_open_func_t(get_this_pointer(), 
+                ipcdetail::DoOpen))
+   {}
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_xsi_shared_memory(BOOST_RV_REF(basic_managed_xsi_shared_memory) moved)
+   {
+      basic_managed_xsi_shared_memory tmp;
+      this->swap(moved);
+      tmp.swap(moved);
+   }
+
+   //!Moves the ownership of "moved"'s managed memory to *this.
+   //!Does not throw
+   basic_managed_xsi_shared_memory &operator=(BOOST_RV_REF(basic_managed_xsi_shared_memory) moved)
+   {
+      basic_managed_xsi_shared_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;
+   }
+
+   //!Swaps the ownership of the managed shared memories managed by *this and other.
+   //!Never throws.
+   void swap(basic_managed_xsi_shared_memory &other)
+   {
+      base_t::swap(other);
+      base2_t::swap(other);
+   }
+
+   //!Erases a XSI shared memory object identified by shmid
+   //!from the system.
+   //!Returns false on error. Never throws
+   static bool remove(int shmid)
+   {  return device_type::remove(shmid); }
+
+   int get_shmid() const
+   {  return base2_t::get_device().get_shmid(); }
+
+   /// @cond
+
+   //!Tries to find a previous named allocation address. Returns a memory
+   //!buffer and the object count. If not found returned pointer is 0.
+   //!Never throws.
+   template <class T>
+   std::pair<T*, std::size_t> find  (char_ptr_holder_t name)
+   {
+      if(base2_t::get_mapped_region().get_mode() == read_only){
+         return base_t::template find_no_lock<T>(name);
+      }
+      else{
+         return base_t::template find<T>(name);
+      }
+   }
+
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MANAGED_XSI_SHARED_MEMORY_HPP
+
diff --git a/boost/interprocess/mapped_region.hpp b/boost/interprocess/mapped_region.hpp
new file mode 100644
index 0000000000..eae3f36220
--- /dev/null
+++ b/boost/interprocess/mapped_region.hpp
@@ -0,0 +1,605 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MAPPED_REGION_HPP
+#define BOOST_INTERPROCESS_MAPPED_REGION_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <string>
+#include <limits>
+
+#if (defined BOOST_INTERPROCESS_WINDOWS)
+#  include <boost/interprocess/detail/win32_api.hpp>
+#else
+#  ifdef BOOST_HAS_UNISTD_H
+#    include <fcntl.h>
+#    include <sys/mman.h>     //mmap
+#    include <unistd.h>
+#    include <sys/stat.h>
+#    include <sys/types.h>
+#    if defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS)
+#      include <sys/shm.h>      //System V shared memory...
+#    endif
+#    include <boost/assert.hpp>
+#  else
+#    error Unknown platform
+#  endif
+
+#endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+//!\file
+//!Describes mapped region class
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+namespace ipcdetail{ class raw_mapped_region_creator; }
+
+/// @endcond
+
+//!The mapped_region class represents a portion or region created from a
+//!memory_mappable object.
+class mapped_region
+{
+   /// @cond
+   //Non-copyable
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(mapped_region)
+   /// @endcond
+
+   public:
+
+   //!Creates a mapping region of the mapped memory "mapping", starting in
+   //!offset "offset", and the mapping's size will be "size". The mapping 
+   //!can be opened for read-only "read_only" or read-write
+   //!"read_write.
+   template<class MemoryMappable>
+   mapped_region(const MemoryMappable& mapping
+                ,mode_t mode
+                ,offset_t offset = 0
+                ,std::size_t size = 0
+                ,const void *address = 0);
+
+   //!Default constructor. Default constructor. Address will be 0 (nullptr).
+   //!Size and offset will be 0.
+   //!Does not throw
+   mapped_region();
+
+   //!Move constructor. *this will be constructed taking ownership of "other"'s
+   //!region and "other" will be left in default constructor state.
+   mapped_region(BOOST_RV_REF(mapped_region) other)
+   #if defined (BOOST_INTERPROCESS_WINDOWS)
+   :  m_base(0), m_size(0), m_offset(0)
+   ,  m_extra_offset(0)
+   ,  m_mode(read_only)
+   ,  m_file_mapping_hnd(ipcdetail::invalid_file())
+   #else
+   :  m_base(0), m_size(0), m_offset(0),  m_extra_offset(0), m_mode(read_only), m_is_xsi(false)
+   #endif
+   {  this->swap(other);   }
+
+   //!Destroys the mapped region.
+   //!Does not throw
+   ~mapped_region();
+
+   //!Move assignment. If *this owns a memory mapped region, it will be
+   //!destroyed and it will take ownership of "other"'s memory mapped region.
+   mapped_region &operator=(BOOST_RV_REF(mapped_region) other)
+   {
+      mapped_region tmp(boost::move(other));
+      this->swap(tmp);
+      return *this;
+   }
+
+   //!Returns the size of the mapping. Note for windows users: If
+   //!windows_shared_memory is mapped using 0 as the size, it returns 0
+   //!because the size is unknown. Never throws.
+   std::size_t get_size() const;
+
+   //!Returns the base address of the mapping.
+   //!Never throws.
+   void*       get_address() const;
+
+   //!Returns the offset of the mapping from the beginning of the
+   //!mapped memory. Never throws.
+   offset_t    get_offset() const;
+
+   //!Returns the mode of the mapping used to construct the mapped file.
+   //!Never throws.
+   mode_t get_mode() const;
+
+   //!Flushes to the disk a byte range within the mapped memory. 
+   //!Never throws
+   bool flush(std::size_t mapping_offset = 0, std::size_t numbytes = 0);
+
+   //!Swaps the mapped_region with another
+   //!mapped region
+   void swap(mapped_region &other);
+
+   //!Returns the size of the page. This size is the minimum memory that
+   //!will be used by the system when mapping a memory mappable source.
+   static std::size_t get_page_size();
+
+   /// @cond
+   private:
+   //!Closes a previously opened memory mapping. Never throws
+   void priv_close();
+
+   template<int dummy>
+   struct page_size_holder
+   {
+      static const std::size_t PageSize;
+      static std::size_t get_page_size();
+   };
+
+   void*             m_base;
+   std::size_t       m_size;
+   offset_t          m_offset;
+   offset_t          m_extra_offset;
+   mode_t            m_mode;
+   #if (defined BOOST_INTERPROCESS_WINDOWS)
+   file_handle_t     m_file_mapping_hnd;
+   #else
+   bool              m_is_xsi;
+   #endif
+
+   friend class ipcdetail::interprocess_tester;
+   friend class ipcdetail::raw_mapped_region_creator;
+   void dont_close_on_destruction();
+   /// @endcond
+};
+
+///@cond
+
+inline void swap(mapped_region &x, mapped_region &y)
+{  x.swap(y);  }
+
+inline mapped_region::~mapped_region()
+{  this->priv_close(); }
+
+inline std::size_t mapped_region::get_size()  const
+{  return m_size; }
+
+inline offset_t mapped_region::get_offset()  const 
+{  return m_offset;   }
+
+inline mode_t mapped_region::get_mode()  const
+{  return m_mode;   }
+
+inline void*    mapped_region::get_address()  const
+{  return m_base; }
+
+#if defined (BOOST_INTERPROCESS_WINDOWS)
+
+inline mapped_region::mapped_region()
+   :  m_base(0), m_size(0), m_offset(0),  m_extra_offset(0), m_mode(read_only)
+   ,  m_file_mapping_hnd(ipcdetail::invalid_file())
+{}
+
+template<int dummy>
+inline std::size_t mapped_region::page_size_holder<dummy>::get_page_size()
+{
+   winapi::system_info info;
+   get_system_info(&info);
+   return std::size_t(info.dwAllocationGranularity);
+}
+
+template<class MemoryMappable>
+inline mapped_region::mapped_region
+   (const MemoryMappable &mapping
+   ,mode_t mode
+   ,offset_t offset
+   ,std::size_t size
+   ,const void *address)
+   :  m_base(0), m_size(0), m_offset(0),  m_extra_offset(0), m_mode(mode)
+   ,  m_file_mapping_hnd(ipcdetail::invalid_file())
+{
+   mapping_handle_t mhandle = mapping.get_mapping_handle();
+   file_handle_t native_mapping_handle = 0;
+
+   //Set accesses
+   unsigned long file_map_access = 0;
+   unsigned long map_access = 0;
+
+   switch(mode)
+   {
+      case read_only:
+      case read_private:
+         file_map_access   |= winapi::page_readonly;
+         map_access        |= winapi::file_map_read;
+      break;
+      case read_write:
+         file_map_access   |= winapi::page_readwrite;
+         map_access        |= winapi::file_map_write;
+      break;
+      case copy_on_write:
+         file_map_access   |= winapi::page_writecopy;
+         map_access        |= winapi::file_map_copy;
+      break;
+      default:
+         {
+            error_info err(mode_error);
+            throw interprocess_exception(err);
+         }
+      break;
+   }
+
+   if(!mhandle.is_shm){
+      //Update mapping size if the user does not specify it
+      if(size == 0){
+         __int64 total_size;
+         if(!winapi::get_file_size
+            (ipcdetail::file_handle_from_mapping_handle
+               (mapping.get_mapping_handle()), total_size)){
+            error_info err(winapi::get_last_error());
+            throw interprocess_exception(err);
+         }
+
+         if(static_cast<unsigned __int64>(total_size) >
+            (std::numeric_limits<std::size_t>::max)()){
+            error_info err(size_error);
+            throw interprocess_exception(err);
+         }
+         size = static_cast<std::size_t>(total_size - offset);
+      }
+
+      //Create file mapping
+      native_mapping_handle =
+         winapi::create_file_mapping
+         (ipcdetail::file_handle_from_mapping_handle(mapping.get_mapping_handle()), file_map_access, 0, 0, 0, 0);
+
+      //Check if all is correct
+      if(!native_mapping_handle){
+         error_info err = winapi::get_last_error();
+         this->priv_close();
+         throw interprocess_exception(err);
+      }
+   }
+
+   //We can't map any offset so we have to obtain system's
+   //memory granularity
+   unsigned long granularity = 0;
+   unsigned long foffset_low;
+   unsigned long foffset_high;
+
+   winapi::system_info info;
+   get_system_info(&info);
+   granularity = info.dwAllocationGranularity;
+
+   //Now we calculate valid offsets
+   foffset_low  = (unsigned long)(offset / granularity) * granularity;
+   foffset_high = (unsigned long)(((offset / granularity) * granularity) >> 32);
+
+   //We calculate the difference between demanded and valid offset
+   m_extra_offset = (offset - (offset / granularity) * granularity);
+
+   //Store user values in memory
+   m_offset = offset;
+   m_size   = size;
+
+   //Update the mapping address
+   if(address){
+      address = static_cast<const char*>(address) - m_extra_offset;
+   }
+
+   if(mhandle.is_shm){
+      //Windows shared memory needs the duplication of the handle if we want to
+      //make mapped_region independent from the mappable device
+      if(!winapi::duplicate_current_process_handle(mhandle.handle, &m_file_mapping_hnd)){
+         error_info err = winapi::get_last_error();
+         this->priv_close();
+         throw interprocess_exception(err);
+      }
+      native_mapping_handle = m_file_mapping_hnd;
+   }
+
+   //Map with new offsets and size
+   m_base = winapi::map_view_of_file_ex
+                               (native_mapping_handle,
+                                map_access,
+                                foffset_high,
+                                foffset_low,
+                                m_size ? static_cast<std::size_t>(m_extra_offset + m_size) : 0,
+                                const_cast<void*>(address));
+
+   if(!mhandle.is_shm){
+      //For files we don't need the file mapping anymore
+      winapi::close_handle(native_mapping_handle);
+   }
+
+   //Check error
+   if(!m_base){
+      error_info err = winapi::get_last_error();
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+
+   //Calculate new base for the user
+   m_base = static_cast<char*>(m_base) + m_extra_offset;
+}
+
+inline bool mapped_region::flush(std::size_t mapping_offset, std::size_t numbytes)
+{
+   //Check some errors
+   if(m_base == 0)
+      return false;
+
+   if(mapping_offset >= m_size || (mapping_offset + numbytes) > m_size){
+      return false;
+   }
+
+   //Update flush size if the user does not provide it
+   if(m_size == 0){
+      numbytes = 0;
+   }
+   else if(numbytes == 0){
+      numbytes = m_size - mapping_offset;
+   }
+
+   //Flush it all
+   return winapi::flush_view_of_file
+      (static_cast<char*>(m_base)+mapping_offset,
+       static_cast<std::size_t>(numbytes));
+}
+
+inline void mapped_region::priv_close()
+{
+   if(m_base){
+      winapi::unmap_view_of_file(static_cast<char*>(m_base) - m_extra_offset);
+      m_base = 0;
+   }
+   #if (defined BOOST_INTERPROCESS_WINDOWS)
+      if(m_file_mapping_hnd != ipcdetail::invalid_file()){
+         winapi::close_handle(m_file_mapping_hnd);
+         m_file_mapping_hnd = ipcdetail::invalid_file();
+      }
+   #endif
+}
+
+inline void mapped_region::dont_close_on_destruction()
+{}
+
+#else    //#if (defined BOOST_INTERPROCESS_WINDOWS)
+
+inline mapped_region::mapped_region()
+   :  m_base(0), m_size(0), m_offset(0), m_extra_offset(0), m_mode(read_only), m_is_xsi(false)
+{}
+
+template<int dummy>
+inline std::size_t mapped_region::page_size_holder<dummy>::get_page_size()
+{  return std::size_t(sysconf(_SC_PAGESIZE)); }
+
+template<class MemoryMappable>
+inline mapped_region::mapped_region
+   ( const MemoryMappable &mapping
+   , mode_t mode
+   , offset_t offset
+   , std::size_t size
+   , const void *address)
+   : m_base(0), m_size(0), m_offset(0), m_extra_offset(0), m_mode(mode), m_is_xsi(false)
+{
+   mapping_handle_t map_hnd = mapping.get_mapping_handle();
+
+   //Some systems dont' support XSI shared memory
+   #ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+   if(map_hnd.is_xsi){
+      //Get the size
+      ::shmid_ds xsi_ds;
+      int ret = ::shmctl(map_hnd.handle, IPC_STAT, &xsi_ds);
+      if(ret == -1){
+         error_info err(system_error_code());
+         throw interprocess_exception(err);
+      }
+      //Compare sizess
+      if(size == 0){
+         size = (std::size_t)xsi_ds.shm_segsz;
+      }
+      else if(size != (std::size_t)xsi_ds.shm_segsz){
+         error_info err(size_error);
+         throw interprocess_exception(err);
+      }
+      //Calculate flag
+      int flag = 0;
+      if(m_mode == read_only){
+         flag |= SHM_RDONLY;
+      }
+      else if(m_mode != read_write){
+         error_info err(mode_error);
+         throw interprocess_exception(err);
+      }
+      //Attach memory
+      void *base = ::shmat(map_hnd.handle, (void*)address, flag);
+      if(base == (void*)-1){
+         error_info err(system_error_code());
+         throw interprocess_exception(err);
+      }
+      //Update members
+      m_base   = base;
+      m_offset = offset;
+      m_size   = size;
+      m_mode   = mode;
+      m_extra_offset = 0;
+      m_is_xsi = true;
+      return;
+   }
+   #endif   //ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+   if(size == 0){
+      struct ::stat buf;
+      if(0 != fstat(map_hnd.handle, &buf)){
+         error_info err(system_error_code());
+         throw interprocess_exception(err);
+      }
+      std::size_t filesize = (std::size_t)buf.st_size;
+      if((std::size_t)offset >= filesize){
+         error_info err(size_error);
+         throw interprocess_exception(err);
+      }
+
+      filesize -= offset;
+      size = filesize;
+   }
+
+   //Create new mapping
+   int prot    = 0;
+   int flags   = 0;
+
+   switch(mode)
+   {
+      case read_only:
+         prot  |= PROT_READ;
+         flags |= MAP_SHARED;
+      break;
+
+      case read_private:
+         prot  |= (PROT_READ);
+         flags |= MAP_PRIVATE;
+      break;
+
+      case read_write:
+         prot  |= (PROT_WRITE | PROT_READ);
+         flags |= MAP_SHARED;
+      break;
+
+      case copy_on_write:
+         prot  |= (PROT_WRITE | PROT_READ);
+         flags |= MAP_PRIVATE;
+      break;
+
+      default:
+         {
+            error_info err(mode_error);
+            throw interprocess_exception(err);
+         }
+      break;
+   }
+
+   //We calculate the difference between demanded and valid offset
+   const std::size_t page_size = this->get_page_size();
+   const offset_t extra_offset = offset - (offset / page_size) * page_size;
+
+
+   //Update the mapping address
+   if(address){
+      address = static_cast<const char*>(address) - extra_offset;
+   }
+
+   //Map it to the address space
+   void* base = mmap ( const_cast<void*>(address)
+                     , static_cast<std::size_t>(extra_offset + size)
+                     , prot
+                     , flags
+                     , mapping.get_mapping_handle().handle
+                     , offset - extra_offset);
+
+   //Check if mapping was successful
+   if(base == MAP_FAILED){
+      error_info err = system_error_code();
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+
+   //Calculate new base for the user
+   m_base = static_cast<char*>(base) + extra_offset; 
+   m_extra_offset = extra_offset;
+   m_offset = offset;
+   m_size   = size;
+
+   //Check for fixed mapping error
+   if(address && (base != address)){
+      error_info err(busy_error);
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+}
+
+inline bool mapped_region::flush(std::size_t mapping_offset, std::size_t numbytes)
+{
+   if(mapping_offset >= m_size || (mapping_offset+numbytes)> m_size){
+      return false;
+   }
+
+   if(numbytes == 0){
+      numbytes = m_size - mapping_offset;
+   }
+   //Flush it all
+   return msync(static_cast<char*>(m_base)+mapping_offset, numbytes, MS_ASYNC) == 0;
+}
+
+inline void mapped_region::priv_close()
+{
+   if(m_base != 0){
+      #ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+      if(m_is_xsi){
+         int ret = ::shmdt(m_base);
+         BOOST_ASSERT(ret == 0);
+         (void)ret;
+         return;
+      }
+      #endif //#ifdef BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS
+      munmap(static_cast<char*>(m_base) - m_extra_offset, m_size + m_extra_offset);
+      m_base = 0;
+   }
+}
+
+inline void mapped_region::dont_close_on_destruction()
+{  m_base = 0;   }
+
+#endif   //##if (defined BOOST_INTERPROCESS_WINDOWS)
+
+template<int dummy>
+const std::size_t mapped_region::page_size_holder<dummy>::PageSize
+   = mapped_region::page_size_holder<dummy>::get_page_size();
+
+inline std::size_t mapped_region::get_page_size()
+{
+   if(!page_size_holder<0>::PageSize)
+      return page_size_holder<0>::get_page_size();
+   else
+      return page_size_holder<0>::PageSize;
+}
+
+inline void mapped_region::swap(mapped_region &other)
+{
+   ipcdetail::do_swap(this->m_base, other.m_base);
+   ipcdetail::do_swap(this->m_size, other.m_size);
+   ipcdetail::do_swap(this->m_offset, other.m_offset);
+   ipcdetail::do_swap(this->m_extra_offset,     other.m_extra_offset);
+   ipcdetail::do_swap(this->m_mode,  other.m_mode);
+   #if (defined BOOST_INTERPROCESS_WINDOWS)
+   ipcdetail::do_swap(this->m_file_mapping_hnd, other.m_file_mapping_hnd);
+   #else
+   ipcdetail::do_swap(this->m_is_xsi, other.m_is_xsi);
+   #endif
+}
+
+//!No-op functor
+struct null_mapped_region_function
+{
+   bool operator()(void *, std::size_t , bool) const
+      {   return true;   }
+};
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MAPPED_REGION_HPP
+
diff --git a/boost/interprocess/mem_algo/detail/mem_algo_common.hpp b/boost/interprocess/mem_algo/detail/mem_algo_common.hpp
new file mode 100644
index 0000000000..d609f46aee
--- /dev/null
+++ b/boost/interprocess/mem_algo/detail/mem_algo_common.hpp
@@ -0,0 +1,554 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_MEM_ALGO_COMMON_HPP
+#define BOOST_INTERPROCESS_DETAIL_MEM_ALGO_COMMON_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/containers/allocation_type.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/detail/math_functions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/min_max.hpp>
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <algorithm>
+#include <utility>
+#include <iterator>
+#include <boost/assert.hpp>
+
+//!\file
+//!Implements common operations for memory algorithms.
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+//!This class implements several allocation functions shared by different algorithms
+//!(aligned allocation, multiple allocation...).
+template<class MemoryAlgorithm>
+class memory_algorithm_common
+{
+   public:
+   typedef typename MemoryAlgorithm::void_pointer              void_pointer;
+   typedef typename MemoryAlgorithm::block_ctrl                block_ctrl;
+   typedef typename MemoryAlgorithm::multiallocation_chain     multiallocation_chain;
+   typedef memory_algorithm_common<MemoryAlgorithm>            this_type;
+   typedef typename MemoryAlgorithm::size_type                 size_type;
+
+   static const size_type Alignment              = MemoryAlgorithm::Alignment;
+   static const size_type MinBlockUnits          = MemoryAlgorithm::MinBlockUnits;
+   static const size_type AllocatedCtrlBytes     = MemoryAlgorithm::AllocatedCtrlBytes;
+   static const size_type AllocatedCtrlUnits     = MemoryAlgorithm::AllocatedCtrlUnits;
+   static const size_type BlockCtrlBytes         = MemoryAlgorithm::BlockCtrlBytes;
+   static const size_type BlockCtrlUnits         = MemoryAlgorithm::BlockCtrlUnits;
+   static const size_type UsableByPreviousChunk  = MemoryAlgorithm::UsableByPreviousChunk;
+
+   static void assert_alignment(const void *ptr)
+   {  assert_alignment((std::size_t)ptr); }
+
+   static void assert_alignment(size_type uint_ptr)
+   {
+      (void)uint_ptr;
+      BOOST_ASSERT(uint_ptr % Alignment == 0);
+   }
+
+   static bool check_alignment(const void *ptr)
+   {  return (((std::size_t)ptr) % Alignment == 0);   }
+
+   static size_type ceil_units(size_type size)
+   {  return get_rounded_size(size, Alignment)/Alignment; }
+
+   static size_type floor_units(size_type size)
+   {  return size/Alignment;  }
+
+   static size_type multiple_of_units(size_type size)
+   {  return get_rounded_size(size, Alignment);  }
+
+   static multiallocation_chain allocate_many
+      (MemoryAlgorithm *memory_algo, size_type elem_bytes, size_type n_elements)
+   {
+      return this_type::priv_allocate_many(memory_algo, &elem_bytes, n_elements, 0);
+   }
+
+   static void deallocate_many(MemoryAlgorithm *memory_algo, multiallocation_chain chain)
+   {
+      return this_type::priv_deallocate_many(memory_algo, boost::move(chain));
+   }
+
+   static bool calculate_lcm_and_needs_backwards_lcmed
+      (size_type backwards_multiple, size_type received_size, size_type size_to_achieve,
+      size_type &lcm_out, size_type &needs_backwards_lcmed_out)
+   {
+      // Now calculate lcm_val
+      size_type max = backwards_multiple;
+      size_type min = Alignment;
+      size_type needs_backwards;
+      size_type needs_backwards_lcmed;
+      size_type lcm_val;
+      size_type current_forward;
+      //Swap if necessary
+      if(max < min){
+         size_type tmp = min;
+         min = max;
+         max = tmp;
+      }
+      //Check if it's power of two
+      if((backwards_multiple & (backwards_multiple-1)) == 0){
+         if(0 != (size_to_achieve & ((backwards_multiple-1)))){
+            return false;
+         }
+
+         lcm_val = max;
+         //If we want to use minbytes data to get a buffer between maxbytes
+         //and minbytes if maxbytes can't be achieved, calculate the 
+         //biggest of all possibilities
+         current_forward = get_truncated_size_po2(received_size, backwards_multiple);
+         needs_backwards = size_to_achieve - current_forward;
+         BOOST_ASSERT((needs_backwards % backwards_multiple) == 0);
+         needs_backwards_lcmed = get_rounded_size_po2(needs_backwards, lcm_val);
+         lcm_out = lcm_val;
+         needs_backwards_lcmed_out = needs_backwards_lcmed;
+         return true;
+      }
+      //Check if it's multiple of alignment
+      else if((backwards_multiple & (Alignment - 1u)) == 0){
+         lcm_val = backwards_multiple;
+         current_forward = get_truncated_size(received_size, backwards_multiple);
+         //No need to round needs_backwards because backwards_multiple == lcm_val
+         needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;
+         BOOST_ASSERT((needs_backwards_lcmed & (Alignment - 1u)) == 0);
+         lcm_out = lcm_val;
+         needs_backwards_lcmed_out = needs_backwards_lcmed;
+         return true;
+      }
+      //Check if it's multiple of the half of the alignmment
+      else if((backwards_multiple & ((Alignment/2u) - 1u)) == 0){
+         lcm_val = backwards_multiple*2u;
+         current_forward = get_truncated_size(received_size, backwards_multiple);
+         needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;
+         if(0 != (needs_backwards_lcmed & (Alignment-1)))
+         //while(0 != (needs_backwards_lcmed & (Alignment-1)))
+            needs_backwards_lcmed += backwards_multiple;
+         BOOST_ASSERT((needs_backwards_lcmed % lcm_val) == 0);
+         lcm_out = lcm_val;
+         needs_backwards_lcmed_out = needs_backwards_lcmed;
+         return true;
+      }
+      //Check if it's multiple of the quarter of the alignmment
+      else if((backwards_multiple & ((Alignment/4u) - 1u)) == 0){
+         size_type remainder;
+         lcm_val = backwards_multiple*4u;
+         current_forward = get_truncated_size(received_size, backwards_multiple);
+         needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;
+         //while(0 != (needs_backwards_lcmed & (Alignment-1)))
+            //needs_backwards_lcmed += backwards_multiple;
+         if(0 != (remainder = ((needs_backwards_lcmed & (Alignment-1))>>(Alignment/8u)))){
+            if(backwards_multiple & Alignment/2u){
+               needs_backwards_lcmed += (remainder)*backwards_multiple;
+            }
+            else{
+               needs_backwards_lcmed += (4-remainder)*backwards_multiple;
+            }
+         }
+         BOOST_ASSERT((needs_backwards_lcmed % lcm_val) == 0);
+         lcm_out = lcm_val;
+         needs_backwards_lcmed_out = needs_backwards_lcmed;
+         return true;
+      }
+      else{
+         lcm_val = lcm(max, min);
+      }
+      //If we want to use minbytes data to get a buffer between maxbytes
+      //and minbytes if maxbytes can't be achieved, calculate the 
+      //biggest of all possibilities
+      current_forward = get_truncated_size(received_size, backwards_multiple);
+      needs_backwards = size_to_achieve - current_forward;
+      BOOST_ASSERT((needs_backwards % backwards_multiple) == 0);
+      needs_backwards_lcmed = get_rounded_size(needs_backwards, lcm_val);
+      lcm_out = lcm_val;
+      needs_backwards_lcmed_out = needs_backwards_lcmed;
+      return true;
+   }
+
+   static multiallocation_chain allocate_many
+      ( MemoryAlgorithm *memory_algo
+      , const size_type *elem_sizes
+      , size_type n_elements
+      , size_type sizeof_element)
+   {
+      return this_type::priv_allocate_many(memory_algo, elem_sizes, n_elements, sizeof_element);
+   }
+
+   static void* allocate_aligned
+      (MemoryAlgorithm *memory_algo, size_type nbytes, size_type alignment)
+   {
+      
+      //Ensure power of 2
+      if ((alignment & (alignment - size_type(1u))) != 0){
+         //Alignment is not power of two
+         BOOST_ASSERT((alignment & (alignment - size_type(1u))) == 0);
+         return 0;
+      }
+
+      size_type real_size;
+      if(alignment <= Alignment){
+         return memory_algo->priv_allocate
+            (boost::interprocess::allocate_new, nbytes, nbytes, real_size).first;
+      }
+
+      if(nbytes > UsableByPreviousChunk)
+         nbytes -= UsableByPreviousChunk;
+      
+      //We can find a aligned portion if we allocate a block that has alignment
+      //nbytes + alignment bytes or more.
+      size_type minimum_allocation = max_value
+         (nbytes + alignment, size_type(MinBlockUnits*Alignment));
+      //Since we will split that block, we must request a bit more memory
+      //if the alignment is near the beginning of the buffer, because otherwise,
+      //there is no space for a new block before the alignment.
+      // 
+      //            ____ Aligned here
+      //           |
+      //  -----------------------------------------------------
+      // | MBU | 
+      //  -----------------------------------------------------
+      size_type request = 
+         minimum_allocation + (2*MinBlockUnits*Alignment - AllocatedCtrlBytes
+         //prevsize - UsableByPreviousChunk
+         );
+
+      //Now allocate the buffer
+      void *buffer = memory_algo->priv_allocate
+         (boost::interprocess::allocate_new, request, request, real_size).first;
+      if(!buffer){
+         return 0;
+      }
+      else if ((((std::size_t)(buffer)) % alignment) == 0){
+         //If we are lucky and the buffer is aligned, just split it and
+         //return the high part
+         block_ctrl *first  = memory_algo->priv_get_block(buffer);
+         size_type old_size = first->m_size;
+         const size_type first_min_units =
+            max_value(ceil_units(nbytes) + AllocatedCtrlUnits, size_type(MinBlockUnits));
+         //We can create a new block in the end of the segment
+         if(old_size >= (first_min_units + MinBlockUnits)){
+            block_ctrl *second =  reinterpret_cast<block_ctrl *>
+               (reinterpret_cast<char*>(first) + Alignment*first_min_units);
+            first->m_size  = first_min_units;
+            second->m_size = old_size - first->m_size;
+            BOOST_ASSERT(second->m_size >= MinBlockUnits);
+            memory_algo->priv_mark_new_allocated_block(first);
+            //memory_algo->priv_tail_size(first, first->m_size);
+            memory_algo->priv_mark_new_allocated_block(second);
+            memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(second));
+         }
+         return buffer;
+      }
+
+      //Buffer not aligned, find the aligned part.
+      // 
+      //                    ____ Aligned here
+      //                   |
+      //  -----------------------------------------------------
+      // | MBU +more | ACB |
+      //  -----------------------------------------------------
+      char *pos = reinterpret_cast<char*>
+         (reinterpret_cast<std::size_t>(static_cast<char*>(buffer) +
+            //This is the minimum size of (2)
+            (MinBlockUnits*Alignment - AllocatedCtrlBytes) +
+            //This is the next MBU for the aligned memory
+            AllocatedCtrlBytes +
+            //This is the alignment trick
+            alignment - 1) & -alignment);
+
+      //Now obtain the address of the blocks
+      block_ctrl *first  = memory_algo->priv_get_block(buffer);
+      block_ctrl *second = memory_algo->priv_get_block(pos);
+      BOOST_ASSERT(pos <= (reinterpret_cast<char*>(first) + first->m_size*Alignment));
+      BOOST_ASSERT(first->m_size >= 2*MinBlockUnits);
+      BOOST_ASSERT((pos + MinBlockUnits*Alignment - AllocatedCtrlBytes + nbytes*Alignment/Alignment) <=
+             (reinterpret_cast<char*>(first) + first->m_size*Alignment));
+      //Set the new size of the first block
+      size_type old_size = first->m_size;
+      first->m_size  = (size_type)(reinterpret_cast<char*>(second) - reinterpret_cast<char*>(first))/Alignment;
+      memory_algo->priv_mark_new_allocated_block(first);
+
+      //Now check if we can create a new buffer in the end
+      //
+      //              __"second" block
+      //             |      __Aligned here
+      //             |     |      __"third" block
+      //  -----------|-----|-----|------------------------------
+      // | MBU +more | ACB | (3) | BCU |
+      //  -----------------------------------------------------
+      //This size will be the minimum size to be able to create a
+      //new block in the end.
+      const size_type second_min_units = max_value(size_type(MinBlockUnits),
+                        ceil_units(nbytes) + AllocatedCtrlUnits );
+
+      //Check if we can create a new block (of size MinBlockUnits) in the end of the segment
+      if((old_size - first->m_size) >= (second_min_units + MinBlockUnits)){
+         //Now obtain the address of the end block
+         block_ctrl *third = new (reinterpret_cast<char*>(second) + Alignment*second_min_units)block_ctrl;
+         second->m_size = second_min_units;
+         third->m_size  = old_size - first->m_size - second->m_size;
+         BOOST_ASSERT(third->m_size >= MinBlockUnits);
+         memory_algo->priv_mark_new_allocated_block(second);
+         memory_algo->priv_mark_new_allocated_block(third);
+         memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(third));
+      }
+      else{
+         second->m_size = old_size - first->m_size;
+         BOOST_ASSERT(second->m_size >= MinBlockUnits);
+         memory_algo->priv_mark_new_allocated_block(second);
+      }
+
+      memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(first));
+      return memory_algo->priv_get_user_buffer(second);
+   }
+
+   static bool try_shrink 
+      (MemoryAlgorithm *memory_algo, void *ptr
+      ,const size_type max_size,   const size_type preferred_size
+      ,size_type &received_size)
+   {
+      (void)memory_algo;
+      //Obtain the real block
+      block_ctrl *block = memory_algo->priv_get_block(ptr);
+      size_type old_block_units = (size_type)block->m_size;
+
+      //The block must be marked as allocated
+      BOOST_ASSERT(memory_algo->priv_is_allocated_block(block));
+
+      //Check if alignment and block size are right
+      assert_alignment(ptr);
+
+      //Put this to a safe value
+      received_size = (old_block_units - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+
+      //Now translate it to Alignment units
+      const size_type max_user_units       = floor_units(max_size - UsableByPreviousChunk);
+      const size_type preferred_user_units = ceil_units(preferred_size - UsableByPreviousChunk);
+
+      //Check if rounded max and preferred are possible correct
+      if(max_user_units < preferred_user_units)
+         return false;
+
+      //Check if the block is smaller than the requested minimum
+      size_type old_user_units = old_block_units - AllocatedCtrlUnits;
+
+      if(old_user_units < preferred_user_units)
+         return false;
+
+      //If the block is smaller than the requested minimum
+      if(old_user_units == preferred_user_units)
+         return true;
+
+      size_type shrunk_user_units = 
+         ((BlockCtrlUnits - AllocatedCtrlUnits) > preferred_user_units)
+         ? (BlockCtrlUnits - AllocatedCtrlUnits)
+         : preferred_user_units;
+
+      //Some parameter checks
+      if(max_user_units < shrunk_user_units)
+         return false;
+
+      //We must be able to create at least a new empty block
+      if((old_user_units - shrunk_user_units) < BlockCtrlUnits ){
+         return false;
+      }
+
+      //Update new size
+      received_size = shrunk_user_units*Alignment + UsableByPreviousChunk;
+      return true;
+   }
+
+   static bool shrink 
+      (MemoryAlgorithm *memory_algo, void *ptr
+      ,const size_type max_size,   const size_type preferred_size
+      ,size_type &received_size)
+   {
+      //Obtain the real block
+      block_ctrl *block = memory_algo->priv_get_block(ptr);
+      size_type old_block_units = (size_type)block->m_size;
+
+      if(!try_shrink 
+         (memory_algo, ptr, max_size, preferred_size, received_size)){
+         return false;
+      }
+
+      //Check if the old size was just the shrunk size (no splitting)
+      if((old_block_units - AllocatedCtrlUnits) == ceil_units(preferred_size - UsableByPreviousChunk))
+         return true;
+
+      //Now we can just rewrite the size of the old buffer
+      block->m_size = (received_size-UsableByPreviousChunk)/Alignment + AllocatedCtrlUnits;
+      BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
+
+      //We create the new block
+      block_ctrl *new_block = reinterpret_cast<block_ctrl*>
+                  (reinterpret_cast<char*>(block) + block->m_size*Alignment);
+      //Write control data to simulate this new block was previously allocated
+      //and deallocate it
+      new_block->m_size = old_block_units - block->m_size;
+      BOOST_ASSERT(new_block->m_size >= BlockCtrlUnits);
+      memory_algo->priv_mark_new_allocated_block(block);
+      memory_algo->priv_mark_new_allocated_block(new_block);
+      memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(new_block));
+      return true;
+   }
+
+   private:
+   static multiallocation_chain priv_allocate_many
+      ( MemoryAlgorithm *memory_algo
+      , const size_type *elem_sizes
+      , size_type n_elements
+      , size_type sizeof_element)
+   {
+      //Note: sizeof_element == 0 indicates that we want to
+      //allocate n_elements of the same size "*elem_sizes"
+
+      //Calculate the total size of all requests
+      size_type total_request_units = 0;
+      size_type elem_units = 0;
+      const size_type ptr_size_units = memory_algo->priv_get_total_units(sizeof(void_pointer));
+      if(!sizeof_element){
+         elem_units = memory_algo->priv_get_total_units(*elem_sizes);
+         elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
+         total_request_units = n_elements*elem_units;
+      }
+      else{
+         for(size_type i = 0; i < n_elements; ++i){
+            elem_units = memory_algo->priv_get_total_units(elem_sizes[i]*sizeof_element);
+            elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
+            total_request_units += elem_units;
+         }
+      }
+
+      multiallocation_chain chain;
+
+      size_type low_idx = 0;
+      while(low_idx < n_elements){
+         size_type total_bytes = total_request_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
+         size_type min_allocation = (!sizeof_element)
+            ?  elem_units
+            :  memory_algo->priv_get_total_units(elem_sizes[low_idx]*sizeof_element);
+         min_allocation = min_allocation*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
+
+         size_type received_size;
+         std::pair<void *, bool> ret = memory_algo->priv_allocate
+            (boost::interprocess::allocate_new, min_allocation, total_bytes, received_size, 0);
+         if(!ret.first){
+            break;
+         }
+
+         block_ctrl *block = memory_algo->priv_get_block(ret.first);
+         size_type received_units = (size_type)block->m_size;
+         char *block_address = reinterpret_cast<char*>(block);
+
+         size_type total_used_units = 0;
+//         block_ctrl *prev_block = 0;
+         while(total_used_units < received_units){
+            if(sizeof_element){
+               elem_units = memory_algo->priv_get_total_units(elem_sizes[low_idx]*sizeof_element);
+               elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
+            }
+            if(total_used_units + elem_units > received_units)
+               break;
+            total_request_units -= elem_units;
+            //This is the position where the new block must be created
+            block_ctrl *new_block = reinterpret_cast<block_ctrl *>(block_address);
+            assert_alignment(new_block);
+
+            //The last block should take all the remaining space
+            if((low_idx + 1) == n_elements ||
+               (total_used_units + elem_units + 
+               ((!sizeof_element)
+                  ? elem_units
+              : std::max(memory_algo->priv_get_total_units(elem_sizes[low_idx+1]*sizeof_element), ptr_size_units))
+               ) > received_units){
+               //By default, the new block will use the rest of the buffer
+               new_block->m_size = received_units - total_used_units;
+               memory_algo->priv_mark_new_allocated_block(new_block);
+
+               //If the remaining units are bigger than needed and we can
+               //split it obtaining a new free memory block do it.
+               if((received_units - total_used_units) >= (elem_units + MemoryAlgorithm::BlockCtrlUnits)){
+                  size_type shrunk_received;
+                  size_type shrunk_request = elem_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
+                  bool shrink_ok = shrink
+                        (memory_algo
+                        ,memory_algo->priv_get_user_buffer(new_block)
+                        ,shrunk_request
+                        ,shrunk_request
+                        ,shrunk_received);
+                  (void)shrink_ok;
+                  //Shrink must always succeed with passed parameters
+                  BOOST_ASSERT(shrink_ok);
+                  //Some sanity checks
+                  BOOST_ASSERT(shrunk_request == shrunk_received);
+                  BOOST_ASSERT(elem_units == ((shrunk_request-UsableByPreviousChunk)/Alignment + AllocatedCtrlUnits));
+                  //"new_block->m_size" must have been reduced to elem_units by "shrink"
+                  BOOST_ASSERT(new_block->m_size == elem_units);
+                  //Now update the total received units with the reduction
+                  received_units = elem_units + total_used_units;
+               }
+            }
+            else{
+               new_block->m_size = elem_units;
+               memory_algo->priv_mark_new_allocated_block(new_block);
+            }
+
+            block_address += new_block->m_size*Alignment;
+            total_used_units += (size_type)new_block->m_size;
+            //Check we have enough room to overwrite the intrusive pointer
+            BOOST_ASSERT((new_block->m_size*Alignment - AllocatedCtrlUnits) >= sizeof(void_pointer));
+            void_pointer p = new(memory_algo->priv_get_user_buffer(new_block))void_pointer(0);
+            chain.push_back(p);
+            ++low_idx;
+            //prev_block = new_block;
+         }
+         //Sanity check
+         BOOST_ASSERT(total_used_units == received_units);
+      }
+      
+      if(low_idx != n_elements){
+         priv_deallocate_many(memory_algo, boost::move(chain));
+      }
+      return boost::move(chain);
+   }
+
+   static void priv_deallocate_many(MemoryAlgorithm *memory_algo, multiallocation_chain chain)
+   {
+      while(!chain.empty()){
+         void *addr = to_raw_pointer(chain.front());
+         chain.pop_front();
+         memory_algo->priv_deallocate(addr);
+      }
+   }
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_MEM_ALGO_COMMON_HPP
diff --git a/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp b/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp
new file mode 100644
index 0000000000..e8b678d9f3
--- /dev/null
+++ b/boost/interprocess/mem_algo/detail/multi_simple_seq_fit.hpp
@@ -0,0 +1,61 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MULTI_SIMPLE_SEQ_FIT_HPP
+#define BOOST_INTERPROCESS_MULTI_SIMPLE_SEQ_FIT_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp>
+#include <boost/interprocess/intersegment_ptr.hpp>
+
+/*!\file
+   Describes sequential fit algorithm used to allocate objects in shared memory.
+*/
+
+namespace boost {
+
+namespace interprocess {
+
+/*!This class implements the simple sequential fit algorithm with a simply
+   linked list of free buffers.*/
+template<class MutexFamily, class VoidPtr>
+class multi_simple_seq_fit 
+   : public ipcdetail::simple_seq_fit_impl<MutexFamily, VoidPtr>
+{
+   typedef ipcdetail::simple_seq_fit_impl<MutexFamily, VoidPtr> base_t;
+ public:
+   /*!Constructor. "size" is the total size of the managed memory segment, 
+      "extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(multi_simple_seq_fit)
+      offset that the allocator should not use at all.*/
+   multi_simple_seq_fit           (size_type size, size_type extra_hdr_bytes)
+      : base_t(size, extra_hdr_bytes){}
+
+   /*!Allocates bytes from existing segments. If there is no memory, it uses
+      the growing functor associated with the group to allocate a new segment.
+      If this fails, returns 0.*/
+   void* allocate             (size_type nbytes)
+      {  return base_t::multi_allocate(nbytes);   }
+};
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MULTI_SIMPLE_SEQ_FIT_HPP
+
diff --git a/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp b/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp
new file mode 100644
index 0000000000..7a2c7a83c1
--- /dev/null
+++ b/boost/interprocess/mem_algo/detail/multi_simple_seq_fit_impl.hpp
@@ -0,0 +1,983 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MEM_ALGO_DETAIL_SIMPLE_SEQ_FIT_IMPL_HPP
+#define BOOST_INTERPROCESS_MEM_ALGO_DETAIL_SIMPLE_SEQ_FIT_IMPL_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/containers/allocation_type.hpp>
+#include <boost/interprocess/offset_ptr.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/multi_segment_services.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/interprocess/detail/min_max.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <algorithm>
+#include <utility>
+#include <cstring>
+
+#include <boost/assert.hpp>
+#include <new>
+
+/*!\file
+   Describes sequential fit algorithm used to allocate objects in shared memory.
+   This class is intended as a base class for single segment and multi-segment
+   implementations.
+*/
+
+namespace boost {
+
+namespace interprocess {
+
+namespace ipcdetail {
+
+/*!This class implements the simple sequential fit algorithm with a simply
+   linked list of free buffers.
+   This class is intended as a base class for single segment and multi-segment
+   implementations.*/
+template<class MutexFamily, class VoidPointer>
+class simple_seq_fit_impl
+{
+   //Non-copyable
+   simple_seq_fit_impl();
+   simple_seq_fit_impl(const simple_seq_fit_impl &);
+   simple_seq_fit_impl &operator=(const simple_seq_fit_impl &);
+
+   public:
+   /*!Shared interprocess_mutex family used for the rest of the Interprocess framework*/
+   typedef MutexFamily        mutex_family;
+   /*!Pointer type to be used with the rest of the Interprocess framework*/
+   typedef VoidPointer        void_pointer;
+
+   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type size_type;
+
+
+   private:
+   struct block_ctrl;
+   typedef typename boost::intrusive::
+      pointer_traits<void_pointer>::template
+         rebind_pointer<block_ctrl>::type                         block_ctrl_ptr;
+
+   /*!Block control structure*/
+   struct block_ctrl
+   {
+      /*!Offset pointer to the next block.*/
+      block_ctrl_ptr m_next;
+      /*!This block's memory size (including block_ctrl 
+         header) in BasicSize units*/
+      size_type    m_size;
+   
+      size_type get_user_bytes() const
+      {  return this->m_size*Alignment - BlockCtrlBytes; }
+
+      size_type get_total_bytes() const
+      {  return this->m_size*Alignment; }
+
+      static block_ctrl *get_block_from_addr(void *addr)
+      {
+         return reinterpret_cast<block_ctrl*>
+            (reinterpret_cast<char*>(addr) - BlockCtrlBytes);
+      }
+
+      void *get_addr() const
+      {
+         return reinterpret_cast<block_ctrl*>
+            (reinterpret_cast<const char*>(this) + BlockCtrlBytes);
+      }
+
+   };
+
+   /*!Shared interprocess_mutex to protect memory allocate/deallocate*/
+   typedef typename MutexFamily::mutex_type        interprocess_mutex;
+
+   /*!This struct includes needed data and derives from
+      interprocess_mutex to allow EBO when using null interprocess_mutex*/
+   struct header_t : public interprocess_mutex
+   {
+      /*!Pointer to the first free block*/
+      block_ctrl        m_root;
+      /*!Allocated bytes for internal checking*/
+      size_type       m_allocated;
+      /*!The size of the memory segment*/
+      size_type       m_size;
+   }  m_header;
+
+   public:
+   /*!Constructor. "size" is the total size of the managed memory segment, 
+      "extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit_impl)
+      offset that the allocator should not use at all.*/
+   simple_seq_fit_impl           (size_type size, size_type extra_hdr_bytes);
+   /*!Destructor.*/
+   ~simple_seq_fit_impl();
+   /*!Obtains the minimum size needed by the algorithm*/
+   static size_type get_min_size (size_type extra_hdr_bytes);
+
+   //Functions for single segment management
+
+   /*!Allocates bytes, returns 0 if there is not more memory*/
+   void* allocate             (size_type nbytes);
+
+   /*!Deallocates previously allocated bytes*/
+   void   deallocate          (void *addr);
+
+   /*!Returns the size of the memory segment*/
+   size_type get_size()  const;
+
+   /*!Increases managed memory in extra_size bytes more*/
+   void grow(size_type extra_size);
+
+   /*!Returns true if all allocated memory has been deallocated*/
+   bool all_memory_deallocated();
+
+   /*!Makes an internal sanity check and returns true if success*/
+   bool check_sanity();
+
+   //!Initializes to zero all the memory that's not in use.
+   //!This function is normally used for security reasons.
+   void clear_free_memory();
+
+   std::pair<void *, bool>
+      allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                           size_type preferred_size,size_type &received_size, 
+                           void *reuse_ptr = 0, size_type backwards_multiple = 1);
+
+   /*!Returns the size of the buffer previously allocated pointed by ptr*/
+   size_type size(void *ptr) const;
+
+   /*!Allocates aligned bytes, returns 0 if there is not more memory.
+      Alignment must be power of 2*/
+   void* allocate_aligned     (size_type nbytes, size_type alignment);
+
+   /*!Allocates bytes, if there is no more memory, it executes functor
+      f(size_type) to allocate a new segment to manage. The functor returns 
+      std::pair<void*, size_type> indicating the base address and size of 
+      the new segment. If the new segment can't be allocated, allocate
+      it will return 0.*/
+   void* multi_allocate(size_type nbytes);
+
+   private:
+   /*!Real allocation algorithm with min allocation option*/
+   std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
+                                        ,size_type min_size
+                                        ,size_type preferred_size
+                                        ,size_type &received_size
+                                        ,void *reuse_ptr = 0);
+   /*!Returns next block if it's free.
+      Returns 0 if next block is not free.*/
+   block_ctrl *priv_next_block_if_free(block_ctrl *ptr);
+
+   /*!Returns previous block's if it's free.
+      Returns 0 if previous block is not free.*/
+   std::pair<block_ctrl*, block_ctrl*>priv_prev_block_if_free(block_ctrl *ptr);
+
+   /*!Real expand function implementation*/
+   bool priv_expand(void *ptr
+                   ,size_type min_size, size_type preferred_size
+                   ,size_type &received_size);
+
+   /*!Real expand to both sides implementation*/
+   void* priv_expand_both_sides(boost::interprocess::allocation_type command
+                               ,size_type min_size
+                               ,size_type preferred_size
+                               ,size_type &received_size
+                               ,void *reuse_ptr
+                               ,bool only_preferred_backwards);
+
+   /*!Real shrink function implementation*/
+   bool priv_shrink(void *ptr
+                   ,size_type max_size, size_type preferred_size
+                   ,size_type &received_size);
+
+   //!Real private aligned allocation function
+   void* priv_allocate_aligned     (size_type nbytes, size_type alignment);
+
+   /*!Checks if block has enough memory and splits/unlinks the block
+      returning the address to the users*/
+   void* priv_check_and_allocate(size_type units
+                                ,block_ctrl* prev
+                                ,block_ctrl* block
+                                ,size_type &received_size);
+   /*!Real deallocation algorithm*/
+   void priv_deallocate(void *addr);
+
+   /*!Makes a new memory portion available for allocation*/
+   void priv_add_segment(void *addr, size_type size);
+
+   static const std::size_t Alignment = ::boost::alignment_of<boost::ipcdetail::max_align>::value;
+   static const std::size_t BlockCtrlBytes = ipcdetail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
+   static const std::size_t BlockCtrlSize  = BlockCtrlBytes/Alignment;
+   static const std::size_t MinBlockSize   = BlockCtrlSize + Alignment;
+
+   public:
+   static const std::size_t PayloadPerAllocation = BlockCtrlBytes;
+};
+
+template<class MutexFamily, class VoidPointer>
+inline simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   simple_seq_fit_impl(size_type size, size_type extra_hdr_bytes)
+{
+   //Initialize sizes and counters
+   m_header.m_allocated = 0;
+   m_header.m_size      = size;
+
+   //Initialize pointers
+   size_type block1_off  = ipcdetail::get_rounded_size(sizeof(*this)+extra_hdr_bytes, Alignment);
+   m_header.m_root.m_next  = reinterpret_cast<block_ctrl*>
+                              (reinterpret_cast<char*>(this) + block1_off);
+   m_header.m_root.m_next->m_size  = (size - block1_off)/Alignment;
+   m_header.m_root.m_next->m_next  = &m_header.m_root;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline simple_seq_fit_impl<MutexFamily, VoidPointer>::~simple_seq_fit_impl()
+{
+   //There is a memory leak!
+//   BOOST_ASSERT(m_header.m_allocated == 0);
+//   BOOST_ASSERT(m_header.m_root.m_next->m_next == block_ctrl_ptr(&m_header.m_root));
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::grow(size_type extra_size)
+{  
+   //Old highest address block's end offset
+   size_type old_end = m_header.m_size/Alignment*Alignment;
+
+   //Update managed buffer's size
+   m_header.m_size += extra_size;
+
+   //We need at least MinBlockSize blocks to create a new block
+   if((m_header.m_size - old_end) < MinBlockSize){
+      return;
+   }
+
+   //We'll create a new free block with extra_size bytes
+   block_ctrl *new_block = reinterpret_cast<block_ctrl*>
+                              (reinterpret_cast<char*>(this) + old_end);
+
+   new_block->m_next = 0;
+   new_block->m_size = (m_header.m_size - old_end)/Alignment;
+   m_header.m_allocated += new_block->m_size*Alignment;
+   this->priv_deallocate(reinterpret_cast<char*>(new_block) + BlockCtrlBytes);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_add_segment(void *addr, size_type size)
+{  
+   //Check size
+   BOOST_ASSERT(!(size < MinBlockSize));
+   if(size < MinBlockSize)
+      return;
+   //Construct big block using the new segment
+   block_ctrl *new_block   = static_cast<block_ctrl *>(addr);
+   new_block->m_size       = size/Alignment;
+   new_block->m_next       = 0;
+   //Simulate this block was previously allocated
+   m_header.m_allocated   += new_block->m_size*Alignment; 
+   //Return block and insert it in the free block list
+   this->priv_deallocate(reinterpret_cast<char*>(new_block) + BlockCtrlBytes);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::get_size()  const
+   {  return m_header.m_size;  }
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   get_min_size (size_type extra_hdr_bytes)
+{
+   return ipcdetail::get_rounded_size(sizeof(simple_seq_fit_impl)+extra_hdr_bytes
+                                  ,Alignment)
+          + MinBlockSize;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+    all_memory_deallocated()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   return m_header.m_allocated == 0 &&
+          ipcdetail::to_raw_pointer(m_header.m_root.m_next->m_next) == &m_header.m_root;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::clear_free_memory()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   block_ctrl *block = ipcdetail::to_raw_pointer(m_header.m_root.m_next);
+
+   //Iterate through all free portions
+   do{
+      //Just clear user the memory part reserved for the user      
+      std::memset( reinterpret_cast<char*>(block) + BlockCtrlBytes
+                 , 0
+                 , block->m_size*Alignment - BlockCtrlBytes);
+      block = ipcdetail::to_raw_pointer(block->m_next);
+   }
+   while(block != &m_header.m_root);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+    check_sanity()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   block_ctrl *block = ipcdetail::to_raw_pointer(m_header.m_root.m_next);
+
+   size_type free_memory = 0;
+
+   //Iterate through all blocks obtaining their size
+   do{
+      //Free blocks's next must be always valid
+      block_ctrl *next = ipcdetail::to_raw_pointer(block->m_next);
+      if(!next){
+         return false;
+      }
+      free_memory += block->m_size*Alignment;
+      block = next;
+   }
+   while(block != &m_header.m_root);
+
+   //Check allocated bytes are less than size
+   if(m_header.m_allocated > m_header.m_size){
+      return false;
+   }
+
+   //Check free bytes are less than size
+   if(free_memory > m_header.m_size){
+      return false;
+   }
+   return true;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   allocate(size_type nbytes)
+{  
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   size_type ignore;
+   return priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   allocate_aligned(size_type nbytes, size_type alignment)
+{  
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   return priv_allocate_aligned(nbytes, alignment);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline std::pair<void *, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   allocation_command  (boost::interprocess::allocation_type command,   size_type min_size,
+                        size_type preferred_size,size_type &received_size, 
+                        void *reuse_ptr, size_type backwards_multiple)
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   (void)backwards_multiple;
+   command &= ~boost::interprocess::expand_bwd;
+   if(!command)
+      return std::pair<void *, bool>(0, false);
+   return priv_allocate(command, min_size, preferred_size, received_size, reuse_ptr);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   size(void *ptr) const
+{
+   //We need no synchronization since this block is not going
+   //to be modified
+   //Obtain the real size of the block
+   block_ctrl *block = reinterpret_cast<block_ctrl*>
+                        (reinterpret_cast<char*>(ptr) - BlockCtrlBytes);
+   return block->m_size*Alignment - BlockCtrlBytes;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   multi_allocate(size_type nbytes)
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   //Multisegment pointer. Let's try first the normal allocation
+   //since it's faster.
+   size_type ignore;
+   void *addr = this->priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
+   if(!addr){
+      //If this fails we will try the allocation through the segment
+      //creator.
+      size_type group, id;
+      //Obtain the segment group of this segment
+      void_pointer::get_group_and_id(this, group, id);
+      if(group == 0){
+         //Ooops, group 0 is not valid.
+         return 0;
+      }
+      //Now obtain the polymorphic functor that creates
+      //new segments and try to allocate again.
+      boost::interprocess::multi_segment_services *p_services = 
+         static_cast<boost::interprocess::multi_segment_services*>
+                     (void_pointer::find_group_data(group));
+      BOOST_ASSERT(p_services);
+     std::pair<void *, std::size_t> ret = 
+         p_services->create_new_segment(MinBlockSize > nbytes ? MinBlockSize : nbytes);
+      if(ret.first){
+         priv_add_segment(ret.first, ret.second);
+         addr = this->priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
+      }
+   }
+   return addr;
+}
+
+template<class MutexFamily, class VoidPointer>
+void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_expand_both_sides(boost::interprocess::allocation_type command
+                         ,size_type min_size
+                         ,size_type preferred_size
+                         ,size_type &received_size
+                         ,void *reuse_ptr
+                         ,bool only_preferred_backwards)
+{
+   typedef std::pair<block_ctrl *, block_ctrl *> prev_block_t;
+   block_ctrl *reuse = block_ctrl::get_block_from_addr(reuse_ptr);
+   received_size = 0;
+
+   if(this->size(reuse_ptr) > min_size){
+      received_size = this->size(reuse_ptr);
+      return reuse_ptr;
+   }
+
+   if(command & boost::interprocess::expand_fwd){
+      if(priv_expand(reuse_ptr, min_size, preferred_size, received_size))
+         return reuse_ptr;
+   }
+   else{
+      received_size = this->size(reuse_ptr);
+   }
+   if(command & boost::interprocess::expand_bwd){
+      size_type extra_forward = !received_size ? 0 : received_size + BlockCtrlBytes;
+      prev_block_t prev_pair = priv_prev_block_if_free(reuse);
+      block_ctrl *prev = prev_pair.second;
+      if(!prev){
+         return 0;
+      }
+
+      size_type needs_backwards = 
+         ipcdetail::get_rounded_size(preferred_size - extra_forward, Alignment);
+   
+      if(!only_preferred_backwards){
+         needs_backwards = 
+            max_value(ipcdetail::get_rounded_size(min_size - extra_forward, Alignment)
+                     ,min_value(prev->get_user_bytes(), needs_backwards));
+      }
+
+      //Check if previous block has enough size
+      if((prev->get_user_bytes()) >=  needs_backwards){
+         //Now take all next space. This will succeed
+         if(!priv_expand(reuse_ptr, received_size, received_size, received_size)){
+            BOOST_ASSERT(0);
+         }
+         
+         //We need a minimum size to split the previous one
+         if((prev->get_user_bytes() - needs_backwards) > 2*BlockCtrlBytes){
+            block_ctrl *new_block = reinterpret_cast<block_ctrl *>
+               (reinterpret_cast<char*>(reuse) - needs_backwards - BlockCtrlBytes);
+            new_block->m_next = 0;
+            new_block->m_size = 
+               BlockCtrlSize + (needs_backwards + extra_forward)/Alignment;
+            prev->m_size = 
+               (prev->get_total_bytes() - needs_backwards)/Alignment - BlockCtrlSize;
+            received_size = needs_backwards + extra_forward;
+            m_header.m_allocated += needs_backwards + BlockCtrlBytes;
+            return new_block->get_addr();
+         }
+         else{
+            //Just merge the whole previous block
+            block_ctrl *prev_2_block = prev_pair.first;
+            //Update received size and allocation
+            received_size = extra_forward + prev->get_user_bytes();
+            m_header.m_allocated += prev->get_total_bytes();
+            //Now unlink it from previous block
+            prev_2_block->m_next = prev->m_next;
+            prev->m_size = reuse->m_size + prev->m_size;
+            prev->m_next = 0;
+            return prev->get_addr();
+         }
+      }
+   }
+   return 0;
+}
+
+template<class MutexFamily, class VoidPointer>
+std::pair<void *, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_allocate(boost::interprocess::allocation_type command
+                ,size_type limit_size
+                ,size_type preferred_size
+                ,size_type &received_size
+                ,void *reuse_ptr)
+{
+   if(command & boost::interprocess::shrink_in_place){
+      bool success = 
+         this->priv_shrink(reuse_ptr, limit_size, preferred_size, received_size);
+      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
+   }
+   typedef std::pair<void *, bool> return_type;
+   received_size = 0;
+
+   if(limit_size > preferred_size)
+      return return_type(0, false);
+
+   //Number of units to request (including block_ctrl header)
+   size_type nunits = ipcdetail::get_rounded_size(preferred_size, Alignment)/Alignment + BlockCtrlSize;
+
+   //Get the root and the first memory block
+   block_ctrl *prev                 = &m_header.m_root;
+   block_ctrl *block                = ipcdetail::to_raw_pointer(prev->m_next);
+   block_ctrl *root                 = &m_header.m_root;
+   block_ctrl *biggest_block        = 0;
+   block_ctrl *prev_biggest_block   = 0;
+   size_type biggest_size         = limit_size;
+
+   //Expand in place
+   //reuse_ptr, limit_size, preferred_size, received_size
+   //
+   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
+      void *ret = priv_expand_both_sides
+         (command, limit_size, preferred_size, received_size, reuse_ptr, true);
+      if(ret)
+         return return_type(ret, true);
+   }
+
+   if(command & boost::interprocess::allocate_new){
+      received_size = 0;
+      while(block != root){
+         //Update biggest block pointers
+         if(block->m_size > biggest_size){
+            prev_biggest_block = prev;
+            biggest_size  = block->m_size;
+            biggest_block = block;
+         }
+         void *addr = this->priv_check_and_allocate(nunits, prev, block, received_size);
+         if(addr) return return_type(addr, false);
+         //Bad luck, let's check next block
+         prev  = block;
+         block = ipcdetail::to_raw_pointer(block->m_next);
+      }
+
+      //Bad luck finding preferred_size, now if we have any biggest_block
+      //try with this block
+      if(biggest_block){
+         received_size = biggest_block->m_size*Alignment - BlockCtrlSize;
+         nunits = ipcdetail::get_rounded_size(limit_size, Alignment)/Alignment + BlockCtrlSize;
+         void *ret = this->priv_check_and_allocate
+                        (nunits, prev_biggest_block, biggest_block, received_size);
+         if(ret)
+            return return_type(ret, false);
+      }
+   }
+   //Now try to expand both sides with min size
+   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
+      return return_type(priv_expand_both_sides
+         (command, limit_size, preferred_size, received_size, reuse_ptr, false), true);
+   }
+   return return_type(0, false);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *
+   simple_seq_fit_impl<MutexFamily, VoidPointer>::
+      priv_next_block_if_free
+         (typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *ptr)
+{
+   //Take the address where the next block should go
+   block_ctrl *next_block = reinterpret_cast<block_ctrl*>
+      (reinterpret_cast<char*>(ptr) + ptr->m_size*Alignment);
+
+   //Check if the adjacent block is in the managed segment
+   size_type distance = (reinterpret_cast<char*>(next_block) - reinterpret_cast<char*>(this))/Alignment;
+   if(distance >= (m_header.m_size/Alignment)){
+      //"next_block" does not exist so we can't expand "block"
+      return 0;
+   }
+
+   if(!next_block->m_next)
+      return 0;
+
+   return next_block;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline 
+   std::pair<typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *
+            ,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *>
+   simple_seq_fit_impl<MutexFamily, VoidPointer>::
+      priv_prev_block_if_free
+         (typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *ptr)
+{
+   typedef std::pair<block_ctrl *, block_ctrl *> prev_pair_t;
+   //Take the address where the previous block should go
+   block_ctrl *root           = &m_header.m_root;
+   block_ctrl *prev_2_block   = root;
+   block_ctrl *prev_block = ipcdetail::to_raw_pointer(root->m_next);
+   while((reinterpret_cast<char*>(prev_block) + prev_block->m_size*Alignment)
+            != (reinterpret_cast<char*>(ptr))
+         && prev_block != root){
+      prev_2_block = prev_block;
+      prev_block = ipcdetail::to_raw_pointer(prev_block->m_next);
+   }
+
+   if(prev_block == root || !prev_block->m_next)
+      return prev_pair_t(0, 0);
+
+   //Check if the previous block is in the managed segment
+   size_type distance = (reinterpret_cast<char*>(prev_block) - reinterpret_cast<char*>(this))/Alignment;
+   if(distance >= (m_header.m_size/Alignment)){
+      //"previous_block" does not exist so we can't expand "block"
+      return prev_pair_t(0, 0);
+   }
+   return prev_pair_t(prev_2_block, prev_block);
+}
+
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_expand (void *ptr
+               ,size_type min_size
+               ,size_type preferred_size
+               ,size_type &received_size)
+{
+   //Obtain the real size of the block
+   block_ctrl *block = reinterpret_cast<block_ctrl*>
+                        (reinterpret_cast<char*>(ptr) - BlockCtrlBytes);
+   size_type old_block_size = block->m_size;
+
+   //All used blocks' next is marked with 0 so check it
+   BOOST_ASSERT(block->m_next == 0);
+
+   //Put this to a safe value
+   received_size = old_block_size*Alignment - BlockCtrlBytes;
+
+   //Now translate it to Alignment units
+   min_size       = ipcdetail::get_rounded_size(min_size, Alignment)/Alignment;
+   preferred_size = ipcdetail::get_rounded_size(preferred_size, Alignment)/Alignment;
+
+   //Some parameter checks
+   if(min_size > preferred_size)
+      return false;
+
+   size_type data_size = old_block_size - BlockCtrlSize;
+
+   if(data_size >= min_size)
+      return true;
+
+   block_ctrl *next_block = priv_next_block_if_free(block);
+   if(!next_block){
+      return false;
+   }
+
+   //Is "block" + "next_block" big enough?
+   size_type merged_size = old_block_size + next_block->m_size;
+
+   //Now we can expand this block further than before
+   received_size = merged_size*Alignment - BlockCtrlBytes;
+
+   if(merged_size < (min_size + BlockCtrlSize)){
+      return false;
+   }
+
+   //We can fill expand. Merge both blocks,
+   block->m_next = next_block->m_next;
+   block->m_size = merged_size;
+   
+   //Find the previous free block of next_block
+   block_ctrl *prev = &m_header.m_root;
+   while(ipcdetail::to_raw_pointer(prev->m_next) != next_block){
+      prev = ipcdetail::to_raw_pointer(prev->m_next);
+   }
+
+   //Now insert merged block in the free list
+   //This allows reusing allocation logic in this function
+   m_header.m_allocated -= old_block_size*Alignment;   
+   prev->m_next = block;
+
+   //Now use check and allocate to do the allocation logic
+   preferred_size += BlockCtrlSize;
+   size_type nunits = preferred_size < merged_size ? preferred_size : merged_size;
+
+   //This must success since nunits is less than merged_size!
+   if(!this->priv_check_and_allocate (nunits, prev, block, received_size)){
+      //Something very ugly is happening here. This is a bug
+      //or there is memory corruption
+      BOOST_ASSERT(0);
+      return false;
+   }
+   return true;   
+}
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_shrink (void *ptr
+               ,size_type max_size
+               ,size_type preferred_size
+               ,size_type &received_size)
+{
+   //Obtain the real size of the block
+   block_ctrl *block = reinterpret_cast<block_ctrl*>
+                        (reinterpret_cast<char*>(ptr) - BlockCtrlBytes);
+   size_type block_size = block->m_size;
+
+   //All used blocks' next is marked with 0 so check it
+   BOOST_ASSERT(block->m_next == 0);
+
+   //Put this to a safe value
+   received_size = block_size*Alignment - BlockCtrlBytes;
+
+   //Now translate it to Alignment units
+   max_size       = max_size/Alignment;
+   preferred_size = ipcdetail::get_rounded_size(preferred_size, Alignment)/Alignment;
+
+   //Some parameter checks
+   if(max_size < preferred_size)
+      return false;
+
+   size_type data_size = block_size - BlockCtrlSize;
+
+   if(data_size < preferred_size)
+      return false;
+
+   if(data_size == preferred_size)
+      return true;
+
+   //We must be able to create at least a new empty block
+   if((data_size - preferred_size) < BlockCtrlSize){
+      return false;
+   }
+
+   //Now we can just rewrite the size of the old buffer
+   block->m_size = preferred_size + BlockCtrlSize;
+
+   //Update new size
+   received_size = preferred_size*Alignment;
+
+   //We create the new block
+   block = reinterpret_cast<block_ctrl*>
+               (reinterpret_cast<char*>(block) + block->m_size*Alignment);
+
+   //Write control data to simulate this new block was previously allocated
+   block->m_next = 0;
+   block->m_size = data_size - preferred_size;
+
+   //Now deallocate the new block to insert it in the free list
+   this->priv_deallocate(reinterpret_cast<char*>(block)+BlockCtrlBytes);
+   return true;   
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_allocate_aligned(size_type nbytes, size_type alignment)
+{  
+   //Ensure power of 2
+   if ((alignment & (alignment - size_type(1u))) != 0){
+      //Alignment is not power of two
+      BOOST_ASSERT((alignment & (alignment - size_type(1u))) != 0);
+      return 0;
+   }
+
+   size_type ignore;
+   if(alignment <= Alignment){
+      return priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
+   }
+   
+   size_type request = 
+      nbytes + alignment + MinBlockSize*Alignment - BlockCtrlBytes;
+   void *buffer = priv_allocate(boost::interprocess::allocate_new, request, request, ignore).first;
+   if(!buffer)
+      return 0;
+   else if ((((std::size_t)(buffer)) % alignment) == 0)
+      return buffer;
+
+   char *aligned_portion = reinterpret_cast<char*>
+      (reinterpret_cast<size_type>(static_cast<char*>(buffer) + alignment - 1) & -alignment);
+
+   char *pos = ((aligned_portion - reinterpret_cast<char*>(buffer)) >= (MinBlockSize*Alignment)) ? 
+      aligned_portion : (aligned_portion + alignment);
+
+   block_ctrl *first = reinterpret_cast<block_ctrl*>
+                           (reinterpret_cast<char*>(buffer) - BlockCtrlBytes);
+
+   block_ctrl *second = reinterpret_cast<block_ctrl*>(pos - BlockCtrlBytes);
+
+   size_type old_size = first->m_size;
+
+   first->m_size  = (reinterpret_cast<char*>(second) - reinterpret_cast<char*>(first))/Alignment;
+   second->m_size = old_size - first->m_size;
+
+   //Write control data to simulate this new block was previously allocated
+   second->m_next = 0;
+
+   //Now deallocate the new block to insert it in the free list
+   this->priv_deallocate(reinterpret_cast<char*>(first) + BlockCtrlBytes);
+   return reinterpret_cast<char*>(second) + BlockCtrlBytes;
+}
+
+template<class MutexFamily, class VoidPointer> inline
+void* simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_check_and_allocate
+   (size_type nunits
+   ,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* prev
+   ,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* block
+   ,size_type &received_size)
+{
+   size_type upper_nunits = nunits + BlockCtrlSize;
+   bool found = false;
+
+   if (block->m_size > upper_nunits){
+      //This block is bigger than needed, split it in 
+      //two blocks, the first's size will be (block->m_size-units)
+      //the second's size (units)
+      size_type total_size = block->m_size;
+      block->m_size  = nunits;
+      block_ctrl *new_block = reinterpret_cast<block_ctrl*>
+                     (reinterpret_cast<char*>(block) + Alignment*nunits);
+      new_block->m_size  = total_size - nunits;
+      new_block->m_next  = block->m_next;
+      prev->m_next = new_block;
+      found = true;
+   }
+   else if (block->m_size >= nunits){
+      //This block has exactly the right size with an extra
+      //unusable extra bytes.
+      prev->m_next = block->m_next;
+      found = true;
+   }
+
+   if(found){
+      //We need block_ctrl for deallocation stuff, so
+      //return memory user can overwrite
+      m_header.m_allocated += block->m_size*Alignment;
+      received_size =  block->m_size*Alignment - BlockCtrlBytes;
+      //Mark the block as allocated
+      block->m_next = 0;
+      //Check alignment
+      BOOST_ASSERT(((reinterpret_cast<char*>(block) - reinterpret_cast<char*>(this))
+               % Alignment) == 0 );
+      return reinterpret_cast<char*>(block) + BlockCtrlBytes;
+   }
+   return 0;
+}
+
+template<class MutexFamily, class VoidPointer>
+void simple_seq_fit_impl<MutexFamily, VoidPointer>::deallocate(void* addr)
+{
+   if(!addr)   return;
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   return this->priv_deallocate(addr);
+}
+
+template<class MutexFamily, class VoidPointer>
+void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_deallocate(void* addr)
+{
+   if(!addr)   return;
+
+   //Let's get free block list. List is always sorted
+   //by memory address to allow block merging.
+   //Pointer next always points to the first 
+   //(lower address) block
+   block_ctrl_ptr prev  = &m_header.m_root;
+   block_ctrl_ptr pos   = m_header.m_root.m_next;
+   block_ctrl_ptr block = reinterpret_cast<block_ctrl*>
+                           (reinterpret_cast<char*>(addr) - BlockCtrlBytes);
+
+   //All used blocks' next is marked with 0 so check it
+   BOOST_ASSERT(block->m_next == 0);
+
+   //Check if alignment and block size are right
+   BOOST_ASSERT((reinterpret_cast<char*>(addr) - reinterpret_cast<char*>(this))
+            % Alignment == 0 );
+
+   size_type total_size = Alignment*block->m_size;
+   BOOST_ASSERT(m_header.m_allocated >= total_size);
+  
+   //Update used memory count
+   m_header.m_allocated -= total_size;   
+
+   //Let's find the previous and the next block of the block to deallocate
+   //This ordering comparison must be done with original pointers
+   //types since their mapping to raw pointers can be different
+   //in each process
+   while((ipcdetail::to_raw_pointer(pos) != &m_header.m_root) && (block > pos)){
+      prev = pos;
+      pos = pos->m_next;
+   }
+
+   //Try to combine with upper block
+   if ((reinterpret_cast<char*>(ipcdetail::to_raw_pointer(block))
+            + Alignment*block->m_size) == 
+        reinterpret_cast<char*>(ipcdetail::to_raw_pointer(pos))){
+
+      block->m_size += pos->m_size;
+      block->m_next  = pos->m_next;
+   }
+   else{
+      block->m_next = pos;
+   }
+
+   //Try to combine with lower block
+   if ((reinterpret_cast<char*>(ipcdetail::to_raw_pointer(prev))
+            + Alignment*prev->m_size) == 
+        reinterpret_cast<char*>(ipcdetail::to_raw_pointer(block))){
+      prev->m_size += block->m_size;
+      prev->m_next  = block->m_next;
+   }
+   else{
+      prev->m_next = block;
+   }
+}
+
+}  //namespace ipcdetail {
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MEM_ALGO_DETAIL_SIMPLE_SEQ_FIT_IMPL_HPP
+
diff --git a/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp b/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp
new file mode 100644
index 0000000000..378cd82fd5
--- /dev/null
+++ b/boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp
@@ -0,0 +1,1122 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MEM_ALGO_DETAIL_SIMPLE_SEQ_FIT_IMPL_HPP
+#define BOOST_INTERPROCESS_MEM_ALGO_DETAIL_SIMPLE_SEQ_FIT_IMPL_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/containers/allocation_type.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/offset_ptr.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/min_max.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/interprocess/mem_algo/detail/mem_algo_common.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <algorithm>
+#include <utility>
+#include <cstring>
+#include <boost/assert.hpp>
+#include <new>
+
+//!\file
+//!Describes sequential fit algorithm used to allocate objects in shared memory.
+//!This class is intended as a base class for single segment and multi-segment
+//!implementations.
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+//!This class implements the simple sequential fit algorithm with a simply
+//!linked list of free buffers.
+//!This class is intended as a base class for single segment and multi-segment
+//!implementations.
+template<class MutexFamily, class VoidPointer>
+class simple_seq_fit_impl
+{
+   //Non-copyable
+   simple_seq_fit_impl();
+   simple_seq_fit_impl(const simple_seq_fit_impl &);
+   simple_seq_fit_impl &operator=(const simple_seq_fit_impl &);
+   
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<char>::type                         char_ptr;
+
+   public:
+
+   //!Shared interprocess_mutex family used for the rest of the Interprocess framework
+   typedef MutexFamily        mutex_family;
+   //!Pointer type to be used with the rest of the Interprocess framework
+   typedef VoidPointer        void_pointer;
+   typedef boost::container::container_detail::
+      basic_multiallocation_chain<VoidPointer>     multiallocation_chain;
+
+   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type size_type;
+
+
+   private:
+   class block_ctrl;
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<block_ctrl>::type                   block_ctrl_ptr;
+
+   class block_ctrl;
+   friend class block_ctrl;
+
+   //!Block control structure
+   class block_ctrl
+   {
+      public:
+      //!Offset pointer to the next block.
+      block_ctrl_ptr m_next;
+      //!This block's memory size (including block_ctrl 
+      //!header) in BasicSize units
+      size_type    m_size;
+   
+      size_type get_user_bytes() const
+      {  return this->m_size*Alignment - BlockCtrlBytes; }
+
+      size_type get_total_bytes() const
+      {  return this->m_size*Alignment; }
+   };
+
+   //!Shared interprocess_mutex to protect memory allocate/deallocate
+   typedef typename MutexFamily::mutex_type        interprocess_mutex;
+
+   //!This struct includes needed data and derives from
+   //!interprocess_mutex to allow EBO when using null interprocess_mutex
+   struct header_t : public interprocess_mutex
+   {
+      //!Pointer to the first free block
+      block_ctrl        m_root;
+      //!Allocated bytes for internal checking
+      size_type         m_allocated;
+      //!The size of the memory segment
+      size_type         m_size;
+      //!The extra size required by the segment
+      size_type         m_extra_hdr_bytes;
+   }  m_header;
+
+   friend class ipcdetail::memory_algorithm_common<simple_seq_fit_impl>;
+
+   typedef ipcdetail::memory_algorithm_common<simple_seq_fit_impl> algo_impl_t;
+
+   public:
+   //!Constructor. "size" is the total size of the managed memory segment, 
+   //!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit_impl)
+   //!offset that the allocator should not use at all.
+   simple_seq_fit_impl           (size_type size, size_type extra_hdr_bytes);
+
+   //!Destructor
+   ~simple_seq_fit_impl();
+
+   //!Obtains the minimum size needed by the algorithm
+   static size_type get_min_size (size_type extra_hdr_bytes);
+
+   //Functions for single segment management
+
+   //!Allocates bytes, returns 0 if there is not more memory
+   void* allocate             (size_type nbytes);
+
+   /// @cond
+
+   //!Multiple element allocation, same size
+   multiallocation_chain
+      allocate_many(size_type elem_bytes, size_type num_elements)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+      //-----------------------
+      return algo_impl_t::allocate_many(this, elem_bytes, num_elements);
+   }
+
+   //!Multiple element allocation, different size
+   multiallocation_chain
+      allocate_many(const size_type *elem_sizes, size_type n_elements, size_type sizeof_element)
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+      //-----------------------
+      return algo_impl_t::allocate_many(this, elem_sizes, n_elements, sizeof_element);
+   }
+
+   //!Multiple element deallocation
+   void deallocate_many(multiallocation_chain chain);
+
+   /// @endcond
+
+   //!Deallocates previously allocated bytes
+   void   deallocate          (void *addr);
+
+   //!Returns the size of the memory segment
+   size_type get_size()  const;
+
+   //!Returns the number of free bytes of the memory segment
+   size_type get_free_memory()  const;
+
+   //!Increases managed memory in extra_size bytes more
+   void grow(size_type extra_size);
+
+   //!Decreases managed memory as much as possible
+   void shrink_to_fit();
+
+   //!Returns true if all allocated memory has been deallocated
+   bool all_memory_deallocated();
+
+   //!Makes an internal sanity check and returns true if success
+   bool check_sanity();
+
+   //!Initializes to zero all the memory that's not in use.
+   //!This function is normally used for security reasons.
+   void zero_free_memory();
+
+   template<class T>
+   std::pair<T *, bool>
+      allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                           size_type preferred_size,size_type &received_size, 
+                           T *reuse_ptr = 0);
+
+   std::pair<void *, bool>
+      raw_allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                               size_type preferred_size,size_type &received_size, 
+                               void *reuse_ptr = 0, size_type sizeof_object = 1);
+
+   //!Returns the size of the buffer previously allocated pointed by ptr
+   size_type size(const void *ptr) const;
+
+   //!Allocates aligned bytes, returns 0 if there is not more memory.
+   //!Alignment must be power of 2
+   void* allocate_aligned     (size_type nbytes, size_type alignment);
+
+   private:
+
+   //!Obtains the pointer returned to the user from the block control
+   static void *priv_get_user_buffer(const block_ctrl *block);
+
+   //!Obtains the block control structure of the user buffer
+   static block_ctrl *priv_get_block(const void *ptr);
+
+   //!Real allocation algorithm with min allocation option
+   std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
+                                        ,size_type min_size
+                                        ,size_type preferred_size
+                                        ,size_type &received_size
+                                        ,void *reuse_ptr = 0);
+
+   std::pair<void *, bool> priv_allocation_command(boost::interprocess::allocation_type command
+                                        ,size_type min_size
+                                        ,size_type preferred_size
+                                        ,size_type &received_size
+                                        ,void *reuse_ptr
+                                        ,size_type sizeof_object);
+
+   //!Returns the number of total units that a user buffer
+   //!of "userbytes" bytes really occupies (including header)
+   static size_type priv_get_total_units(size_type userbytes);
+
+   static size_type priv_first_block_offset(const void *this_ptr, size_type extra_hdr_bytes);
+   size_type priv_block_end_offset() const;
+
+   //!Returns next block if it's free.
+   //!Returns 0 if next block is not free.
+   block_ctrl *priv_next_block_if_free(block_ctrl *ptr);
+
+   //!Check if this block is free (not allocated)
+   bool priv_is_allocated_block(block_ctrl *ptr);
+
+   //!Returns previous block's if it's free.
+   //!Returns 0 if previous block is not free.
+   std::pair<block_ctrl*, block_ctrl*>priv_prev_block_if_free(block_ctrl *ptr);
+
+   //!Real expand function implementation
+   bool priv_expand(void *ptr
+                   ,size_type min_size, size_type preferred_size
+                   ,size_type &received_size);
+
+   //!Real expand to both sides implementation
+   void* priv_expand_both_sides(boost::interprocess::allocation_type command
+                               ,size_type min_size
+                               ,size_type preferred_size
+                               ,size_type &received_size
+                               ,void *reuse_ptr
+                               ,bool only_preferred_backwards);
+
+   //!Real private aligned allocation function
+   //void* priv_allocate_aligned     (size_type nbytes, size_type alignment);
+
+   //!Checks if block has enough memory and splits/unlinks the block
+   //!returning the address to the users
+   void* priv_check_and_allocate(size_type units
+                                ,block_ctrl* prev
+                                ,block_ctrl* block
+                                ,size_type &received_size);
+   //!Real deallocation algorithm
+   void priv_deallocate(void *addr);
+
+   //!Makes a new memory portion available for allocation
+   void priv_add_segment(void *addr, size_type size);
+
+   void priv_mark_new_allocated_block(block_ctrl *block);
+
+   public:
+	static const size_type Alignment      = ::boost::alignment_of< ::boost::detail::max_align>::value;
+   private:
+   static const size_type BlockCtrlBytes = ipcdetail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
+   static const size_type BlockCtrlUnits = BlockCtrlBytes/Alignment;
+   static const size_type MinBlockUnits  = BlockCtrlUnits;
+   static const size_type MinBlockSize   = MinBlockUnits*Alignment;
+   static const size_type AllocatedCtrlBytes = BlockCtrlBytes;
+   static const size_type AllocatedCtrlUnits = BlockCtrlUnits;
+   static const size_type UsableByPreviousChunk = 0;
+
+   public:
+   static const size_type PayloadPerAllocation = BlockCtrlBytes;
+};
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>
+   ::priv_first_block_offset(const void *this_ptr, size_type extra_hdr_bytes)
+{
+   //First align "this" pointer
+   size_type uint_this         = (std::size_t)this_ptr;
+   size_type uint_aligned_this = uint_this/Alignment*Alignment;
+   size_type this_disalignment = (uint_this - uint_aligned_this);
+   size_type block1_off = 
+      ipcdetail::get_rounded_size(sizeof(simple_seq_fit_impl) + extra_hdr_bytes + this_disalignment, Alignment)
+      - this_disalignment;
+   algo_impl_t::assert_alignment(this_disalignment + block1_off);
+   return block1_off;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>
+   ::priv_block_end_offset() const
+{
+   //First align "this" pointer
+   size_type uint_this         = (std::size_t)this;
+   size_type uint_aligned_this = uint_this/Alignment*Alignment;
+   size_type this_disalignment = (uint_this - uint_aligned_this);
+   size_type old_end = 
+      ipcdetail::get_truncated_size(m_header.m_size + this_disalignment, Alignment)
+      - this_disalignment;
+   algo_impl_t::assert_alignment(old_end + this_disalignment);
+   return old_end;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   simple_seq_fit_impl(size_type size, size_type extra_hdr_bytes)
+{
+   //Initialize sizes and counters
+   m_header.m_allocated = 0;
+   m_header.m_size      = size;
+   m_header.m_extra_hdr_bytes = extra_hdr_bytes;
+
+   //Initialize pointers
+   size_type block1_off = priv_first_block_offset(this, extra_hdr_bytes);
+
+   m_header.m_root.m_next  = reinterpret_cast<block_ctrl*>
+      ((reinterpret_cast<char*>(this) + block1_off));
+   algo_impl_t::assert_alignment(ipcdetail::to_raw_pointer(m_header.m_root.m_next));
+   m_header.m_root.m_next->m_size  = (size - block1_off)/Alignment;
+   m_header.m_root.m_next->m_next  = &m_header.m_root;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline simple_seq_fit_impl<MutexFamily, VoidPointer>::~simple_seq_fit_impl()
+{
+   //There is a memory leak!
+//   BOOST_ASSERT(m_header.m_allocated == 0);
+//   BOOST_ASSERT(m_header.m_root.m_next->m_next == block_ctrl_ptr(&m_header.m_root));
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::grow(size_type extra_size)
+{
+   //Old highest address block's end offset
+   size_type old_end = this->priv_block_end_offset();
+
+   //Update managed buffer's size
+   m_header.m_size += extra_size;
+
+   //We need at least MinBlockSize blocks to create a new block
+   if((m_header.m_size - old_end) < MinBlockSize){
+      return;
+   }
+
+   //We'll create a new free block with extra_size bytes
+
+   block_ctrl *new_block = reinterpret_cast<block_ctrl*>
+      (reinterpret_cast<char*>(this) + old_end);
+
+   algo_impl_t::assert_alignment(new_block);
+   new_block->m_next = 0;
+   new_block->m_size = (m_header.m_size - old_end)/Alignment;
+   m_header.m_allocated += new_block->m_size*Alignment;
+   this->priv_deallocate(priv_get_user_buffer(new_block));
+}
+
+template<class MutexFamily, class VoidPointer>
+void simple_seq_fit_impl<MutexFamily, VoidPointer>::shrink_to_fit()
+{
+   //Get the root and the first memory block
+   block_ctrl *prev                 = &m_header.m_root;
+   block_ctrl *last                 = &m_header.m_root;
+   block_ctrl *block                = ipcdetail::to_raw_pointer(last->m_next);
+   block_ctrl *root                 = &m_header.m_root;
+
+   //No free block?
+   if(block == root) return;
+
+   //Iterate through the free block list
+   while(block != root){
+      prev  = last;
+      last  = block;
+      block = ipcdetail::to_raw_pointer(block->m_next);
+   }
+
+   char *last_free_end_address   = reinterpret_cast<char*>(last) + last->m_size*Alignment;
+   if(last_free_end_address != (reinterpret_cast<char*>(this) + priv_block_end_offset())){
+      //there is an allocated block in the end of this block
+      //so no shrinking is possible
+      return;
+   }
+
+   //Check if have only 1 big free block
+   void *unique_block = 0;
+   if(!m_header.m_allocated){
+      BOOST_ASSERT(prev == root);
+      size_type ignore;
+      unique_block = priv_allocate(boost::interprocess::allocate_new, 0, 0, ignore).first;
+      if(!unique_block)
+         return;
+      last = ipcdetail::to_raw_pointer(m_header.m_root.m_next);
+      BOOST_ASSERT(last_free_end_address == (reinterpret_cast<char*>(last) + last->m_size*Alignment));
+   }
+   size_type last_units = last->m_size;
+
+   size_type received_size;
+   void *addr = priv_check_and_allocate(last_units, prev, last, received_size);
+   (void)addr;
+   BOOST_ASSERT(addr);
+   BOOST_ASSERT(received_size == last_units*Alignment - AllocatedCtrlBytes);
+   
+   //Shrink it
+   m_header.m_size /= Alignment;
+   m_header.m_size -= last->m_size;
+   m_header.m_size *= Alignment;
+   m_header.m_allocated -= last->m_size*Alignment;
+
+   if(unique_block)
+      priv_deallocate(unique_block);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_mark_new_allocated_block(block_ctrl *new_block)
+{
+   new_block->m_next = 0;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline
+typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *
+   simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_get_block(const void *ptr)
+{
+   return const_cast<block_ctrl*>(reinterpret_cast<const block_ctrl*>
+      (reinterpret_cast<const char*>(ptr) - AllocatedCtrlBytes));
+}
+
+template<class MutexFamily, class VoidPointer>
+inline
+void *simple_seq_fit_impl<MutexFamily, VoidPointer>::
+      priv_get_user_buffer(const typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *block)
+{
+   return const_cast<char*>(reinterpret_cast<const char*>(block) + AllocatedCtrlBytes);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_add_segment(void *addr, size_type size)
+{  
+   algo_impl_t::assert_alignment(addr);
+   //Check size
+   BOOST_ASSERT(!(size < MinBlockSize));
+   if(size < MinBlockSize)
+      return;
+   //Construct big block using the new segment
+   block_ctrl *new_block   = static_cast<block_ctrl *>(addr);
+   new_block->m_size       = size/Alignment;
+   new_block->m_next       = 0;
+   //Simulate this block was previously allocated
+   m_header.m_allocated   += new_block->m_size*Alignment; 
+   //Return block and insert it in the free block list
+   this->priv_deallocate(priv_get_user_buffer(new_block));
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::get_size()  const
+   {  return m_header.m_size;  }
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::get_free_memory()  const
+{
+   return m_header.m_size - m_header.m_allocated - 
+      algo_impl_t::multiple_of_units(sizeof(*this) + m_header.m_extra_hdr_bytes);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   get_min_size (size_type extra_hdr_bytes)
+{
+   return ipcdetail::get_rounded_size((size_type)sizeof(simple_seq_fit_impl),Alignment) +
+          ipcdetail::get_rounded_size(extra_hdr_bytes,Alignment)
+          + MinBlockSize;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+    all_memory_deallocated()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   return m_header.m_allocated == 0 &&
+          ipcdetail::to_raw_pointer(m_header.m_root.m_next->m_next) == &m_header.m_root;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::zero_free_memory()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   block_ctrl *block = ipcdetail::to_raw_pointer(m_header.m_root.m_next);
+
+   //Iterate through all free portions
+   do{
+      //Just clear user the memory part reserved for the user      
+      std::memset( priv_get_user_buffer(block)
+                 , 0
+             , block->get_user_bytes());
+      block = ipcdetail::to_raw_pointer(block->m_next);
+   }
+   while(block != &m_header.m_root);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+    check_sanity()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   block_ctrl *block = ipcdetail::to_raw_pointer(m_header.m_root.m_next);
+
+   size_type free_memory = 0;
+
+   //Iterate through all blocks obtaining their size
+   while(block != &m_header.m_root){
+      algo_impl_t::assert_alignment(block);
+      if(!algo_impl_t::check_alignment(block))
+         return false;
+      //Free blocks's next must be always valid
+      block_ctrl *next = ipcdetail::to_raw_pointer(block->m_next);
+      if(!next){
+         return false;
+      }
+      free_memory += block->m_size*Alignment;
+      block = next;
+   }
+
+   //Check allocated bytes are less than size
+   if(m_header.m_allocated > m_header.m_size){
+      return false;
+   }
+
+   //Check free bytes are less than size
+   if(free_memory > m_header.m_size){
+      return false;
+   }
+   return true;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   allocate(size_type nbytes)
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   size_type ignore;
+   return priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   allocate_aligned(size_type nbytes, size_type alignment)
+{  
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   return algo_impl_t::
+      allocate_aligned(this, nbytes, alignment); 
+}
+
+template<class MutexFamily, class VoidPointer>
+template<class T>
+inline std::pair<T*, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                        size_type preferred_size,size_type &received_size, 
+                        T *reuse_ptr)
+{
+   std::pair<void*, bool> ret = priv_allocation_command
+      (command, limit_size, preferred_size, received_size, static_cast<void*>(reuse_ptr), sizeof(T));
+
+   BOOST_ASSERT(0 == ((std::size_t)ret.first % ::boost::alignment_of<T>::value));
+   return std::pair<T *, bool>(static_cast<T*>(ret.first), ret.second);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline std::pair<void*, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   raw_allocation_command  (boost::interprocess::allocation_type command,   size_type limit_objects,
+                        size_type preferred_objects,size_type &received_objects, 
+                        void *reuse_ptr, size_type sizeof_object)
+{
+   if(!sizeof_object)
+      return std::pair<void *, bool>(static_cast<void*>(0), false);
+   if(command & boost::interprocess::try_shrink_in_place){
+      bool success = algo_impl_t::try_shrink
+         ( this, reuse_ptr, limit_objects*sizeof_object
+         , preferred_objects*sizeof_object, received_objects);
+      received_objects /= sizeof_object;
+      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
+   }
+   return priv_allocation_command
+      (command, limit_objects, preferred_objects, received_objects, reuse_ptr, sizeof_object);
+}
+
+template<class MutexFamily, class VoidPointer>
+inline std::pair<void*, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_allocation_command (boost::interprocess::allocation_type command,   size_type limit_size,
+                       size_type preferred_size, size_type &received_size, 
+                       void *reuse_ptr, size_type sizeof_object)
+{
+   command &= ~boost::interprocess::expand_bwd;
+   if(!command)   return std::pair<void *, bool>(static_cast<void*>(0), false);
+
+   std::pair<void*, bool> ret;
+   size_type max_count = m_header.m_size/sizeof_object;
+   if(limit_size > max_count || preferred_size > max_count){
+      ret.first = 0; return ret;
+   }
+   size_type l_size = limit_size*sizeof_object;
+   size_type p_size = preferred_size*sizeof_object;
+   size_type r_size;
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+      //-----------------------
+      ret = priv_allocate(command, l_size, p_size, r_size, reuse_ptr);
+   }
+   received_size = r_size/sizeof_object;
+   return ret;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   size(const void *ptr) const
+{
+   //We need no synchronization since this block is not going
+   //to be modified
+   //Obtain the real size of the block
+   const block_ctrl *block = static_cast<const block_ctrl*>(priv_get_block(ptr));
+   return block->get_user_bytes();
+}
+
+template<class MutexFamily, class VoidPointer>
+void* simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_expand_both_sides(boost::interprocess::allocation_type command
+                         ,size_type min_size
+                         ,size_type preferred_size
+                         ,size_type &received_size
+                         ,void *reuse_ptr
+                         ,bool only_preferred_backwards)
+{
+   typedef std::pair<block_ctrl *, block_ctrl *> prev_block_t;
+   block_ctrl *reuse = priv_get_block(reuse_ptr);
+   received_size = 0;
+
+   if(this->size(reuse_ptr) > min_size){
+      received_size = this->size(reuse_ptr);
+      return reuse_ptr;
+   }
+
+   if(command & boost::interprocess::expand_fwd){
+      if(priv_expand(reuse_ptr, min_size, preferred_size, received_size))
+         return reuse_ptr;
+   }
+   else{
+      received_size = this->size(reuse_ptr);
+   }
+   if(command & boost::interprocess::expand_bwd){
+      size_type extra_forward = !received_size ? 0 : received_size + BlockCtrlBytes;
+      prev_block_t prev_pair = priv_prev_block_if_free(reuse);
+      block_ctrl *prev = prev_pair.second;
+      if(!prev){
+         return 0;
+      }
+
+      size_type needs_backwards = 
+         ipcdetail::get_rounded_size(preferred_size - extra_forward, Alignment);
+   
+      if(!only_preferred_backwards){
+            max_value(ipcdetail::get_rounded_size(min_size - extra_forward, Alignment)
+                     ,min_value(prev->get_user_bytes(), needs_backwards));
+      }
+
+      //Check if previous block has enough size
+      if((prev->get_user_bytes()) >=  needs_backwards){
+         //Now take all next space. This will succeed
+         if(!priv_expand(reuse_ptr, received_size, received_size, received_size)){
+            BOOST_ASSERT(0);
+         }
+         
+         //We need a minimum size to split the previous one
+         if((prev->get_user_bytes() - needs_backwards) > 2*BlockCtrlBytes){
+             block_ctrl *new_block = reinterpret_cast<block_ctrl*>
+                  (reinterpret_cast<char*>(reuse) - needs_backwards - BlockCtrlBytes);
+
+            new_block->m_next = 0;
+            new_block->m_size = 
+               BlockCtrlUnits + (needs_backwards + extra_forward)/Alignment;
+            prev->m_size = 
+               (prev->get_total_bytes() - needs_backwards)/Alignment - BlockCtrlUnits;
+            received_size = needs_backwards + extra_forward;
+            m_header.m_allocated += needs_backwards + BlockCtrlBytes;
+            return priv_get_user_buffer(new_block);
+         }
+         else{
+            //Just merge the whole previous block
+            block_ctrl *prev_2_block = prev_pair.first;
+            //Update received size and allocation
+            received_size = extra_forward + prev->get_user_bytes();
+            m_header.m_allocated += prev->get_total_bytes();
+            //Now unlink it from previous block
+            prev_2_block->m_next = prev->m_next;
+            prev->m_size = reuse->m_size + prev->m_size;
+            prev->m_next = 0;
+            priv_get_user_buffer(prev);
+         }
+      }
+   }
+   return 0;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline void simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   deallocate_many(typename simple_seq_fit_impl<MutexFamily, VoidPointer>::multiallocation_chain chain)
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   while(!chain.empty()){
+      void *addr = chain.front();
+      chain.pop_front();
+      this->priv_deallocate(addr);
+   }
+}
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::size_type
+simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_get_total_units(size_type userbytes)
+{
+   size_type s = ipcdetail::get_rounded_size(userbytes, Alignment)/Alignment;
+   if(!s)   ++s;
+   return BlockCtrlUnits + s;
+}
+
+template<class MutexFamily, class VoidPointer>
+std::pair<void *, bool> simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_allocate(boost::interprocess::allocation_type command
+                ,size_type limit_size
+                ,size_type preferred_size
+                ,size_type &received_size
+                ,void *reuse_ptr)
+{
+   if(command & boost::interprocess::shrink_in_place){
+      bool success = 
+         algo_impl_t::shrink(this, reuse_ptr, limit_size, preferred_size, received_size);
+      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
+   }
+   typedef std::pair<void *, bool> return_type;
+   received_size = 0;
+
+   if(limit_size > preferred_size)
+      return return_type(static_cast<void*>(0), false);
+
+   //Number of units to request (including block_ctrl header)
+   size_type nunits = ipcdetail::get_rounded_size(preferred_size, Alignment)/Alignment + BlockCtrlUnits;
+
+   //Get the root and the first memory block
+   block_ctrl *prev                 = &m_header.m_root;
+   block_ctrl *block                = ipcdetail::to_raw_pointer(prev->m_next);
+   block_ctrl *root                 = &m_header.m_root;
+   block_ctrl *biggest_block        = 0;
+   block_ctrl *prev_biggest_block   = 0;
+   size_type biggest_size         = 0;
+
+   //Expand in place
+   //reuse_ptr, limit_size, preferred_size, received_size
+   //
+   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
+      void *ret = priv_expand_both_sides
+         (command, limit_size, preferred_size, received_size, reuse_ptr, true);
+      if(ret){
+         algo_impl_t::assert_alignment(ret);
+         return return_type(ret, true);
+      }
+   }
+
+   if(command & boost::interprocess::allocate_new){
+      received_size = 0;
+      while(block != root){
+         //Update biggest block pointers
+         if(block->m_size > biggest_size){
+            prev_biggest_block = prev;
+            biggest_size  = block->m_size;
+            biggest_block = block;
+         }
+         algo_impl_t::assert_alignment(block);
+         void *addr = this->priv_check_and_allocate(nunits, prev, block, received_size);
+         if(addr){
+            algo_impl_t::assert_alignment(addr);
+            return return_type(addr, false);
+         }
+         //Bad luck, let's check next block
+         prev  = block;
+         block = ipcdetail::to_raw_pointer(block->m_next);
+      }
+
+      //Bad luck finding preferred_size, now if we have any biggest_block
+      //try with this block
+      if(biggest_block){
+         size_type limit_units = ipcdetail::get_rounded_size(limit_size, Alignment)/Alignment + BlockCtrlUnits;
+         if(biggest_block->m_size < limit_units)
+            return return_type(static_cast<void*>(0), false);
+
+         received_size = biggest_block->m_size*Alignment - BlockCtrlUnits;
+         void *ret = this->priv_check_and_allocate
+            (biggest_block->m_size, prev_biggest_block, biggest_block, received_size);
+         BOOST_ASSERT(ret != 0);
+         algo_impl_t::assert_alignment(ret);
+         return return_type(ret, false);
+      }
+   }
+   //Now try to expand both sides with min size
+   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
+      return_type ret (priv_expand_both_sides
+         (command, limit_size, preferred_size, received_size, reuse_ptr, false), true);
+      algo_impl_t::assert_alignment(ret.first);
+      return ret;
+   }
+   return return_type(static_cast<void*>(0), false);
+}
+
+template<class MutexFamily, class VoidPointer> inline
+bool simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_is_allocated_block
+      (typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *block)
+{  return block->m_next == 0;  }
+
+template<class MutexFamily, class VoidPointer>
+inline typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *
+   simple_seq_fit_impl<MutexFamily, VoidPointer>::
+      priv_next_block_if_free
+         (typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *ptr)
+{
+   //Take the address where the next block should go
+   block_ctrl *next_block = reinterpret_cast<block_ctrl*>
+      (reinterpret_cast<char*>(ptr) + ptr->m_size*Alignment);
+
+   //Check if the adjacent block is in the managed segment
+   char *this_char_ptr = reinterpret_cast<char*>(this);
+   char *next_char_ptr = reinterpret_cast<char*>(next_block);
+   size_type distance = (size_type)(next_char_ptr - this_char_ptr)/Alignment;
+
+   if(distance >= (m_header.m_size/Alignment)){
+      //"next_block" does not exist so we can't expand "block"
+      return 0;
+   }
+
+   if(!next_block->m_next)
+      return 0;
+
+   return next_block;
+}
+
+template<class MutexFamily, class VoidPointer>
+inline 
+   std::pair<typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *
+            ,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *>
+   simple_seq_fit_impl<MutexFamily, VoidPointer>::
+      priv_prev_block_if_free
+         (typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl *ptr)
+{
+   typedef std::pair<block_ctrl *, block_ctrl *> prev_pair_t;
+   //Take the address where the previous block should go
+   block_ctrl *root           = &m_header.m_root;
+   block_ctrl *prev_2_block   = root;
+   block_ctrl *prev_block = ipcdetail::to_raw_pointer(root->m_next);
+
+   while((reinterpret_cast<char*>(prev_block) + prev_block->m_size*Alignment)
+            != reinterpret_cast<char*>(ptr)
+         && prev_block != root){
+      prev_2_block = prev_block;
+      prev_block = ipcdetail::to_raw_pointer(prev_block->m_next);
+   }
+
+   if(prev_block == root || !prev_block->m_next)
+      return prev_pair_t(static_cast<block_ctrl*>(0), static_cast<block_ctrl*>(0));
+
+   //Check if the previous block is in the managed segment
+   char *this_char_ptr = reinterpret_cast<char*>(this);
+   char *prev_char_ptr = reinterpret_cast<char*>(prev_block);
+   size_type distance = (size_type)(prev_char_ptr - this_char_ptr)/Alignment;
+
+   if(distance >= (m_header.m_size/Alignment)){
+      //"previous_block" does not exist so we can't expand "block"
+      return prev_pair_t(static_cast<block_ctrl*>(0), static_cast<block_ctrl*>(0));
+   }
+   return prev_pair_t(prev_2_block, prev_block);
+}
+
+
+template<class MutexFamily, class VoidPointer>
+inline bool simple_seq_fit_impl<MutexFamily, VoidPointer>::
+   priv_expand (void *ptr
+               ,size_type min_size
+               ,size_type preferred_size
+               ,size_type &received_size)
+{
+   //Obtain the real size of the block
+   block_ctrl *block = reinterpret_cast<block_ctrl*>(priv_get_block(ptr));
+   size_type old_block_size = block->m_size;
+
+   //All used blocks' next is marked with 0 so check it
+   BOOST_ASSERT(block->m_next == 0);
+
+   //Put this to a safe value
+   received_size = old_block_size*Alignment - BlockCtrlBytes;
+
+   //Now translate it to Alignment units
+   min_size       = ipcdetail::get_rounded_size(min_size, Alignment)/Alignment;
+   preferred_size = ipcdetail::get_rounded_size(preferred_size, Alignment)/Alignment;
+
+   //Some parameter checks
+   if(min_size > preferred_size)
+      return false;
+
+   size_type data_size = old_block_size - BlockCtrlUnits;
+
+   if(data_size >= min_size)
+      return true;
+
+   block_ctrl *next_block = priv_next_block_if_free(block);
+   if(!next_block){
+      return false;
+   }
+
+   //Is "block" + "next_block" big enough?
+   size_type merged_size = old_block_size + next_block->m_size;
+
+   //Now we can expand this block further than before
+   received_size = merged_size*Alignment - BlockCtrlBytes;
+
+   if(merged_size < (min_size + BlockCtrlUnits)){
+      return false;
+   }
+
+   //We can fill expand. Merge both blocks,
+   block->m_next = next_block->m_next;
+   block->m_size = merged_size;
+   
+   //Find the previous free block of next_block
+   block_ctrl *prev = &m_header.m_root;
+   while(ipcdetail::to_raw_pointer(prev->m_next) != next_block){
+      prev = ipcdetail::to_raw_pointer(prev->m_next);
+   }
+
+   //Now insert merged block in the free list
+   //This allows reusing allocation logic in this function
+   m_header.m_allocated -= old_block_size*Alignment;   
+   prev->m_next = block;
+
+   //Now use check and allocate to do the allocation logic
+   preferred_size += BlockCtrlUnits;
+   size_type nunits = preferred_size < merged_size ? preferred_size : merged_size;
+
+   //This must success since nunits is less than merged_size!
+   if(!this->priv_check_and_allocate (nunits, prev, block, received_size)){
+      //Something very ugly is happening here. This is a bug
+      //or there is memory corruption
+      BOOST_ASSERT(0);
+      return false;
+   }
+   return true;   
+}
+
+template<class MutexFamily, class VoidPointer> inline
+void* simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_check_and_allocate
+   (size_type nunits
+   ,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* prev
+   ,typename simple_seq_fit_impl<MutexFamily, VoidPointer>::block_ctrl* block
+   ,size_type &received_size)
+{
+   size_type upper_nunits = nunits + BlockCtrlUnits;
+   bool found = false;
+
+   if (block->m_size > upper_nunits){
+      //This block is bigger than needed, split it in 
+      //two blocks, the first's size will be "units"
+      //the second's size will be "block->m_size-units"
+      size_type total_size = block->m_size;
+      block->m_size  = nunits;
+
+      block_ctrl *new_block = reinterpret_cast<block_ctrl*>
+         (reinterpret_cast<char*>(block) + Alignment*nunits);
+      new_block->m_size  = total_size - nunits;
+      new_block->m_next  = block->m_next;
+      prev->m_next = new_block;
+      found = true;
+   }
+   else if (block->m_size >= nunits){
+      //This block has exactly the right size with an extra
+      //unusable extra bytes.
+      prev->m_next = block->m_next;
+      found = true;
+   }
+
+   if(found){
+      //We need block_ctrl for deallocation stuff, so
+      //return memory user can overwrite
+      m_header.m_allocated += block->m_size*Alignment;
+      received_size =  block->get_user_bytes();
+      //Mark the block as allocated
+      block->m_next = 0;
+      //Check alignment
+      algo_impl_t::assert_alignment(block);
+      return priv_get_user_buffer(block);
+   }
+   return 0;
+}
+
+template<class MutexFamily, class VoidPointer>
+void simple_seq_fit_impl<MutexFamily, VoidPointer>::deallocate(void* addr)
+{
+   if(!addr)   return;
+   //-----------------------
+   boost::interprocess::scoped_lock<interprocess_mutex> guard(m_header);
+   //-----------------------
+   return this->priv_deallocate(addr);
+}
+
+template<class MutexFamily, class VoidPointer>
+void simple_seq_fit_impl<MutexFamily, VoidPointer>::priv_deallocate(void* addr)
+{
+   if(!addr)   return;
+
+   //Let's get free block list. List is always sorted
+   //by memory address to allow block merging.
+   //Pointer next always points to the first 
+   //(lower address) block
+   block_ctrl * prev  = &m_header.m_root;
+   block_ctrl * pos   = ipcdetail::to_raw_pointer(m_header.m_root.m_next);
+   block_ctrl * block = reinterpret_cast<block_ctrl*>(priv_get_block(addr));
+
+   //All used blocks' next is marked with 0 so check it
+   BOOST_ASSERT(block->m_next == 0);
+
+   //Check if alignment and block size are right
+   algo_impl_t::assert_alignment(addr);
+
+   size_type total_size = Alignment*block->m_size;
+   BOOST_ASSERT(m_header.m_allocated >= total_size);
+  
+   //Update used memory count
+   m_header.m_allocated -= total_size;   
+
+   //Let's find the previous and the next block of the block to deallocate
+   //This ordering comparison must be done with original pointers
+   //types since their mapping to raw pointers can be different
+   //in each process
+   while((ipcdetail::to_raw_pointer(pos) != &m_header.m_root) && (block > pos)){
+      prev = pos;
+      pos = ipcdetail::to_raw_pointer(pos->m_next);
+   }
+
+   //Try to combine with upper block
+   char *block_char_ptr = reinterpret_cast<char*>(ipcdetail::to_raw_pointer(block));
+
+   if ((block_char_ptr + Alignment*block->m_size) == 
+         reinterpret_cast<char*>(ipcdetail::to_raw_pointer(pos))){
+      block->m_size += pos->m_size;
+      block->m_next  = pos->m_next;
+   }
+   else{
+      block->m_next = pos;
+   }
+
+   //Try to combine with lower block
+   if ((reinterpret_cast<char*>(ipcdetail::to_raw_pointer(prev))
+            + Alignment*prev->m_size) == 
+        block_char_ptr){
+
+
+      prev->m_size += block->m_size;
+      prev->m_next  = block->m_next;
+   }
+   else{
+      prev->m_next = block;
+   }
+}
+
+}  //namespace ipcdetail {
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MEM_ALGO_DETAIL_SIMPLE_SEQ_FIT_IMPL_HPP
+
diff --git a/boost/interprocess/mem_algo/rbtree_best_fit.hpp b/boost/interprocess/mem_algo/rbtree_best_fit.hpp
new file mode 100644
index 0000000000..f6f0c03a17
--- /dev/null
+++ b/boost/interprocess/mem_algo/rbtree_best_fit.hpp
@@ -0,0 +1,1416 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MEM_ALGO_RBTREE_BEST_FIT_HPP
+#define BOOST_INTERPROCESS_MEM_ALGO_RBTREE_BEST_FIT_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/mem_algo/detail/mem_algo_common.hpp>
+#include <boost/interprocess/containers/allocation_type.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/interprocess/offset_ptr.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/min_max.hpp>
+#include <boost/interprocess/detail/math_functions.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits.hpp>
+#include <algorithm>
+#include <utility>
+#include <climits>
+#include <cstring>
+#include <iterator>
+
+#include <boost/assert.hpp>
+#include <new>
+
+#include <boost/intrusive/set.hpp>
+
+//#define BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+//to maintain ABI compatible with the original version
+//ABI had to be updated to fix compatibility issues when
+//sharing shared memory between 32 adn 64 bit processes.
+
+//!\file
+//!Describes a best-fit algorithm based in an intrusive red-black tree used to allocate
+//!objects in shared memory. This class is intended as a base class for single segment
+//!and multi-segment implementations.
+
+namespace boost {
+namespace interprocess {
+
+//!This class implements an algorithm that stores the free nodes in a red-black tree
+//!to have logarithmic search/insert times.
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+class rbtree_best_fit
+{
+   /// @cond
+   //Non-copyable
+   rbtree_best_fit();
+   rbtree_best_fit(const rbtree_best_fit &);
+   rbtree_best_fit &operator=(const rbtree_best_fit &);
+
+   private:
+   struct block_ctrl;
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<block_ctrl>::type                   block_ctrl_ptr;
+
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<char>::type                         char_ptr;
+
+   /// @endcond
+
+   public:
+   //!Shared mutex family used for the rest of the Interprocess framework
+   typedef MutexFamily        mutex_family;
+   //!Pointer type to be used with the rest of the Interprocess framework
+   typedef VoidPointer        void_pointer;
+   typedef boost::container::container_detail::
+      basic_multiallocation_chain<VoidPointer>  multiallocation_chain;
+
+   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type difference_type;
+   typedef typename boost::make_unsigned<difference_type>::type     size_type;
+
+   /// @cond
+
+   private:
+
+   typedef typename bi::make_set_base_hook
+      < bi::void_pointer<VoidPointer>
+      , bi::optimize_size<true>
+      , bi::link_mode<bi::normal_link> >::type           TreeHook;
+
+   struct SizeHolder
+   {
+      //!This block's memory size (including block_ctrl 
+      //!header) in Alignment units
+      size_type m_prev_size :  sizeof(size_type)*CHAR_BIT;
+      size_type m_size      :  sizeof(size_type)*CHAR_BIT - 2;
+      size_type m_prev_allocated :  1;
+      size_type m_allocated :  1;
+   };
+
+   //!Block control structure
+   struct block_ctrl
+      :  public SizeHolder, public TreeHook
+   {
+      block_ctrl()
+      {  this->m_size = 0; this->m_allocated = 0, this->m_prev_allocated = 0;  }
+
+      friend bool operator<(const block_ctrl &a, const block_ctrl &b)
+      {  return a.m_size < b.m_size;  }
+      friend bool operator==(const block_ctrl &a, const block_ctrl &b)
+      {  return a.m_size == b.m_size;  }
+   };
+
+   struct size_block_ctrl_compare
+   {
+      bool operator()(size_type size, const block_ctrl &block) const
+      {  return size < block.m_size;  }
+
+      bool operator()(const block_ctrl &block, size_type size) const
+      {  return block.m_size < size;  }      
+   };
+
+   //!Shared mutex to protect memory allocate/deallocate
+   typedef typename MutexFamily::mutex_type                       mutex_type;
+   typedef typename bi::make_multiset
+      <block_ctrl, bi::base_hook<TreeHook> >::type                Imultiset;
+
+   typedef typename Imultiset::iterator                           imultiset_iterator;
+
+   //!This struct includes needed data and derives from
+   //!mutex_type to allow EBO when using null mutex_type
+   struct header_t : public mutex_type
+   {
+      Imultiset            m_imultiset;
+
+      //!The extra size required by the segment
+      size_type            m_extra_hdr_bytes;
+      //!Allocated bytes for internal checking
+      size_type            m_allocated;
+      //!The size of the memory segment
+      size_type            m_size;
+   }  m_header;
+
+   friend class ipcdetail::memory_algorithm_common<rbtree_best_fit>;
+   
+   typedef ipcdetail::memory_algorithm_common<rbtree_best_fit> algo_impl_t;
+
+   public:
+   /// @endcond
+
+   //!Constructor. "size" is the total size of the managed memory segment, 
+   //!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(rbtree_best_fit)
+   //!offset that the allocator should not use at all.
+   rbtree_best_fit           (size_type size, size_type extra_hdr_bytes);
+
+   //!Destructor.
+   ~rbtree_best_fit();
+
+   //!Obtains the minimum size needed by the algorithm
+   static size_type get_min_size (size_type extra_hdr_bytes);
+
+   //Functions for single segment management
+
+   //!Allocates bytes, returns 0 if there is not more memory
+   void* allocate             (size_type nbytes);
+
+   /// @cond
+
+   //Experimental. Dont' use
+
+   //!Multiple element allocation, same size
+   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
+   {
+
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      return algo_impl_t::allocate_many(this, elem_bytes, num_elements);
+   }
+
+   //!Multiple element allocation, different size
+   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements, size_type sizeof_element)
+   {
+
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      return algo_impl_t::allocate_many(this, elem_sizes, n_elements, sizeof_element);
+   }
+
+   //!Multiple element allocation, different size
+   void deallocate_many(multiallocation_chain chain);
+
+   /// @endcond
+
+   //!Deallocates previously allocated bytes
+   void   deallocate          (void *addr);
+
+   //!Returns the size of the memory segment
+   size_type get_size()  const;
+
+   //!Returns the number of free bytes of the segment
+   size_type get_free_memory()  const;
+
+   //!Initializes to zero all the memory that's not in use.
+   //!This function is normally used for security reasons.
+   void zero_free_memory();
+
+   //!Increases managed memory in
+   //!extra_size bytes more
+   void grow(size_type extra_size);
+
+   //!Decreases managed memory as much as possible
+   void shrink_to_fit();
+
+   //!Returns true if all allocated memory has been deallocated
+   bool all_memory_deallocated();
+
+   //!Makes an internal sanity check
+   //!and returns true if success
+   bool check_sanity();
+
+   template<class T>
+   std::pair<T *, bool>
+      allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                           size_type preferred_size,size_type &received_size, 
+                           T *reuse_ptr = 0);
+
+   std::pair<void *, bool>
+     raw_allocation_command  (boost::interprocess::allocation_type command,   size_type limit_object,
+                              size_type preferred_object,size_type &received_object, 
+                              void *reuse_ptr = 0, size_type sizeof_object = 1);
+
+   //!Returns the size of the buffer previously allocated pointed by ptr
+   size_type size(const void *ptr) const;
+
+   //!Allocates aligned bytes, returns 0 if there is not more memory.
+   //!Alignment must be power of 2
+   void* allocate_aligned     (size_type nbytes, size_type alignment);
+
+   /// @cond
+   private:
+   static size_type priv_first_block_offset_from_this(const void *this_ptr, size_type extra_hdr_bytes);
+
+   block_ctrl *priv_first_block();
+
+   block_ctrl *priv_end_block();
+
+   std::pair<void*, bool>
+      priv_allocation_command(boost::interprocess::allocation_type command,   size_type limit_size,
+                        size_type preferred_size,size_type &received_size, 
+                        void *reuse_ptr, size_type sizeof_object);
+
+
+   //!Real allocation algorithm with min allocation option
+   std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
+                                        ,size_type limit_size
+                                        ,size_type preferred_size
+                                        ,size_type &received_size
+                                        ,void *reuse_ptr = 0
+                                        ,size_type backwards_multiple = 1);
+
+   //!Obtains the block control structure of the user buffer
+   static block_ctrl *priv_get_block(const void *ptr);
+
+   //!Obtains the pointer returned to the user from the block control
+   static void *priv_get_user_buffer(const block_ctrl *block);
+
+   //!Returns the number of total units that a user buffer
+   //!of "userbytes" bytes really occupies (including header)
+   static size_type priv_get_total_units(size_type userbytes);
+
+   //!Real expand function implementation
+   bool priv_expand(void *ptr
+                   ,const size_type min_size, const size_type preferred_size
+                   ,size_type &received_size);
+
+   //!Real expand to both sides implementation
+   void* priv_expand_both_sides(boost::interprocess::allocation_type command
+                               ,size_type min_size
+                               ,size_type preferred_size
+                               ,size_type &received_size
+                               ,void *reuse_ptr
+                               ,bool only_preferred_backwards
+                               ,size_type backwards_multiple);
+
+   //!Returns true if the previous block is allocated
+   bool priv_is_prev_allocated(block_ctrl *ptr);
+
+   //!Get a pointer of the "end" block from the first block of the segment
+   static block_ctrl * priv_end_block(block_ctrl *first_segment_block);
+
+   //!Get a pointer of the "first" block from the end block of the segment
+   static block_ctrl * priv_first_block(block_ctrl *end_segment_block);
+
+   //!Get poitner of the previous block (previous block must be free)
+   static block_ctrl * priv_prev_block(block_ctrl *ptr);
+
+   //!Get the size in the tail of the previous block
+   static block_ctrl * priv_next_block(block_ctrl *ptr);
+
+   //!Check if this block is free (not allocated)
+   bool priv_is_allocated_block(block_ctrl *ptr);
+
+   //!Marks the block as allocated
+   void priv_mark_as_allocated_block(block_ctrl *ptr);
+
+   //!Marks the block as allocated
+   void priv_mark_new_allocated_block(block_ctrl *ptr)
+   {  return priv_mark_as_allocated_block(ptr); }
+
+   //!Marks the block as allocated
+   void priv_mark_as_free_block(block_ctrl *ptr);
+
+   //!Checks if block has enough memory and splits/unlinks the block
+   //!returning the address to the users
+   void* priv_check_and_allocate(size_type units
+                                ,block_ctrl* block
+                                ,size_type &received_size);
+   //!Real deallocation algorithm
+   void priv_deallocate(void *addr);
+
+   //!Makes a new memory portion available for allocation
+   void priv_add_segment(void *addr, size_type size);
+
+   public:
+   
+   static const size_type Alignment = !MemAlignment
+      ? size_type(::boost::alignment_of< ::boost::detail::max_align>::value)
+      : size_type(MemAlignment)
+      ;
+
+   private:
+   //Due to embedded bits in size, Alignment must be at least 4
+   BOOST_STATIC_ASSERT((Alignment >= 4));
+   //Due to rbtree size optimizations, Alignment must have at least pointer alignment
+   BOOST_STATIC_ASSERT((Alignment >= ::boost::alignment_of<void_pointer>::value));
+   static const size_type AlignmentMask = (Alignment - 1);
+   static const size_type BlockCtrlBytes = ipcdetail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
+   static const size_type BlockCtrlUnits = BlockCtrlBytes/Alignment;
+   static const size_type AllocatedCtrlBytes  = ipcdetail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
+   static const size_type AllocatedCtrlUnits  = AllocatedCtrlBytes/Alignment;
+   static const size_type EndCtrlBlockBytes   = ipcdetail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
+   static const size_type EndCtrlBlockUnits   = EndCtrlBlockBytes/Alignment;
+   static const size_type MinBlockUnits       = BlockCtrlUnits;
+   static const size_type UsableByPreviousChunk   = sizeof(size_type);
+
+   //Make sure the maximum alignment is power of two
+   BOOST_STATIC_ASSERT((0 == (Alignment & (Alignment - size_type(1u)))));
+   /// @endcond
+   public:
+   static const size_type PayloadPerAllocation = AllocatedCtrlBytes - UsableByPreviousChunk;
+};
+
+/// @cond
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type 
+       rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
+   ::priv_first_block_offset_from_this(const void *this_ptr, size_type extra_hdr_bytes)
+{
+   size_type uint_this      = (std::size_t)this_ptr;
+   size_type main_hdr_end   = uint_this + sizeof(rbtree_best_fit) + extra_hdr_bytes;
+   size_type aligned_main_hdr_end = ipcdetail::get_rounded_size(main_hdr_end, Alignment);
+   size_type block1_off = aligned_main_hdr_end -  uint_this;
+   algo_impl_t::assert_alignment(aligned_main_hdr_end);
+   algo_impl_t::assert_alignment(uint_this + block1_off);
+   return block1_off;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   priv_add_segment(void *addr, size_type size)
+{  
+   //Check alignment
+   algo_impl_t::check_alignment(addr);
+   //Check size
+   BOOST_ASSERT(size >= (BlockCtrlBytes + EndCtrlBlockBytes));
+
+   //Initialize the first big block and the "end" node
+   block_ctrl *first_big_block = new(addr)block_ctrl;
+   first_big_block->m_size = size/Alignment - EndCtrlBlockUnits;
+   BOOST_ASSERT(first_big_block->m_size >= BlockCtrlUnits);
+
+   //The "end" node is just a node of size 0 with the "end" bit set
+   block_ctrl *end_block = static_cast<block_ctrl*> 
+      (new (reinterpret_cast<char*>(addr) + first_big_block->m_size*Alignment)SizeHolder);
+
+   //This will overwrite the prev part of the "end" node
+   priv_mark_as_free_block (first_big_block);
+   #ifdef BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+   first_big_block->m_prev_size = end_block->m_size = 
+      (reinterpret_cast<char*>(first_big_block) - reinterpret_cast<char*>(end_block))/Alignment;
+   #else
+   first_big_block->m_prev_size = end_block->m_size = 
+      (reinterpret_cast<char*>(end_block) - reinterpret_cast<char*>(first_big_block))/Alignment;
+   #endif
+   end_block->m_allocated = 1;
+   first_big_block->m_prev_allocated = 1;
+
+   BOOST_ASSERT(priv_next_block(first_big_block) == end_block);
+   BOOST_ASSERT(priv_prev_block(end_block) == first_big_block);
+   BOOST_ASSERT(priv_first_block() == first_big_block);
+   BOOST_ASSERT(priv_end_block() == end_block);
+
+   //Some check to validate the algorithm, since it makes some assumptions
+   //to optimize the space wasted in bookkeeping:
+
+   //Check that the sizes of the header are placed before the rbtree
+   BOOST_ASSERT(static_cast<void*>(static_cast<SizeHolder*>(first_big_block))
+          < static_cast<void*>(static_cast<TreeHook*>(first_big_block)));
+   //Insert it in the intrusive containers
+   m_header.m_imultiset.insert(*first_big_block);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+       rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
+   ::priv_first_block()
+{
+   size_type block1_off = priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+   return reinterpret_cast<block_ctrl *>(reinterpret_cast<char*>(this) + block1_off);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+       rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
+   ::priv_end_block()
+{
+   size_type block1_off  = priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+   const size_type original_first_block_size = m_header.m_size/Alignment*Alignment - block1_off/Alignment*Alignment - EndCtrlBlockBytes;
+   block_ctrl *end_block = reinterpret_cast<block_ctrl*> 
+      (reinterpret_cast<char*>(this) + block1_off + original_first_block_size);
+   return end_block;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   rbtree_best_fit(size_type size, size_type extra_hdr_bytes)
+{
+   //Initialize the header
+   m_header.m_allocated       = 0;
+   m_header.m_size            = size;
+   m_header.m_extra_hdr_bytes = extra_hdr_bytes;
+
+   //Now write calculate the offset of the first big block that will
+   //cover the whole segment
+   BOOST_ASSERT(get_min_size(extra_hdr_bytes) <= size);
+   size_type block1_off  = priv_first_block_offset_from_this(this, extra_hdr_bytes);
+   priv_add_segment(reinterpret_cast<char*>(this) + block1_off, size - block1_off);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::~rbtree_best_fit()
+{
+   //There is a memory leak!
+//   BOOST_ASSERT(m_header.m_allocated == 0);
+//   BOOST_ASSERT(m_header.m_root.m_next->m_next == block_ctrl_ptr(&m_header.m_root));
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::grow(size_type extra_size)
+{
+   //Get the address of the first block
+   block_ctrl *first_block = priv_first_block();
+   block_ctrl *old_end_block = priv_end_block();
+   size_type old_border_offset = (size_type)(reinterpret_cast<char*>(old_end_block) - 
+                                    reinterpret_cast<char*>(this)) + EndCtrlBlockBytes;
+
+   //Update managed buffer's size
+   m_header.m_size += extra_size;
+
+   //We need at least MinBlockUnits blocks to create a new block
+   if((m_header.m_size - old_border_offset) < MinBlockUnits){
+      return;
+   }
+
+   //Now create a new block between the old end and the new end
+   size_type align_offset = (m_header.m_size - old_border_offset)/Alignment;
+   block_ctrl *new_end_block = reinterpret_cast<block_ctrl*>
+      (reinterpret_cast<char*>(old_end_block) + align_offset*Alignment);
+
+   //the last and first block are special:
+   //new_end_block->m_size & first_block->m_prev_size store the absolute value
+   //between them
+   new_end_block->m_allocated = 1;
+   #ifdef BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+   new_end_block->m_size      = (reinterpret_cast<char*>(first_block) - 
+                                 reinterpret_cast<char*>(new_end_block))/Alignment;
+   #else
+   new_end_block->m_size      = (reinterpret_cast<char*>(new_end_block) - 
+                                 reinterpret_cast<char*>(first_block))/Alignment;
+   #endif
+   first_block->m_prev_size = new_end_block->m_size;
+   first_block->m_prev_allocated = 1;
+   BOOST_ASSERT(new_end_block == priv_end_block());
+
+   //The old end block is the new block
+   block_ctrl *new_block = old_end_block;
+   new_block->m_size = (reinterpret_cast<char*>(new_end_block) - 
+                        reinterpret_cast<char*>(new_block))/Alignment;
+   BOOST_ASSERT(new_block->m_size >= BlockCtrlUnits);
+   priv_mark_as_allocated_block(new_block);
+   BOOST_ASSERT(priv_next_block(new_block) == new_end_block);
+
+   m_header.m_allocated += (size_type)new_block->m_size*Alignment;
+
+   //Now deallocate the newly created block
+   this->priv_deallocate(priv_get_user_buffer(new_block));
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::shrink_to_fit()
+{
+   //Get the address of the first block
+   block_ctrl *first_block = priv_first_block();
+   algo_impl_t::assert_alignment(first_block);
+
+   //block_ctrl *old_end_block = priv_end_block(first_block);
+   block_ctrl *old_end_block = priv_end_block();
+   algo_impl_t::assert_alignment(old_end_block);
+   size_type old_end_block_size = old_end_block->m_size;
+
+   void *unique_buffer = 0;
+   block_ctrl *last_block;
+   //Check if no memory is allocated between the first and last block
+   if(priv_next_block(first_block) == old_end_block){
+      //If so check if we can allocate memory
+      size_type ignore;
+      unique_buffer = priv_allocate(boost::interprocess::allocate_new, 0, 0, ignore).first;
+      //If not, return, we can't shrink
+      if(!unique_buffer)
+         return;
+      //If we can, mark the position just after the new allocation as the new end
+      algo_impl_t::assert_alignment(unique_buffer);
+      block_ctrl *unique_block = priv_get_block(unique_buffer);
+      BOOST_ASSERT(priv_is_allocated_block(unique_block));
+      algo_impl_t::assert_alignment(unique_block);
+      last_block = priv_next_block(unique_block);
+      BOOST_ASSERT(!priv_is_allocated_block(last_block));
+      algo_impl_t::assert_alignment(last_block);
+   }
+   else{
+      //If memory is allocated, check if the last block is allocated
+      if(priv_is_prev_allocated(old_end_block))
+         return;
+      //If not, mark last block after the free block
+      last_block = priv_prev_block(old_end_block);
+   }
+
+   size_type last_block_size = last_block->m_size;
+
+   //Erase block from the free tree, since we will erase it
+   m_header.m_imultiset.erase(Imultiset::s_iterator_to(*last_block));
+
+   size_type shrunk_border_offset = (size_type)(reinterpret_cast<char*>(last_block) - 
+                                       reinterpret_cast<char*>(this)) + EndCtrlBlockBytes;
+   
+   block_ctrl *new_end_block = last_block;
+   algo_impl_t::assert_alignment(new_end_block);
+
+   //Write new end block attributes
+   #ifdef BOOST_INTERPROCESS_RBTREE_BEST_FIT_ABI_V1_HPP
+   new_end_block->m_size = first_block->m_prev_size = 
+      (reinterpret_cast<char*>(first_block) - reinterpret_cast<char*>(new_end_block))/Alignment;
+   #else
+   new_end_block->m_size = first_block->m_prev_size = 
+      (reinterpret_cast<char*>(new_end_block) - reinterpret_cast<char*>(first_block))/Alignment;
+   #endif
+
+   new_end_block->m_allocated = 1;
+   (void)last_block_size;
+   (void)old_end_block_size;
+   BOOST_ASSERT(new_end_block->m_size == (old_end_block_size - last_block_size));
+
+   //Update managed buffer's size
+   m_header.m_size = shrunk_border_offset;
+   BOOST_ASSERT(priv_end_block() == new_end_block);
+   if(unique_buffer)
+      priv_deallocate(unique_buffer);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_size()  const
+{  return m_header.m_size;  }
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_free_memory()  const
+{
+   return m_header.m_size - m_header.m_allocated - 
+      priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   get_min_size (size_type extra_hdr_bytes)
+{
+   return (algo_impl_t::ceil_units(sizeof(rbtree_best_fit)) +
+           algo_impl_t::ceil_units(extra_hdr_bytes) + 
+           MinBlockUnits + EndCtrlBlockUnits)*Alignment;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+    all_memory_deallocated()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   size_type block1_off  = 
+      priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+
+   return m_header.m_allocated == 0 && 
+      m_header.m_imultiset.begin() != m_header.m_imultiset.end() &&
+       (++m_header.m_imultiset.begin()) == m_header.m_imultiset.end()
+       && m_header.m_imultiset.begin()->m_size == 
+         (m_header.m_size - block1_off - EndCtrlBlockBytes)/Alignment;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+    check_sanity()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   imultiset_iterator ib(m_header.m_imultiset.begin()), ie(m_header.m_imultiset.end());
+
+   size_type free_memory = 0;
+
+   //Iterate through all blocks obtaining their size
+   for(; ib != ie; ++ib){
+      free_memory += (size_type)ib->m_size*Alignment;
+      algo_impl_t::assert_alignment(&*ib);
+      if(!algo_impl_t::check_alignment(&*ib))
+         return false;
+   }
+
+   //Check allocated bytes are less than size
+   if(m_header.m_allocated > m_header.m_size){
+      return false;
+   }
+
+   size_type block1_off  = 
+      priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
+
+   //Check free bytes are less than size
+   if(free_memory > (m_header.m_size - block1_off)){
+      return false;
+   }
+   return true;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   allocate(size_type nbytes)
+{  
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   size_type ignore;
+   void * ret = priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
+   return ret;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   allocate_aligned(size_type nbytes, size_type alignment)
+{ 
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   return algo_impl_t::allocate_aligned(this, nbytes, alignment); 
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+template<class T>
+inline std::pair<T*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                        size_type preferred_size,size_type &received_size, 
+                        T *reuse_ptr)
+{
+   std::pair<void*, bool> ret = priv_allocation_command
+      (command, limit_size, preferred_size, received_size, static_cast<void*>(reuse_ptr), sizeof(T));
+
+   BOOST_ASSERT(0 == ((std::size_t)ret.first % ::boost::alignment_of<T>::value));
+   return std::pair<T *, bool>(static_cast<T*>(ret.first), ret.second);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline std::pair<void*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   raw_allocation_command  (boost::interprocess::allocation_type command,   size_type limit_objects,
+                        size_type preferred_objects,size_type &received_objects, 
+                        void *reuse_ptr, size_type sizeof_object)
+{
+   if(!sizeof_object)
+      return std::pair<void *, bool>(static_cast<void*>(0), false);
+   if(command & boost::interprocess::try_shrink_in_place){
+      bool success = algo_impl_t::try_shrink
+         ( this, reuse_ptr, limit_objects*sizeof_object
+         , preferred_objects*sizeof_object, received_objects);
+      received_objects /= sizeof_object;
+      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
+   }
+   return priv_allocation_command
+      (command, limit_objects, preferred_objects, received_objects, reuse_ptr, sizeof_object);
+}
+
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline std::pair<void*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   priv_allocation_command (boost::interprocess::allocation_type command,   size_type limit_size,
+                       size_type preferred_size,size_type &received_size, 
+                       void *reuse_ptr, size_type sizeof_object)
+{
+   std::pair<void*, bool> ret;
+   size_type max_count = m_header.m_size/sizeof_object;
+   if(limit_size > max_count || preferred_size > max_count){
+      ret.first = 0; return ret;
+   }
+   size_type l_size = limit_size*sizeof_object;
+   size_type p_size = preferred_size*sizeof_object;
+   size_type r_size;
+   {
+      //-----------------------
+      boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+      //-----------------------
+      ret = priv_allocate(command, l_size, p_size, r_size, reuse_ptr, sizeof_object);
+   }
+   received_size = r_size/sizeof_object;
+   return ret;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   size(const void *ptr) const
+{
+   //We need no synchronization since this block's size is not going
+   //to be modified by anyone else
+   //Obtain the real size of the block
+   return ((size_type)priv_get_block(ptr)->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::zero_free_memory()
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   imultiset_iterator ib(m_header.m_imultiset.begin()), ie(m_header.m_imultiset.end());
+
+   //Iterate through all blocks obtaining their size
+   while(ib != ie){
+      //Just clear user the memory part reserved for the user
+      volatile char *ptr = reinterpret_cast<char*>(&*ib) + BlockCtrlBytes;
+      size_type s = (size_type)ib->m_size*Alignment - BlockCtrlBytes;
+      while(s--){
+         *ptr++ = 0;
+      }
+
+      //This surprisingly is optimized out by Visual C++ 7.1 in release mode!
+      //std::memset( reinterpret_cast<char*>(&*ib) + BlockCtrlBytes
+      //           , 0
+      //           , ib->m_size*Alignment - BlockCtrlBytes);
+      ++ib;
+   }
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   priv_expand_both_sides(boost::interprocess::allocation_type command
+                         ,size_type min_size
+                         ,size_type preferred_size
+                         ,size_type &received_size
+                         ,void *reuse_ptr
+                         ,bool only_preferred_backwards
+                         ,size_type backwards_multiple)
+{
+   algo_impl_t::assert_alignment(reuse_ptr);
+   if(command & boost::interprocess::expand_fwd){
+      if(priv_expand(reuse_ptr, min_size, preferred_size, received_size))
+         return reuse_ptr;
+   }
+   else{
+      received_size = this->size(reuse_ptr);
+      if(received_size >= preferred_size || received_size >= min_size)
+         return reuse_ptr;
+   }
+
+   if(backwards_multiple){
+      BOOST_ASSERT(0 == (min_size       % backwards_multiple));
+      BOOST_ASSERT(0 == (preferred_size % backwards_multiple));
+   }
+
+   if(command & boost::interprocess::expand_bwd){
+      //Obtain the real size of the block
+      block_ctrl *reuse = priv_get_block(reuse_ptr);
+
+      //Sanity check 
+      //BOOST_ASSERT(reuse->m_size == priv_tail_size(reuse));
+      algo_impl_t::assert_alignment(reuse);
+
+      block_ctrl *prev_block;
+
+      //If the previous block is not free, there is nothing to do
+      if(priv_is_prev_allocated(reuse)){
+         return 0;
+      }
+
+      prev_block = priv_prev_block(reuse);
+      BOOST_ASSERT(!priv_is_allocated_block(prev_block));
+
+      //Some sanity checks
+      BOOST_ASSERT(prev_block->m_size == reuse->m_prev_size);
+      algo_impl_t::assert_alignment(prev_block);
+
+      size_type needs_backwards_aligned;
+      size_type lcm;
+      if(!algo_impl_t::calculate_lcm_and_needs_backwards_lcmed
+         ( backwards_multiple
+         , received_size
+         , only_preferred_backwards ? preferred_size : min_size
+         , lcm, needs_backwards_aligned)){
+         return 0;
+      }
+
+      //Check if previous block has enough size
+      if(size_type(prev_block->m_size*Alignment) >= needs_backwards_aligned){
+         //Now take all next space. This will succeed
+         if(command & boost::interprocess::expand_fwd){
+            size_type received_size2;
+            if(!priv_expand(reuse_ptr, received_size, received_size, received_size2)){
+               BOOST_ASSERT(0);
+            }
+            BOOST_ASSERT(received_size = received_size2);
+         }
+         //We need a minimum size to split the previous one
+         if(prev_block->m_size >= (needs_backwards_aligned/Alignment + BlockCtrlUnits)){
+            block_ctrl *new_block = reinterpret_cast<block_ctrl *>
+               (reinterpret_cast<char*>(reuse) - needs_backwards_aligned);
+
+            //Free old previous buffer
+            new_block->m_size = 
+               AllocatedCtrlUnits + (needs_backwards_aligned + (received_size - UsableByPreviousChunk))/Alignment;
+            BOOST_ASSERT(new_block->m_size >= BlockCtrlUnits);
+            priv_mark_as_allocated_block(new_block);
+
+            prev_block->m_size = (reinterpret_cast<char*>(new_block) - 
+                                  reinterpret_cast<char*>(prev_block))/Alignment;
+            BOOST_ASSERT(prev_block->m_size >= BlockCtrlUnits);
+            priv_mark_as_free_block(prev_block);
+
+            //Update the old previous block in the free blocks tree
+            //If the new size fulfills tree invariants do nothing,
+            //otherwise erase() + insert()
+            {
+               imultiset_iterator prev_block_it(Imultiset::s_iterator_to(*prev_block));
+               imultiset_iterator was_smaller_it(prev_block_it);
+               if(prev_block_it != m_header.m_imultiset.begin() && 
+                  (--(was_smaller_it = prev_block_it))->m_size > prev_block->m_size){
+                  m_header.m_imultiset.erase(prev_block_it);
+                  m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *prev_block);
+               }
+            }
+
+            received_size = needs_backwards_aligned + received_size;
+            m_header.m_allocated += needs_backwards_aligned;
+         
+            //Check alignment
+            algo_impl_t::assert_alignment(new_block);
+
+            //If the backwards expansion has remaining bytes in the
+            //first bytes, fill them with a pattern
+            void *p = priv_get_user_buffer(new_block);
+            void *user_ptr = reinterpret_cast<char*>(p);
+            BOOST_ASSERT((static_cast<char*>(reuse_ptr) - static_cast<char*>(user_ptr)) % backwards_multiple == 0);
+            algo_impl_t::assert_alignment(user_ptr);
+            return user_ptr;
+         }
+         //Check if there is no place to create a new block and
+         //the whole new block is multiple of the backwards expansion multiple
+         else if(prev_block->m_size >= needs_backwards_aligned/Alignment &&
+                 0 == ((prev_block->m_size*Alignment) % lcm)) {
+            //Erase old previous block, since we will change it
+            m_header.m_imultiset.erase(Imultiset::s_iterator_to(*prev_block));
+
+            //Just merge the whole previous block
+            //prev_block->m_size*Alignment is multiple of lcm (and backwards_multiple)
+            received_size = received_size + (size_type)prev_block->m_size*Alignment;
+
+            m_header.m_allocated += (size_type)prev_block->m_size*Alignment;
+            //Now update sizes
+            prev_block->m_size = prev_block->m_size + reuse->m_size;
+            BOOST_ASSERT(prev_block->m_size >= BlockCtrlUnits);
+            priv_mark_as_allocated_block(prev_block);
+
+            //If the backwards expansion has remaining bytes in the
+            //first bytes, fill them with a pattern
+            void *user_ptr = priv_get_user_buffer(prev_block);
+            BOOST_ASSERT((static_cast<char*>(reuse_ptr) - static_cast<char*>(user_ptr)) % backwards_multiple == 0);
+            algo_impl_t::assert_alignment(user_ptr);
+            return user_ptr;
+         }
+         else{
+            //Alignment issues
+         }
+      }
+   }
+   return 0;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   deallocate_many(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::multiallocation_chain chain)
+{
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   algo_impl_t::deallocate_many(this, boost::move(chain));
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+std::pair<void *, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   priv_allocate(boost::interprocess::allocation_type command
+                ,size_type limit_size
+                ,size_type preferred_size
+                ,size_type &received_size
+                ,void *reuse_ptr
+               ,size_type backwards_multiple)
+{
+   //Remove me. Forbid backwards allocation
+   //command &= (~boost::interprocess::expand_bwd);
+
+   if(command & boost::interprocess::shrink_in_place){
+      bool success = 
+         algo_impl_t::shrink(this, reuse_ptr, limit_size, preferred_size, received_size);
+      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
+   }
+
+   typedef std::pair<void *, bool> return_type;
+   received_size = 0;
+
+   if(limit_size > preferred_size)
+      return return_type(static_cast<void*>(0), false);
+
+   //Number of units to request (including block_ctrl header)
+   size_type preferred_units = priv_get_total_units(preferred_size);
+
+   //Number of units to request (including block_ctrl header)
+   size_type limit_units = priv_get_total_units(limit_size);
+
+   //Expand in place
+   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
+      void *ret = priv_expand_both_sides
+         (command, limit_size, preferred_size, received_size, reuse_ptr, true, backwards_multiple);
+      if(ret)
+         return return_type(ret, true);
+   }
+
+   if(command & boost::interprocess::allocate_new){
+      size_block_ctrl_compare comp;
+      imultiset_iterator it(m_header.m_imultiset.lower_bound(preferred_units, comp));
+
+      if(it != m_header.m_imultiset.end()){
+         return return_type(this->priv_check_and_allocate
+            (preferred_units, ipcdetail::to_raw_pointer(&*it), received_size), false);
+      }
+
+      if(it != m_header.m_imultiset.begin()&&
+              (--it)->m_size >= limit_units){
+         return return_type(this->priv_check_and_allocate
+            (it->m_size, ipcdetail::to_raw_pointer(&*it), received_size), false);
+      }
+   }
+
+
+   //Now try to expand both sides with min size
+   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
+      return return_type(priv_expand_both_sides
+         (command, limit_size, preferred_size, received_size, reuse_ptr, false, backwards_multiple), true);
+   }
+
+   return return_type(static_cast<void*>(0), false);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_get_block(const void *ptr)
+{
+   return const_cast<block_ctrl*>
+      (reinterpret_cast<const block_ctrl*>
+         (reinterpret_cast<const char*>(ptr) - AllocatedCtrlBytes));
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline
+void *rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+      priv_get_user_buffer(const typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
+{  return const_cast<char*>(reinterpret_cast<const char*>(block) + AllocatedCtrlBytes);   }
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
+rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   priv_get_total_units(size_type userbytes)
+{
+   if(userbytes < UsableByPreviousChunk)
+      userbytes = UsableByPreviousChunk;
+   size_type units = ipcdetail::get_rounded_size(userbytes - UsableByPreviousChunk, Alignment)/Alignment + AllocatedCtrlUnits;
+   if(units < BlockCtrlUnits) units = BlockCtrlUnits;
+   return units;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
+   priv_expand (void *ptr
+               ,const size_type min_size
+               ,const size_type preferred_size
+               ,size_type &received_size)
+{
+   //Obtain the real size of the block
+   block_ctrl *block = priv_get_block(ptr);
+   size_type old_block_units = block->m_size;
+
+   //The block must be marked as allocated and the sizes must be equal
+   BOOST_ASSERT(priv_is_allocated_block(block));
+   //BOOST_ASSERT(old_block_units == priv_tail_size(block));
+   
+   //Put this to a safe value
+   received_size = (old_block_units - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+   if(received_size >= preferred_size || received_size >= min_size)
+      return true;
+
+   //Now translate it to Alignment units
+   const size_type min_user_units = algo_impl_t::ceil_units(min_size - UsableByPreviousChunk);
+   const size_type preferred_user_units = algo_impl_t::ceil_units(preferred_size - UsableByPreviousChunk);
+
+   //Some parameter checks
+   BOOST_ASSERT(min_user_units <= preferred_user_units);
+
+   block_ctrl *next_block;
+
+   if(priv_is_allocated_block(next_block = priv_next_block(block))){
+      return received_size >= min_size ? true : false;
+   }
+   algo_impl_t::assert_alignment(next_block);
+
+   //Is "block" + "next_block" big enough?
+   const size_type merged_units = old_block_units + (size_type)next_block->m_size;
+
+   //Now get the expansion size
+   const size_type merged_user_units = merged_units - AllocatedCtrlUnits;
+
+   if(merged_user_units < min_user_units){
+      received_size = merged_units*Alignment - UsableByPreviousChunk;
+      return false;
+   }
+
+   //Now get the maximum size the user can allocate
+   size_type intended_user_units = (merged_user_units < preferred_user_units) ?
+      merged_user_units : preferred_user_units;
+
+   //These are total units of the merged block (supposing the next block can be split)
+   const size_type intended_units = AllocatedCtrlUnits + intended_user_units;
+
+   //Check if we can split the next one in two parts
+   if((merged_units - intended_units) >=  BlockCtrlUnits){
+      //This block is bigger than needed, split it in 
+      //two blocks, the first one will be merged and
+      //the second's size will be the remaining space
+      BOOST_ASSERT(next_block->m_size == priv_next_block(next_block)->m_prev_size);
+      const size_type rem_units = merged_units - intended_units;
+
+      //Check if we we need to update the old next block in the free blocks tree
+      //If the new size fulfills tree invariants, we just need to replace the node
+      //(the block start has been displaced), otherwise erase() + insert().
+      //
+      //This fixup must be done in two parts, because the new next block might
+      //overwrite the tree hook of the old next block. So we first erase the
+      //old if needed and we'll insert the new one after creating the new next
+      imultiset_iterator old_next_block_it(Imultiset::s_iterator_to(*next_block));
+      const bool size_invariants_broken = 
+            (next_block->m_size - rem_units ) < BlockCtrlUnits ||
+            (old_next_block_it != m_header.m_imultiset.begin() && 
+            (--imultiset_iterator(old_next_block_it))->m_size > rem_units);
+      if(size_invariants_broken){
+         m_header.m_imultiset.erase(old_next_block_it);
+      }
+      //This is the remaining block
+      block_ctrl *rem_block = new(reinterpret_cast<block_ctrl*>
+                     (reinterpret_cast<char*>(block) + intended_units*Alignment))block_ctrl;
+      rem_block->m_size  = rem_units;
+      algo_impl_t::assert_alignment(rem_block);
+      BOOST_ASSERT(rem_block->m_size >= BlockCtrlUnits);
+      priv_mark_as_free_block(rem_block);
+
+      //Now the second part of the fixup
+      if(size_invariants_broken)
+         m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *rem_block);
+      else
+         m_header.m_imultiset.replace_node(old_next_block_it, *rem_block);
+
+      //Write the new length
+      block->m_size = intended_user_units + AllocatedCtrlUnits;
+      BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
+      m_header.m_allocated += (intended_units - old_block_units)*Alignment;
+   }
+   //There is no free space to create a new node: just merge both blocks
+   else{
+      //Now we have to update the data in the tree
+      m_header.m_imultiset.erase(Imultiset::s_iterator_to(*next_block));
+
+      //Write the new length
+      block->m_size = merged_units;
+      BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
+      m_header.m_allocated += (merged_units - old_block_units)*Alignment;
+   }
+   priv_mark_as_allocated_block(block);
+   received_size = ((size_type)block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+   return true;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_prev_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *ptr)
+{
+   BOOST_ASSERT(!ptr->m_prev_allocated);
+   return reinterpret_cast<block_ctrl *>
+      (reinterpret_cast<char*>(ptr) - ptr->m_prev_size*Alignment);
+}
+
+
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_end_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *first_segment_block)
+{
+   //The first block's logic is different from the rest of blocks: stores in m_prev_size the absolute
+   //distance with the end block
+   BOOST_ASSERT(first_segment_block->m_prev_allocated);
+   block_ctrl *end_block = reinterpret_cast<block_ctrl *>
+      (reinterpret_cast<char*>(first_segment_block) + first_segment_block->m_prev_size*Alignment);
+   (void)end_block;
+   BOOST_ASSERT(end_block->m_allocated == 1);
+   BOOST_ASSERT(end_block->m_size == first_segment_block->m_prev_size);
+   BOOST_ASSERT(end_block > first_segment_block);
+   return end_block;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_first_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *end_segment_block)
+{
+   //The first block's logic is different from the rest of blocks: stores in m_prev_size the absolute
+   //distance with the end block
+   BOOST_ASSERT(end_segment_block->m_allocated);
+   block_ctrl *first_block = reinterpret_cast<block_ctrl *>
+      (reinterpret_cast<char*>(end_segment_block) - end_segment_block->m_size*Alignment);
+   (void)first_block;
+   BOOST_ASSERT(first_block->m_prev_allocated == 1);
+   BOOST_ASSERT(first_block->m_prev_size == end_segment_block->m_size);
+   BOOST_ASSERT(end_segment_block > first_block);
+   return first_block;
+}
+
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
+   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_next_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *ptr)
+{
+   return reinterpret_cast<block_ctrl *>
+      (reinterpret_cast<char*>(ptr) + ptr->m_size*Alignment);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_is_allocated_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
+{
+   bool allocated = block->m_allocated != 0;
+   #ifndef NDEBUG
+   if(block != priv_end_block()){
+      block_ctrl *next_block = reinterpret_cast<block_ctrl *>
+         (reinterpret_cast<char*>(block) + block->m_size*Alignment);
+      bool next_block_prev_allocated = next_block->m_prev_allocated != 0;
+      (void)next_block_prev_allocated;
+      BOOST_ASSERT(allocated == next_block_prev_allocated);
+   }
+   else{
+      block = block;
+   }
+   #endif
+   return allocated;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_is_prev_allocated
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
+{
+   if(block->m_prev_allocated){
+      return true;
+   }
+   else{
+      #ifndef NDEBUG
+      if(block != priv_first_block()){
+         block_ctrl *prev = priv_prev_block(block);
+         (void)prev;
+         BOOST_ASSERT(!prev->m_allocated);
+      }
+      else{
+         block = block;
+      }
+      #endif
+      return false;
+   }
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_mark_as_allocated_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
+{
+   block->m_allocated = 1;
+   reinterpret_cast<block_ctrl *>
+      (reinterpret_cast<char*>(block)+ block->m_size*Alignment)->m_prev_allocated = 1;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_mark_as_free_block
+      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
+{
+   block->m_allocated = 0;
+   block_ctrl *next_block = priv_next_block(block);
+   next_block->m_prev_allocated = 0;
+   next_block->m_prev_size = block->m_size;
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
+void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_check_and_allocate
+   (size_type nunits
+   ,typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl* block
+   ,size_type &received_size)
+{
+   size_type upper_nunits = nunits + BlockCtrlUnits;
+   imultiset_iterator it_old = Imultiset::s_iterator_to(*block);
+   algo_impl_t::assert_alignment(block);
+
+   if (block->m_size >= upper_nunits){
+      //This block is bigger than needed, split it in 
+      //two blocks, the first's size will be "units" and
+      //the second's size "block->m_size-units"
+      size_type block_old_size = block->m_size;
+      block->m_size = nunits;
+      BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
+
+      //This is the remaining block
+      block_ctrl *rem_block = new(reinterpret_cast<block_ctrl*>
+                     (reinterpret_cast<char*>(block) + Alignment*nunits))block_ctrl;
+      algo_impl_t::assert_alignment(rem_block);
+      rem_block->m_size  = block_old_size - nunits;
+      BOOST_ASSERT(rem_block->m_size >= BlockCtrlUnits);
+      priv_mark_as_free_block(rem_block);
+
+      imultiset_iterator it_hint;
+      if(it_old == m_header.m_imultiset.begin()
+         || (--imultiset_iterator(it_old))->m_size < rem_block->m_size){
+         //option a: slow but secure
+         //m_header.m_imultiset.insert(m_header.m_imultiset.erase(it_old), *rem_block);
+         //option b: Construct an empty node and swap
+         //Imultiset::init_node(*rem_block);
+         //block->swap_nodes(*rem_block);
+         //option c: replace the node directly
+         m_header.m_imultiset.replace_node(Imultiset::s_iterator_to(*it_old), *rem_block);
+      }
+      else{
+         //Now we have to update the data in the tree
+         m_header.m_imultiset.erase(it_old);
+         m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *rem_block);
+      }
+         
+   }
+   else if (block->m_size >= nunits){
+      m_header.m_imultiset.erase(it_old);
+   }
+   else{
+      BOOST_ASSERT(0);
+      return 0;
+   }
+   //We need block_ctrl for deallocation stuff, so
+   //return memory user can overwrite
+   m_header.m_allocated += (size_type)block->m_size*Alignment;
+   received_size =  ((size_type)block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
+
+   //Mark the block as allocated
+   priv_mark_as_allocated_block(block);
+
+   //Clear the memory occupied by the tree hook, since this won't be
+   //cleared with zero_free_memory
+   TreeHook *t = static_cast<TreeHook*>(block);
+   //Just clear the memory part reserved for the user      
+   std::size_t tree_hook_offset_in_block = (char*)t - (char*)block;
+   //volatile char *ptr = 
+   char *ptr = reinterpret_cast<char*>(block)+tree_hook_offset_in_block;
+   const std::size_t s = BlockCtrlBytes - tree_hook_offset_in_block;
+   std::memset(ptr, 0, s);
+   this->priv_next_block(block)->m_prev_size = 0;
+   return priv_get_user_buffer(block);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::deallocate(void* addr)
+{
+   if(!addr)   return;
+   //-----------------------
+   boost::interprocess::scoped_lock<mutex_type> guard(m_header);
+   //-----------------------
+   return this->priv_deallocate(addr);
+}
+
+template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
+void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_deallocate(void* addr)
+{
+   if(!addr)   return;
+
+   block_ctrl *block = priv_get_block(addr);
+  
+   //The blocks must be marked as allocated and the sizes must be equal
+   BOOST_ASSERT(priv_is_allocated_block(block));
+//   BOOST_ASSERT(block->m_size == priv_tail_size(block));
+
+   //Check if alignment and block size are right
+   algo_impl_t::assert_alignment(addr);
+
+   size_type block_old_size = Alignment*(size_type)block->m_size;
+   BOOST_ASSERT(m_header.m_allocated >= block_old_size);
+
+   //Update used memory count
+   m_header.m_allocated -= block_old_size;
+
+   //The block to insert in the tree
+   block_ctrl *block_to_insert = block;
+
+   //Get the next block
+   block_ctrl *next_block  = priv_next_block(block);
+   bool merge_with_prev    = !priv_is_prev_allocated(block);
+   bool merge_with_next    = !priv_is_allocated_block(next_block);
+
+   //Merge logic. First just update block sizes, then fix free blocks tree
+   if(merge_with_prev || merge_with_next){
+      //Merge if the previous is free
+      if(merge_with_prev){
+         //Get the previous block
+         block_ctrl *prev_block = priv_prev_block(block);
+         prev_block->m_size += block->m_size;
+         BOOST_ASSERT(prev_block->m_size >= BlockCtrlUnits);
+         block_to_insert = prev_block;
+      }
+      //Merge if the next is free
+      if(merge_with_next){
+         block_to_insert->m_size += next_block->m_size;
+         BOOST_ASSERT(block_to_insert->m_size >= BlockCtrlUnits);
+         if(merge_with_prev)
+            m_header.m_imultiset.erase(Imultiset::s_iterator_to(*next_block));
+      }
+
+      bool only_merge_next = !merge_with_prev && merge_with_next;
+      imultiset_iterator free_block_to_check_it
+         (Imultiset::s_iterator_to(only_merge_next ? *next_block : *block_to_insert));
+      imultiset_iterator was_bigger_it(free_block_to_check_it);
+
+      //Now try to shortcut erasure + insertion (O(log(N))) with
+      //a O(1) operation if merging does not alter tree positions
+      if(++was_bigger_it != m_header.m_imultiset.end()   &&
+         block_to_insert->m_size > was_bigger_it->m_size ){
+         m_header.m_imultiset.erase(free_block_to_check_it);
+         m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *block_to_insert);
+      }
+      else if(only_merge_next){
+         m_header.m_imultiset.replace_node(free_block_to_check_it, *block_to_insert);
+      }
+   }
+   else{
+      m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *block_to_insert);
+   }
+   priv_mark_as_free_block(block_to_insert);
+}
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MEM_ALGO_RBTREE_BEST_FIT_HPP
diff --git a/boost/interprocess/mem_algo/simple_seq_fit.hpp b/boost/interprocess/mem_algo/simple_seq_fit.hpp
new file mode 100644
index 0000000000..5cc92c1103
--- /dev/null
+++ b/boost/interprocess/mem_algo/simple_seq_fit.hpp
@@ -0,0 +1,58 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SIMPLE_SEQ_FIT_HPP
+#define BOOST_INTERPROCESS_SIMPLE_SEQ_FIT_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/mem_algo/detail/simple_seq_fit_impl.hpp>
+#include <boost/interprocess/offset_ptr.hpp>
+
+//!\file
+//!Describes sequential fit algorithm used to allocate objects in shared memory.
+
+namespace boost {
+namespace interprocess {
+
+//!This class implements the simple sequential fit algorithm with a simply
+//!linked list of free buffers.
+template<class MutexFamily, class VoidPointer>
+class simple_seq_fit 
+   : public ipcdetail::simple_seq_fit_impl<MutexFamily, VoidPointer>
+{
+   /// @cond
+   typedef ipcdetail::simple_seq_fit_impl<MutexFamily, VoidPointer> base_t;
+   /// @endcond
+
+   public:
+   typedef typename base_t::size_type                            size_type;
+
+   //!Constructor. "size" is the total size of the managed memory segment, 
+   //!"extra_hdr_bytes" indicates the extra bytes beginning in the sizeof(simple_seq_fit)
+   //!offset that the allocator should not use at all.*/
+   simple_seq_fit           (size_type size, size_type extra_hdr_bytes)
+      : base_t(size, extra_hdr_bytes){}
+};
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_SIMPLE_SEQ_FIT_HPP
+
diff --git a/boost/interprocess/offset_ptr.hpp b/boost/interprocess/offset_ptr.hpp
new file mode 100644
index 0000000000..4187543d57
--- /dev/null
+++ b/boost/interprocess/offset_ptr.hpp
@@ -0,0 +1,528 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_OFFSET_PTR_HPP
+#define BOOST_INTERPROCESS_OFFSET_PTR_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/cast_tags.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/assert.hpp>
+#include <ostream>
+#include <istream>
+#include <iterator>
+#include <boost/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+
+//!\file
+//!Describes a smart pointer that stores the offset between this pointer and
+//!target pointee, called offset_ptr.
+
+namespace boost {
+
+//Predeclarations
+template <class T>
+struct has_trivial_constructor;
+
+template <class T>
+struct has_trivial_destructor;
+
+namespace interprocess {
+
+//!A smart pointer that stores the offset between between the pointer and the
+//!the object it points. This allows offset allows special properties, since
+//!the pointer is independent from the address address of the pointee, if the
+//!pointer and the pointee are still separated by the same offset. This feature
+//!converts offset_ptr in a smart pointer that can be placed in shared memory and
+//!memory mapped files mapped in different addresses in every process.
+template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
+class offset_ptr
+{
+   /// @cond
+   typedef offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment>   self_t;
+   void unspecified_bool_type_func() const {}
+   typedef void (self_t::*unspecified_bool_type)() const;
+   /// @endcond
+
+   public:
+   typedef PointedType                       element_type;
+   typedef PointedType *                     pointer;
+   typedef typename ipcdetail::
+      add_reference<PointedType>::type       reference;
+   typedef typename ipcdetail::
+      remove_volatile<typename ipcdetail::
+         remove_const<PointedType>::type
+            >::type                          value_type;
+   typedef DifferenceType                    difference_type;
+   typedef std::random_access_iterator_tag   iterator_category;
+   typedef OffsetType                        offset_type;
+
+   public:   //Public Functions
+
+   //!Constructor from raw pointer (allows "0" pointer conversion).
+   //!Never throws.
+   offset_ptr(pointer ptr = 0) {  this->set_offset(ptr); }
+
+   //!Constructor from other pointer.
+   //!Never throws.
+   template <class T>
+   offset_ptr( T *ptr
+             , typename ipcdetail::enable_if< ipcdetail::is_convertible<T*, PointedType*> >::type * = 0) 
+   {  this->set_offset(static_cast<PointedType*>(ptr)); }
+
+   //!Constructor from other offset_ptr
+   //!Never throws.
+   offset_ptr(const offset_ptr& ptr) 
+   {  this->set_offset(ptr.get());   }
+
+   //!Constructor from other offset_ptr. If pointers of pointee types are 
+   //!convertible, offset_ptrs will be convertibles. Never throws.
+   template<class T2, class P2, class O2, std::size_t A2>
+   offset_ptr( const offset_ptr<T2, P2, O2, A2> &ptr
+             , typename ipcdetail::enable_if< ipcdetail::is_convertible<T2*, PointedType*> >::type * = 0) 
+   {  this->set_offset(static_cast<PointedType*>(ptr.get()));   }
+
+   //!Emulates static_cast operator.
+   //!Never throws.
+   template<class T2, class P2, class O2, std::size_t A2>
+   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::static_cast_tag)
+   {  this->set_offset(static_cast<PointedType*>(r.get()));   }
+
+   //!Emulates const_cast operator.
+   //!Never throws.
+   template<class T2, class P2, class O2, std::size_t A2>
+   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::const_cast_tag)
+   {  this->set_offset(const_cast<PointedType*>(r.get()));   }
+
+   //!Emulates dynamic_cast operator.
+   //!Never throws.
+   template<class T2, class P2, class O2, std::size_t A2>
+   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::dynamic_cast_tag)
+   {  this->set_offset(dynamic_cast<PointedType*>(r.get()));   }
+
+   //!Emulates reinterpret_cast operator.
+   //!Never throws.
+   template<class T2, class P2, class O2, std::size_t A2>
+   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::reinterpret_cast_tag)
+   {  this->set_offset(reinterpret_cast<PointedType*>(r.get()));   }
+
+   //!Obtains raw pointer from offset.
+   //!Never throws.
+   pointer get()const
+   {  return this->to_raw_pointer();   }
+
+   offset_type get_offset() const
+   {  return internal.m_offset;  }
+
+   //!Pointer-like -> operator. It can return 0 pointer.
+   //!Never throws.
+   pointer operator->() const           
+   {  return this->get(); }
+
+   //!Dereferencing operator, if it is a null offset_ptr behavior 
+   //!   is undefined. Never throws.
+   reference operator* () const           
+   {
+      pointer p = this->get();
+      reference r = *p;
+      return r;
+   }
+
+   //!Indexing operator.
+   //!Never throws.
+   template<class T>
+   reference operator[](T idx) const   
+   {  return this->get()[idx];  }
+
+   //!Assignment from pointer (saves extra conversion).
+   //!Never throws.
+   offset_ptr& operator= (pointer from)
+   {  this->set_offset(from); return *this;  }
+
+   //!Assignment from other offset_ptr.
+   //!Never throws.
+   offset_ptr& operator= (const offset_ptr & pt)
+   {  pointer p(pt.get());  (void)p; this->set_offset(p);  return *this;  }
+
+   //!Assignment from related offset_ptr. If pointers of pointee types 
+   //!   are assignable, offset_ptrs will be assignable. Never throws.
+   template<class T2, class P2, class O2, std::size_t A2>
+   typename ipcdetail::enable_if<ipcdetail::is_convertible<T2*, PointedType*>, offset_ptr&>::type
+      operator= (const offset_ptr<T2, P2, O2, A2> & ptr)
+   {  this->set_offset(static_cast<PointedType*>(ptr.get()));  return *this;  }
+ 
+   //!offset_ptr += difference_type.
+   //!Never throws.
+   offset_ptr &operator+= (difference_type offset)
+   {  this->inc_offset(offset * sizeof (PointedType));   return *this;  }
+
+   //!offset_ptr -= difference_type.
+   //!Never throws.
+   template<class T>
+   offset_ptr &operator-= (T offset)
+   {  this->dec_offset(offset * sizeof (PointedType));   return *this;  }
+
+   //!++offset_ptr.
+   //!Never throws.
+   offset_ptr& operator++ (void) 
+   {  this->inc_offset(sizeof (PointedType));   return *this;  }
+
+   //!offset_ptr++.
+   //!Never throws.
+   offset_ptr operator++ (int)
+   {  offset_ptr temp(*this); ++*this; return temp; }
+
+   //!--offset_ptr.
+   //!Never throws.
+   offset_ptr& operator-- (void) 
+   {  this->dec_offset(sizeof (PointedType));   return *this;  }
+
+   //!offset_ptr--.
+   //!Never throws.
+   offset_ptr operator-- (int)
+   {  offset_ptr temp(*this); --*this; return temp; }
+
+   //!safe bool conversion operator.
+   //!Never throws.
+   operator unspecified_bool_type() const  
+   {  return this->get()? &self_t::unspecified_bool_type_func : 0;   }
+
+   //!Not operator. Not needed in theory, but improves portability. 
+   //!Never throws
+   bool operator! () const
+   {  return this->get() == 0;   }
+
+   //!Compatibility with pointer_traits
+   //!
+   template <class U>
+   struct rebind
+   {  typedef offset_ptr<U, DifferenceType, OffsetType, OffsetAlignment> other;  };
+
+   //!Compatibility with pointer_traits
+   //!
+   static offset_ptr pointer_to(reference r)
+   { return offset_ptr(&r); }
+
+   //!difference_type + offset_ptr
+   //!operation
+   friend offset_ptr operator+(difference_type diff, const offset_ptr& right)
+   {  offset_ptr tmp(right); tmp += diff;  return tmp;  }
+
+   //!offset_ptr + difference_type
+   //!operation
+   friend offset_ptr operator+(const offset_ptr& left, difference_type diff)
+   {  offset_ptr tmp(left); tmp += diff;  return tmp; }
+
+   //!offset_ptr - diff
+   //!operation
+   friend offset_ptr operator-(const offset_ptr &left, difference_type diff)
+   {  offset_ptr tmp(left); tmp -= diff;  return tmp; }
+
+   //!offset_ptr - diff
+   //!operation
+   friend offset_ptr operator-(difference_type diff, const offset_ptr &right)
+   {  offset_ptr tmp(right); tmp -= diff; return tmp; }
+
+   //!offset_ptr - offset_ptr
+   //!operation
+   friend difference_type operator-(const offset_ptr &pt, const offset_ptr &pt2)
+   {  return difference_type(pt.get()- pt2.get());   }
+
+   //Comparison
+   friend bool operator== (const offset_ptr &pt1, const offset_ptr &pt2)
+   {  return pt1.get() == pt2.get();  }
+
+   friend bool operator!= (const offset_ptr &pt1, const offset_ptr &pt2)
+   {  return pt1.get() != pt2.get();  }
+
+   friend bool operator<(const offset_ptr &pt1, const offset_ptr &pt2)
+   {  return pt1.get() < pt2.get();  }
+
+   friend bool operator<=(const offset_ptr &pt1, const offset_ptr &pt2)
+   {  return pt1.get() <= pt2.get();  }
+
+   friend bool operator>(const offset_ptr &pt1, const offset_ptr &pt2)
+   {  return pt1.get() > pt2.get();  }
+
+   friend bool operator>=(const offset_ptr &pt1, const offset_ptr &pt2)
+   {  return pt1.get() >= pt2.get();  }
+
+   //Comparison to raw ptr to support literal 0
+   friend bool operator== (pointer pt1, const offset_ptr &pt2)
+   {  return pt1 == pt2.get();  }
+
+   friend bool operator!= (pointer pt1, const offset_ptr &pt2)
+   {  return pt1 != pt2.get();  }
+
+   friend bool operator<(pointer pt1, const offset_ptr &pt2)
+   {  return pt1 < pt2.get();  }
+
+   friend bool operator<=(pointer pt1, const offset_ptr &pt2)
+   {  return pt1 <= pt2.get();  }
+
+   friend bool operator>(pointer pt1, const offset_ptr &pt2)
+   {  return pt1 > pt2.get();  }
+
+   friend bool operator>=(pointer pt1, const offset_ptr &pt2)
+   {  return pt1 >= pt2.get();  }
+
+   //Comparison
+   friend bool operator== (const offset_ptr &pt1, pointer pt2)
+   {  return pt1.get() == pt2;  }
+
+   friend bool operator!= (const offset_ptr &pt1, pointer pt2)
+   {  return pt1.get() != pt2;  }
+
+   friend bool operator<(const offset_ptr &pt1, pointer pt2)
+   {  return pt1.get() < pt2;  }
+
+   friend bool operator<=(const offset_ptr &pt1, pointer pt2)
+   {  return pt1.get() <= pt2;  }
+
+   friend bool operator>(const offset_ptr &pt1, pointer pt2)
+   {  return pt1.get() > pt2;  }
+
+   friend bool operator>=(const offset_ptr &pt1, pointer pt2)
+   {  return pt1.get() >= pt2;  }
+
+   friend void swap(offset_ptr &left, offset_ptr &right)
+   {
+      pointer ptr = right.get();
+      right = left;
+      left = ptr;
+   }
+
+   private:
+   /// @cond
+
+   //Note: using the address of a local variable to point to another address
+   //is not standard conforming and this can be optimized-away by the compiler.
+   //Non-inlining is a method to remain illegal and correct
+   #if defined(_MSC_VER)
+   __declspec(noinline) //this workaround is needed for MSVC compilers
+   #elif defined (__GNUC__)//this workaround is needed for GCC
+   __attribute__((__noinline__))
+   #endif
+   void set_offset(const PointedType *ptr)
+   {
+      #if defined (__GNUC__)
+      //asm(""); //Prevents the function to be optimized-away (provokes an special "side-effect")
+      #endif
+      //offset == 1 && ptr != 0 is not legal for this pointer
+      if(!ptr){
+         internal.m_offset = 1;
+      }
+      else{
+         internal.m_offset = (OffsetType)((const char*)ptr - (const char*)(this));
+         BOOST_ASSERT(internal.m_offset != 1);
+      }
+   }
+
+   #if defined(_MSC_VER) && (_MSC_VER >= 1400)
+   __declspec(noinline)
+   #elif defined (__GNUC__)
+   __attribute__((__noinline__))
+   #endif
+   PointedType * to_raw_pointer() const
+   {
+      #if defined (__GNUC__)
+      //asm(""); //Prevents the function to be optimized-away (provokes an special "side-effect")
+      #endif
+      return static_cast<PointedType *>(
+         static_cast<void*>(
+            (internal.m_offset == 1) ? 
+               0 : 
+                  (const_cast<char*>(reinterpret_cast<const char*>(this)) + internal.m_offset)
+         )
+      );
+   }
+
+   void inc_offset(DifferenceType bytes)
+   {  internal.m_offset += bytes;   }
+
+   void dec_offset(DifferenceType bytes)
+   {  internal.m_offset -= bytes;   }
+
+   union internal_type{
+      OffsetType m_offset; //Distance between this object and pointee address
+    typename ::boost::aligned_storage
+         < sizeof(OffsetType)
+         , (OffsetAlignment == offset_type_alignment) ?
+            ::boost::alignment_of<OffsetType>::value : OffsetAlignment
+         >::type alignment_helper;
+   } internal;
+   /// @endcond
+};
+
+//!operator<<
+//!for offset ptr
+template<class E, class T, class W, class X, class Y, std::size_t Z> 
+inline std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, offset_ptr<W, X, Y, Z> const & p)
+{  return os << p.get_offset();   }
+
+//!operator>> 
+//!for offset ptr
+template<class E, class T, class W, class X, class Y, std::size_t Z> 
+inline std::basic_istream<E, T> & operator>> 
+   (std::basic_istream<E, T> & is, offset_ptr<W, X, Y, Z> & p)
+{  return is >> p.get_offset();  }
+
+//!Simulation of static_cast between pointers. Never throws.
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1> 
+   static_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
+{  
+   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
+            (r, boost::interprocess::ipcdetail::static_cast_tag());  
+}
+
+//!Simulation of const_cast between pointers. Never throws.
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
+   const_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
+{  
+   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
+            (r, boost::interprocess::ipcdetail::const_cast_tag());  
+}
+
+//!Simulation of dynamic_cast between pointers. Never throws.
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1> 
+   dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
+{  
+   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
+            (r, boost::interprocess::ipcdetail::dynamic_cast_tag());  
+}
+
+//!Simulation of reinterpret_cast between pointers. Never throws.
+template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
+inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
+   reinterpret_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
+{  
+   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
+            (r, boost::interprocess::ipcdetail::reinterpret_cast_tag());  
+}
+
+}  //namespace interprocess {
+
+/// @cond
+
+//!has_trivial_constructor<> == true_type specialization for optimizations
+template <class T, class P, class O, std::size_t A>
+struct has_trivial_constructor< boost::interprocess::offset_ptr<T, P, O, A> > 
+{
+   static const bool value = true;
+};
+
+///has_trivial_destructor<> == true_type specialization for optimizations
+template <class T, class P, class O, std::size_t A>
+struct has_trivial_destructor< boost::interprocess::offset_ptr<T, P, O, A> > 
+{
+   static const bool value = true;
+};
+
+//#if !defined(_MSC_VER) || (_MSC_VER >= 1400)
+namespace interprocess {
+//#endif
+//!to_raw_pointer() enables boost::mem_fn to recognize offset_ptr. 
+//!Never throws.
+template <class T, class P, class O, std::size_t A>
+inline T * to_raw_pointer(boost::interprocess::offset_ptr<T, P, O, A> const & p)
+{  return p.get();   }
+//#if !defined(_MSC_VER) || (_MSC_VER >= 1400)
+}  //namespace interprocess
+//#endif
+
+/// @endcond
+}  //namespace boost {
+
+/// @cond
+
+namespace boost{
+
+//This is to support embedding a bit in the pointer
+//for intrusive containers, saving space
+namespace intrusive {
+
+//Predeclaration to avoid including header
+template<class VoidPointer, std::size_t N>
+struct max_pointer_plus_bits;
+
+template<std::size_t OffsetAlignment, class P, class O, std::size_t A>
+struct max_pointer_plus_bits<boost::interprocess::offset_ptr<void, P, O, A>, OffsetAlignment>
+{
+   //The offset ptr can embed one bit less than the alignment since it
+   //uses offset == 1 to store the null pointer.
+   static const std::size_t value = ::boost::interprocess::ipcdetail::ls_zeros<OffsetAlignment>::value - 1;
+};
+
+//Predeclaration
+template<class Pointer, std::size_t NumBits>
+struct pointer_plus_bits;
+
+template<class T, class P, class O, std::size_t A, std::size_t NumBits>
+struct pointer_plus_bits<boost::interprocess::offset_ptr<T, P, O, A>, NumBits>
+{
+   typedef boost::interprocess::offset_ptr<T, P, O, A>         pointer;
+   //Bits are stored in the lower bits of the pointer except the LSB,
+   //because this bit is used to represent the null pointer.
+   static const std::size_t Mask = ((std::size_t(1) << NumBits)-1)<<1u; 
+
+   static pointer get_pointer(const pointer &n)
+   {  return reinterpret_cast<T*>(std::size_t(n.get()) & ~std::size_t(Mask));  }
+
+   static void set_pointer(pointer &n, pointer p)
+   {
+      std::size_t pint = std::size_t(p.get());
+      BOOST_ASSERT(0 == (std::size_t(pint) & Mask));
+      n = reinterpret_cast<T*>(pint | (std::size_t(n.get()) & std::size_t(Mask)));
+   }
+
+   static std::size_t get_bits(const pointer &n)
+   {  return(std::size_t(n.get()) & std::size_t(Mask)) >> 1u;  }
+
+   static void set_bits(pointer &n, std::size_t b)
+   {
+      BOOST_ASSERT(b < (std::size_t(1) << NumBits));
+      n = reinterpret_cast<T*>(std::size_t(get_pointer(n).get()) | (b << 1u));
+   }
+};
+
+}  //namespace intrusive
+
+//Predeclaration
+template<class T, class U>
+struct pointer_to_other;
+
+
+
+//Backwards compatibility with pointer_to_other
+template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment, class U>
+struct pointer_to_other
+   < ::boost::interprocess::offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment>, U >
+{
+   typedef ::boost::interprocess::offset_ptr<U, DifferenceType, OffsetType, OffsetAlignment> type;
+};
+
+}  //namespace boost{
+/// @endcond
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTERPROCESS_OFFSET_PTR_HPP
diff --git a/boost/interprocess/permissions.hpp b/boost/interprocess/permissions.hpp
new file mode 100644
index 0000000000..745f8a8e0f
--- /dev/null
+++ b/boost/interprocess/permissions.hpp
@@ -0,0 +1,132 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_PERMISSIONS_HPP
+#define BOOST_INTERPROCESS_PERMISSIONS_HPP
+
+/// @cond
+
+#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/interprocess/interprocess_fwd.hpp>
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+#include <boost/interprocess/detail/win32_api.hpp>
+
+#endif
+
+/// @endcond
+
+//!\file
+//!Describes permissions class
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+
+namespace ipcdetail {
+
+template <int Dummy>
+struct unrestricted_permissions_holder
+{
+   static winapi::interprocess_all_access_security unrestricted;
+};
+
+template<int Dummy>
+winapi::interprocess_all_access_security unrestricted_permissions_holder<Dummy>::unrestricted;
+
+}  //namespace ipcdetail {
+
+#endif   //defined BOOST_INTERPROCESS_WINDOWS
+
+/// @endcond
+
+//!The permissions class represents permissions to be set to shared memory or
+//!files, that can be constructed form usual permission representations:
+//!a SECURITY_ATTRIBUTES pointer in windows or ORed rwx chmod integer in UNIX.
+class permissions
+{
+   /// @cond
+
+   #if defined(BOOST_INTERPROCESS_WINDOWS)
+   typedef void*  os_permissions_type;
+   #else
+   typedef int    os_permissions_type;
+   #endif
+   os_permissions_type  m_perm;
+
+   /// @endcond
+
+   public:
+   //!Constructs a permissions object from a user provided os-dependent
+   //!permissions.
+   permissions(os_permissions_type type)
+      : m_perm(type)
+   {}
+
+   //!Constructs a default permissions object:
+   //!A null security attributes pointer for windows or 0644
+   //!for UNIX.
+   permissions()
+   {  set_default(); }
+
+   //!Sets permissions to default values:
+   //!A null security attributes pointer for windows or 0644
+   //!for UNIX.
+   void set_default()
+   {
+      /// @cond
+      #if defined (BOOST_INTERPROCESS_WINDOWS)
+      m_perm = 0;
+      #else
+      m_perm = 0644;
+      #endif
+      /// @endcond
+   }
+
+   //!Sets permissions to unrestricted access:
+   //!A null DACL for windows or 0666 for UNIX.
+   void set_unrestricted()
+   {
+      /// @cond
+      #if defined (BOOST_INTERPROCESS_WINDOWS)
+      m_perm = &ipcdetail::unrestricted_permissions_holder<0>::unrestricted;
+      #else
+      m_perm = 0666;
+      #endif
+      /// @endcond
+   }
+
+   //!Sets permissions from a user provided os-dependent
+   //!permissions.
+   void set_permissions(os_permissions_type perm)
+   {  m_perm = perm; }
+
+   //!Returns stored os-dependent
+   //!permissions
+   os_permissions_type get_permissions() const
+   {  return m_perm; }
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_PERMISSIONS_HPP
+
diff --git a/boost/interprocess/segment_manager.hpp b/boost/interprocess/segment_manager.hpp
new file mode 100644
index 0000000000..4424695992
--- /dev/null
+++ b/boost/interprocess/segment_manager.hpp
@@ -0,0 +1,1365 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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
+
+#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/detail/no_exceptions_support.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/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/move.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <cstddef>   //std::size_t
+#include <string>    //char_traits
+#include <new>       //std::nothrow
+#include <utility>   //std::pair
+#include <boost/assert.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif
+
+//!\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;
+   typedef MemoryAlgorithm memory_algorithm;
+   
+   /// @cond
+   
+   //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;
+
+   /// @endcond
+
+   //!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 size, size_type reserved_bytes)
+      :  MemoryAlgorithm(size, 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, std::nothrow_t)
+   {  return MemoryAlgorithm::allocate(nbytes);   }
+
+   /// @cond
+
+   //Experimental. Dont' use.
+   //!Allocates n_elements of
+   //!elem_size bytes. Throws bad_alloc on failure.
+   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
+   {
+      multiallocation_chain mem(MemoryAlgorithm::allocate_many(elem_bytes, num_elements));
+      if(mem.empty()) throw bad_alloc();
+      return boost::move(mem);
+   }
+
+   //!Allocates n_elements, each one of
+   //!element_lenghts[i]*sizeof_element bytes. Throws bad_alloc on failure.
+   multiallocation_chain allocate_many
+      (const size_type *element_lenghts, size_type n_elements, size_type sizeof_element = 1)
+   {
+      multiallocation_chain mem(MemoryAlgorithm::allocate_many(element_lenghts, n_elements, sizeof_element));
+      if(mem.empty()) throw bad_alloc();
+      return boost::move(mem);
+   }
+
+   //!Allocates n_elements of
+   //!elem_size bytes. Returns a default constructed iterator on failure.
+   multiallocation_chain allocate_many
+      (size_type elem_bytes, size_type num_elements, std::nothrow_t)
+   {  return MemoryAlgorithm::allocate_many(elem_bytes, num_elements); }
+
+   //!Allocates n_elements, each one of
+   //!element_lenghts[i]*sizeof_element bytes.
+   //!Returns a default constructed iterator on failure.
+   multiallocation_chain allocate_many
+      (const size_type *elem_sizes, size_type n_elements, size_type sizeof_element, std::nothrow_t)
+   {  return MemoryAlgorithm::allocate_many(elem_sizes, n_elements, sizeof_element); }
+
+   //!Deallocates elements pointed by the
+   //!multiallocation iterator range.
+   void deallocate_many(multiallocation_chain chain)
+   {  MemoryAlgorithm::deallocate_many(boost::move(chain)); }
+
+   /// @endcond
+
+   //!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, 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;
+   }
+
+   template<class T>
+   std::pair<T *, bool>
+      allocation_command  (boost::interprocess::allocation_type command,   size_type limit_size,
+                           size_type preferred_size,size_type &received_size,
+                           T *reuse_ptr = 0)
+   {
+      std::pair<T *, bool> ret = MemoryAlgorithm::allocation_command
+         ( command | boost::interprocess::nothrow_allocation, limit_size, preferred_size, received_size
+         , reuse_ptr);
+      if(!(command & boost::interprocess::nothrow_allocation) && !ret.first)
+         throw bad_alloc();
+      return ret;
+   }
+
+   std::pair<void *, bool>
+      raw_allocation_command  (boost::interprocess::allocation_type command,   size_type limit_objects,
+                           size_type preferred_objects,size_type &received_objects,
+                           void *reuse_ptr = 0, size_type sizeof_object = 1)
+   {
+      std::pair<void *, bool> ret = MemoryAlgorithm::raw_allocation_command
+         ( command | boost::interprocess::nothrow_allocation, limit_objects, preferred_objects, received_objects
+         , reuse_ptr, sizeof_object);
+      if(!(command & boost::interprocess::nothrow_allocation) && !ret.first)
+         throw bad_alloc();
+      return ret;
+   }
+
+   //!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)
+   {  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); }
+
+   /// @cond
+   protected:
+   void * prot_anonymous_construct
+      (size_type num, bool dothrow, ipcdetail::in_place_interface &table)
+   {
+      typedef ipcdetail::block_header<size_type> block_header_t;
+      block_header_t block_info (  size_type(table.size*num)
+                                 , size_type(table.alignment)
+                                 , anonymous_type
+                                 , 1
+                                 , 0);
+
+      //Allocate memory
+      void *ptr_struct = this->allocate(block_info.total_size(), std::nothrow_t());
+
+      //Check if there is enough memory
+      if(!ptr_struct){
+         if(dothrow){
+            throw bad_alloc();
+         }
+         else{
+            return 0; 
+         }
+      }
+
+      //Build scoped ptr to avoid leaks with constructor exception
+      ipcdetail::mem_algo_deallocator<MemoryAlgorithm> mem(ptr_struct, *this);
+
+      //Now construct the header
+      block_header_t * hdr = new(ptr_struct) block_header_t(block_info);
+      void *ptr = 0; //avoid gcc warning
+      ptr = hdr->value();
+
+      //Now call constructors
+      ipcdetail::array_construct(ptr, num, table);
+
+      //All constructors successful, we don't want erase memory
+      mem.release();
+      return ptr;
+   }
+
+   //!Calls the destructor and makes an anonymous deallocate
+   void prot_anonymous_destroy(const void *object, ipcdetail::in_place_interface &table)
+   {
+
+      //Get control data from associated with this object    
+      typedef ipcdetail::block_header<size_type> block_header_t;
+      block_header_t *ctrl_data = block_header_t::block_header_from_value(object, table.size, table.alignment);
+
+      //-------------------------------
+      //scoped_lock<rmutex> guard(m_header);
+      //-------------------------------
+
+      if(ctrl_data->alloc_type() != anonymous_type){
+         //This is not an anonymous object, the pointer is wrong!
+         BOOST_ASSERT(0);
+      }
+
+      //Call destructors and free memory
+      //Build scoped ptr to avoid leaks with destructor exception
+      std::size_t destroyed = 0;
+     table.destroy_n(const_cast<void*>(object), ctrl_data->m_value_bytes/table.size, destroyed);
+      this->deallocate(ctrl_data);
+   }
+   /// @endcond
+};
+
+//!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>
+{ 
+   /// @cond
+   //Non-copyable
+   segment_manager();
+   segment_manager(const segment_manager &);
+   segment_manager &operator=(const segment_manager &);
+   typedef segment_manager_base<MemoryAlgorithm> Base;
+   /// @endcond
+
+   public:
+   typedef MemoryAlgorithm                memory_algorithm;
+   typedef typename Base::void_pointer    void_pointer;
+   typedef typename Base::size_type       size_type;
+   typedef typename Base::difference_type difference_type;
+   typedef CharType                       char_type;
+
+   typedef segment_manager_base<MemoryAlgorithm>   segment_manager_base_type;
+
+   static const size_type PayloadPerAllocation = Base::PayloadPerAllocation;
+
+   /// @cond
+   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;
+   /// @endcond
+
+   typedef typename Base::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;
+
+   /// @cond
+
+   //!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;
+   };
+
+   /// @endcond
+
+   //!Constructor of the segment manager
+   //!"size" is the size of the memory segment where
+   //!the segment manager is being constructed.
+   //!Can throw
+   segment_manager(size_type size)
+      :  Base(size, priv_get_reserved_bytes())
+      ,  m_header(static_cast<Base*>(get_this_pointer()))
+   {
+      (void) anonymous_instance;   (void) unique_instance;
+      BOOST_ASSERT(static_cast<const void*>(this) == static_cast<const void*>(static_cast<Base*>(this)));
+   }
+
+   //!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> find  (const CharType* name)
+   {  return this->priv_find_impl<T>(name, true);  }
+
+   //!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> find (const ipcdetail::unique_instance_t* name)
+   {  return this->priv_find_impl<T>(name, true);  }
+
+   //!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. This search is not mutex-protected!
+   template <class T>
+   std::pair<T*, size_type> find_no_lock  (const CharType* name)
+   {  return this->priv_find_impl<T>(name, false);  }
+
+   //!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. This search is not mutex-protected!
+   template <class T>
+   std::pair<T*, size_type> find_no_lock (const ipcdetail::unique_instance_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, 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, 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, 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, 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 unique instance.
+   //!Returns false if the object was not present.
+   template <class T>
+   bool destroy(const ipcdetail::unique_instance_t *)
+   {
+      ipcdetail::placement_destroy<T> dtor;
+      return this->priv_generic_named_destroy<char>
+         (typeid(T).name(), m_header.m_unique_index, dtor, is_intrusive_t());
+   }
+
+   //!Destroys the named object with
+   //!the given name. Returns false if that object can't be found.
+   template <class T>
+   bool destroy(const CharType *name)
+   {
+      ipcdetail::placement_destroy<T> dtor;
+      return this->priv_generic_named_destroy<CharType>
+               (name, m_header.m_named_index, dtor, is_intrusive_t());
+   }
+
+   //!Destroys an anonymous, unique or named object
+   //!using it's address
+   template <class T>
+   void destroy_ptr(const T *p)
+   {
+      //If T is void transform it to char
+      typedef typename ipcdetail::char_if_void<T>::type data_t;
+      ipcdetail::placement_destroy<data_t> dtor;
+      priv_destroy_ptr(p, dtor);
+   }
+
+   //!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 Base::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 allocator for type T
+   //!initialized that allocates memory from this segment manager.
+   template<class T>
+   typename deleter<T>::type
+      get_deleter()
+   {   return typename deleter<T>::type(this); }
+
+   /// @cond
+
+   //!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 T>
+   T *generic_construct(const CharType *name, 
+                        size_type num, 
+                         bool try2find, 
+                         bool dothrow,
+                         ipcdetail::in_place_interface &table)
+   {
+      return static_cast<T*>
+         (priv_generic_construct(name, num, try2find, dothrow, table));
+   }
+
+   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);
+      ipcdetail::placement_destroy<T> table;
+      size_type size;
+      void *ret;
+
+      if(name == reinterpret_cast<const CharType*>(-1)){
+         ret = priv_generic_find<char> (typeid(T).name(), m_header.m_unique_index, table, size, is_intrusive_t(), lock);
+      }
+      else{
+         ret = priv_generic_find<CharType> (name, m_header.m_named_index, table, size, is_intrusive_t(), lock);
+      }
+      return std::pair<T*, size_type>(static_cast<T*>(ret), size);
+   }
+
+   //!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* name, bool lock)
+   {
+      ipcdetail::placement_destroy<T> table;
+      size_type size;
+      void *ret = priv_generic_find<char>(name, m_header.m_unique_index, table, size, is_intrusive_t(), lock); 
+      return std::pair<T*, size_type>(static_cast<T*>(ret), size);
+   }
+
+   void *priv_generic_construct(const CharType *name, 
+                   size_type num, 
+                         bool try2find, 
+                         bool dothrow,
+                         ipcdetail::in_place_interface &table)
+   {
+      void *ret;
+      //Security overflow check
+     if(num > ((std::size_t)-1)/table.size){
+         if(dothrow)
+            throw bad_alloc();
+         else
+            return 0;
+      }
+      if(name == 0){
+         ret = this->prot_anonymous_construct(num, dothrow, table);
+      }
+      else if(name == reinterpret_cast<const CharType*>(-1)){
+         ret = this->priv_generic_named_construct<char>
+            (unique_type, table.type_name, num, try2find, dothrow, table, m_header.m_unique_index, is_intrusive_t());
+      }
+      else{
+         ret = this->priv_generic_named_construct<CharType>
+            (named_type, name, num, try2find, dothrow, table, m_header.m_named_index, is_intrusive_t());
+      }
+      return ret;
+   }
+
+   void priv_destroy_ptr(const void *ptr, ipcdetail::in_place_interface &dtor)
+   {
+      block_header_t *ctrl_data = block_header_t::block_header_from_value(ptr, dtor.size, dtor.alignment);
+      switch(ctrl_data->alloc_type()){
+         case anonymous_type:
+            this->prot_anonymous_destroy(ptr, dtor);
+         break;
+
+         case named_type:
+            this->priv_generic_named_destroy<CharType>
+               (ctrl_data, m_header.m_named_index, dtor, is_node_index_t());
+         break;
+
+         case unique_type:
+            this->priv_generic_named_destroy<char>
+               (ctrl_data, m_header.m_unique_index, dtor, is_node_index_t());
+         break;
+
+         default:
+            //This type is unknown, bad pointer passed to this function!
+            BOOST_ASSERT(0);
+         break;
+      }
+   }
+
+   //!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 != named_type){
+         BOOST_ASSERT((type == anonymous_type && ctrl_data->m_num_char == 0) ||
+                (type == unique_type    && ctrl_data->m_num_char != 0) );
+         return 0;
+      }
+      CharType *name = static_cast<CharType*>(ctrl_data->template name<CharType>());
+   
+      //Sanity checks
+      BOOST_ASSERT(ctrl_data->sizeof_char() == sizeof(CharType));
+      BOOST_ASSERT(ctrl_data->m_num_char == 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 Base base.
+      return sizeof(segment_manager) - sizeof(Base);
+   }
+
+   template <class CharT>
+   void *priv_generic_find
+      (const CharT* name, 
+       IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+       ipcdetail::in_place_interface &table,
+       size_type &length,
+       ipcdetail::true_ is_intrusive,
+       bool use_lock)
+   {
+      (void)is_intrusive;
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >         index_type;
+      typedef ipcdetail::index_key<CharT, void_pointer>  index_key_t;
+      typedef typename index_type::iterator           index_it;
+
+      //-------------------------------
+      scoped_lock<rmutex> guard(priv_get_lock(use_lock));
+      //-------------------------------
+      //Find name in index
+      ipcdetail::intrusive_compare_key<CharT> 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 = it->get_block_header();
+
+         //Sanity check
+         BOOST_ASSERT((ctrl_data->m_value_bytes % table.size) == 0);
+         BOOST_ASSERT(ctrl_data->sizeof_char() == sizeof(CharT));
+         ret_ptr  = ctrl_data->value();
+         length  = ctrl_data->m_value_bytes/table.size;
+      }
+      return ret_ptr;
+   }
+
+   template <class CharT>
+   void *priv_generic_find
+      (const CharT* name, 
+       IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+       ipcdetail::in_place_interface &table,
+       size_type &length,
+       ipcdetail::false_ is_intrusive,
+       bool use_lock)
+   {
+      (void)is_intrusive;
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >      index_type;
+      typedef typename index_type::key_type        key_type;
+      typedef typename index_type::iterator        index_it;
+
+      //-------------------------------
+      scoped_lock<rmutex> guard(priv_get_lock(use_lock));
+      //-------------------------------
+      //Find name in index
+      index_it it = index.find(key_type(name, std::char_traits<CharT>::length(name)));
+
+      //Initialize return values
+      void *ret_ptr  = 0;
+      length         = 0;
+
+      //If found, assign values
+      if(it != index.end()){
+         //Get header
+         block_header_t *ctrl_data = reinterpret_cast<block_header_t*>
+                                    (ipcdetail::to_raw_pointer(it->second.m_ptr));
+
+         //Sanity check
+         BOOST_ASSERT((ctrl_data->m_value_bytes % table.size) == 0);
+         BOOST_ASSERT(ctrl_data->sizeof_char() == sizeof(CharT));
+         ret_ptr  = ctrl_data->value();
+         length  = ctrl_data->m_value_bytes/table.size;
+      }
+      return ret_ptr;
+   }
+
+   template <class CharT>
+   bool priv_generic_named_destroy
+     (block_header_t *block_header,
+      IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+      ipcdetail::in_place_interface &table,
+      ipcdetail::true_ is_node_index)
+   {
+      (void)is_node_index;
+      typedef typename IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >::iterator index_it;
+
+      index_it *ihdr = block_header_t::template to_first_header<index_it>(block_header);
+      return this->priv_generic_named_destroy_impl<CharT>(*ihdr, index, table);
+   }
+
+   template <class CharT>
+   bool priv_generic_named_destroy
+     (block_header_t *block_header,
+      IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+      ipcdetail::in_place_interface &table,
+      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<CharT>(name, index, table, is_intrusive_t());
+   }
+
+   template <class CharT>
+   bool priv_generic_named_destroy(const CharT *name, 
+                                   IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+                                   ipcdetail::in_place_interface &table,
+                                   ipcdetail::true_ is_intrusive_index)
+   {
+      (void)is_intrusive_index;
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >         index_type;
+      typedef ipcdetail::index_key<CharT, void_pointer>  index_key_t;
+      typedef typename index_type::iterator           index_it;
+      typedef typename index_type::value_type         intrusive_value_type;
+      
+      //-------------------------------
+      scoped_lock<rmutex> guard(m_header);
+      //-------------------------------
+      //Find name in index
+      ipcdetail::intrusive_compare_key<CharT> 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;
+      }
+
+      block_header_t *ctrl_data = it->get_block_header();
+      intrusive_value_type *iv = intrusive_value_type::get_intrusive_value_type(ctrl_data);
+      void *memory = iv;
+      void *values = ctrl_data->value();
+      std::size_t num = ctrl_data->m_value_bytes/table.size;
+      
+      //Sanity check
+      BOOST_ASSERT((ctrl_data->m_value_bytes % table.size) == 0);
+      BOOST_ASSERT(sizeof(CharT) == ctrl_data->sizeof_char());
+
+      //Erase node from index
+      index.erase(it);
+
+      //Destroy the headers
+      ctrl_data->~block_header_t();
+      iv->~intrusive_value_type();
+
+      //Call destructors and free memory
+      std::size_t destroyed;
+      table.destroy_n(values, num, destroyed);
+      this->deallocate(memory);
+      return true;
+   }
+
+   template <class CharT>
+   bool priv_generic_named_destroy(const CharT *name, 
+                                   IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+                                   ipcdetail::in_place_interface &table,
+                                   ipcdetail::false_ is_intrusive_index)
+   {
+      (void)is_intrusive_index;
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >            index_type;
+      typedef typename index_type::iterator              index_it;
+      typedef typename index_type::key_type              key_type;
+
+      //-------------------------------
+      scoped_lock<rmutex> guard(m_header);
+      //-------------------------------
+      //Try to find the name in the index
+      index_it it = index.find(key_type (name, 
+                                     std::char_traits<CharT>::length(name)));
+
+      //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<CharT>(it, index, table);
+   }
+
+   template <class CharT>
+   bool priv_generic_named_destroy_impl
+      (const typename IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >::iterator &it,
+      IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+      ipcdetail::in_place_interface &table)
+   {
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >      index_type;
+      typedef typename index_type::iterator        index_it;
+
+      //Get allocation parameters
+      block_header_t *ctrl_data = reinterpret_cast<block_header_t*>
+                                 (ipcdetail::to_raw_pointer(it->second.m_ptr));
+      char *stored_name       = static_cast<char*>(static_cast<void*>(const_cast<CharT*>(it->first.name())));
+      (void)stored_name;
+
+      //Check if the distance between the name pointer and the memory pointer 
+      //is correct (this can detect incorrect type in destruction)
+     std::size_t num = ctrl_data->m_value_bytes/table.size;
+      void *values = ctrl_data->value();
+
+      //Sanity check
+      BOOST_ASSERT((ctrl_data->m_value_bytes % table.size) == 0);
+      BOOST_ASSERT(static_cast<void*>(stored_name) == static_cast<void*>(ctrl_data->template name<CharT>()));
+      BOOST_ASSERT(sizeof(CharT) == ctrl_data->sizeof_char());
+
+      //Erase node from index
+      index.erase(it);
+
+      //Destroy the header
+      ctrl_data->~block_header_t();
+
+      void *memory;
+      if(is_node_index_t::value){
+         index_it *ihdr = block_header_t::template
+            to_first_header<index_it>(ctrl_data);
+         ihdr->~index_it();
+         memory = ihdr;
+      }
+      else{
+         memory = ctrl_data;
+      }
+
+      //Call destructors and free memory
+     std::size_t destroyed;
+      table.destroy_n(values, num, destroyed);
+      this->deallocate(memory);
+      return true;
+   }
+
+   template<class CharT>
+   void * priv_generic_named_construct(unsigned char type,
+                               const CharT *name,
+                        size_type num, 
+                               bool try2find, 
+                               bool dothrow,
+                               ipcdetail::in_place_interface &table,
+                               IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+                               ipcdetail::true_ is_intrusive)
+   {
+      (void)is_intrusive;
+     std::size_t namelen  = std::char_traits<CharT>::length(name);
+
+      block_header_t block_info ( size_type(table.size*num)
+                                 , size_type(table.alignment)
+                                 , type
+                                 , sizeof(CharT)
+                                 , namelen);
+
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >            index_type;
+      typedef typename index_type::iterator              index_it;
+      typedef std::pair<index_it, bool>                  index_ib;
+
+      //-------------------------------
+      scoped_lock<rmutex> guard(m_header);
+      //-------------------------------
+      //Insert the node. This can throw.
+      //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.
+      //
+      //Since equal_range(key) + insert(hint, value) approach is
+      //quite inefficient in container implementations 
+      //(they re-test if the position is correct), I've chosen
+      //to insert the node, do an ugly un-const cast and modify
+      //the key (which is a smart pointer) to an equivalent one
+      index_ib insert_ret;
+
+      typename index_type::insert_commit_data   commit_data;
+      typedef typename index_type::value_type   intrusive_value_type;
+
+      BOOST_TRY{
+         ipcdetail::intrusive_compare_key<CharT> key(name, namelen);
+         insert_ret = index.insert_check(key, commit_data);
+      }
+      //Ignore exceptions
+      BOOST_CATCH(...){
+         if(dothrow)
+            BOOST_RETHROW
+         return 0;
+      }
+      BOOST_CATCH_END
+
+      index_it it = insert_ret.first;
+
+      //If found and this is find or construct, return data
+      //else return null
+      if(!insert_ret.second){
+         if(try2find){
+            return it->get_block_header()->value();
+         }
+         if(dothrow){
+            throw interprocess_exception(already_exists_error);
+         }
+         else{
+            return 0;
+         }
+      }
+
+      //Allocates buffer for name + data, this can throw (it hurts)
+      void *buffer_ptr; 
+
+      //Check if there is enough memory
+      if(dothrow){
+         buffer_ptr = this->allocate
+            (block_info.template total_size_with_header<intrusive_value_type>());
+      }
+      else{
+         buffer_ptr = this->allocate
+            (block_info.template total_size_with_header<intrusive_value_type>(), std::nothrow_t());
+         if(!buffer_ptr)
+            return 0; 
+      }
+
+      //Now construct the intrusive hook plus the header
+      intrusive_value_type * intrusive_hdr = new(buffer_ptr) intrusive_value_type();
+      block_header_t * hdr = new(intrusive_hdr->get_block_header())block_header_t(block_info);
+      void *ptr = 0; //avoid gcc warning
+      ptr = hdr->value();
+
+      //Copy name to memory segment and insert data
+      CharT *name_ptr = static_cast<CharT *>(hdr->template name<CharT>());
+      std::char_traits<CharT>::copy(name_ptr, name, namelen+1);
+
+      BOOST_TRY{
+         //Now commit the insertion using previous context data
+         it = index.insert_commit(*intrusive_hdr, commit_data);
+      }
+      //Ignore exceptions
+      BOOST_CATCH(...){
+         if(dothrow)
+            BOOST_RETHROW
+         return 0;
+      }
+      BOOST_CATCH_END
+
+      //Avoid constructions if constructor is trivial
+      //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));
+
+      //Initialize the node value_eraser to erase inserted node
+      //if something goes wrong. This will be executed *before*
+      //the memory allocation as the intrusive value is built in that
+      //memory
+      value_eraser<index_type> v_eraser(index, it);
+      
+      //Construct array, this can throw
+      ipcdetail::array_construct(ptr, num, table);
+
+      //Release rollbacks since construction was successful
+      v_eraser.release();
+      mem.release();
+      return ptr;
+   }
+
+   //!Generic named new function for
+   //!named functions
+   template<class CharT>
+   void * priv_generic_named_construct(unsigned char type,  
+                               const CharT *name,
+                        size_type num, 
+                               bool try2find, 
+                               bool dothrow,
+                               ipcdetail::in_place_interface &table,
+                               IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
+                               ipcdetail::false_ is_intrusive)
+   {
+      (void)is_intrusive;
+      std::size_t namelen  = std::char_traits<CharT>::length(name);
+
+      block_header_t block_info ( size_type(table.size*num)
+                                 , size_type(table.alignment)
+                                 , type
+                                 , sizeof(CharT)
+                                 , namelen);
+
+      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >            index_type;
+      typedef typename index_type::key_type              key_type;
+      typedef typename index_type::mapped_type           mapped_type;
+      typedef typename index_type::value_type            value_type;
+      typedef typename index_type::iterator              index_it;
+      typedef std::pair<index_it, bool>                  index_ib;
+
+      //-------------------------------
+      scoped_lock<rmutex> guard(m_header);
+      //-------------------------------
+      //Insert the node. This can throw.
+      //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.
+      //
+      //Since equal_range(key) + insert(hint, value) approach is
+      //quite inefficient in container implementations 
+      //(they re-test if the position is correct), I've chosen
+      //to insert the node, do an ugly un-const cast and modify
+      //the key (which is a smart pointer) to an equivalent one
+      index_ib insert_ret;
+      BOOST_TRY{
+         insert_ret = index.insert(value_type(key_type (name, namelen), mapped_type(0)));
+      }
+      //Ignore exceptions
+      BOOST_CATCH(...){
+         if(dothrow)
+            BOOST_RETHROW;
+         return 0;
+      }
+      BOOST_CATCH_END
+
+      index_it it = insert_ret.first;
+
+      //If found and this is find or construct, return data
+      //else return null
+      if(!insert_ret.second){
+         if(try2find){
+            block_header_t *hdr = static_cast<block_header_t*>
+               (ipcdetail::to_raw_pointer(it->second.m_ptr));
+            return hdr->value();
+         }
+         return 0;
+      }
+      //Initialize the node value_eraser to erase inserted node
+      //if something goes wrong
+      value_eraser<index_type> v_eraser(index, it);
+
+      //Allocates buffer for name + data, this can throw (it hurts)
+      void *buffer_ptr; 
+      block_header_t * hdr;
+
+      //Allocate and construct the headers
+      if(is_node_index_t::value){
+         size_type total_size = block_info.template total_size_with_header<index_it>();
+         if(dothrow){
+            buffer_ptr = this->allocate(total_size);
+         }
+         else{
+            buffer_ptr = this->allocate(total_size, std::nothrow_t());
+            if(!buffer_ptr)
+               return 0; 
+         }
+         index_it *idr = new(buffer_ptr) index_it(it);
+         hdr = block_header_t::template from_first_header<index_it>(idr);
+      }
+      else{
+         if(dothrow){
+            buffer_ptr = this->allocate(block_info.total_size());
+         }
+         else{
+            buffer_ptr = this->allocate(block_info.total_size(), std::nothrow_t());
+            if(!buffer_ptr)
+               return 0; 
+         }
+         hdr = static_cast<block_header_t*>(buffer_ptr);
+      }
+
+      hdr = new(hdr)block_header_t(block_info);
+      void *ptr = 0; //avoid gcc warning
+      ptr = hdr->value();
+
+      //Copy name to memory segment and insert data
+      CharT *name_ptr = static_cast<CharT *>(hdr->template name<CharT>());
+      std::char_traits<CharT>::copy(name_ptr, name, namelen+1);
+
+      //Do the ugly cast, please mama, forgive me!
+      //This new key points to an identical string, so it must have the 
+      //same position than the overwritten key according to the predicate
+      const_cast<key_type &>(it->first).name(name_ptr);
+      it->second.m_ptr  = hdr;
+
+      //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));
+
+      //Construct array, this can throw
+      ipcdetail::array_construct(ptr, num, table);
+
+      //All constructors successful, we don't want to release memory
+      mem.release();
+
+      //Release node v_eraser since construction was successful
+      v_eraser.release();
+      return ptr;
+   }
+
+   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(Base *restricted_segment_mngr)
+         :  m_named_index (restricted_segment_mngr)
+         ,  m_unique_index(restricted_segment_mngr)
+      {}
+   }  m_header;
+
+   /// @endcond
+};
+
+
+}} //namespace boost { namespace interprocess
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_INTERPROCESS_SEGMENT_MANAGER_HPP
+
diff --git a/boost/interprocess/shared_memory_object.hpp b/boost/interprocess/shared_memory_object.hpp
new file mode 100644
index 0000000000..7c8fcf61bd
--- /dev/null
+++ b/boost/interprocess/shared_memory_object.hpp
@@ -0,0 +1,422 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SHARED_MEMORY_OBJECT_HPP
+#define BOOST_INTERPROCESS_SHARED_MEMORY_OBJECT_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <cstddef>
+#include <string>
+#include <algorithm>
+
+#if defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS_ONLY)
+#  include <sys/shm.h>      //System V shared memory...
+#elif defined(BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS)
+#  include <fcntl.h>        //O_CREAT, O_*... 
+#  include <sys/mman.h>     //shm_xxx
+#  include <unistd.h>       //ftruncate, close
+#  include <sys/stat.h>     //mode_t, S_IRWXG, S_IRWXO, S_IRWXU,
+#  if defined(BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
+#     if defined(__FreeBSD__)
+#        include <sys/sysctl.h>
+#     endif
+#  endif
+#else
+//
+#endif
+
+//!\file
+//!Describes a shared memory object management class.
+
+namespace boost {
+namespace interprocess {
+
+//!A class that wraps a shared memory mapping that can be used to
+//!create mapped regions from the mapped files
+class shared_memory_object
+{
+   /// @cond
+   //Non-copyable and non-assignable
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(shared_memory_object)
+   /// @endcond
+
+   public:
+   //!Default constructor. Represents an empty shared_memory_object.
+   shared_memory_object();
+
+   //!Creates a shared memory object with name "name" and mode "mode", with the access mode "mode"
+   //!If the file previously exists, throws an error.*/
+   shared_memory_object(create_only_t, const char *name, mode_t mode, const permissions &perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoCreate, name, mode, perm);  }
+
+   //!Tries to create a shared memory object with name "name" and mode "mode", with the
+   //!access mode "mode". If the file previously exists, it tries to open it with mode "mode".
+   //!Otherwise throws an error.
+   shared_memory_object(open_or_create_t, const char *name, mode_t mode, const permissions &perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoOpenOrCreate, name, mode, perm);  }
+
+   //!Tries to open a shared memory object with name "name", with the access mode "mode". 
+   //!If the file does not previously exist, it throws an error.
+   shared_memory_object(open_only_t, const char *name, mode_t mode)
+   {  this->priv_open_or_create(ipcdetail::DoOpen, name, mode, permissions());  }
+
+   //!Moves the ownership of "moved"'s shared memory object to *this. 
+   //!After the call, "moved" does not represent any shared memory object. 
+   //!Does not throw
+   shared_memory_object(BOOST_RV_REF(shared_memory_object) moved)
+      :  m_handle(file_handle_t(ipcdetail::invalid_file()))
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s shared memory to *this.
+   //!After the call, "moved" does not represent any shared memory. 
+   //!Does not throw
+   shared_memory_object &operator=(BOOST_RV_REF(shared_memory_object) moved)
+   {  
+      shared_memory_object tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps the shared_memory_objects. Does not throw
+   void swap(shared_memory_object &moved);
+
+   //!Erases a shared memory object from the system.
+   //!Returns false on error. Never throws
+   static bool remove(const char *name);
+   
+   //!Sets the size of the shared memory mapping
+   void truncate(offset_t length);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. All mapped regions are still
+   //!valid after destruction. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~shared_memory_object();
+
+   //!Returns the name of the shared memory object.
+   const char *get_name() const;
+
+   //!Returns true if the size of the shared memory object
+   //!can be obtained and writes the size in the passed reference
+   bool get_size(offset_t &size) const;
+
+   //!Returns access mode
+   mode_t get_mode() const;
+
+   //!Returns mapping handle. Never throws.
+   mapping_handle_t get_mapping_handle() const;
+
+   /// @cond
+   private:
+
+   //!Closes a previously opened file mapping. Never throws.
+   void priv_close();
+
+   //!Closes a previously opened file mapping. Never throws.
+   bool priv_open_or_create(ipcdetail::create_enum_t type, const char *filename, mode_t mode, const permissions &perm);
+
+   file_handle_t  m_handle;
+   mode_t         m_mode;
+   std::string    m_filename;
+   /// @endcond
+};
+
+/// @cond
+
+inline shared_memory_object::shared_memory_object() 
+   :  m_handle(file_handle_t(ipcdetail::invalid_file()))
+{}
+
+inline shared_memory_object::~shared_memory_object() 
+{  this->priv_close(); }
+
+
+inline const char *shared_memory_object::get_name() const
+{  return m_filename.c_str(); }
+
+inline bool shared_memory_object::get_size(offset_t &size) const
+{  return ipcdetail::get_file_size((file_handle_t)m_handle, size);  }
+
+inline void shared_memory_object::swap(shared_memory_object &other)
+{  
+   std::swap(m_handle,  other.m_handle);
+   std::swap(m_mode,    other.m_mode);
+   m_filename.swap(other.m_filename);   
+}
+
+inline mapping_handle_t shared_memory_object::get_mapping_handle() const
+{
+   return ipcdetail::mapping_handle_from_file_handle(m_handle);
+}
+
+inline mode_t shared_memory_object::get_mode() const
+{  return m_mode; }
+
+#if !defined(BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS)
+
+inline bool shared_memory_object::priv_open_or_create
+   (ipcdetail::create_enum_t type, const char *filename, mode_t mode, const permissions &perm)
+{
+   m_filename = filename;
+   std::string shmfile;
+   ipcdetail::create_tmp_and_clean_old_and_get_filename(filename, shmfile);
+
+   //Set accesses
+   if (mode != read_write && mode != read_only){
+      error_info err = other_error;
+      throw interprocess_exception(err);
+   }
+
+   switch(type){
+      case ipcdetail::DoOpen:
+         m_handle = ipcdetail::open_existing_file(shmfile.c_str(), mode, true);
+      break;
+      case ipcdetail::DoCreate:
+         m_handle = ipcdetail::create_new_file(shmfile.c_str(), mode, perm, true);
+      break;
+      case ipcdetail::DoOpenOrCreate:
+         m_handle = ipcdetail::create_or_open_file(shmfile.c_str(), mode, perm, true);
+      break;
+      default:
+         {
+            error_info err = other_error;
+            throw interprocess_exception(err);
+         }
+   }
+
+   //Check for error
+   if(m_handle == ipcdetail::invalid_file()){
+      error_info err = system_error_code();
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+
+   m_mode = mode;
+   return true;
+}
+
+inline bool shared_memory_object::remove(const char *filename)
+{
+   try{
+      //Make sure a temporary path is created for shared memory
+      std::string shmfile;
+      ipcdetail::tmp_filename(filename, shmfile);
+      return ipcdetail::delete_file(shmfile.c_str());
+   }
+   catch(...){
+      return false;
+   }
+}
+
+inline void shared_memory_object::truncate(offset_t length)
+{
+   if(!ipcdetail::truncate_file(m_handle, length)){
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+}
+
+inline void shared_memory_object::priv_close()
+{
+   if(m_handle != ipcdetail::invalid_file()){
+      ipcdetail::close_file(m_handle);
+      m_handle = ipcdetail::invalid_file();
+   }
+}
+
+#else //!defined(BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS)
+
+namespace shared_memory_object_detail {
+
+#ifdef BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY
+
+#if defined(__FreeBSD__)
+
+inline bool use_filesystem_based_posix()
+{
+   int jailed = 0;
+   std::size_t len = sizeof(jailed);
+   ::sysctlbyname("security.jail.jailed", &jailed, &len, NULL, 0);
+   return jailed != 0;
+}
+
+#else
+#error "Not supported platform for BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY"
+#endif
+
+#endif
+
+}  //shared_memory_object_detail
+
+inline bool shared_memory_object::priv_open_or_create
+   (ipcdetail::create_enum_t type, 
+    const char *filename,
+    mode_t mode, const permissions &perm)
+{
+   #if defined(BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
+   const bool add_leading_slash = false;
+   #elif defined(BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
+   const bool add_leading_slash = !shared_memory_object_detail::use_filesystem_based_posix();
+   #else
+   const bool add_leading_slash = true;
+   #endif
+   if(add_leading_slash){
+      ipcdetail::add_leading_slash(filename, m_filename);
+   }
+   else{
+      ipcdetail::create_tmp_and_clean_old_and_get_filename(filename, m_filename);
+   }
+
+   //Create new mapping
+   int oflag = 0;
+   if(mode == read_only){
+      oflag |= O_RDONLY;
+   }
+   else if(mode == read_write){
+      oflag |= O_RDWR;
+   }
+   else{
+      error_info err(mode_error);
+      throw interprocess_exception(err);
+   }
+   int unix_perm = perm.get_permissions();
+
+   switch(type){
+      case ipcdetail::DoOpen:
+      {
+         //No oflag addition
+         m_handle = shm_open(m_filename.c_str(), oflag, unix_perm);
+      }
+      break;
+      case ipcdetail::DoCreate:
+      {
+         oflag |= (O_CREAT | O_EXCL);
+         m_handle = shm_open(m_filename.c_str(), oflag, unix_perm);
+         if(m_handle >= 0){
+            ::fchmod(m_handle, unix_perm);
+         }
+      }
+      break;
+      case ipcdetail::DoOpenOrCreate:
+      {
+         oflag |= O_CREAT;
+         //We need a loop to change permissions correctly using fchmod, since
+         //with "O_CREAT only" shm_open we don't know if we've created or opened the file.
+         while(1){
+            m_handle = shm_open(m_filename.c_str(), oflag, unix_perm);
+            if(m_handle >= 0){
+               ::fchmod(m_handle, unix_perm);
+               break;
+            }
+            else if(errno == EEXIST){
+               if((m_handle = shm_open(m_filename.c_str(), oflag, unix_perm)) >= 0 || errno != ENOENT){
+                  break;
+               }
+            }
+         }
+      }
+      break;
+      default:
+      {
+         error_info err = other_error;
+         throw interprocess_exception(err);
+      }
+   }
+
+   //Check for error
+   if(m_handle == -1){
+      error_info err = errno;
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+
+   m_filename = filename;
+   m_mode = mode;
+   return true;
+}
+
+inline bool shared_memory_object::remove(const char *filename)
+{
+   try{
+      std::string file_str;
+      #if defined(BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
+      const bool add_leading_slash = false;
+      #elif defined(BOOST_INTERPROCESS_RUNTIME_FILESYSTEM_BASED_POSIX_SHARED_MEMORY)
+      const bool add_leading_slash = !shared_memory_object_detail::use_filesystem_based_posix();
+      #else
+      const bool add_leading_slash = true;
+      #endif
+      if(add_leading_slash){
+         ipcdetail::add_leading_slash(filename, file_str);
+      }
+      else{
+         ipcdetail::tmp_filename(filename, file_str);
+      }
+      return 0 == shm_unlink(file_str.c_str());
+   }
+   catch(...){
+      return false;
+   }
+}
+
+inline void shared_memory_object::truncate(offset_t length)
+{
+   if(0 != ftruncate(m_handle, length)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+inline void shared_memory_object::priv_close()
+{
+   if(m_handle != -1){
+      ::close(m_handle);
+      m_handle = -1;
+   }
+}
+
+#endif
+
+///@endcond
+
+//!A class that stores the name of a shared memory
+//!and calls shared_memory_object::remove(name) in its destructor
+//!Useful to remove temporary shared memory objects in the presence
+//!of exceptions
+class remove_shared_memory_on_destroy
+{
+   const char * m_name;
+   public:
+   remove_shared_memory_on_destroy(const char *name)
+      :  m_name(name)
+   {}
+
+   ~remove_shared_memory_on_destroy()
+   {  shared_memory_object::remove(m_name);  }
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_SHARED_MEMORY_OBJECT_HPP
diff --git a/boost/interprocess/smart_ptr/deleter.hpp b/boost/interprocess/smart_ptr/deleter.hpp
new file mode 100644
index 0000000000..4aba772975
--- /dev/null
+++ b/boost/interprocess/smart_ptr/deleter.hpp
@@ -0,0 +1,64 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2011.
+//
+// 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_DELETER_HPP
+#define BOOST_INTERPROCESS_DELETER_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+
+//!\file
+//!Describes the functor to delete objects from the segment.
+
+namespace boost {
+namespace interprocess { 
+
+//!A deleter that uses the segment manager's destroy_ptr 
+//!function to destroy the passed pointer resource.
+//!
+//!This deleter is used
+template<class T, class SegmentManager>
+class deleter
+{
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<typename SegmentManager::void_pointer>::template
+         rebind_pointer<T>::type                pointer;
+
+   private:
+   typedef typename boost::intrusive::
+      pointer_traits<pointer>::template
+         rebind_pointer<SegmentManager>::type                segment_manager_pointer;
+
+   segment_manager_pointer mp_mngr;
+
+   public:
+   deleter(segment_manager_pointer pmngr)
+      :  mp_mngr(pmngr)
+   {}
+
+   void operator()(const pointer &p)
+   {  mp_mngr->destroy_ptr(ipcdetail::to_raw_pointer(p));   }
+};
+
+}  //namespace interprocess { 
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DELETER_HPP
diff --git a/boost/interprocess/smart_ptr/detail/bad_weak_ptr.hpp b/boost/interprocess/smart_ptr/detail/bad_weak_ptr.hpp
new file mode 100644
index 0000000000..9429613492
--- /dev/null
+++ b/boost/interprocess/smart_ptr/detail/bad_weak_ptr.hpp
@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/detail/bad_weak_ptr.hpp
+//
+// (C) Copyright Peter Dimov and Multi Media Ltd. 2001, 2002, 2003
+// (C) Copyright Ion Gaztanaga 2006. 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_BAD_WEAK_PTR_HPP_INCLUDED
+#define BOOST_INTERPROCESS_BAD_WEAK_PTR_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+#endif
+
+namespace boost{
+namespace interprocess{
+
+class bad_weak_ptr
+   :  public std::exception
+{
+   public:
+
+   virtual char const * what() const throw()
+   {  return "boost::interprocess::bad_weak_ptr"; }
+};
+
+} // namespace interprocess 
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_BAD_WEAK_PTR_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/detail/shared_count.hpp b/boost/interprocess/smart_ptr/detail/shared_count.hpp
new file mode 100644
index 0000000000..0150ef6c00
--- /dev/null
+++ b/boost/interprocess/smart_ptr/detail/shared_count.hpp
@@ -0,0 +1,338 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/detail/shared_count.hpp
+//
+// (C) Copyright Peter Dimov and Multi Media Ltd. 2001, 2002, 2003
+// (C) Copyright Peter Dimov 2004-2005
+// (C) Copyright Ion Gaztanaga 2006-2011. 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_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#define BOOST_INTERPROCESS_DETAIL_SHARED_COUNT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/checked_delete.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/interprocess/smart_ptr/detail/bad_weak_ptr.hpp>
+#include <boost/interprocess/smart_ptr/detail/sp_counted_impl.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/container/allocator/allocator_traits.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <functional>       // std::less
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+template<class T, class VoidAllocator, class Deleter>
+class weak_count;
+
+template<class T, class VoidAllocator, class Deleter>
+class shared_count
+{
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<T>::type                         pointer;
+
+   private:
+   typedef sp_counted_impl_pd<VoidAllocator, Deleter>       counted_impl;
+
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<counted_impl>::type                         counted_impl_ptr;
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<sp_counted_base>::type                       counted_base_ptr;
+
+   typedef boost::container::allocator_traits<VoidAllocator>         vallocator_traits;
+
+   typedef typename vallocator_traits::template
+      portable_rebind_alloc<counted_impl>::type                      counted_impl_allocator;
+
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<const Deleter>::type                         const_deleter_pointer;
+
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<const VoidAllocator>::type                   const_allocator_pointer;
+
+   pointer           m_px;
+   counted_impl_ptr  m_pi;
+
+   template <class T2, class VoidAllocator2, class Deleter2>
+   friend class weak_count;
+
+   template <class T2, class VoidAllocator2, class Deleter2>
+   friend class shared_count;
+
+   public:
+
+   shared_count()
+      :  m_px(0), m_pi(0) // nothrow
+   {}
+
+   template <class Ptr>
+   shared_count(const shared_count &other_shared_count, const Ptr &p)
+      :  m_px(p), m_pi(other_shared_count.m_pi)
+   {}
+
+   template <class Ptr>
+   shared_count(const Ptr &p, const VoidAllocator &a, Deleter d)
+      :  m_px(p), m_pi(0)
+   {
+      BOOST_TRY{
+         if(p){
+            counted_impl_allocator alloc(a);
+            m_pi = alloc.allocate(1);
+            //Anti-exception deallocator
+            scoped_ptr<counted_impl, 
+                     scoped_ptr_dealloc_functor<counted_impl_allocator> >
+                        deallocator(m_pi, alloc);
+            //It's more correct to use VoidAllocator::construct but
+            //this needs copy constructor and we don't like it
+            new(ipcdetail::to_raw_pointer(m_pi))counted_impl(p, a, d);
+            deallocator.release();
+         }
+      }
+      BOOST_CATCH (...){
+         d(p); // delete p
+         BOOST_RETHROW
+      }
+      BOOST_CATCH_END
+   }
+
+   ~shared_count() // nothrow
+   {  
+      if(m_pi)
+         m_pi->release();
+   }
+
+   shared_count(shared_count const & r)
+      :  m_px(r.m_px), m_pi(r.m_pi) // nothrow
+   { if( m_pi != 0 ) m_pi->add_ref_copy(); }
+
+   //this is a test
+   template<class Y>
+   explicit shared_count(shared_count<Y, VoidAllocator, Deleter> const & r)
+      :  m_px(r.m_px), m_pi(r.m_pi) // nothrow
+   {  if( m_pi != 0 ) m_pi->add_ref_copy();  }
+
+   //this is a test
+   template<class Y>
+   explicit shared_count(const pointer & ptr, shared_count<Y, VoidAllocator, Deleter> const & r)
+      :  m_px(ptr), m_pi(r.m_pi) // nothrow
+   {  if( m_pi != 0 ) m_pi->add_ref_copy();  }
+
+/*
+   explicit shared_count(weak_count<Y, VoidAllocator, Deleter> const & r)
+      // throws bad_weak_ptr when r.use_count() == 0
+      : m_pi( r.m_pi )
+   {
+      if( m_pi == 0 || !m_pi->add_ref_lock() ){
+         boost::throw_exception( boost::interprocess::bad_weak_ptr() );
+      }
+   }
+*/
+   template<class Y>
+   explicit shared_count(weak_count<Y, VoidAllocator, Deleter> const & r)
+      // throws bad_weak_ptr when r.use_count() == 0
+      : m_px(r.m_px), m_pi( r.m_pi )
+   {
+      if( m_pi == 0 || !m_pi->add_ref_lock() ){
+         throw( boost::interprocess::bad_weak_ptr() );
+      }
+   }
+
+   const pointer &to_raw_pointer() const
+   {  return m_px;   }
+
+   pointer &to_raw_pointer()
+   {  return m_px;   }
+
+   shared_count & operator= (shared_count const & r) // nothrow
+   {
+      m_px = r.m_px;
+      counted_impl_ptr tmp = r.m_pi;
+      if( tmp != m_pi ){
+         if(tmp != 0)   tmp->add_ref_copy();
+         if(m_pi != 0)  m_pi->release();
+         m_pi = tmp;
+      }
+      return *this;
+   }
+
+   template<class Y>
+   shared_count & operator= (shared_count<Y, VoidAllocator, Deleter> const & r) // nothrow
+   {
+      m_px = r.m_px;
+      counted_impl_ptr tmp = r.m_pi;
+      if( tmp != m_pi ){
+         if(tmp != 0)   tmp->add_ref_copy();
+         if(m_pi != 0)  m_pi->release();
+         m_pi = tmp;
+      }
+      return *this;
+   }
+
+   void swap(shared_count & r) // nothrow
+   {  ipcdetail::do_swap(m_px, r.m_px);   ipcdetail::do_swap(m_pi, r.m_pi);   }
+
+   long use_count() const // nothrow
+   {  return m_pi != 0? m_pi->use_count(): 0;  }
+
+   bool unique() const // nothrow
+   {  return use_count() == 1;   }
+
+   const_deleter_pointer get_deleter() const
+   {  return m_pi ? m_pi->get_deleter() : 0; }
+
+//   const_allocator_pointer get_allocator() const
+//   {  return m_pi ? m_pi->get_allocator() : 0; }
+
+   template<class T2, class VoidAllocator2, class Deleter2>
+   bool internal_equal (shared_count<T2, VoidAllocator2, Deleter2> const & other) const
+   {  return this->m_pi == other.m_pi;   }
+
+   template<class T2, class VoidAllocator2, class Deleter2>
+   bool internal_less  (shared_count<T2, VoidAllocator2, Deleter2> const & other) const
+   {  return std::less<counted_base_ptr>()(this->m_pi, other.m_pi);  }
+};
+
+template<class T, class VoidAllocator, class Deleter, class T2, class VoidAllocator2, class Deleter2> inline
+bool operator==(shared_count<T, VoidAllocator, Deleter> const & a, shared_count<T2, VoidAllocator2, Deleter2> const & b)
+{  return a.internal_equal(b);  }
+
+template<class T, class VoidAllocator, class Deleter, class T2, class VoidAllocator2, class Deleter2> inline
+bool operator<(shared_count<T, VoidAllocator, Deleter> const & a, shared_count<T2, VoidAllocator2, Deleter2> const & b)
+{  return a.internal_less(b);   }
+
+
+template<class T, class VoidAllocator, class Deleter>
+class weak_count
+{
+   public:
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<T>::type                         pointer;
+
+   private:
+
+   typedef sp_counted_impl_pd<VoidAllocator, Deleter>                counted_impl;
+
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<counted_impl>::type                          counted_impl_ptr;
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<sp_counted_base>::type                       counted_base_ptr;
+
+   pointer           m_px;
+   counted_impl_ptr  m_pi;
+
+   template <class T2, class VoidAllocator2, class Deleter2>
+   friend class weak_count;
+
+   template <class T2, class VoidAllocator2, class Deleter2>
+   friend class shared_count;
+
+   public:
+
+   weak_count(): m_px(0), m_pi(0) // nothrow
+   {}
+
+   template <class Y>
+   explicit weak_count(shared_count<Y, VoidAllocator, Deleter> const & r)
+      :  m_px(r.m_px), m_pi(r.m_pi) // nothrow
+   {  if(m_pi != 0) m_pi->weak_add_ref(); }
+
+   weak_count(weak_count const & r)
+      :  m_px(r.m_px), m_pi(r.m_pi) // nothrow
+   {  if(m_pi != 0) m_pi->weak_add_ref(); }
+
+   template<class Y>
+   weak_count(weak_count<Y, VoidAllocator, Deleter> const & r)
+      : m_px(r.m_px), m_pi(r.m_pi) // nothrow
+   {  if(m_pi != 0) m_pi->weak_add_ref(); }
+
+   ~weak_count() // nothrow
+   {  if(m_pi != 0) m_pi->weak_release(); }
+
+   template<class Y>
+   weak_count & operator= (shared_count<Y, VoidAllocator, Deleter> const & r) // nothrow
+   {
+      m_px = r.m_px;
+      counted_impl_ptr tmp = r.m_pi;
+      if(tmp != 0)   tmp->weak_add_ref();
+      if(m_pi != 0)  m_pi->weak_release();
+      m_pi = tmp;
+      return *this;
+   }
+
+   weak_count & operator= (weak_count const & r) // nothrow
+   {
+      counted_impl_ptr tmp = r.m_pi;
+      if(tmp != 0) tmp->weak_add_ref();
+      if(m_pi != 0) m_pi->weak_release();
+      m_pi = tmp;
+      return *this;
+   }
+
+   void set_pointer(const pointer &ptr)
+   {  m_px = ptr; }
+
+   template<class Y>
+   weak_count & operator= (weak_count<Y, VoidAllocator, Deleter> const& r) // nothrow
+   {
+      counted_impl_ptr tmp = r.m_pi;
+      if(tmp != 0) tmp->weak_add_ref();
+      if(m_pi != 0) m_pi->weak_release();
+      m_pi = tmp;
+      return *this;
+   }
+
+   void swap(weak_count & r) // nothrow
+   {  ipcdetail::do_swap(m_px, r.m_px);  ipcdetail::do_swap(m_pi, r.m_pi);   }
+
+   long use_count() const // nothrow
+   {  return m_pi != 0? m_pi->use_count() : 0;   }
+
+   template<class T2, class VoidAllocator2, class Deleter2>
+   bool internal_equal (weak_count<T2, VoidAllocator2, Deleter2> const & other) const
+   {  return this->m_pi == other.m_pi;   }
+
+   template<class T2, class VoidAllocator2, class Deleter2>
+   bool internal_less (weak_count<T2, VoidAllocator2, Deleter2> const & other) const
+   {  return std::less<counted_base_ptr>()(this->m_pi, other.m_pi);  }
+};
+
+template<class T, class VoidAllocator, class Deleter, class T2, class VoidAllocator2, class Deleter2> inline
+bool operator==(weak_count<T, VoidAllocator, Deleter> const & a, weak_count<T2, VoidAllocator2, Deleter2> const & b)
+{  return a.internal_equal(b);  }
+
+template<class T, class VoidAllocator, class Deleter, class T2, class VoidAllocator2, class Deleter2> inline
+bool operator<(weak_count<T, VoidAllocator, Deleter> const & a, weak_count<T2, VoidAllocator2, Deleter2> const & b)
+{  return a.internal_less(b);   }
+
+} // namespace ipcdetail
+} // namespace interprocess
+} // namespace boost
+
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+
+#endif  // #ifndef BOOST_INTERPROCESS_DETAIL_SHARED_COUNT_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/detail/sp_counted_base.hpp b/boost/interprocess/smart_ptr/detail/sp_counted_base.hpp
new file mode 100644
index 0000000000..24d96ee482
--- /dev/null
+++ b/boost/interprocess/smart_ptr/detail/sp_counted_base.hpp
@@ -0,0 +1,18 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2011.
+//
+// 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_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
+#define BOOST_INTERPROCESS_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
+
+# include <boost/interprocess/smart_ptr/detail/sp_counted_base_atomic.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
+
diff --git a/boost/interprocess/smart_ptr/detail/sp_counted_base_atomic.hpp b/boost/interprocess/smart_ptr/detail/sp_counted_base_atomic.hpp
new file mode 100644
index 0000000000..edb39eeeb3
--- /dev/null
+++ b/boost/interprocess/smart_ptr/detail/sp_counted_base_atomic.hpp
@@ -0,0 +1,92 @@
+#ifndef BOOST_INTERPROCESS_DETAIL_SP_COUNTED_BASE_ATOMIC_HPP_INCLUDED
+#define BOOST_INTERPROCESS_DETAIL_SP_COUNTED_BASE_ATOMIC_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//  Copyright 2004-2005 Peter Dimov
+//  Copyright 2007-2011 Ion Gaztanaga
+//
+// 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)
+//
+//
+//  Lock-free algorithm by Alexander Terekhov
+//
+//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
+//  formulation
+//
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/detail/atomic.hpp>
+#include <typeinfo>
+
+namespace boost {
+
+namespace interprocess {
+
+namespace ipcdetail {
+
+class sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    boost::uint32_t use_count_;        // #shared
+    boost::uint32_t weak_count_;       // #weak + (#shared != 0)
+
+public:
+
+    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    {}
+
+    ~sp_counted_base() // nothrow
+    {}
+
+    void add_ref_copy()
+    {
+        ipcdetail::atomic_inc32( &use_count_ );
+    }
+
+    bool add_ref_lock() // true on success
+    {
+        for( ;; )
+        {
+            boost::uint32_t tmp = static_cast< boost::uint32_t const volatile& >( use_count_ );
+            if( tmp == 0 ) return false;
+            if( ipcdetail::atomic_cas32( &use_count_, tmp + 1, tmp ) == tmp )
+               return true;
+        }
+    }
+
+   bool ref_release() // nothrow
+   { return 1 == ipcdetail::atomic_dec32( &use_count_ );  }
+
+   void weak_add_ref() // nothrow
+   { ipcdetail::atomic_inc32( &weak_count_ ); }
+
+   bool weak_release() // nothrow
+   { return 1 == ipcdetail::atomic_dec32( &weak_count_ ); }
+
+   long use_count() const // nothrow
+   { return (long)static_cast<boost::uint32_t const volatile &>( use_count_ ); }
+};
+
+} // namespace ipcdetail
+
+} // namespace interprocess
+
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_DETAIL_SP_COUNTED_BASE_ATOMIC_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/detail/sp_counted_impl.hpp b/boost/interprocess/smart_ptr/detail/sp_counted_impl.hpp
new file mode 100644
index 0000000000..4e2e664c86
--- /dev/null
+++ b/boost/interprocess/smart_ptr/detail/sp_counted_impl.hpp
@@ -0,0 +1,155 @@
+#ifndef BOOST_INTERPROCESS_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
+#define BOOST_INTERPROCESS_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  This file is the adaptation for shared memory memory mapped
+//  files of boost/detail/sp_counted_impl.hpp
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//  Copyright 2004-2005 Peter Dimov
+//  Copyright 2006      Ion Gaztanaga
+//
+// 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)
+//
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/smart_ptr/detail/sp_counted_base.hpp>
+#include <boost/interprocess/smart_ptr/scoped_ptr.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/container/allocator/allocator_traits.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+
+namespace boost {
+
+namespace interprocess {
+
+namespace ipcdetail {
+
+//!A deleter for scoped_ptr that deallocates the memory
+//!allocated for an object using a STL allocator.
+template <class Allocator>
+struct scoped_ptr_dealloc_functor
+{
+   typedef typename Allocator::pointer pointer;
+   typedef ipcdetail::integral_constant<unsigned,
+      boost::interprocess::version<Allocator>::value>                   alloc_version;
+   typedef ipcdetail::integral_constant<unsigned, 1>     allocator_v1;
+   typedef ipcdetail::integral_constant<unsigned, 2>     allocator_v2;
+
+   private:
+   void priv_deallocate(const typename Allocator::pointer &p, allocator_v1)
+   {  m_alloc.deallocate(p, 1); }
+
+   void priv_deallocate(const typename Allocator::pointer &p, allocator_v2)
+   {  m_alloc.deallocate_one(p); }
+
+   public:
+   Allocator& m_alloc;
+
+   scoped_ptr_dealloc_functor(Allocator& a)
+      : m_alloc(a) {}
+
+   void operator()(pointer ptr)
+   {  if (ptr) priv_deallocate(ptr, alloc_version());  }
+};
+
+   
+
+template<class A, class D>
+class sp_counted_impl_pd 
+   :  public sp_counted_base
+   ,  boost::container::allocator_traits<A>::template
+         portable_rebind_alloc< sp_counted_impl_pd<A, D> >::type
+   ,  D  // copy constructor must not throw
+{
+   private:
+   typedef sp_counted_impl_pd<A, D>          this_type;
+   typedef typename boost::container::
+      allocator_traits<A>::template
+         portable_rebind_alloc
+            < this_type >::type              this_allocator;
+   typedef typename boost::container::
+      allocator_traits<A>::template
+         portable_rebind_alloc
+            < const this_type >::type        const_this_allocator;
+   typedef typename this_allocator::pointer  this_pointer;
+
+   sp_counted_impl_pd( sp_counted_impl_pd const & );
+   sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
+
+   typedef typename boost::intrusive::
+      pointer_traits<typename A::pointer>::template
+         rebind_pointer<const D>::type                   const_deleter_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<typename A::pointer>::template
+         rebind_pointer<const A>::type                   const_allocator_pointer;
+
+   typedef typename D::pointer   pointer;
+   pointer m_ptr;
+
+   public:
+   // pre: d(p) must not throw
+   template<class Ptr>
+   sp_counted_impl_pd(const Ptr & p, const A &a, const D &d )
+      :  this_allocator(a), D(d), m_ptr(p)
+   {}
+
+   const_deleter_pointer get_deleter() const
+   {  return const_deleter_pointer(&static_cast<const D&>(*this)); }
+
+   const_allocator_pointer get_allocator() const
+   {  return const_allocator_pointer(&static_cast<const A&>(*this)); }
+
+   void dispose() // nothrow
+   {  static_cast<D&>(*this)(m_ptr);   }
+
+   void destroy() // nothrow
+   {
+      //Self destruction, so get a copy of the allocator
+      //(in the future we could move it)
+      this_allocator a_copy(*this);
+      BOOST_ASSERT(a_copy == *this);
+      this_pointer this_ptr (this);
+      //Do it now!
+      scoped_ptr< this_type, scoped_ptr_dealloc_functor<this_allocator> >
+         deleter(this_ptr, a_copy);
+      typedef typename this_allocator::value_type value_type;
+      ipcdetail::to_raw_pointer(this_ptr)->~value_type();
+   }
+
+   void release() // nothrow
+   {
+      if(this->ref_release()){
+         this->dispose();
+         this->weak_release();
+      }
+   }
+
+   void weak_release() // nothrow
+   {
+      if(sp_counted_base::weak_release()){
+         this->destroy();
+      }
+   }
+};
+
+
+} // namespace ipcdetail
+
+} // namespace interprocess
+
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/enable_shared_from_this.hpp b/boost/interprocess/smart_ptr/enable_shared_from_this.hpp
new file mode 100644
index 0000000000..9c8c7918f5
--- /dev/null
+++ b/boost/interprocess/smart_ptr/enable_shared_from_this.hpp
@@ -0,0 +1,79 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/enable_shared_from_this.hpp
+//
+// (C) Copyright Peter Dimov 2002
+// (C) Copyright Ion Gaztanaga 2006. 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_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_INTERPROCESS_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/interprocess/smart_ptr/weak_ptr.hpp>
+#include <boost/interprocess/smart_ptr/shared_ptr.hpp>
+
+//!\file
+//!Describes an utility to form a shared pointer from this
+
+namespace boost{
+namespace interprocess{
+
+//!This class is used as a base class that allows a shared_ptr to the current
+//!object to be obtained from within a member function.
+//!enable_shared_from_this defines two member functions called shared_from_this
+//!that return a shared_ptr<T> and shared_ptr<T const>, depending on constness, to this.
+template<class T, class A, class D>
+class enable_shared_from_this
+{
+   /// @cond
+   protected:
+   enable_shared_from_this()
+   {}
+
+   enable_shared_from_this(enable_shared_from_this const &)
+   {}
+
+   enable_shared_from_this & operator=(enable_shared_from_this const &)
+   {  return *this;  }
+
+   ~enable_shared_from_this()
+   {}
+   /// @endcond
+
+   public:
+   shared_ptr<T, A, D> shared_from_this()
+   {
+      shared_ptr<T, A, D> p(_internal_weak_this);
+      BOOST_ASSERT(ipcdetail::to_raw_pointer(p.get()) == this);
+      return p;
+   }
+
+   shared_ptr<T const, A, D> shared_from_this() const
+   {
+      shared_ptr<T const, A, D> p(_internal_weak_this);
+      BOOST_ASSERT(ipcdetail::to_raw_pointer(p.get()) == this);
+      return p;
+   }
+
+   /// @cond
+   typedef T element_type;
+   mutable weak_ptr<element_type, A, D> _internal_weak_this;
+   /// @endcond
+};
+
+} // namespace interprocess
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
diff --git a/boost/interprocess/smart_ptr/intrusive_ptr.hpp b/boost/interprocess/smart_ptr/intrusive_ptr.hpp
new file mode 100644
index 0000000000..3f086f5360
--- /dev/null
+++ b/boost/interprocess/smart_ptr/intrusive_ptr.hpp
@@ -0,0 +1,296 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/intrusive_ptr.hpp
+//
+// (C) Copyright Peter Dimov 2001, 2002
+// (C) Copyright Ion Gaztanaga 2006. 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_INTRUSIVE_PTR_HPP_INCLUDED
+#define BOOST_INTERPROCESS_INTRUSIVE_PTR_HPP_INCLUDED
+
+//!\file
+//!Describes an intrusive ownership pointer.
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/assert.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+
+#include <functional>           // for std::less
+#include <iosfwd>               // for std::basic_ostream
+
+
+namespace boost {
+namespace interprocess {
+
+//!The intrusive_ptr class template stores a pointer to an object
+//!with an embedded reference count. intrusive_ptr is parameterized on
+//!T (the type of the object pointed to) and VoidPointer(a void pointer type 
+//!that defines the type of pointer that intrusive_ptr will store).
+//!intrusive_ptr<T, void *> defines a class with a T* member whereas
+//!intrusive_ptr<T, offset_ptr<void> > defines a class with a offset_ptr<T> member.
+//!Relies on unqualified calls to:
+//! 
+//!  void intrusive_ptr_add_ref(T * p);
+//!  void intrusive_ptr_release(T * p);
+//!
+//!  with (p != 0)
+//!
+//!The object is responsible for destroying itself.
+template<class T, class VoidPointer>
+class intrusive_ptr
+{
+   public:
+   //!Provides the type of the internal stored pointer.
+   typedef typename boost::intrusive::
+      pointer_traits<VoidPointer>::template
+         rebind_pointer<T>::type                pointer;
+   //!Provides the type of the stored pointer.
+   typedef T element_type;
+
+   /// @cond
+   private:
+   typedef VoidPointer VP;
+   typedef intrusive_ptr this_type;
+   typedef pointer this_type::*unspecified_bool_type;
+   /// @endcond
+
+   public:
+   //!Constructor. Initializes internal pointer to 0.
+   //!Does not throw
+   intrusive_ptr(): m_ptr(0)
+   {}
+
+   //!Constructor. Copies pointer and if "p" is not zero and 
+   //!"add_ref" is true calls intrusive_ptr_add_ref(to_raw_pointer(p)).
+   //!Does not throw
+   intrusive_ptr(const pointer &p, bool add_ref = true): m_ptr(p)
+   {
+      if(m_ptr != 0 && add_ref) intrusive_ptr_add_ref(ipcdetail::to_raw_pointer(m_ptr));
+   }
+
+   //!Copy constructor. Copies the internal pointer and if "p" is not
+   //!zero calls intrusive_ptr_add_ref(to_raw_pointer(p)). Does not throw
+   intrusive_ptr(intrusive_ptr const & rhs)
+      :  m_ptr(rhs.m_ptr)
+   {
+      if(m_ptr != 0) intrusive_ptr_add_ref(ipcdetail::to_raw_pointer(m_ptr));
+   }
+
+   //!Constructor from related. Copies the internal pointer and if "p" is not
+   //!zero calls intrusive_ptr_add_ref(to_raw_pointer(p)). Does not throw
+   template<class U> intrusive_ptr
+      (intrusive_ptr<U, VP> const & rhs)
+      :  m_ptr(rhs.get())
+   {
+      if(m_ptr != 0) intrusive_ptr_add_ref(ipcdetail::to_raw_pointer(m_ptr));
+   }
+
+   //!Destructor. If internal pointer is not 0, calls
+   //!intrusive_ptr_release(to_raw_pointer(m_ptr)). Does not throw
+   ~intrusive_ptr()
+   {
+      if(m_ptr != 0) intrusive_ptr_release(ipcdetail::to_raw_pointer(m_ptr));
+   }
+
+   //!Assignment operator. Equivalent to intrusive_ptr(r).swap(*this). 
+   //!Does not throw
+   intrusive_ptr & operator=(intrusive_ptr const & rhs)
+   {
+      this_type(rhs).swap(*this);
+      return *this;
+   }
+
+   //!Assignment from related. Equivalent to intrusive_ptr(r).swap(*this). 
+   //!Does not throw
+   template<class U> intrusive_ptr & operator=
+      (intrusive_ptr<U, VP> const & rhs)
+   {
+      this_type(rhs).swap(*this);
+      return *this;
+   }
+
+   //!Assignment from pointer. Equivalent to intrusive_ptr(r).swap(*this). 
+   //!Does not throw
+   intrusive_ptr & operator=(pointer rhs)
+   {
+      this_type(rhs).swap(*this);
+      return *this;
+   }
+   
+   //!Returns a reference to the internal pointer.
+   //!Does not throw
+   pointer &get()
+   {  return m_ptr;  }
+
+   //!Returns a reference to the internal pointer.
+   //!Does not throw
+   const pointer &get() const
+   {  return m_ptr;  }
+
+   //!Returns *get().
+   //!Does not throw
+   T & operator*() const
+   {  return *m_ptr; }
+
+   //!Returns *get().
+   //!Does not throw
+   const pointer &operator->() const
+   {  return m_ptr;  }
+
+   //!Returns get().
+   //!Does not throw
+   pointer &operator->()
+   {  return m_ptr;  }
+
+   //!Conversion to boolean.
+   //!Does not throw
+   operator unspecified_bool_type () const
+   {  return m_ptr == 0? 0: &this_type::m_ptr;  }
+
+   //!Not operator.
+   //!Does not throw
+   bool operator! () const
+   {  return m_ptr == 0;   }
+
+   //!Exchanges the contents of the two smart pointers.
+   //!Does not throw
+   void swap(intrusive_ptr & rhs)
+   {  ipcdetail::do_swap(m_ptr, rhs.m_ptr);  }
+
+   /// @cond
+   private:
+   pointer m_ptr;
+   /// @endcond
+};
+
+//!Returns a.get() == b.get().
+//!Does not throw
+template<class T, class U, class VP> inline
+bool operator==(intrusive_ptr<T, VP> const & a, 
+                intrusive_ptr<U, VP> const & b)
+{  return a.get() == b.get(); }
+
+//!Returns a.get() != b.get().
+//!Does not throw
+template<class T, class U, class VP> inline
+bool operator!=(intrusive_ptr<T, VP> const & a,
+                intrusive_ptr<U, VP> const & b)
+{  return a.get() != b.get(); }
+
+//!Returns a.get() == b.
+//!Does not throw
+template<class T, class VP> inline
+bool operator==(intrusive_ptr<T, VP> const & a,
+                       const typename intrusive_ptr<T, VP>::pointer &b)
+{  return a.get() == b; }
+
+//!Returns a.get() != b.
+//!Does not throw
+template<class T, class VP> inline
+bool operator!=(intrusive_ptr<T, VP> const & a,
+                const typename intrusive_ptr<T, VP>::pointer &b)
+{  return a.get() != b; }
+
+//!Returns a == b.get().
+//!Does not throw
+template<class T, class VP> inline
+bool operator==(const typename intrusive_ptr<T, VP>::pointer &a,
+                intrusive_ptr<T, VP> const & b)
+{  return a == b.get(); }
+
+//!Returns a != b.get().
+//!Does not throw
+template<class T, class VP> inline
+bool operator!=(const typename intrusive_ptr<T, VP>::pointer &a,
+                       intrusive_ptr<T, VP> const & b)
+{  return a != b.get(); }
+
+//!Returns a.get() < b.get().
+//!Does not throw
+template<class T, class VP> inline
+bool operator<(intrusive_ptr<T, VP> const & a, 
+               intrusive_ptr<T, VP> const & b)
+{  
+   return std::less<typename intrusive_ptr<T, VP>::pointer>()
+      (a.get(), b.get());   
+}
+
+//!Exchanges the contents of the two intrusive_ptrs.
+//!Does not throw
+template<class T, class VP> inline
+void swap(intrusive_ptr<T, VP> & lhs,
+          intrusive_ptr<T, VP> & rhs)
+{  lhs.swap(rhs); }
+
+// operator<<
+template<class E, class T, class Y, class VP>
+inline std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, intrusive_ptr<Y, VP> const & p)
+{  os << p.get(); return os;  }
+
+//!Returns p.get().
+//!Does not throw
+template<class T, class VP>
+inline typename boost::interprocess::intrusive_ptr<T, VP>::pointer
+   to_raw_pointer(intrusive_ptr<T, VP> p)
+{  return p.get();   }
+
+/*Emulates static cast operator. Does not throw*/
+/*
+template<class T, class U, class VP>
+inline boost::interprocess::intrusive_ptr<T, VP> static_pointer_cast
+   (boost::interprocess::intrusive_ptr<U, VP> const & p)
+{  return do_static_cast<U>(p.get());  }
+*/
+/*Emulates const cast operator. Does not throw*/
+/*
+template<class T, class U, class VP>
+inline boost::interprocess::intrusive_ptr<T, VP> const_pointer_cast
+   (boost::interprocess::intrusive_ptr<U, VP> const & p)
+{  return do_const_cast<U>(p.get());   }
+*/
+
+/*Emulates dynamic cast operator. Does not throw*/
+/*
+template<class T, class U, class VP>
+inline boost::interprocess::intrusive_ptr<T, VP> dynamic_pointer_cast
+   (boost::interprocess::intrusive_ptr<U, VP> const & p)
+{  return do_dynamic_cast<U>(p.get()); }
+*/
+
+/*Emulates reinterpret cast operator. Does not throw*/
+/*
+template<class T, class U, class VP>
+inline boost::interprocess::intrusive_ptr<T, VP>reinterpret_pointer_cast
+   (boost::interprocess::intrusive_ptr<U, VP> const & p)
+{  return do_reinterpret_cast<U>(p.get());   }
+*/
+
+} // namespace interprocess
+
+/// @cond
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+//!Returns p.get().
+//!Does not throw
+template<class T, class VP>
+inline T *to_raw_pointer(boost::interprocess::intrusive_ptr<T, VP> p)
+{  return p.get();   }
+#endif
+
+/// @endcond
+
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_INTRUSIVE_PTR_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/scoped_ptr.hpp b/boost/interprocess/smart_ptr/scoped_ptr.hpp
new file mode 100644
index 0000000000..1885838ffe
--- /dev/null
+++ b/boost/interprocess/smart_ptr/scoped_ptr.hpp
@@ -0,0 +1,164 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/scoped_ptr.hpp
+//
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// (C) Copyright Peter Dimov 2001, 2002
+// (C) Copyright Ion Gaztanaga 2006. 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_SCOPED_PTR_HPP_INCLUDED
+#define BOOST_INTERPROCESS_SCOPED_PTR_HPP_INCLUDED
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/pointer_type.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/assert.hpp>
+
+//!\file
+//!Describes the smart pointer scoped_ptr
+
+namespace boost {
+namespace interprocess {
+
+//!scoped_ptr stores a pointer to a dynamically allocated object. 
+//!The object pointed to is guaranteed to be deleted, either on destruction
+//!of the scoped_ptr, or via an explicit reset. The user can avoid this
+//!deletion using release().
+//!scoped_ptr is parameterized on T (the type of the object pointed to) and 
+//!Deleter (the functor to be executed to delete the internal pointer).
+//!The internal pointer will be of the same pointer type as typename 
+//!Deleter::pointer type (that is, if typename Deleter::pointer is 
+//!offset_ptr<void>, the internal pointer will be offset_ptr<T>).
+template<class T, class Deleter>
+class scoped_ptr
+   : private Deleter
+{
+   /// @cond
+   scoped_ptr(scoped_ptr const &);
+   scoped_ptr & operator=(scoped_ptr const &);
+
+   typedef scoped_ptr<T, Deleter> this_type;
+   typedef typename ipcdetail::add_reference<T>::type reference;
+   /// @endcond
+
+   public:
+
+   typedef T element_type;
+   typedef Deleter deleter_type;
+   typedef typename ipcdetail::pointer_type<T, Deleter>::type pointer;
+
+   //!Constructs a scoped_ptr, storing a copy of p(which can be 0) and d.
+   //!Does not throw.
+   explicit scoped_ptr(const pointer &p = 0, const Deleter &d = Deleter())
+      : Deleter(d), m_ptr(p) // throws if pointer/Deleter copy ctor throws
+   {}
+
+   //!If the stored pointer is not 0, destroys the object pointed to by the stored pointer. 
+   //!calling the operator() of the stored deleter. Never throws
+   ~scoped_ptr()
+   { 
+      if(m_ptr){
+         Deleter &del = static_cast<Deleter&>(*this);
+         del(m_ptr);
+      }
+   }
+
+   //!Deletes the object pointed to by the stored pointer and then
+   //!stores a copy of p. Never throws
+   void reset(const pointer &p = 0) // never throws
+   {  BOOST_ASSERT(p == 0 || p != m_ptr); this_type(p).swap(*this);  }
+
+   //!Deletes the object pointed to by the stored pointer and then
+   //!stores a copy of p and a copy of d.
+   void reset(const pointer &p, const Deleter &d) // never throws
+   {  BOOST_ASSERT(p == 0 || p != m_ptr); this_type(p, d).swap(*this);  }
+
+   //!Assigns internal pointer as 0 and returns previous pointer. This will
+   //!avoid deletion on destructor
+   pointer release()
+   {  pointer tmp(m_ptr);  m_ptr = 0;  return tmp; }
+
+   //!Returns a reference to the object pointed to by the stored pointer.
+   //!Never throws.
+   reference operator*() const
+   {  BOOST_ASSERT(m_ptr != 0);  return *m_ptr; }
+
+   //!Returns the internal stored pointer.
+   //!Never throws.
+   pointer &operator->()
+   {  BOOST_ASSERT(m_ptr != 0);  return m_ptr;  }
+
+   //!Returns the internal stored pointer.
+   //!Never throws.
+   const pointer &operator->() const
+   {  BOOST_ASSERT(m_ptr != 0);  return m_ptr;  }
+
+   //!Returns the stored pointer.
+   //!Never throws.
+   pointer & get()
+   {  return m_ptr;  }
+
+   //!Returns the stored pointer.
+   //!Never throws.
+   const pointer & get() const
+   {  return m_ptr;  }
+
+   typedef pointer this_type::*unspecified_bool_type;
+
+   //!Conversion to bool
+   //!Never throws
+   operator unspecified_bool_type() const
+   {  return m_ptr == 0? 0: &this_type::m_ptr;  }
+
+   //!Returns true if the stored pointer is 0.
+   //!Never throws.
+   bool operator! () const // never throws
+   {  return m_ptr == 0;   }
+
+   //!Exchanges the internal pointer and deleter with other scoped_ptr
+   //!Never throws.
+   void swap(scoped_ptr & b) // never throws
+   {  ipcdetail::do_swap<Deleter>(*this, b); ipcdetail::do_swap(m_ptr, b.m_ptr); }
+
+   /// @cond
+   private:
+   pointer m_ptr;
+   /// @endcond
+};
+
+//!Exchanges the internal pointer and deleter with other scoped_ptr
+//!Never throws.
+template<class T, class D> inline
+void swap(scoped_ptr<T, D> & a, scoped_ptr<T, D> & b)
+{  a.swap(b); }
+
+//!Returns a copy of the stored pointer
+//!Never throws
+template<class T, class D> inline
+typename scoped_ptr<T, D>::pointer to_raw_pointer(scoped_ptr<T, D> const & p)
+{  return p.get();   }
+
+} // namespace interprocess
+
+/// @cond
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+template<class T, class D> inline
+T *to_raw_pointer(boost::interprocess::scoped_ptr<T, D> const & p)
+{  return p.get();   }
+#endif
+
+/// @endcond
+
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // #ifndef BOOST_INTERPROCESS_SCOPED_PTR_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/shared_ptr.hpp b/boost/interprocess/smart_ptr/shared_ptr.hpp
new file mode 100644
index 0000000000..61829078e8
--- /dev/null
+++ b/boost/interprocess/smart_ptr/shared_ptr.hpp
@@ -0,0 +1,417 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/shared_ptr.hpp
+//
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// (C) Copyright Peter Dimov 2001, 2002, 2003
+// (C) Copyright Ion Gaztanaga 2006-2011.
+// 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_SHARED_PTR_HPP_INCLUDED
+#define BOOST_INTERPROCESS_SHARED_PTR_HPP_INCLUDED
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/cast_tags.hpp>
+#include <boost/assert.hpp>
+#include <boost/interprocess/smart_ptr/detail/shared_count.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/smart_ptr/deleter.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+
+#include <algorithm>            // for std::swap
+#include <functional>           // for std::less
+#include <typeinfo>             // for std::bad_cast
+#include <iosfwd>               // for std::basic_ostream
+
+//!\file
+//!Describes the smart pointer shared_ptr
+
+namespace boost{
+namespace interprocess{
+
+template<class T, class VoidAllocator, class Deleter> class weak_ptr;
+template<class T, class VoidAllocator, class Deleter> class enable_shared_from_this;
+
+namespace ipcdetail{
+
+template<class T, class VoidAllocator, class Deleter>
+inline void sp_enable_shared_from_this
+  (shared_count<T, VoidAllocator, Deleter> const & pn
+  ,enable_shared_from_this<T, VoidAllocator, Deleter> *pe
+  ,T *ptr)
+   
+{
+   (void)ptr;
+   if(pe != 0){
+      pe->_internal_weak_this._internal_assign(pn);
+   }
+}
+
+template<class T, class VoidAllocator, class Deleter>
+inline void sp_enable_shared_from_this(shared_count<T, VoidAllocator, Deleter> const &, ...)
+{}
+
+} // namespace ipcdetail
+
+//!shared_ptr stores a pointer to a dynamically allocated object. 
+//!The object pointed to is guaranteed to be deleted when the last shared_ptr pointing to 
+//!it is destroyed or reset.
+//!
+//!shared_ptr is parameterized on 
+//!T (the type of the object pointed to), VoidAllocator (the void allocator to be used
+//!to allocate the auxiliary data) and Deleter (the deleter whose 
+//!operator() will be used to delete the object.
+//!
+//!The internal pointer will be of the same pointer type as typename 
+//!VoidAllocator::pointer type (that is, if typename VoidAllocator::pointer is 
+//!offset_ptr<void>, the internal pointer will be offset_ptr<T>).
+//!
+//!Because the implementation uses reference counting, cycles of shared_ptr
+//!instances will not be reclaimed. For example, if main() holds a
+//!shared_ptr to A, which directly or indirectly holds a shared_ptr back
+//!to A, A's use count will be 2. Destruction of the original shared_ptr
+//!will leave A dangling with a use count of 1.
+//!Use weak_ptr to "break cycles."
+template<class T, class VoidAllocator, class Deleter>
+class shared_ptr
+{
+   /// @cond
+   private:
+   typedef shared_ptr<T, VoidAllocator, Deleter> this_type;
+   /// @endcond
+
+   public:
+
+   typedef T                                                   element_type;
+   typedef T                                                   value_type;
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<T>::type                               pointer;
+   typedef typename ipcdetail::add_reference
+                     <value_type>::type                        reference;
+   typedef typename ipcdetail::add_reference
+                     <const value_type>::type                  const_reference;
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<const Deleter>::type                               const_deleter_pointer;
+   typedef typename boost::intrusive::
+      pointer_traits<typename VoidAllocator::pointer>::template
+         rebind_pointer<const VoidAllocator>::type                         const_allocator_pointer;
+
+   BOOST_COPYABLE_AND_MOVABLE(shared_ptr)
+   public:
+
+   //!Constructs an empty shared_ptr.
+   //!Use_count() == 0 && get()== 0.
+   shared_ptr()
+      :  m_pn() // never throws
+   {}
+
+   //!Constructs a shared_ptr that owns the pointer p. Auxiliary data will be allocated
+   //!with a copy of a and the object will be deleted with a copy of d.
+   //!Requirements: Deleter and A's copy constructor must not throw.
+   explicit shared_ptr(const pointer&p, const VoidAllocator &a = VoidAllocator(), const Deleter &d = Deleter())
+      :  m_pn(p, a, d)
+   {  
+      //Check that the pointer passed is of the same type that
+      //the pointer the allocator defines or it's a raw pointer
+      typedef typename boost::intrusive::
+         pointer_traits<pointer>::template
+            rebind_pointer<T>::type                         ParameterPointer;
+
+      BOOST_STATIC_ASSERT((ipcdetail::is_same<pointer, ParameterPointer>::value) ||
+                          (ipcdetail::is_pointer<pointer>::value));
+      ipcdetail::sp_enable_shared_from_this<T, VoidAllocator, Deleter>( m_pn, ipcdetail::to_raw_pointer(p), ipcdetail::to_raw_pointer(p) ); 
+   }
+
+
+   //!Constructs a shared_ptr that shares ownership with r and stores p.
+   //!Postconditions: get() == p && use_count() == r.use_count().
+   //!Throws: nothing.
+   shared_ptr(const shared_ptr &other, const pointer &p)
+      :  m_pn(other.m_pn, p)
+   {}
+
+   //!If r is empty, constructs an empty shared_ptr. Otherwise, constructs 
+   //!a shared_ptr that shares ownership with r. Never throws.
+   template<class Y>
+   shared_ptr(shared_ptr<Y, VoidAllocator, Deleter> const & r)
+      :  m_pn(r.m_pn) // never throws
+   {}
+
+   //!Constructs a shared_ptr that shares ownership with r and stores 
+   //!a copy of the pointer stored in r.
+   template<class Y>
+   explicit shared_ptr(weak_ptr<Y, VoidAllocator, Deleter> const & r)
+      :  m_pn(r.m_pn) // may throw
+   {}
+
+   //!Move-Constructs a shared_ptr that takes ownership of other resource and
+   //!other is put in default-constructed state.
+   //!Throws: nothing.
+   explicit shared_ptr(BOOST_RV_REF(shared_ptr) other)
+      :  m_pn()
+   {  this->swap(other);   }
+
+   /// @cond
+   template<class Y>
+   shared_ptr(shared_ptr<Y, VoidAllocator, Deleter> const & r, ipcdetail::static_cast_tag)
+      :  m_pn( pointer(static_cast<T*>(ipcdetail::to_raw_pointer(r.m_pn.to_raw_pointer())))
+             , r.m_pn) 
+   {}
+
+   template<class Y>
+   shared_ptr(shared_ptr<Y, VoidAllocator, Deleter> const & r, ipcdetail::const_cast_tag)
+      :  m_pn( pointer(const_cast<T*>(ipcdetail::to_raw_pointer(r.m_pn.to_raw_pointer())))
+             , r.m_pn) 
+   {}
+
+   template<class Y>
+   shared_ptr(shared_ptr<Y, VoidAllocator, Deleter> const & r, ipcdetail::dynamic_cast_tag)
+      :  m_pn( pointer(dynamic_cast<T*>(ipcdetail::to_raw_pointer(r.m_pn.to_raw_pointer())))
+             , r.m_pn) 
+   {
+      if(!m_pn.to_raw_pointer()){ // need to allocate new counter -- the cast failed
+         m_pn = ipcdetail::shared_count<T, VoidAllocator, Deleter>();
+      }
+   }
+   /// @endcond
+
+   //!Equivalent to shared_ptr(r).swap(*this).
+   //!Never throws
+   template<class Y>
+   shared_ptr & operator=(shared_ptr<Y, VoidAllocator, Deleter> const & r)
+   {
+      m_pn = r.m_pn; // shared_count::op= doesn't throw
+      return *this;
+   }
+
+   //!Equivalent to shared_ptr(r).swap(*this).
+   //!Never throws
+   shared_ptr & operator=(BOOST_COPY_ASSIGN_REF(shared_ptr) r)
+   {
+      m_pn = r.m_pn; // shared_count::op= doesn't throw
+      return *this;
+   }
+
+   //!Move-assignment. Equivalent to shared_ptr(other).swap(*this).
+   //!Never throws
+   shared_ptr & operator=(BOOST_RV_REF(shared_ptr) other) // never throws
+   {
+      this_type(other).swap(*this);
+      return *this;
+   }
+
+   //!This is equivalent to:
+   //!this_type().swap(*this);
+   void reset()
+   {  
+      this_type().swap(*this);   
+   }
+
+   //!This is equivalent to:
+   //!this_type(p, a, d).swap(*this);
+   template<class Pointer>
+   void reset(const Pointer &p, const VoidAllocator &a = VoidAllocator(), const Deleter &d = Deleter())
+   {  
+      //Check that the pointer passed is of the same type that
+      //the pointer the allocator defines or it's a raw pointer
+      typedef typename boost::intrusive::
+         pointer_traits<Pointer>::template
+            rebind_pointer<T>::type                         ParameterPointer;
+      BOOST_STATIC_ASSERT((ipcdetail::is_same<pointer, ParameterPointer>::value) ||
+                          (ipcdetail::is_pointer<Pointer>::value));
+      this_type(p, a, d).swap(*this);  
+   }
+
+   template<class Y>
+   void reset(shared_ptr<Y, VoidAllocator, Deleter> const & r, const pointer &p)
+   {
+      this_type(r, p).swap(*this);
+   }
+
+   //!Returns a reference to the
+   //!pointed type
+   reference operator* () const // never throws
+   {  BOOST_ASSERT(m_pn.to_raw_pointer() != 0);  return *m_pn.to_raw_pointer(); }
+
+   //!Returns the pointer pointing 
+   //!to the owned object
+   pointer operator-> () const // never throws
+   {  BOOST_ASSERT(m_pn.to_raw_pointer() != 0);  return m_pn.to_raw_pointer();  }
+
+   //!Returns the pointer pointing 
+   //!to the owned object
+   pointer get() const  // never throws
+   {  return m_pn.to_raw_pointer();  }
+
+   /// @cond
+   // implicit conversion to "bool"
+   void unspecified_bool_type_func() const {}
+   typedef void (this_type::*unspecified_bool_type)() const;
+
+   operator unspecified_bool_type() const // never throws
+   {  return !m_pn.to_raw_pointer() ? 0 : &this_type::unspecified_bool_type_func;  }
+   /// @endcond
+
+   //!Not operator.
+   //!Returns true if this->get() != 0, false otherwise
+   bool operator! () const // never throws
+   {  return !m_pn.to_raw_pointer();   }
+
+   //!Returns use_count() == 1.
+   //!unique() might be faster than use_count()
+   bool unique() const // never throws
+   {  return m_pn.unique();  }
+
+   //!Returns the number of shared_ptr objects, *this included,
+   //!that share ownership with *this, or an unspecified nonnegative
+   //!value when *this is empty.
+   //!use_count() is not necessarily efficient. Use only for
+   //!debugging and testing purposes, not for production code.
+   long use_count() const // never throws
+   {  return m_pn.use_count();  }
+
+   //!Exchanges the contents of the two
+   //!smart pointers.
+   void swap(shared_ptr<T, VoidAllocator, Deleter> & other) // never throws
+   {  m_pn.swap(other.m_pn);   }
+
+   /// @cond
+
+   template<class T2, class A2, class Deleter2> 
+   bool _internal_less(shared_ptr<T2, A2, Deleter2> const & rhs) const
+   {  return m_pn < rhs.m_pn;  }
+
+   const_deleter_pointer get_deleter() const
+   {  return m_pn.get_deleter(); }
+
+//   const_allocator_pointer get_allocator() const
+//   {  return m_pn.get_allocator(); }
+
+   private:
+
+   template<class T2, class A2, class Deleter2> friend class shared_ptr;
+   template<class T2, class A2, class Deleter2> friend class weak_ptr;
+
+   ipcdetail::shared_count<T, VoidAllocator, Deleter>   m_pn;    // reference counter
+   /// @endcond
+};  // shared_ptr
+
+template<class T, class VoidAllocator, class Deleter, class U, class VoidAllocator2, class Deleter2> inline 
+bool operator==(shared_ptr<T, VoidAllocator, Deleter> const & a, shared_ptr<U, VoidAllocator2, Deleter2> const & b)
+{  return a.get() == b.get(); }
+
+template<class T, class VoidAllocator, class Deleter, class U, class VoidAllocator2, class Deleter2> inline 
+bool operator!=(shared_ptr<T, VoidAllocator, Deleter> const & a, shared_ptr<U, VoidAllocator2, Deleter2> const & b)
+{  return a.get() != b.get(); }
+
+template<class T, class VoidAllocator, class Deleter, class U, class VoidAllocator2, class Deleter2> inline 
+bool operator<(shared_ptr<T, VoidAllocator, Deleter> const & a, shared_ptr<U, VoidAllocator2, Deleter2> const & b)
+{  return a._internal_less(b);   }
+
+template<class T, class VoidAllocator, class Deleter> inline 
+void swap(shared_ptr<T, VoidAllocator, Deleter> & a, shared_ptr<T, VoidAllocator, Deleter> & b)
+{  a.swap(b);  }
+
+template<class T, class VoidAllocator, class Deleter, class U> inline
+shared_ptr<T, VoidAllocator, Deleter> static_pointer_cast(shared_ptr<U, VoidAllocator, Deleter> const & r)
+{  return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::static_cast_tag());   }
+
+template<class T, class VoidAllocator, class Deleter, class U> inline 
+shared_ptr<T, VoidAllocator, Deleter> const_pointer_cast(shared_ptr<U, VoidAllocator, Deleter> const & r)
+{  return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::const_cast_tag()); }
+
+template<class T, class VoidAllocator, class Deleter, class U> inline 
+shared_ptr<T, VoidAllocator, Deleter> dynamic_pointer_cast(shared_ptr<U, VoidAllocator, Deleter> const & r)
+{  return shared_ptr<T, VoidAllocator, Deleter>(r, ipcdetail::dynamic_cast_tag());  }
+
+// to_raw_pointer() enables boost::mem_fn to recognize shared_ptr
+template<class T, class VoidAllocator, class Deleter> inline
+T * to_raw_pointer(shared_ptr<T, VoidAllocator, Deleter> const & p)
+{  return p.get();   }
+
+// operator<<
+template<class E, class T, class Y, class VoidAllocator, class Deleter> inline
+std::basic_ostream<E, T> & operator<< 
+   (std::basic_ostream<E, T> & os, shared_ptr<Y, VoidAllocator, Deleter> const & p)
+{  os << p.get();   return os;   }
+
+//!Returns the type of a shared pointer
+//!of type T with the allocator boost::interprocess::allocator allocator
+//!and boost::interprocess::deleter deleter
+//!that can be constructed in the given managed segment type.
+template<class T, class ManagedMemory>
+struct managed_shared_ptr
+{
+   typedef typename ManagedMemory::template allocator<void>::type void_allocator;
+   typedef typename ManagedMemory::template deleter<T>::type      deleter;
+   typedef shared_ptr< T, void_allocator, deleter>                type;
+};
+
+//!Returns an instance of a shared pointer constructed
+//!with the default allocator and deleter from a pointer
+//!of type T that has been allocated in the passed managed segment
+template<class T, class ManagedMemory>
+inline typename managed_shared_ptr<T, ManagedMemory>::type
+   make_managed_shared_ptr(T *constructed_object, ManagedMemory &managed_memory)
+{
+   return typename managed_shared_ptr<T, ManagedMemory>::type
+   ( constructed_object
+   , managed_memory.template get_allocator<void>()
+   , managed_memory.template get_deleter<T>()
+   );
+}
+
+//!Returns an instance of a shared pointer constructed
+//!with the default allocator and deleter from a pointer
+//!of type T that has been allocated in the passed managed segment.
+//!Does not throw, return null shared pointer in error.
+template<class T, class ManagedMemory>
+inline typename managed_shared_ptr<T, ManagedMemory>::type
+   make_managed_shared_ptr(T *constructed_object, ManagedMemory &managed_memory, std::nothrow_t)
+{
+   try{
+      return typename managed_shared_ptr<T, ManagedMemory>::type
+      ( constructed_object
+      , managed_memory.template get_allocator<void>()
+      , managed_memory.template get_deleter<T>()
+      );
+   }
+   catch(...){
+      return typename managed_shared_ptr<T, ManagedMemory>::type();
+   }
+}
+
+
+} // namespace interprocess
+
+/// @cond
+
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+// to_raw_pointer() enables boost::mem_fn to recognize shared_ptr
+template<class T, class VoidAllocator, class Deleter> inline
+T * to_raw_pointer(boost::interprocess::shared_ptr<T, VoidAllocator, Deleter> const & p)
+{  return p.get();   }
+#endif
+
+/// @endcond
+
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_SHARED_PTR_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/unique_ptr.hpp b/boost/interprocess/smart_ptr/unique_ptr.hpp
new file mode 100644
index 0000000000..547038b69b
--- /dev/null
+++ b/boost/interprocess/smart_ptr/unique_ptr.hpp
@@ -0,0 +1,551 @@
+//////////////////////////////////////////////////////////////////////////////
+// I, Howard Hinnant, hereby place this code in the public domain.
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of
+// Howard Hinnant's unique_ptr emulation code.
+//
+// (C) Copyright Ion Gaztanaga 2006. 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_UNIQUE_PTR_HPP_INCLUDED
+#define BOOST_INTERPROCESS_UNIQUE_PTR_HPP_INCLUDED
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/assert.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/pointer_type.hpp>
+#include <boost/move/move.hpp>
+#include <boost/compressed_pair.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/smart_ptr/deleter.hpp>
+#include <cstddef>
+
+//!\file
+//!Describes the smart pointer unique_ptr
+
+namespace boost{
+namespace interprocess{
+
+/// @cond
+template <class T, class D> class unique_ptr;
+
+namespace ipcdetail {
+
+template <class T> struct unique_ptr_error;
+
+template <class T, class D>
+struct unique_ptr_error<const unique_ptr<T, D> >
+{
+    typedef unique_ptr<T, D> type;
+};
+
+}  //namespace ipcdetail {
+/// @endcond
+
+//!Template unique_ptr stores a pointer to an object and deletes that object
+//!using the associated deleter when it is itself destroyed (such as when
+//!leaving block scope.
+//!
+//!The unique_ptr provides a semantics of strict ownership. A unique_ptr owns the
+//!object it holds a pointer to.
+//!
+//!A unique_ptr is not CopyConstructible, nor CopyAssignable, however it is
+//!MoveConstructible and Move-Assignable.
+//!
+//!The uses of unique_ptr include providing exception safety for dynamically
+//!allocated memory, passing ownership of dynamically allocated memory to a
+//!function, and returning dynamically allocated memory from a function
+//!
+//!A client-supplied template argument D must be a
+//!function pointer or functor for which, given a value d of type D and a pointer
+//!ptr to a type T*, the expression d(ptr) is
+//!valid and has the effect of deallocating the pointer as appropriate for that
+//!deleter. D may also be an lvalue-reference to a deleter.
+//!
+//!If the deleter D maintains state, it is intended that this state stay with
+//!the associated pointer as ownership is transferred
+//!from unique_ptr to unique_ptr. The deleter state need never be copied,
+//!only moved or swapped as pointer ownership
+//!is moved around. That is, the deleter need only be MoveConstructible,
+//!MoveAssignable, and Swappable, and need not be CopyConstructible
+//!(unless copied into the unique_ptr) nor CopyAssignable.
+template <class T, class D>
+class unique_ptr
+{
+   /// @cond
+   struct nat {int for_bool_;};
+   typedef typename ipcdetail::add_reference<D>::type deleter_reference;
+   typedef typename ipcdetail::add_reference<const D>::type deleter_const_reference;
+   /// @endcond
+
+   public:
+
+   typedef T element_type;
+   typedef D deleter_type;
+   typedef typename ipcdetail::pointer_type<T, D>::type pointer;
+
+   //!Requires: D must be default constructible, and that construction must not
+   //!throw an exception. D must not be a reference type.
+   //!
+   //!Effects: Constructs a unique_ptr which owns nothing.
+   //!
+   //!Postconditions: get() == 0. get_deleter() returns a reference to a
+   //!default constructed deleter D.
+   //!
+   //!Throws: nothing.
+   unique_ptr()
+      :  ptr_(pointer(0))
+   {}
+
+   //!Requires: The expression D()(p) must be well formed. The default constructor
+   //!of D must not throw an exception.
+   //!
+   //!D must not be a reference type.
+   //!
+   //!Effects: Constructs a unique_ptr which owns p.
+   //!
+   //!Postconditions: get() == p. get_deleter() returns a reference to a default constructed deleter D.
+   //!
+   //!Throws: nothing.
+   explicit unique_ptr(pointer p)
+      :  ptr_(p)
+   {}
+
+   //!Requires: The expression d(p) must be well formed.
+   //!
+   //!Postconditions: get() == p. get_deleter() returns a reference to the
+   //!internally stored deleter. If D is a
+   //!reference type then get_deleter() returns a reference to the lvalue d.
+   //!
+   //!Throws: nothing.
+   unique_ptr(pointer p
+             ,typename ipcdetail::if_<ipcdetail::is_reference<D>
+                  ,D
+                  ,typename ipcdetail::add_reference<const D>::type>::type d)
+      : ptr_(p, d)
+   {}
+
+   //!Requires: If the deleter is not a reference type, construction of the
+   //!deleter D from an lvalue D must not throw an exception.
+   //!
+   //!Effects: Constructs a unique_ptr which owns the pointer which u owns
+   //!(if any). If the deleter is not a reference type, it is move constructed
+   //!from u's deleter, otherwise the reference is copy constructed from u's deleter.
+   //!
+   //!After the construction, u no longer owns a pointer.
+   //![ Note: The deleter constructor can be implemented with
+   //!   boost::forward<D>. -end note ]
+   //!
+   //!Postconditions: get() == value u.get() had before the construction.
+   //!get_deleter() returns a reference to the internally stored deleter which
+   //!was constructed from u.get_deleter(). If D is a reference type then get_-
+   //!deleter() and u.get_deleter() both reference the same lvalue deleter.
+   //!
+   //!Throws: nothing.
+   unique_ptr(BOOST_RV_REF(unique_ptr) u)
+      : ptr_(u.release(), boost::forward<D>(u.get_deleter()))
+   {}
+
+   //!Requires: If D is not a reference type, construction of the deleter
+   //!D from an rvalue of type E must be well formed
+   //!and not throw an exception. If D is a reference type, then E must be
+   //!the same type as D (diagnostic required). unique_ptr<U, E>::pointer
+   //!must be implicitly convertible to pointer.
+   //!
+   //!Effects: Constructs a unique_ptr which owns the pointer which u owns
+   //!(if any). If the deleter is not a reference
+   //!type, it is move constructed from u's deleter, otherwise the reference
+   //!is copy constructed from u's deleter.
+   //!
+   //!After the construction, u no longer owns a pointer.
+   //!
+   //!postconditions get() == value u.get() had before the construction,
+   //!modulo any required offset adjustments
+   //!resulting from the cast from U* to T*. get_deleter() returns a reference to the internally stored deleter which
+   //!was constructed from u.get_deleter().
+   //!
+   //!Throws: nothing.
+   template <class U, class E>
+   unique_ptr(BOOST_RV_REF_2_TEMPL_ARGS(unique_ptr, U, E) u,
+      typename ipcdetail::enable_if_c<
+            ipcdetail::is_convertible<typename unique_ptr<U, E>::pointer, pointer>::value &&
+            ipcdetail::is_convertible<E, D>::value &&
+            (
+               !ipcdetail::is_reference<D>::value ||
+               ipcdetail::is_same<D, E>::value
+            )
+            ,
+            nat
+            >::type = nat())
+      : ptr_(const_cast<unique_ptr<U,E>&>(u).release(), boost::move<D>(u.get_deleter()))
+   {}
+
+   //!Effects: If get() == 0 there are no effects. Otherwise get_deleter()(get()).
+   //!
+   //!Throws: nothing.
+   ~unique_ptr()
+   {  reset(); }
+
+   // assignment
+
+   //!Requires: Assignment of the deleter D from an rvalue D must not throw an exception.
+   //!
+   //!Effects: reset(u.release()) followed by a move assignment from u's deleter to
+   //!this deleter.
+   //!
+   //!Postconditions: This unique_ptr now owns the pointer which u owned, and u no
+   //!longer owns it.
+   //!
+   //!Returns: *this.
+   //!
+   //!Throws: nothing.
+   unique_ptr& operator=(BOOST_RV_REF(unique_ptr) u)
+   {
+      reset(u.release());
+      ptr_.second() = boost::move(u.get_deleter());
+      return *this;
+   }
+
+   //!Requires: Assignment of the deleter D from an rvalue D must not
+   //!throw an exception. U* must be implicitly convertible to T*.
+   //!
+   //!Effects: reset(u.release()) followed by a move assignment from
+   //!u's deleter to this deleter. If either D or E is
+   //!a reference type, then the referenced lvalue deleter participates
+   //!in the move assignment.
+   //!
+   //!Postconditions: This unique_ptr now owns the pointer which u owned,
+   //!and u no longer owns it.
+   //!
+   //!Returns: *this.
+   //!
+   //!Throws: nothing.
+   template <class U, class E>
+   unique_ptr& operator=(BOOST_RV_REF_2_TEMPL_ARGS(unique_ptr, U, E) u)
+   {
+      reset(u.release());
+      ptr_.second() = boost::move(u.get_deleter());
+      return *this;
+   }
+
+   //!Assigns from the literal 0 or NULL.
+   //!
+   //!Effects: reset().
+   //!
+   //!Postcondition: get() == 0
+   //!
+   //!Returns: *this.
+   //!
+   //!Throws: nothing.
+   unique_ptr& operator=(int nat::*)
+   {
+      reset();
+      return *this;
+   }
+
+   //!Requires: get() != 0.
+   //!Returns: *get().
+   //!Throws: nothing.
+   typename ipcdetail::add_reference<T>::type operator*()  const
+   {  return *ptr_.first();   }
+
+   //!Requires: get() != 0.
+   //!Returns: get().
+   //!Throws: nothing.
+   pointer operator->() const
+   {  return ptr_.first(); }
+
+   //!Returns: The stored pointer.
+   //!Throws: nothing.
+   pointer get()        const
+   {  return ptr_.first(); }
+
+   //!Returns: A reference to the stored deleter.
+   //!
+   //!Throws: nothing.
+   deleter_reference       get_deleter()       
+   {  return ptr_.second();   }
+
+   //!Returns: A const reference to the stored deleter.
+   //!
+   //!Throws: nothing.
+   deleter_const_reference get_deleter() const 
+   {  return ptr_.second();   }
+
+   //!Returns: An unspecified value that, when used in boolean
+   //!contexts, is equivalent to get() != 0.
+   //!
+   //!Throws: nothing.
+   operator int nat::*() const 
+   {  return ptr_.first() ? &nat::for_bool_ : 0;   }
+
+   //!Postcondition: get() == 0.
+   //!
+   //!Returns: The value get() had at the start of the call to release.
+   //!
+   //!Throws: nothing.
+   pointer release()
+   {
+      pointer tmp = ptr_.first();
+      ptr_.first() = 0;
+      return tmp;
+   }
+
+   //!Effects: If p == get() there are no effects. Otherwise get_deleter()(get()).
+   //!
+   //!Postconditions: get() == p.
+   //!
+   //!Throws: nothing.
+   void reset(pointer p = 0)
+   {
+      if (ptr_.first() != p){
+         if (ptr_.first())
+            ptr_.second()(ptr_.first());
+         ptr_.first() = p;
+      }
+   }
+
+   //!Requires: The deleter D is Swappable and will not throw an exception under swap.
+   //!
+   //!Effects: The stored pointers of this and u are exchanged.
+   //!   The stored deleters are swapped (unqualified).
+   //!Throws: nothing.
+   void swap(unique_ptr& u)
+   {  ptr_.swap(u.ptr_);   }
+
+   /// @cond
+   private:
+   boost::compressed_pair<pointer, D> ptr_;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(unique_ptr)
+   template <class U, class E> unique_ptr(unique_ptr<U, E>&);
+   template <class U> unique_ptr(U&, typename ipcdetail::unique_ptr_error<U>::type = 0);
+   
+   template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&);
+   template <class U> typename ipcdetail::unique_ptr_error<U>::type operator=(U&);
+   /// @endcond
+};
+/*
+template <class T, class D>
+class unique_ptr<T[], D>
+{
+    struct nat {int for_bool_;};
+    typedef typename ipcdetail::add_reference<D>::type deleter_reference;
+    typedef typename ipcdetail::add_reference<const D>::type deleter_const_reference;
+public:
+    typedef T element_type;
+    typedef D deleter_type;
+    typedef typename ipcdetail::pointer_type<T, D>::type pointer;
+
+    // constructors
+    unique_ptr() : ptr_(pointer()) {}
+    explicit unique_ptr(pointer p) : ptr_(p) {}
+    unique_ptr(pointer p, typename if_<
+                          boost::is_reference<D>,
+                          D,
+                          typename ipcdetail::add_reference<const D>::type>::type d)
+        : ptr_(p, d) {}
+    unique_ptr(const unique_ptr& u)
+        : ptr_(const_cast<unique_ptr&>(u).release(), u.get_deleter()) {}
+
+    // destructor
+    ~unique_ptr() {reset();}
+
+    // assignment
+    unique_ptr& operator=(const unique_ptr& cu)
+    {
+        unique_ptr& u = const_cast<unique_ptr&>(cu);
+        reset(u.release());
+        ptr_.second() = u.get_deleter();
+        return *this;
+    }
+    unique_ptr& operator=(int nat::*)
+    {
+        reset();
+        return *this;
+    }
+
+    // observers
+    typename ipcdetail::add_reference<T>::type operator[](std::size_t i)  const {return ptr_.first()[i];}
+    pointer get()        const {return ptr_.first();}
+    deleter_reference       get_deleter()       {return ptr_.second();}
+    deleter_const_reference get_deleter() const {return ptr_.second();}
+    operator int nat::*() const {return ptr_.first() ? &nat::for_bool_ : 0;}
+
+    // modifiers
+    pointer release()
+    {
+        pointer tmp = ptr_.first();
+        ptr_.first() = 0;
+        return tmp;
+    }
+    void reset(pointer p = 0)
+    {
+        if (ptr_.first() != p)
+        {
+            if (ptr_.first())
+                ptr_.second()(ptr_.first());
+            ptr_.first() = p;
+        }
+    }
+    void swap(unique_ptr& u) {ptr_.swap(u.ptr_);}
+private:
+    boost::compressed_pair<pointer, D> ptr_;
+
+    template <class U, class E> unique_ptr(U p, E,
+        typename boost::enable_if<boost::is_convertible<U, pointer> >::type* = 0);
+    template <class U> explicit unique_ptr(U,
+        typename boost::enable_if<boost::is_convertible<U, pointer> >::type* = 0);
+
+    unique_ptr(unique_ptr&);
+    template <class U> unique_ptr(U&, typename ipcdetail::unique_ptr_error<U>::type = 0);
+
+    unique_ptr& operator=(unique_ptr&);
+    template <class U> typename ipcdetail::unique_ptr_error<U>::type operator=(U&);
+};
+
+template <class T, class D, std::size_t N>
+class unique_ptr<T[N], D>
+{
+    struct nat {int for_bool_;};
+    typedef typename ipcdetail::add_reference<D>::type deleter_reference;
+    typedef typename ipcdetail::add_reference<const D>::type deleter_const_reference;
+public:
+    typedef T element_type;
+    typedef D deleter_type;
+    typedef typename ipcdetail::pointer_type<T, D>::type pointer;
+    static const std::size_t size = N;
+
+    // constructors
+    unique_ptr() : ptr_(0) {}
+    explicit unique_ptr(pointer p) : ptr_(p) {}
+    unique_ptr(pointer p, typename if_<
+                         boost::is_reference<D>,
+                         D,
+                         typename ipcdetail::add_reference<const D>::type>::type d)
+        : ptr_(p, d) {}
+    unique_ptr(const unique_ptr& u)
+        : ptr_(const_cast<unique_ptr&>(u).release(), u.get_deleter()) {}
+
+    // destructor
+    ~unique_ptr() {reset();}
+
+    // assignment
+    unique_ptr& operator=(const unique_ptr& cu)
+    {
+        unique_ptr& u = const_cast<unique_ptr&>(cu);
+        reset(u.release());
+        ptr_.second() = u.get_deleter();
+        return *this;
+    }
+    unique_ptr& operator=(int nat::*)
+    {
+        reset();
+        return *this;
+    }
+
+    // observers
+    typename ipcdetail::add_reference<T>::type operator[](std::size_t i)  const {return ptr_.first()[i];}
+    pointer get()        const {return ptr_.first();}
+    deleter_reference       get_deleter()       {return ptr_.second();}
+    deleter_const_reference get_deleter() const {return ptr_.second();}
+    operator int nat::*() const {return ptr_.first() ? &nat::for_bool_ : 0;}
+
+    // modifiers
+    pointer release()
+    {
+        pointer tmp = ptr_.first();
+        ptr_.first() = 0;
+        return tmp;
+    }
+    void reset(pointer p = 0)
+    {
+        if (ptr_.first() != p)
+        {
+            if (ptr_.first())
+                ptr_.second()(ptr_.first(), N);
+            ptr_.first() = p;
+        }
+    }
+    void swap(unique_ptr& u) {ptr_.swap(u.ptr_);}
+private:
+    boost::compressed_pair<pointer, D> ptr_;
+
+    template <class U, class E> unique_ptr(U p, E,
+        typename boost::enable_if<boost::is_convertible<U, pointer> >::type* = 0);
+    template <class U> explicit unique_ptr(U,
+        typename boost::enable_if<boost::is_convertible<U, pointer> >::type* = 0);
+
+    unique_ptr(unique_ptr&);
+    template <class U> unique_ptr(U&, typename ipcdetail::unique_ptr_error<U>::type = 0);
+
+    unique_ptr& operator=(unique_ptr&);
+    template <class U> typename ipcdetail::unique_ptr_error<U>::type operator=(U&);
+};
+*/
+template <class T, class D> inline
+void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y)
+{  x.swap(y);  }
+
+template <class T1, class D1, class T2, class D2> inline
+bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)
+{  return x.get() == y.get(); }
+
+template <class T1, class D1, class T2, class D2> inline
+bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)
+{  return x.get() != y.get(); }
+
+template <class T1, class D1, class T2, class D2> inline
+bool operator <(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)
+{  return x.get() < y.get();  }
+
+template <class T1, class D1, class T2, class D2> inline
+bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)
+{  return x.get() <= y.get(); }
+
+template <class T1, class D1, class T2, class D2> inline
+bool operator >(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)
+{  return x.get() > y.get();  }
+
+template <class T1, class D1, class T2, class D2> inline
+bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)
+{  return x.get() >= y.get(); }
+
+
+//!Returns the type of a unique pointer
+//!of type T with boost::interprocess::deleter deleter
+//!that can be constructed in the given managed segment type.
+template<class T, class ManagedMemory>
+struct managed_unique_ptr
+{
+   typedef unique_ptr
+   < T
+   , typename ManagedMemory::template deleter<T>::type
+   > type;
+};
+
+//!Returns an instance of a unique pointer constructed
+//!with boost::interproces::deleter from a pointer
+//!of type T that has been allocated in the passed managed segment
+template<class T, class ManagedMemory>
+inline typename managed_unique_ptr<T, ManagedMemory>::type
+   make_managed_unique_ptr(T *constructed_object, ManagedMemory &managed_memory)
+{
+   return typename managed_unique_ptr<T, ManagedMemory>::type 
+      (constructed_object, managed_memory.template get_deleter<T>());
+}
+
+}  //namespace interprocess{
+}  //namespace boost{
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_UNIQUE_PTR_HPP_INCLUDED
diff --git a/boost/interprocess/smart_ptr/weak_ptr.hpp b/boost/interprocess/smart_ptr/weak_ptr.hpp
new file mode 100644
index 0000000000..7126d055aa
--- /dev/null
+++ b/boost/interprocess/smart_ptr/weak_ptr.hpp
@@ -0,0 +1,260 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file is the adaptation for Interprocess of boost/weak_ptr.hpp
+//
+// (C) Copyright Peter Dimov 2001, 2002, 2003
+// (C) Copyright Ion Gaztanaga 2006-2011.
+// 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_WEAK_PTR_HPP_INCLUDED
+#define BOOST_INTERPROCESS_WEAK_PTR_HPP_INCLUDED
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/smart_ptr/shared_ptr.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/smart_ptr/deleter.hpp>
+#include <boost/intrusive/pointer_traits.hpp>
+
+//!\file
+//!Describes the smart pointer weak_ptr.
+
+namespace boost{
+namespace interprocess{
+
+//!The weak_ptr class template stores a "weak reference" to an object
+//!that's already managed by a shared_ptr. To access the object, a weak_ptr 
+//!can be converted to a shared_ptr using  the shared_ptr constructor or the
+//!member function  lock. When the last shared_ptr to the object goes away
+//!and the object is deleted, the attempt to obtain a shared_ptr from the
+//!weak_ptr instances that refer to the deleted object will fail: the constructor
+//!will throw an exception of type bad_weak_ptr, and weak_ptr::lock will
+//!return an empty shared_ptr.
+//!
+//!Every weak_ptr meets the CopyConstructible and Assignable requirements
+//!of the C++ Standard Library, and so can be used in standard library containers.
+//!Comparison operators are supplied so that weak_ptr works with the standard
+//!library's associative containers.
+//!
+//!weak_ptr operations never throw exceptions.
+//!
+//!The class template is parameterized on T, the type of the object pointed to.
+template<class T, class A, class D>
+class weak_ptr
+{
+   /// @cond
+   private:
+   // Borland 5.5.1 specific workarounds
+   typedef weak_ptr<T, A, D> this_type;
+   typedef typename boost::intrusive::
+      pointer_traits<typename A::pointer>::template
+         rebind_pointer<T>::type                         pointer;
+   typedef typename ipcdetail::add_reference
+                     <T>::type            reference;
+   typedef typename ipcdetail::add_reference
+                     <T>::type            const_reference;
+   /// @endcond
+
+   public:
+   typedef T element_type;
+   typedef T value_type;
+
+   //!Effects: Constructs an empty weak_ptr.
+   //!Postconditions: use_count() == 0.
+   weak_ptr()
+   : m_pn() // never throws
+   {}
+   //  generated copy constructor, assignment, destructor are fine
+   //
+   //  The "obvious" converting constructor implementation:
+   //
+   //  template<class Y>
+   //  weak_ptr(weak_ptr<Y> const & r): m_px(r.m_px), m_pn(r.m_pn) // never throws
+   //  {
+   //  }
+   //
+   //  has a serious problem.
+   //
+   //  r.m_px may already have been invalidated. The m_px(r.m_px)
+   //  conversion may require access to *r.m_px (virtual inheritance).
+   //
+   //  It is not possible to avoid spurious access violations since
+   //  in multithreaded programs r.m_px may be invalidated at any point.
+
+   //!Effects: If r is empty, constructs an empty weak_ptr; otherwise,
+   //!constructs a weak_ptr that shares ownership with r as if by storing a
+   //!copy of the pointer stored in r.
+   //!
+   //!Postconditions: use_count() == r.use_count().
+   //!
+   //!Throws: nothing.
+   template<class Y>
+   weak_ptr(weak_ptr<Y, A, D> const & r)
+      : m_pn(r.m_pn) // never throws
+   {  
+      //Construct a temporary shared_ptr so that nobody
+      //can destroy the value while constructing this
+      const shared_ptr<T, A, D> &ref = r.lock();
+      m_pn.set_pointer(ref.get()); 
+   }
+
+   //!Effects: If r is empty, constructs an empty weak_ptr; otherwise,
+   //!constructs a weak_ptr that shares ownership with r as if by storing a
+   //!copy of the pointer stored in r.
+   //!
+   //!Postconditions: use_count() == r.use_count().
+   //!
+   //!Throws: nothing.
+   template<class Y>
+   weak_ptr(shared_ptr<Y, A, D> const & r)
+      : m_pn(r.m_pn) // never throws
+   {}
+
+   //!Effects: Equivalent to weak_ptr(r).swap(*this).
+   //!
+   //!Throws: nothing.
+   //!
+   //!Notes: The implementation is free to meet the effects (and the
+   //!implied guarantees) via different means, without creating a temporary.
+   template<class Y>
+   weak_ptr & operator=(weak_ptr<Y, A, D> const & r) // never throws
+   {  
+      //Construct a temporary shared_ptr so that nobody
+      //can destroy the value while constructing this
+      const shared_ptr<T, A, D> &ref = r.lock();
+      m_pn = r.m_pn;
+      m_pn.set_pointer(ref.get());
+      return *this;
+   }
+
+   //!Effects: Equivalent to weak_ptr(r).swap(*this).
+   //!
+   //!Throws: nothing.
+   //!
+   //!Notes: The implementation is free to meet the effects (and the
+   //!implied guarantees) via different means, without creating a temporary.
+   template<class Y>
+   weak_ptr & operator=(shared_ptr<Y, A, D> const & r) // never throws
+   {  m_pn = r.m_pn;  return *this;  }
+
+   //!Returns: expired()? shared_ptr<T>(): shared_ptr<T>(*this).
+   //!
+   //!Throws: nothing.
+   shared_ptr<T, A, D> lock() const // never throws
+   {
+      // optimization: avoid throw overhead
+      if(expired()){
+         return shared_ptr<element_type, A, D>();
+      }
+      BOOST_TRY{
+         return shared_ptr<element_type, A, D>(*this);
+      }
+      BOOST_CATCH(bad_weak_ptr const &){
+         // Q: how can we get here?
+         // A: another thread may have invalidated r after the use_count test above.
+         return shared_ptr<element_type, A, D>();
+      }
+      BOOST_CATCH_END
+   }
+
+   //!Returns: 0 if *this is empty; otherwise, the number of shared_ptr objects
+   //!that share ownership with *this.
+   //!
+   //!Throws: nothing.
+   //!
+   //!Notes: use_count() is not necessarily efficient. Use only for debugging and
+   //!testing purposes, not for production code.
+   long use_count() const // never throws
+   {  return m_pn.use_count();  }
+    
+   //!Returns: Returns: use_count() == 0.
+   //!
+   //!Throws: nothing.
+   //!
+   //!Notes: expired() may be faster than use_count().
+   bool expired() const // never throws
+   {  return m_pn.use_count() == 0;   }
+
+   //!Effects: Equivalent to:
+   //!weak_ptr().swap(*this).
+   void reset() // never throws in 1.30+
+   {  this_type().swap(*this);   }
+
+   //!Effects: Exchanges the contents of the two
+   //!smart pointers.
+   //!
+   //!Throws: nothing.
+   void swap(this_type & other) // never throws
+   {  ipcdetail::do_swap(m_pn, other.m_pn);   }
+
+   /// @cond
+   template<class T2, class A2, class D2> 
+   bool _internal_less(weak_ptr<T2, A2, D2> const & rhs) const
+   {  return m_pn < rhs.m_pn;  }
+   
+   template<class Y>
+   void _internal_assign(const ipcdetail::shared_count<Y, A, D> & pn2)
+   {
+
+      m_pn = pn2;
+   }
+
+   private:
+
+   template<class T2, class A2, class D2> friend class shared_ptr;
+   template<class T2, class A2, class D2> friend class weak_ptr;
+
+   ipcdetail::weak_count<T, A, D> m_pn;      // reference counter
+   /// @endcond
+};  // weak_ptr
+
+template<class T, class A, class D, class U, class A2, class D2> inline 
+bool operator<(weak_ptr<T, A, D> const & a, weak_ptr<U, A2, D2> const & b)
+{  return a._internal_less(b);   }
+
+template<class T, class A, class D> inline
+void swap(weak_ptr<T, A, D> & a, weak_ptr<T, A, D> & b)
+{  a.swap(b);  }
+
+//!Returns the type of a weak pointer
+//!of type T with the allocator boost::interprocess::allocator allocator
+//!and boost::interprocess::deleter deleter
+//!that can be constructed in the given managed segment type.
+template<class T, class ManagedMemory>
+struct managed_weak_ptr
+{
+   typedef weak_ptr
+   < T
+   , typename ManagedMemory::template allocator<void>::type
+   , typename ManagedMemory::template deleter<T>::type
+   > type;
+};
+
+//!Returns an instance of a weak pointer constructed
+//!with the default allocator and deleter from a pointer
+//!of type T that has been allocated in the passed managed segment
+template<class T, class ManagedMemory>
+inline typename managed_weak_ptr<T, ManagedMemory>::type
+   make_managed_weak_ptr(T *constructed_object, ManagedMemory &managed_memory)
+{
+   return typename managed_weak_ptr<T, ManagedMemory>::type
+   ( constructed_object
+   , managed_memory.template get_allocator<void>()
+   , managed_memory.template get_deleter<T>()
+   );
+}
+
+} // namespace interprocess
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif  // #ifndef BOOST_INTERPROCESS_WEAK_PTR_HPP_INCLUDED
diff --git a/boost/interprocess/streams/bufferstream.hpp b/boost/interprocess/streams/bufferstream.hpp
new file mode 100644
index 0000000000..834b3d1e01
--- /dev/null
+++ b/boost/interprocess/streams/bufferstream.hpp
@@ -0,0 +1,444 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file comes from SGI's sstream file. Modified by Ion Gaztanaga 2005.
+// Changed internal SGI string to a buffer. Added efficient
+// internal buffer get/set/swap functions, so that we can obtain/establish the
+// internal buffer without any reallocation or copy. Kill those temporaries!
+///////////////////////////////////////////////////////////////////////////////
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+//!\file
+//!This file defines basic_bufferbuf, basic_ibufferstream,
+//!basic_obufferstream, and basic_bufferstream classes. These classes
+//!represent streamsbufs and streams whose sources or destinations
+//!are fixed size character buffers.
+
+#ifndef BOOST_INTERPROCESS_BUFFERSTREAM_HPP
+#define BOOST_INTERPROCESS_BUFFERSTREAM_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <string>    // char traits            
+#include <cstddef>   // ptrdiff_t
+#include <boost/assert.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+
+namespace boost {  namespace interprocess {
+
+//!A streambuf class that controls the transmission of elements to and from
+//!a basic_xbufferstream. The elements are transmitted from a to a fixed
+//!size buffer
+template <class CharT, class CharTraits>
+class basic_bufferbuf 
+   : public std::basic_streambuf<CharT, CharTraits>
+{
+   public:
+   typedef CharT                                         char_type;
+   typedef typename CharTraits::int_type                 int_type;
+   typedef typename CharTraits::pos_type                 pos_type;
+   typedef typename CharTraits::off_type                 off_type;
+   typedef CharTraits                                    traits_type;
+   typedef std::basic_streambuf<char_type, traits_type>  base_t;
+
+   public:
+   //!Constructor.
+   //!Does not throw.
+   explicit basic_bufferbuf(std::ios_base::openmode mode
+                            = std::ios_base::in | std::ios_base::out)
+      :  base_t(), m_mode(mode), m_buffer(0), m_length(0)
+      {}
+
+   //!Constructor. Assigns formatting buffer.
+   //!Does not throw.
+   explicit basic_bufferbuf(CharT *buffer, std::size_t length, 
+                            std::ios_base::openmode mode
+                              = std::ios_base::in | std::ios_base::out)
+      :  base_t(), m_mode(mode), m_buffer(buffer), m_length(length)
+      {  this->set_pointers();   }
+
+   virtual ~basic_bufferbuf(){}
+
+   public:
+   //!Returns the pointer and size of the internal buffer. 
+   //!Does not throw.
+   std::pair<CharT *, std::size_t> buffer() const
+      { return std::pair<CharT *, std::size_t>(m_buffer, m_length); }
+
+   //!Sets the underlying buffer to a new value
+   //!Does not throw.
+   void buffer(CharT *buffer, std::size_t length)
+      {  m_buffer = buffer;   m_length = length;   this->set_pointers();   }
+
+   /// @cond
+   private:
+   void set_pointers()
+   {
+      // The initial read position is the beginning of the buffer.
+      if(m_mode & std::ios_base::in)
+         this->setg(m_buffer, m_buffer, m_buffer + m_length);
+
+      // The initial write position is the beginning of the buffer.
+      if(m_mode & std::ios_base::out)
+         this->setp(m_buffer, m_buffer + m_length);
+   }
+
+   protected:
+   virtual int_type underflow()
+   {
+      // Precondition: gptr() >= egptr(). Returns a character, if available.
+      return this->gptr() != this->egptr() ?
+         CharTraits::to_int_type(*this->gptr()) : CharTraits::eof();
+   }
+
+   virtual int_type pbackfail(int_type c = CharTraits::eof())
+   {
+      if(this->gptr() != this->eback()) {
+         if(!CharTraits::eq_int_type(c, CharTraits::eof())) {
+            if(CharTraits::eq(CharTraits::to_char_type(c), this->gptr()[-1])) {
+               this->gbump(-1);
+               return c;
+            }
+            else if(m_mode & std::ios_base::out) {
+               this->gbump(-1);
+               *this->gptr() = c;
+               return c;
+            }
+            else
+               return CharTraits::eof();
+         }
+         else {
+            this->gbump(-1);
+            return CharTraits::not_eof(c);
+         }
+      }
+      else
+         return CharTraits::eof();
+   }
+
+   virtual int_type overflow(int_type c = CharTraits::eof())
+   {
+      if(m_mode & std::ios_base::out) {
+         if(!CharTraits::eq_int_type(c, CharTraits::eof())) {
+//            if(!(m_mode & std::ios_base::in)) {
+//               if(this->pptr() != this->epptr()) {
+//                  *this->pptr() = CharTraits::to_char_type(c);
+//                  this->pbump(1);
+//                  return c;
+//               }
+//               else
+//                  return CharTraits::eof();
+//            }
+//            else {
+               if(this->pptr() == this->epptr()) {
+                  //We can't append to a static buffer
+                  return CharTraits::eof();
+               }
+               else {
+                  *this->pptr() = CharTraits::to_char_type(c);
+                  this->pbump(1);
+                  return c;
+               }
+//            }
+         }
+         else  // c is EOF, so we don't have to do anything
+            return CharTraits::not_eof(c);
+      }
+      else     // Overflow always fails if it's read-only.
+         return CharTraits::eof();
+   }
+
+   virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir,
+                              std::ios_base::openmode mode 
+                                 = std::ios_base::in | std::ios_base::out)
+   {
+      bool in  = false;
+      bool out = false;
+        
+      const std::ios_base::openmode inout = 
+         std::ios_base::in | std::ios_base::out;
+
+      if((mode & inout) == inout) {
+         if(dir == std::ios_base::beg || dir == std::ios_base::end)
+            in = out = true;
+      }
+      else if(mode & std::ios_base::in)
+         in = true;
+      else if(mode & std::ios_base::out)
+         out = true;
+
+      if(!in && !out)
+         return pos_type(off_type(-1));
+      else if((in  && (!(m_mode & std::ios_base::in) || this->gptr() == 0)) ||
+               (out && (!(m_mode & std::ios_base::out) || this->pptr() == 0)))
+         return pos_type(off_type(-1));
+
+      std::streamoff newoff;
+      switch(dir) {
+         case std::ios_base::beg:
+            newoff = 0;
+         break;
+         case std::ios_base::end:
+            newoff = static_cast<std::streamoff>(m_length);
+         break;
+         case std::ios_base::cur:
+            newoff = in ? static_cast<std::streamoff>(this->gptr() - this->eback()) 
+                        : static_cast<std::streamoff>(this->pptr() - this->pbase());
+         break;
+         default:
+            return pos_type(off_type(-1));
+      }
+
+      off += newoff;
+
+      if(in) {
+         std::ptrdiff_t n = this->egptr() - this->eback();
+
+         if(off < 0 || off > n)
+            return pos_type(off_type(-1));
+         else
+            this->setg(this->eback(), this->eback() + off, this->eback() + n);
+      }
+
+      if(out) {
+         std::ptrdiff_t n = this->epptr() - this->pbase();
+
+         if(off < 0 || off > n)
+            return pos_type(off_type(-1));
+         else {
+            this->setp(this->pbase(), this->pbase() + n);
+            this->pbump(off);
+         }
+      }
+
+      return pos_type(off);
+   }
+
+   virtual pos_type seekpos(pos_type pos, std::ios_base::openmode mode 
+                                 = std::ios_base::in | std::ios_base::out)
+   {  return seekoff(pos - pos_type(off_type(0)), std::ios_base::beg, mode);  }
+
+   private:
+   std::ios_base::openmode m_mode;
+   CharT *                 m_buffer;
+   std::size_t             m_length;
+   /// @endcond
+};
+
+//!A basic_istream class that uses a fixed size character buffer
+//!as its formatting buffer.
+template <class CharT, class CharTraits>
+class basic_ibufferstream
+   : public std::basic_istream<CharT, CharTraits>
+{
+   public:                         // Typedefs
+   typedef typename std::basic_ios
+      <CharT, CharTraits>::char_type          char_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::int_type     int_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::pos_type     pos_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::off_type     off_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::traits_type  traits_type;
+
+   private:
+   typedef std::basic_ios<char_type, CharTraits>                basic_ios_t;
+   typedef std::basic_istream<char_type, CharTraits>            base_t;
+
+   public:
+   //!Constructor.
+   //!Does not throw.
+   basic_ibufferstream(std::ios_base::openmode mode = std::ios_base::in)
+      :  basic_ios_t(), base_t(0), m_buf(mode | std::ios_base::in)
+      {  basic_ios_t::init(&m_buf); }
+
+   //!Constructor. Assigns formatting buffer.
+   //!Does not throw.
+   basic_ibufferstream(const CharT *buffer, std::size_t length,
+                          std::ios_base::openmode mode = std::ios_base::in)
+      :  basic_ios_t(), base_t(0), 
+         m_buf(const_cast<CharT*>(buffer), length, mode | std::ios_base::in)
+      {  basic_ios_t::init(&m_buf); }
+
+   ~basic_ibufferstream(){};
+
+   public:
+   //!Returns the address of the stored
+   //!stream buffer.
+   basic_bufferbuf<CharT, CharTraits>* rdbuf() const
+      { return const_cast<basic_bufferbuf<CharT, CharTraits>*>(&m_buf); }
+
+   //!Returns the pointer and size of the internal buffer. 
+   //!Does not throw.
+   std::pair<const CharT *, std::size_t> buffer() const
+      { return m_buf.buffer(); }
+
+   //!Sets the underlying buffer to a new value. Resets 
+   //!stream position. Does not throw.
+   void buffer(const CharT *buffer, std::size_t length)
+      {  m_buf.buffer(const_cast<CharT*>(buffer), length);  }
+
+   /// @cond
+   private:
+   basic_bufferbuf<CharT, CharTraits> m_buf;
+   /// @endcond
+};
+
+//!A basic_ostream class that uses a fixed size character buffer
+//!as its formatting buffer.
+template <class CharT, class CharTraits>
+class basic_obufferstream
+   : public std::basic_ostream<CharT, CharTraits>
+{
+   public:
+   typedef typename std::basic_ios
+      <CharT, CharTraits>::char_type          char_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::int_type     int_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::pos_type     pos_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::off_type     off_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::traits_type  traits_type;
+
+   /// @cond
+   private:
+   typedef std::basic_ios<char_type, CharTraits>      basic_ios_t;
+   typedef std::basic_ostream<char_type, CharTraits>  base_t;
+   /// @endcond
+   public:
+   //!Constructor.
+   //!Does not throw.
+   basic_obufferstream(std::ios_base::openmode mode = std::ios_base::out)
+      :  basic_ios_t(), base_t(0), m_buf(mode | std::ios_base::out)
+      {  basic_ios_t::init(&m_buf); }
+
+   //!Constructor. Assigns formatting buffer.
+   //!Does not throw.
+   basic_obufferstream(CharT *buffer, std::size_t length,
+                       std::ios_base::openmode mode = std::ios_base::out)
+      :  basic_ios_t(), base_t(0), 
+         m_buf(buffer, length, mode | std::ios_base::out)
+      {  basic_ios_t::init(&m_buf); }
+
+   ~basic_obufferstream(){}
+
+   public:
+   //!Returns the address of the stored
+   //!stream buffer.
+   basic_bufferbuf<CharT, CharTraits>* rdbuf() const
+      { return const_cast<basic_bufferbuf<CharT, CharTraits>*>(&m_buf); }
+
+   //!Returns the pointer and size of the internal buffer. 
+   //!Does not throw.
+   std::pair<CharT *, std::size_t> buffer() const
+      { return m_buf.buffer(); }
+
+   //!Sets the underlying buffer to a new value. Resets 
+   //!stream position. Does not throw.
+   void buffer(CharT *buffer, std::size_t length)
+      {  m_buf.buffer(buffer, length);  }
+
+   /// @cond
+   private:
+   basic_bufferbuf<CharT, CharTraits> m_buf;
+   /// @endcond
+};
+
+
+//!A basic_iostream class that uses a fixed size character buffer
+//!as its formatting buffer.
+template <class CharT, class CharTraits>
+class basic_bufferstream 
+   : public std::basic_iostream<CharT, CharTraits>
+
+{
+   public:                         // Typedefs
+   typedef typename std::basic_ios
+      <CharT, CharTraits>::char_type          char_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::int_type     int_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::pos_type     pos_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::off_type     off_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::traits_type  traits_type;
+
+   /// @cond
+   private:
+   typedef std::basic_ios<char_type, CharTraits>                 basic_ios_t;
+   typedef std::basic_iostream<char_type, CharTraits>            base_t;
+   /// @endcond
+
+   public:
+   //!Constructor.
+   //!Does not throw.
+   basic_bufferstream(std::ios_base::openmode mode 
+                      = std::ios_base::in | std::ios_base::out)
+      :  basic_ios_t(), base_t(0), m_buf(mode)
+      {  basic_ios_t::init(&m_buf); }
+
+   //!Constructor. Assigns formatting buffer.
+   //!Does not throw.
+   basic_bufferstream(CharT *buffer, std::size_t length,
+                      std::ios_base::openmode mode
+                        = std::ios_base::in | std::ios_base::out)
+      :  basic_ios_t(), base_t(0), m_buf(buffer, length, mode)
+      {  basic_ios_t::init(&m_buf); }
+
+   ~basic_bufferstream(){}
+
+   public:
+   //!Returns the address of the stored
+   //!stream buffer.
+   basic_bufferbuf<CharT, CharTraits>* rdbuf() const
+      { return const_cast<basic_bufferbuf<CharT, CharTraits>*>(&m_buf); }
+
+   //!Returns the pointer and size of the internal buffer. 
+   //!Does not throw.
+   std::pair<CharT *, std::size_t> buffer() const
+      { return m_buf.buffer(); }
+
+   //!Sets the underlying buffer to a new value. Resets 
+   //!stream position. Does not throw.
+   void buffer(CharT *buffer, std::size_t length)
+      {  m_buf.buffer(buffer, length);  }
+
+   /// @cond
+   private:
+   basic_bufferbuf<CharT, CharTraits> m_buf;
+   /// @endcond
+};
+
+//Some typedefs to simplify usage
+typedef basic_bufferbuf<char>        bufferbuf;
+typedef basic_bufferstream<char>     bufferstream;
+typedef basic_ibufferstream<char>    ibufferstream;
+typedef basic_obufferstream<char>    obufferstream;
+
+typedef basic_bufferbuf<wchar_t>     wbufferbuf;
+typedef basic_bufferstream<wchar_t>  wbufferstream;
+typedef basic_ibufferstream<wchar_t> wibufferstream;
+typedef basic_obufferstream<wchar_t> wobufferstream;
+
+
+}} //namespace boost {  namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif /* BOOST_INTERPROCESS_BUFFERSTREAM_HPP */
diff --git a/boost/interprocess/streams/vectorstream.hpp b/boost/interprocess/streams/vectorstream.hpp
new file mode 100644
index 0000000000..83041f2b2e
--- /dev/null
+++ b/boost/interprocess/streams/vectorstream.hpp
@@ -0,0 +1,601 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file comes from SGI's sstream file. Modified by Ion Gaztanaga 2005.
+// Changed internal SGI string to a generic, templatized vector. Added efficient
+// internal buffer get/set/swap functions, so that we can obtain/establish the
+// internal buffer without any reallocation or copy. Kill those temporaries!
+///////////////////////////////////////////////////////////////////////////////
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+//!\file
+//!This file defines basic_vectorbuf, basic_ivectorstream,
+//!basic_ovectorstream, and basic_vectorstreamclasses.  These classes
+//!represent streamsbufs and streams whose sources or destinations are
+//!STL-like vectors that can be swapped with external vectors to avoid 
+//!unnecessary allocations/copies.
+
+#ifndef BOOST_INTERPROCESS_VECTORSTREAM_HPP
+#define BOOST_INTERPROCESS_VECTORSTREAM_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+#include <string>    // char traits            
+#include <cstddef>   // ptrdiff_t
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {  namespace interprocess {
+
+//!A streambuf class that controls the transmission of elements to and from
+//!a basic_ivectorstream, basic_ovectorstream or basic_vectorstream. 
+//!It holds a character vector specified by CharVector template parameter
+//!as its formatting buffer. The vector must have contiguous storage, like 
+//!std::vector, boost::interprocess::vector or boost::interprocess::basic_string
+template <class CharVector, class CharTraits>
+class basic_vectorbuf
+   : public std::basic_streambuf<typename CharVector::value_type, CharTraits>
+{
+   public:
+   typedef CharVector                        vector_type;
+   typedef typename CharVector::value_type   char_type;
+   typedef typename CharTraits::int_type     int_type;
+   typedef typename CharTraits::pos_type     pos_type;
+   typedef typename CharTraits::off_type     off_type;
+   typedef CharTraits                        traits_type;
+
+   /// @cond
+   private:
+   typedef std::basic_streambuf<char_type, traits_type> base_t;
+
+   basic_vectorbuf(const basic_vectorbuf&);
+   basic_vectorbuf & operator =(const basic_vectorbuf&);
+   /// @endcond
+
+   public:
+   //!Constructor. Throws if vector_type default
+   //!constructor throws.
+   explicit basic_vectorbuf(std::ios_base::openmode mode
+                              = std::ios_base::in | std::ios_base::out)
+      :  base_t(), m_mode(mode)
+   {  this->initialize_pointers();   }
+
+   //!Constructor. Throws if
+   //!vector_type(const VectorParameter &param) throws.
+   template<class VectorParameter>
+   explicit basic_vectorbuf(const VectorParameter &param,
+                            std::ios_base::openmode mode
+                                 = std::ios_base::in | std::ios_base::out)
+      :  base_t(), m_mode(mode), m_vect(param)
+   {  this->initialize_pointers();   }
+
+   virtual ~basic_vectorbuf(){}
+
+   public:
+
+   //!Swaps the underlying vector with the passed vector. 
+   //!This function resets the read/write position in the stream.
+   //!Does not throw.
+   void swap_vector(vector_type &vect)
+   {  
+      if (this->m_mode & std::ios_base::out){
+         //Update high water if necessary
+         //And resize vector to remove extra size
+         if (mp_high_water < base_t::pptr()){
+            //Restore the vector's size if necessary
+            mp_high_water = base_t::pptr();
+         }
+         //This does not reallocate
+         m_vect.resize(mp_high_water - (m_vect.size() ? &m_vect[0] : 0));
+      }
+      //Now swap vector
+      m_vect.swap(vect);
+      this->initialize_pointers();
+   }
+
+   //!Returns a const reference to the internal vector.
+   //!Does not throw.
+   const vector_type &vector() const 
+   {  
+      if (this->m_mode & std::ios_base::out){
+         if (mp_high_water < base_t::pptr()){
+            //Restore the vector's size if necessary
+            mp_high_water = base_t::pptr();
+         }
+         //This shouldn't reallocate
+         typedef typename vector_type::size_type size_type;
+         char_type *old_ptr = base_t::pbase();
+         size_type high_pos = size_type(mp_high_water-old_ptr);
+         if(m_vect.size() > high_pos){
+            m_vect.resize(high_pos);
+            //But we must update end write pointer because vector size is now shorter
+            int old_pos = base_t::pptr() - base_t::pbase();
+            const_cast<basic_vectorbuf*>(this)->base_t::setp(old_ptr, old_ptr + high_pos);
+            const_cast<basic_vectorbuf*>(this)->base_t::pbump(old_pos);
+         }
+      }
+      return m_vect; 
+   }
+
+   //!Preallocates memory from the internal vector.
+   //!Resets the stream to the first position.
+   //!Throws if the internals vector's memory allocation throws.
+   void reserve(typename vector_type::size_type size) 
+   {
+      if (this->m_mode & std::ios_base::out && size > m_vect.size()){
+         typename vector_type::difference_type write_pos = base_t::pptr() - base_t::pbase();
+         typename vector_type::difference_type read_pos  = base_t::gptr() - base_t::eback();
+         //Now update pointer data
+         m_vect.reserve(size);
+         this->initialize_pointers();
+         base_t::pbump((int)write_pos);
+         if(this->m_mode & std::ios_base::in){
+            base_t::gbump((int)read_pos);
+         }
+      }
+   }
+
+   //!Calls clear() method of the internal vector.
+   //!Resets the stream to the first position.
+   void clear()
+   {  m_vect.clear();   this->initialize_pointers();   }
+
+   /// @cond
+   private:
+   //Maximizes high watermark to the initial vector size,
+   //initializes read and write iostream buffers to the capacity
+   //and resets stream positions
+   void initialize_pointers()
+   {
+      // The initial read position is the beginning of the vector.
+      if(!(m_mode & std::ios_base::out)){
+         if(m_vect.empty()){
+            this->setg(0, 0, 0);
+         }
+         else{
+            this->setg(&m_vect[0], &m_vect[0], &m_vect[0] + m_vect.size());
+         }
+      }
+
+      // The initial write position is the beginning of the vector.
+      if(m_mode & std::ios_base::out){
+         //First get real size
+         int real_size = (int)m_vect.size();
+         //Then maximize size for high watermarking
+         m_vect.resize(m_vect.capacity());
+         BOOST_ASSERT(m_vect.size() == m_vect.capacity());
+         //Set high watermarking with the expanded size
+         mp_high_water = m_vect.size() ? (&m_vect[0] + real_size) : 0;
+         //Now set formatting pointers
+         if(m_vect.empty()){
+            this->setp(0, 0);
+            if(m_mode & std::ios_base::in)
+               this->setg(0, 0, 0);
+         }
+         else{
+            char_type *p = &m_vect[0];
+            this->setp(p, p + m_vect.size());
+            if(m_mode & std::ios_base::in)
+               this->setg(p, p, p + real_size);
+         }
+         if (m_mode & (std::ios_base::app | std::ios_base::ate)){
+            base_t::pbump((int)real_size);
+         }
+      }
+   }
+
+   protected:
+   virtual int_type underflow()
+   {
+      if (base_t::gptr() == 0)
+         return CharTraits::eof();
+      if(m_mode & std::ios_base::out){
+         if (mp_high_water < base_t::pptr())
+            mp_high_water = base_t::pptr();
+         if (base_t::egptr() < mp_high_water)
+            base_t::setg(base_t::eback(), base_t::gptr(), mp_high_water);
+      }
+      if (base_t::gptr() < base_t::egptr())
+         return CharTraits::to_int_type(*base_t::gptr());
+      return CharTraits::eof();
+   }
+
+   virtual int_type pbackfail(int_type c = CharTraits::eof())
+   {
+      if(this->gptr() != this->eback()) {
+         if(!CharTraits::eq_int_type(c, CharTraits::eof())) {
+            if(CharTraits::eq(CharTraits::to_char_type(c), this->gptr()[-1])) {
+               this->gbump(-1);
+               return c;
+            }
+            else if(m_mode & std::ios_base::out) {
+               this->gbump(-1);
+               *this->gptr() = c;
+               return c;
+            }
+            else
+               return CharTraits::eof();
+         }
+         else {
+            this->gbump(-1);
+            return CharTraits::not_eof(c);
+         }
+      }
+      else
+         return CharTraits::eof();
+   }
+
+   virtual int_type overflow(int_type c = CharTraits::eof())
+   {
+      if(m_mode & std::ios_base::out) {
+         if(!CharTraits::eq_int_type(c, CharTraits::eof())) {
+               typedef typename vector_type::difference_type dif_t;
+               //The new output position is the previous one plus one
+               //because 'overflow' requires putting 'c' on the buffer
+               dif_t new_outpos = base_t::pptr() - base_t::pbase() + 1;
+               //Adjust high water if necessary
+               dif_t hipos = mp_high_water - base_t::pbase();
+               if (hipos < new_outpos)
+                  hipos = new_outpos;
+               //Insert the new data
+               m_vect.push_back(CharTraits::to_char_type(c));
+               m_vect.resize(m_vect.capacity());
+               BOOST_ASSERT(m_vect.size() == m_vect.capacity());
+               char_type* p = const_cast<char_type*>(&m_vect[0]);
+               //A reallocation might have happened, update pointers
+               base_t::setp(p, p + (dif_t)m_vect.size());
+               mp_high_water = p + hipos;
+               if (m_mode & std::ios_base::in)
+                  base_t::setg(p, p + (base_t::gptr() - base_t::eback()), mp_high_water);
+               //Update write position to the old position + 1
+               base_t::pbump((int)new_outpos);
+               return c;
+         }
+         else  // c is EOF, so we don't have to do anything
+            return CharTraits::not_eof(c);
+      }
+      else     // Overflow always fails if it's read-only.
+         return CharTraits::eof();
+   }
+
+   virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir,
+                              std::ios_base::openmode mode 
+                                 = std::ios_base::in | std::ios_base::out)
+   {
+      //Get seek mode
+      bool in(0 != (mode & std::ios_base::in)), out(0 != (mode & std::ios_base::out));
+      //Test for logic errors
+      if(!in & !out)
+         return pos_type(off_type(-1));
+      else if((in && out) && (dir == std::ios_base::cur))
+         return pos_type(off_type(-1));
+      else if((in  && (!(m_mode & std::ios_base::in) || this->gptr() == 0)) ||
+               (out && (!(m_mode & std::ios_base::out) || this->pptr() == 0)))
+         return pos_type(off_type(-1));
+
+      off_type newoff;
+      //Just calculate the end of the stream. If the stream is read-only
+      //the limit is the size of the vector. Otherwise, the high water mark
+      //will mark the real size.
+      off_type limit;
+      if(m_mode & std::ios_base::out){
+         //Update high water marking because pptr() is going to change and it might
+         //have been updated since last overflow()
+         if(mp_high_water < base_t::pptr())
+            mp_high_water = base_t::pptr();
+         //Update read limits in case high water mark was changed
+         if(m_mode & std::ios_base::in){
+            if (base_t::egptr() < mp_high_water)
+               base_t::setg(base_t::eback(), base_t::gptr(), mp_high_water);
+         }
+         limit = static_cast<off_type>(mp_high_water - base_t::pbase());
+      }
+      else{
+         limit = static_cast<off_type>(m_vect.size());
+      }
+
+      switch(dir) {
+         case std::ios_base::beg:
+            newoff = 0;
+         break;
+         case std::ios_base::end:
+            newoff = limit;
+         break;
+         case std::ios_base::cur:
+            newoff = in ? static_cast<std::streamoff>(this->gptr() - this->eback()) 
+                        : static_cast<std::streamoff>(this->pptr() - this->pbase());
+         break;
+         default:
+            return pos_type(off_type(-1));
+      }
+
+      newoff += off;
+
+      if (newoff < 0 || newoff > limit)
+         return pos_type(-1);
+      if (m_mode & std::ios_base::app && mode & std::ios_base::out && newoff != limit)
+         return pos_type(-1);
+      //This can reassign pointers
+      //if(m_vect.size() != m_vect.capacity())
+         //this->initialize_pointers();
+      if (in)
+         base_t::setg(base_t::eback(), base_t::eback() + newoff, base_t::egptr());
+      if (out){
+         base_t::setp(base_t::pbase(), base_t::epptr());
+         base_t::pbump(newoff);
+      }
+      return pos_type(newoff);
+   }
+
+   virtual pos_type seekpos(pos_type pos, std::ios_base::openmode mode 
+                                 = std::ios_base::in | std::ios_base::out)
+   {  return seekoff(pos - pos_type(off_type(0)), std::ios_base::beg, mode);  }
+
+   private:
+   std::ios_base::openmode m_mode;
+   mutable vector_type     m_vect;
+   mutable char_type*      mp_high_water;
+   /// @endcond
+};
+
+//!A basic_istream class that holds a character vector specified by CharVector
+//!template parameter as its formatting buffer. The vector must have
+//!contiguous storage, like std::vector, boost::interprocess::vector or
+//!boost::interprocess::basic_string
+template <class CharVector, class CharTraits>
+class basic_ivectorstream
+   /// @cond
+   : private basic_vectorbuf<CharVector, CharTraits>
+   /// @endcond
+   , public std::basic_istream<typename CharVector::value_type, CharTraits>
+{
+   public:
+   typedef CharVector                                                   vector_type;
+   typedef typename std::basic_ios
+      <typename CharVector::value_type, CharTraits>::char_type          char_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::int_type     int_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::pos_type     pos_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::off_type     off_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::traits_type  traits_type;
+
+   /// @cond
+   private:
+   typedef basic_vectorbuf<CharVector, CharTraits>    vectorbuf_t;
+   typedef std::basic_istream<char_type, CharTraits>  base_t;
+
+   vectorbuf_t &       m_buf()      {  return *this;  }
+   const vectorbuf_t & m_buf() const{  return *this;  }
+   /// @endcond
+
+   public:
+   //!Constructor. Throws if vector_type default
+   //!constructor throws.
+   basic_ivectorstream(std::ios_base::openmode mode = std::ios_base::in)
+      :  vectorbuf_t(mode | std::ios_base::in), base_t(&m_buf())
+   {}
+
+   //!Constructor. Throws if vector_type(const VectorParameter &param)
+   //!throws.
+   template<class VectorParameter>
+   basic_ivectorstream(const VectorParameter &param,
+                       std::ios_base::openmode mode = std::ios_base::in)
+      :  vectorbuf_t(param, mode | std::ios_base::in), base_t(&m_buf())
+   {}
+
+   ~basic_ivectorstream(){};
+
+   public:
+   //!Returns the address of the stored
+   //!stream buffer.
+   basic_vectorbuf<CharVector, CharTraits>* rdbuf() const
+   { return const_cast<basic_vectorbuf<CharVector, CharTraits>*>(&m_buf()); }
+
+   //!Swaps the underlying vector with the passed vector. 
+   //!This function resets the read position in the stream.
+   //!Does not throw.
+   void swap_vector(vector_type &vect)
+   {  m_buf().swap_vector(vect);   }
+
+   //!Returns a const reference to the internal vector.
+   //!Does not throw.
+   const vector_type &vector() const 
+   {  return m_buf().vector();   }
+
+   //!Calls reserve() method of the internal vector.
+   //!Resets the stream to the first position.
+   //!Throws if the internals vector's reserve throws.
+   void reserve(typename vector_type::size_type size) 
+   {  m_buf().reserve(size);   }
+
+   //!Calls clear() method of the internal vector.
+   //!Resets the stream to the first position.
+   void clear() 
+   {  m_buf().clear();   }
+};
+
+//!A basic_ostream class that holds a character vector specified by CharVector
+//!template parameter as its formatting buffer. The vector must have
+//!contiguous storage, like std::vector, boost::interprocess::vector or
+//!boost::interprocess::basic_string
+template <class CharVector, class CharTraits>
+class basic_ovectorstream
+   /// @cond
+   : private basic_vectorbuf<CharVector, CharTraits>
+   /// @endcond
+   , public std::basic_ostream<typename CharVector::value_type, CharTraits>
+{
+   public:
+   typedef CharVector                                                   vector_type;
+   typedef typename std::basic_ios
+      <typename CharVector::value_type, CharTraits>::char_type          char_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::int_type     int_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::pos_type     pos_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::off_type     off_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::traits_type  traits_type;
+
+   /// @cond
+   private:
+   typedef basic_vectorbuf<CharVector, CharTraits>    vectorbuf_t;
+   typedef std::basic_ostream<char_type, CharTraits>  base_t;
+
+   vectorbuf_t &       m_buf()      {  return *this;  }
+   const vectorbuf_t & m_buf()const {  return *this;  }
+   /// @endcond
+
+   public:
+   //!Constructor. Throws if vector_type default
+   //!constructor throws.
+   basic_ovectorstream(std::ios_base::openmode mode = std::ios_base::out)
+      :  vectorbuf_t(mode | std::ios_base::out), base_t(&m_buf())
+   {}
+
+   //!Constructor. Throws if vector_type(const VectorParameter &param)
+   //!throws.
+   template<class VectorParameter>
+   basic_ovectorstream(const VectorParameter &param,
+                        std::ios_base::openmode mode = std::ios_base::out)
+      :  vectorbuf_t(param, mode | std::ios_base::out), base_t(&m_buf())
+   {}
+
+   ~basic_ovectorstream(){}
+
+   public:
+   //!Returns the address of the stored
+   //!stream buffer.
+   basic_vectorbuf<CharVector, CharTraits>* rdbuf() const
+   { return const_cast<basic_vectorbuf<CharVector, CharTraits>*>(&m_buf()); }
+
+   //!Swaps the underlying vector with the passed vector. 
+   //!This function resets the write position in the stream.
+   //!Does not throw.
+   void swap_vector(vector_type &vect)
+   {  m_buf().swap_vector(vect);   }
+
+   //!Returns a const reference to the internal vector.
+   //!Does not throw.
+   const vector_type &vector() const 
+   {  return m_buf().vector();   }
+
+   //!Calls reserve() method of the internal vector.
+   //!Resets the stream to the first position.
+   //!Throws if the internals vector's reserve throws.
+   void reserve(typename vector_type::size_type size) 
+   {  m_buf().reserve(size);   }
+};
+
+
+//!A basic_iostream class that holds a character vector specified by CharVector
+//!template parameter as its formatting buffer. The vector must have
+//!contiguous storage, like std::vector, boost::interprocess::vector or
+//!boost::interprocess::basic_string
+template <class CharVector, class CharTraits>
+class basic_vectorstream
+   : public std::basic_iostream<typename CharVector::value_type, CharTraits>
+
+{
+   public:
+   typedef CharVector                                                   vector_type;
+   typedef typename std::basic_ios
+      <typename CharVector::value_type, CharTraits>::char_type          char_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::int_type     int_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::pos_type     pos_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::off_type     off_type;
+   typedef typename std::basic_ios<char_type, CharTraits>::traits_type  traits_type;
+
+   /// @cond
+   private:
+   typedef std::basic_ios<char_type, CharTraits>                 basic_ios_t;
+   typedef std::basic_iostream<char_type, CharTraits>            base_t;
+   /// @endcond
+
+   public:
+   //!Constructor. Throws if vector_type default
+   //!constructor throws.
+   basic_vectorstream(std::ios_base::openmode mode 
+                      = std::ios_base::in | std::ios_base::out)
+      :  basic_ios_t(), base_t(0), m_buf(mode)
+   {  basic_ios_t::init(&m_buf); }
+
+   //!Constructor. Throws if vector_type(const VectorParameter &param)
+   //!throws.
+   template<class VectorParameter>
+   basic_vectorstream(const VectorParameter &param, std::ios_base::openmode mode
+                      = std::ios_base::in | std::ios_base::out)
+      :  basic_ios_t(), base_t(0), m_buf(param, mode)
+   {  basic_ios_t::init(&m_buf); }
+
+   ~basic_vectorstream(){}
+
+   public:
+   //Returns the address of the stored stream buffer.
+   basic_vectorbuf<CharVector, CharTraits>* rdbuf() const
+   { return const_cast<basic_vectorbuf<CharVector, CharTraits>*>(&m_buf); }
+
+   //!Swaps the underlying vector with the passed vector. 
+   //!This function resets the read/write position in the stream.
+   //!Does not throw.
+   void swap_vector(vector_type &vect)
+   {  m_buf.swap_vector(vect);   }
+
+   //!Returns a const reference to the internal vector.
+   //!Does not throw.
+   const vector_type &vector() const 
+   {  return m_buf.vector();   }
+
+   //!Calls reserve() method of the internal vector.
+   //!Resets the stream to the first position.
+   //!Throws if the internals vector's reserve throws.
+   void reserve(typename vector_type::size_type size) 
+   {  m_buf.reserve(size);   }
+
+   //!Calls clear() method of the internal vector.
+   //!Resets the stream to the first position.
+   void clear() 
+   {  m_buf.clear();   }
+
+   /// @cond
+   private:
+   basic_vectorbuf<CharVector, CharTraits> m_buf;
+   /// @endcond
+};
+
+//Some typedefs to simplify usage
+//!
+//!typedef basic_vectorbuf<std::vector<char> >        vectorbuf;
+//!typedef basic_vectorstream<std::vector<char> >     vectorstream;
+//!typedef basic_ivectorstream<std::vector<char> >    ivectorstream;
+//!typedef basic_ovectorstream<std::vector<char> >    ovectorstream;
+//!
+//!typedef basic_vectorbuf<std::vector<wchar_t> >     wvectorbuf;
+//!typedef basic_vectorstream<std::vector<wchar_t> >  wvectorstream;
+//!typedef basic_ivectorstream<std::vector<wchar_t> > wivectorstream;
+//!typedef basic_ovectorstream<std::vector<wchar_t> > wovectorstream;
+
+}} //namespace boost {  namespace interprocess {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif /* BOOST_INTERPROCESS_VECTORSTREAM_HPP */
diff --git a/boost/interprocess/sync/file_lock.hpp b/boost/interprocess/sync/file_lock.hpp
new file mode 100644
index 0000000000..a60b814a4f
--- /dev/null
+++ b/boost/interprocess/sync/file_lock.hpp
@@ -0,0 +1,305 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_FILE_LOCK_HPP
+#define BOOST_INTERPROCESS_FILE_LOCK_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/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/move/move.hpp>
+
+//!\file
+//!Describes a class that wraps file locking capabilities.
+
+namespace boost {
+namespace interprocess {
+
+
+//!A file lock, is a mutual exclusion utility similar to a mutex using a
+//!file. A file lock has sharable and exclusive locking capabilities and
+//!can be used with scoped_lock and sharable_lock classes.
+//!A file lock can't guarantee synchronization between threads of the same
+//!process so just use file locks to synchronize threads from different processes.
+class file_lock
+{
+   /// @cond
+   //Non-copyable
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(file_lock)
+   /// @endcond
+
+   public:
+   //!Constructs an empty file mapping.
+   //!Does not throw
+   file_lock()
+      :  m_file_hnd(file_handle_t(ipcdetail::invalid_file()))
+   {}
+
+   //!Opens a file lock. Throws interprocess_exception if the file does not
+   //!exist or there are no operating system resources.
+   file_lock(const char *name);
+
+   //!Moves the ownership of "moved"'s file mapping object to *this. 
+   //!After the call, "moved" does not represent any file mapping object. 
+   //!Does not throw
+   file_lock(BOOST_RV_REF(file_lock) moved)
+      :  m_file_hnd(file_handle_t(ipcdetail::invalid_file()))
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s file mapping to *this.
+   //!After the call, "moved" does not represent any file mapping. 
+   //!Does not throw
+   file_lock &operator=(BOOST_RV_REF(file_lock) moved)
+   {  
+      file_lock tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Closes a file lock. Does not throw.
+   ~file_lock();
+
+   //!Swaps two file_locks.
+   //!Does not throw.
+   void swap(file_lock &other)
+   {
+      file_handle_t tmp = m_file_hnd;
+      m_file_hnd = other.m_file_hnd;
+      other.m_file_hnd = tmp;
+   }
+   
+   //Exclusive locking
+
+   //!Effects: The calling thread tries to obtain exclusive ownership of the mutex,
+   //!   and if another thread has exclusive, or sharable ownership of
+   //!   the mutex, it waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   without waiting. If no other thread has exclusive, or sharable
+   //!   ownership of the mutex this succeeds.
+   //!Returns: If it can acquire exclusive ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive, or sharable
+   //!   ownership of the mutex or abs_time is reached.
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The calling thread releases the exclusive ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock();
+
+   //Sharable locking
+
+   //!Effects: The calling thread tries to obtain sharable ownership of the mutex,
+   //!   and if another thread has exclusive ownership of the mutex, waits until
+   //!   it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive ownership of the
+   //!   mutex this succeeds. 
+   //!Returns: If it can acquire sharable ownership immediately returns true. If it
+   //!   has to wait, returns false. 
+   //!Throws: interprocess_exception on error.
+   bool try_lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive ownership of
+   //!   the mutex or abs_time is reached. 
+   //!Returns: If acquires sharable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_sharable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The calling thread releases the sharable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_sharable();
+   /// @cond
+   private:
+   file_handle_t m_file_hnd;
+
+   bool timed_acquire_file_lock
+      (file_handle_t hnd, bool &acquired, const boost::posix_time::ptime &abs_time)
+   {
+      //Obtain current count and target time
+      boost::posix_time::ptime now = microsec_clock::universal_time();
+      using namespace boost::detail;
+
+      if(now >= abs_time) return false;
+
+      do{
+         if(!ipcdetail::try_acquire_file_lock(hnd, acquired))
+            return false;
+
+         if(acquired)
+            return true;
+         else{
+            now = microsec_clock::universal_time();
+
+            if(now >= abs_time){
+               acquired = false;
+               return true;
+            }
+            // relinquish current time slice
+            ipcdetail::thread_yield();
+         }
+      }while (true);
+   }
+
+   bool timed_acquire_file_lock_sharable
+      (file_handle_t hnd, bool &acquired, const boost::posix_time::ptime &abs_time)
+   {  
+      //Obtain current count and target time
+      boost::posix_time::ptime now = microsec_clock::universal_time();
+      using namespace boost::detail;
+
+      if(now >= abs_time) return false;
+
+      do{
+         if(!ipcdetail::try_acquire_file_lock_sharable(hnd, acquired))
+            return false;
+
+         if(acquired)
+            return true;
+         else{
+            now = microsec_clock::universal_time();
+
+            if(now >= abs_time){
+               acquired = false;
+               return true;
+            }
+            // relinquish current time slice
+            ipcdetail::thread_yield();
+         }
+      }while (true);
+   }
+   /// @endcond
+};
+
+inline file_lock::file_lock(const char *name)
+{
+   m_file_hnd = ipcdetail::open_existing_file(name, read_write);
+
+   if(m_file_hnd == ipcdetail::invalid_file()){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+inline file_lock::~file_lock()
+{
+   if(m_file_hnd != ipcdetail::invalid_file()){
+      ipcdetail::close_file(m_file_hnd);
+      m_file_hnd = ipcdetail::invalid_file();
+   }
+}
+
+inline void file_lock::lock()
+{
+   if(!ipcdetail::acquire_file_lock(m_file_hnd)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+inline bool file_lock::try_lock()
+{
+   bool result;
+   if(!ipcdetail::try_acquire_file_lock(m_file_hnd, result)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+   return result;
+}
+
+inline bool file_lock::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   bool result;
+   if(!this->timed_acquire_file_lock(m_file_hnd, result, abs_time)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+   return result;
+}
+
+inline void file_lock::unlock()
+{
+   if(!ipcdetail::release_file_lock(m_file_hnd)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+inline void file_lock::lock_sharable()
+{
+   if(!ipcdetail::acquire_file_lock_sharable(m_file_hnd)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+inline bool file_lock::try_lock_sharable()
+{
+   bool result;
+   if(!ipcdetail::try_acquire_file_lock_sharable(m_file_hnd, result)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+   return result;
+}
+
+inline bool file_lock::timed_lock_sharable(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_sharable();
+      return true;
+   }
+   bool result;
+   if(!this->timed_acquire_file_lock_sharable(m_file_hnd, result, abs_time)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+   return result;
+}
+
+inline void file_lock::unlock_sharable()
+{
+   if(!ipcdetail::release_file_lock_sharable(m_file_hnd)){
+      error_info err(system_error_code());
+      throw interprocess_exception(err);
+   }
+}
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_FILE_LOCK_HPP
diff --git a/boost/interprocess/sync/interprocess_condition.hpp b/boost/interprocess/sync/interprocess_condition.hpp
new file mode 100644
index 0000000000..b0e74fc342
--- /dev/null
+++ b/boost/interprocess/sync/interprocess_condition.hpp
@@ -0,0 +1,172 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_CONDITION_HPP
+#define BOOST_INTERPROCESS_CONDITION_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+/// @cond
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/limits.hpp>
+#include <boost/assert.hpp>
+
+#if !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED)
+   #include <boost/interprocess/sync/posix/condition.hpp>
+   #define BOOST_INTERPROCESS_USE_POSIX
+//Experimental...
+//#elif !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && defined (BOOST_INTERPROCESS_WINDOWS)
+//   #include <boost/interprocess/sync/windows/condition.hpp>
+//   #define BOOST_INTERPROCESS_USE_WINDOWS
+#elif !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   #include <boost/interprocess/sync/spin/condition.hpp>
+   #define BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+#endif
+
+/// @endcond
+
+//!\file
+//!Describes process-shared variables interprocess_condition class
+
+namespace boost {
+
+namespace posix_time
+{  class ptime;   }
+
+namespace interprocess {
+
+class named_condition;
+
+//!This class is a condition variable that can be placed in shared memory or
+//!memory mapped files.
+class interprocess_condition
+{
+   /// @cond
+   //Non-copyable
+   interprocess_condition(const interprocess_condition &);
+   interprocess_condition &operator=(const interprocess_condition &);
+   friend class named_condition;
+   /// @endcond
+   public:
+   //!Constructs a interprocess_condition. On error throws interprocess_exception.
+   interprocess_condition(){}
+
+   //!Destroys *this
+   //!liberating system resources.
+   ~interprocess_condition(){}
+
+   //!If there is a thread waiting on *this, change that 
+   //!thread's state to ready. Otherwise there is no effect.
+   void notify_one()
+   {  m_condition.notify_one();  }
+
+   //!Change the state of all threads waiting on *this to ready.
+   //!If there are no waiting threads, notify_all() has no effect.
+   void notify_all()
+   {  m_condition.notify_all();  }
+
+   //!Releases the lock on the interprocess_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), and then reacquires the lock.
+   template <typename L>
+   void wait(L& lock)
+   {
+      if (!lock)
+         throw lock_exception();
+      this->do_wait(*lock.mutex());
+   }
+
+   //!The same as:
+   //!while (!pred()) wait(lock)
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred)
+   {
+      if (!lock)
+         throw lock_exception();
+
+      while (!pred())
+         this->do_wait(*lock.mutex());
+   }
+
+   //!Releases the lock on the interprocess_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), or until time abs_time is reached, 
+   //!and then reacquires the lock.
+   //!Returns: false if time abs_time is reached, otherwise true.
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock);
+         return true;
+      }
+      if (!lock)
+            throw lock_exception();
+      return this->do_timed_wait(abs_time, *lock.mutex());
+   }
+
+   //!The same as:   while (!pred()) { 
+   //!                  if (!timed_wait(lock, abs_time)) return pred(); 
+   //!               } return true;
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock, pred);
+         return true;
+      }
+      if (!lock)
+            throw lock_exception();
+      while (!pred()){
+         if (!this->do_timed_wait(abs_time, *lock.mutex()))
+            return pred();
+      }
+
+      return true;
+   }
+
+   /// @cond
+
+   void do_wait(interprocess_mutex &mut)
+   {  m_condition.do_wait(mut.mutex);  }
+
+   bool do_timed_wait(const boost::posix_time::ptime &abs_time, interprocess_mutex &mut)
+   {  return m_condition.do_timed_wait(abs_time, mut.mutex);  }
+
+   private:
+   #if defined (BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+      #undef BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+      ipcdetail::spin_condition m_condition;
+   #elif defined(BOOST_INTERPROCESS_USE_POSIX)
+      #undef BOOST_INTERPROCESS_USE_POSIX
+      ipcdetail::posix_condition m_condition;
+   #elif defined(BOOST_INTERPROCESS_USE_WINDOWS)
+      #undef BOOST_INTERPROCESS_USE_WINDOWS
+      ipcdetail::windows_condition m_condition;
+   #else
+      #error "Unknown platform for interprocess_mutex"
+   #endif
+   /// @endcond
+};
+
+}  //namespace interprocess
+}  // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_CONDITION_HPP
diff --git a/boost/interprocess/sync/interprocess_mutex.hpp b/boost/interprocess/sync/interprocess_mutex.hpp
new file mode 100644
index 0000000000..478cf78cc3
--- /dev/null
+++ b/boost/interprocess/sync/interprocess_mutex.hpp
@@ -0,0 +1,170 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Parts of the pthread code come from Boost Threads code.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_MUTEX_HPP
+#define BOOST_INTERPROCESS_MUTEX_HPP
+
+/// @cond
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/assert.hpp>
+
+#if !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && defined (BOOST_INTERPROCESS_POSIX_PROCESS_SHARED)
+   #include <boost/interprocess/sync/posix/mutex.hpp>
+   #define BOOST_INTERPROCESS_USE_POSIX
+//Experimental...
+//#elif !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && defined (BOOST_INTERPROCESS_WINDOWS)
+//   #include <boost/interprocess/sync/windows/mutex.hpp>
+//   #define BOOST_INTERPROCESS_USE_WINDOWS
+#elif !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   #include <boost/interprocess/sync/spin/mutex.hpp>
+   #define BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+namespace robust_emulation_helpers {
+
+template<class T>
+class mutex_traits;
+
+}}}}
+
+#endif
+
+/// @endcond
+
+//!\file
+//!Describes a mutex class that can be placed in memory shared by
+//!several processes.
+
+namespace boost {
+namespace interprocess {
+
+class interprocess_condition;
+
+//!Wraps a interprocess_mutex that can be placed in shared memory and can be 
+//!shared between processes. Allows timed lock tries
+class interprocess_mutex
+{
+   /// @cond
+   //Non-copyable
+   interprocess_mutex(const interprocess_mutex &);
+   interprocess_mutex &operator=(const interprocess_mutex &);
+   friend class interprocess_condition;
+   /// @endcond
+   public:
+
+   //!Constructor.
+   //!Throws interprocess_exception on error.
+   interprocess_mutex();
+
+   //!Destructor. If any process uses the mutex after the destructor is called
+   //!the result is undefined. Does not throw.
+   ~interprocess_mutex();
+
+   //!Effects: The calling thread tries to obtain ownership of the mutex, and
+   //!   if another thread has ownership of the mutex, it waits until it can
+   //!   obtain the ownership. If a thread takes ownership of the mutex the
+   //!   mutex must be unlocked by the same mutex.
+   //!Throws: interprocess_exception on error.
+   void lock();
+
+   //!Effects: The calling thread tries to obtain ownership of the mutex, and
+   //!   if another thread has ownership of the mutex returns immediately.
+   //!Returns: If the thread acquires ownership of the mutex, returns true, if
+   //!   the another thread has ownership of the mutex, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock();
+
+   //!Effects: The calling thread will try to obtain exclusive ownership of the
+   //!   mutex if it can do so in until the specified time is reached. If the
+   //!   mutex supports recursive locking, the mutex must be unlocked the same
+   //!   number of times it is locked. 
+   //!Returns: If the thread acquires ownership of the mutex, returns true, if
+   //!   the timeout expires returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Effects: The calling thread releases the exclusive ownership of the mutex.
+   //!Throws: interprocess_exception on error.
+   void unlock();
+   /// @cond
+   private:
+
+   #if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+      #undef BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+      friend class ipcdetail::robust_emulation_helpers::mutex_traits<interprocess_mutex>;
+      void take_ownership(){ mutex.take_ownership(); }
+      ipcdetail::spin_mutex mutex;
+   #elif defined(BOOST_INTERPROCESS_USE_POSIX)
+      #undef BOOST_INTERPROCESS_USE_POSIX
+      ipcdetail::posix_mutex mutex;
+   #elif defined(BOOST_INTERPROCESS_USE_WINDOWS)
+      #undef BOOST_INTERPROCESS_USE_WINDOWS
+      ipcdetail::windows_mutex mutex;
+   #else
+      #error "Unknown platform for interprocess_mutex"
+   #endif
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+
+namespace boost {
+namespace interprocess {
+
+inline interprocess_mutex::interprocess_mutex(){}
+
+inline interprocess_mutex::~interprocess_mutex(){}
+
+inline void interprocess_mutex::lock()
+{
+   #ifdef BOOST_INTERPROCESS_ENABLE_TIMEOUT_WHEN_LOCKING
+      boost::posix_time::ptime wait_time
+         = boost::posix_time::microsec_clock::universal_time()
+         + boost::posix_time::milliseconds(BOOST_INTERPROCESS_TIMEOUT_WHEN_LOCKING_DURATION_MS);
+      if (!mutex.timed_lock(wait_time))
+      {
+         throw interprocess_exception(timeout_when_locking_error, "Interprocess mutex timeout when locking. Possible deadlock: owner died without unlocking?");
+      }
+   #else
+      mutex.lock();
+   #endif
+}
+
+inline bool interprocess_mutex::try_lock()
+{ return mutex.try_lock(); }
+
+inline bool interprocess_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{ return mutex.timed_lock(abs_time); }
+
+inline void interprocess_mutex::unlock()
+{ mutex.unlock(); }
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_MUTEX_HPP
diff --git a/boost/interprocess/sync/interprocess_recursive_mutex.hpp b/boost/interprocess/sync/interprocess_recursive_mutex.hpp
new file mode 100644
index 0000000000..308819ff27
--- /dev/null
+++ b/boost/interprocess/sync/interprocess_recursive_mutex.hpp
@@ -0,0 +1,177 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Parts of the pthread code come from Boost Threads code:
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_RECURSIVE_MUTEX_HPP
+#define BOOST_INTERPROCESS_RECURSIVE_MUTEX_HPP
+
+/// @cond
+
+#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/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/assert.hpp>
+
+#if !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && \
+   (defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED) && defined (BOOST_INTERPROCESS_POSIX_RECURSIVE_MUTEXES))
+   #include <boost/interprocess/sync/posix/recursive_mutex.hpp>
+   #define BOOST_INTERPROCESS_USE_POSIX
+//Experimental...
+//#elif !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && defined (BOOST_INTERPROCESS_WINDOWS)
+//   #include <boost/interprocess/sync/windows/recursive_mutex.hpp>
+//   #define BOOST_INTERPROCESS_USE_WINDOWS
+#elif !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   #include <boost/interprocess/sync/spin/recursive_mutex.hpp>
+   #define BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+#endif
+
+#if defined (BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+namespace robust_emulation_helpers {
+
+template<class T>
+class mutex_traits;
+
+}}}}
+
+#endif
+
+/// @endcond
+
+//!\file
+//!Describes interprocess_recursive_mutex and shared_recursive_try_mutex classes
+
+namespace boost {
+namespace interprocess {
+
+//!Wraps a interprocess_mutex that can be placed in shared memory and can be 
+//!shared between processes. Allows several locking calls by the same 
+//!process. Allows timed lock tries
+class interprocess_recursive_mutex
+{
+   /// @cond
+   //Non-copyable
+   interprocess_recursive_mutex(const interprocess_recursive_mutex &);
+   interprocess_recursive_mutex &operator=(const interprocess_recursive_mutex &);
+   /// @endcond
+   public:
+   //!Constructor.
+   //!Throws interprocess_exception on error.
+   interprocess_recursive_mutex();
+
+   //!Destructor. If any process uses the mutex after the destructor is called
+   //!the result is undefined. Does not throw.
+  ~interprocess_recursive_mutex();
+
+   //!Effects: The calling thread tries to obtain ownership of the mutex, and
+   //!   if another thread has ownership of the mutex, it waits until it can
+   //!   obtain the ownership. If a thread takes ownership of the mutex the
+   //!   mutex must be unlocked by the same mutex. The mutex must be unlocked
+   //!   the same number of times it is locked.
+   //!Throws: interprocess_exception on error.
+   void lock();
+
+   //!Tries to lock the interprocess_mutex, returns false when interprocess_mutex 
+   //!is already locked, returns true when success. The mutex must be unlocked
+   //!the same number of times it is locked.
+   //!Throws: interprocess_exception if a severe error is found
+   bool try_lock();
+
+   //!Tries to lock the interprocess_mutex, if interprocess_mutex can't be locked before
+   //!abs_time time, returns false. The mutex must be unlocked
+   //!   the same number of times it is locked.
+   //!Throws: interprocess_exception if a severe error is found
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Effects: The calling thread releases the exclusive ownership of the mutex.
+   //!   If the mutex supports recursive locking, the mutex must be unlocked the
+   //!   same number of times it is locked.
+   //!Throws: interprocess_exception on error.
+   void unlock();
+   /// @cond
+   private:
+
+   #if defined (BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+      #undef BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+      void take_ownership(){ mutex.take_ownership(); }
+      friend class ipcdetail::robust_emulation_helpers::mutex_traits<interprocess_recursive_mutex>;
+      ipcdetail::spin_recursive_mutex mutex;
+   #elif defined(BOOST_INTERPROCESS_USE_POSIX)
+      #undef BOOST_INTERPROCESS_USE_POSIX
+      ipcdetail::posix_recursive_mutex mutex;
+   #elif defined(BOOST_INTERPROCESS_USE_WINDOWS)
+      #undef BOOST_INTERPROCESS_USE_WINDOWS
+      ipcdetail::windows_recursive_mutex mutex;
+   #else
+      #error "Unknown platform for interprocess_mutex"
+   #endif
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+namespace boost {
+namespace interprocess {
+
+inline interprocess_recursive_mutex::interprocess_recursive_mutex(){}
+
+inline interprocess_recursive_mutex::~interprocess_recursive_mutex(){}
+
+inline void interprocess_recursive_mutex::lock()
+{
+   #ifdef BOOST_INTERPROCESS_ENABLE_TIMEOUT_WHEN_LOCKING
+      boost::posix_time::ptime wait_time
+         = boost::posix_time::microsec_clock::universal_time()
+         + boost::posix_time::milliseconds(BOOST_INTERPROCESS_TIMEOUT_WHEN_LOCKING_DURATION_MS);
+      if (!mutex.timed_lock(wait_time)){
+         throw interprocess_exception(timeout_when_locking_error, "Interprocess mutex timeout when locking. Possible deadlock: owner died without unlocking?");
+      }
+   #else
+      mutex.lock();
+   #endif
+}
+
+inline bool interprocess_recursive_mutex::try_lock()
+{ return mutex.try_lock(); }
+
+inline bool interprocess_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{ return mutex.timed_lock(abs_time); }
+
+inline void interprocess_recursive_mutex::unlock()
+{ mutex.unlock(); }
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_RECURSIVE_MUTEX_HPP
diff --git a/boost/interprocess/sync/interprocess_semaphore.hpp b/boost/interprocess/sync/interprocess_semaphore.hpp
new file mode 100644
index 0000000000..4ffcdcf691
--- /dev/null
+++ b/boost/interprocess/sync/interprocess_semaphore.hpp
@@ -0,0 +1,145 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_SEMAPHORE_HPP
+
+/// @cond
+
+#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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+#if !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && \
+   (defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED) && defined(BOOST_INTERPROCESS_POSIX_NAMED_SEMAPHORES))
+   #include <boost/interprocess/sync/posix/semaphore.hpp>
+   #define BOOST_INTERPROCESS_USE_POSIX
+//Experimental...
+//#elif !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION) && defined (BOOST_INTERPROCESS_WINDOWS)
+//   #include <boost/interprocess/sync/windows/semaphore.hpp>
+//   #define BOOST_INTERPROCESS_USE_WINDOWS
+#elif !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
+   #include <boost/interprocess/sync/spin/semaphore.hpp>
+   #define BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+#endif
+
+/// @endcond
+
+//!\file
+//!Describes a interprocess_semaphore class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+//!Wraps a interprocess_semaphore that can be placed in shared memory and can be 
+//!shared between processes. Allows timed lock tries
+class interprocess_semaphore
+{
+   /// @cond
+   //Non-copyable
+   interprocess_semaphore(const interprocess_semaphore &);
+   interprocess_semaphore &operator=(const interprocess_semaphore &);
+   /// @endcond
+   public:
+   //!Creates a interprocess_semaphore with the given initial count. 
+   //!interprocess_exception if there is an error.*/
+   interprocess_semaphore(unsigned int initialCount);
+
+   //!Destroys the interprocess_semaphore.
+   //!Does not throw
+   ~interprocess_semaphore();
+
+   //!Increments the interprocess_semaphore count. If there are processes/threads blocked waiting
+   //!for the interprocess_semaphore, then one of these processes will return successfully from
+   //!its wait function. If there is an error an interprocess_exception exception is thrown.
+   void post();
+
+   //!Decrements the interprocess_semaphore. If the interprocess_semaphore value is not greater than zero,
+   //!then the calling process/thread blocks until it can decrement the counter. 
+   //!If there is an error an interprocess_exception exception is thrown.
+   void wait();
+
+   //!Decrements the interprocess_semaphore if the interprocess_semaphore's value is greater than zero
+   //!and returns true. If the value is not greater than zero returns false.
+   //!If there is an error an interprocess_exception exception is thrown.
+   bool try_wait();
+
+   //!Decrements the interprocess_semaphore if the interprocess_semaphore's value is greater
+   //!than zero and returns true. Otherwise, waits for the interprocess_semaphore
+   //!to the posted or the timeout expires. If the timeout expires, the
+   //!function returns false. If the interprocess_semaphore is posted the function
+   //!returns true. If there is an error throws sem_exception
+   bool timed_wait(const boost::posix_time::ptime &abs_time);
+
+   //!Returns the interprocess_semaphore count
+//   int get_count() const;
+   /// @cond
+   private:
+   #if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+      #undef BOOST_INTERPROCESS_USE_GENERIC_EMULATION
+      ipcdetail::spin_semaphore m_sem;
+   #elif defined(BOOST_INTERPROCESS_USE_WINDOWS)
+      #undef BOOST_INTERPROCESS_USE_WINDOWS
+      ipcdetail::windows_semaphore m_sem;
+   #else 
+      #undef BOOST_INTERPROCESS_USE_POSIX
+      ipcdetail::posix_semaphore m_sem;
+   #endif   //#if defined(BOOST_INTERPROCESS_USE_GENERIC_EMULATION)
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+namespace boost {
+namespace interprocess {
+
+inline interprocess_semaphore::interprocess_semaphore(unsigned int initialCount)
+   : m_sem(initialCount)
+{}
+
+inline interprocess_semaphore::~interprocess_semaphore(){}
+
+inline void interprocess_semaphore::wait()
+{
+   #ifdef BOOST_INTERPROCESS_ENABLE_TIMEOUT_WHEN_LOCKING
+      boost::posix_time::ptime wait_time
+         = boost::posix_time::microsec_clock::universal_time()
+         + boost::posix_time::milliseconds(BOOST_INTERPROCESS_TIMEOUT_WHEN_LOCKING_DURATION_MS);
+      if (!m_sem.timed_wait(wait_time))
+      {
+         throw interprocess_exception(timeout_when_waiting_error, "Interprocess semaphore timeout when waiting. Possible deadlock: owner died without posting?");
+      }
+   #else
+      m_sem.wait();
+   #endif
+}
+inline bool interprocess_semaphore::try_wait()
+{ return m_sem.try_wait(); }
+
+inline bool interprocess_semaphore::timed_wait(const boost::posix_time::ptime &abs_time)
+{ return m_sem.timed_wait(abs_time); }
+
+inline void interprocess_semaphore::post()
+{ m_sem.post(); }
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/interprocess_upgradable_mutex.hpp b/boost/interprocess/sync/interprocess_upgradable_mutex.hpp
new file mode 100644
index 0000000000..048407f4b3
--- /dev/null
+++ b/boost/interprocess/sync/interprocess_upgradable_mutex.hpp
@@ -0,0 +1,659 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_UPGRADABLE_MUTEX_HPP
+#define BOOST_INTERPROCESS_UPGRADABLE_MUTEX_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/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/interprocess_condition.hpp>
+#include <climits>
+
+
+//!\file
+//!Describes interprocess_upgradable_mutex class
+
+namespace boost {
+namespace interprocess {
+
+//!Wraps a interprocess_upgradable_mutex that can be placed in shared memory and can be 
+//!shared between processes. Allows timed lock tries
+class interprocess_upgradable_mutex
+{
+   //Non-copyable
+   interprocess_upgradable_mutex(const interprocess_upgradable_mutex &);
+   interprocess_upgradable_mutex &operator=(const interprocess_upgradable_mutex &);
+
+   friend class interprocess_condition;
+   public:
+
+   //!Constructs the upgradable lock.
+   //!Throws interprocess_exception on error.
+   interprocess_upgradable_mutex();
+
+   //!Destroys the upgradable lock.
+   //!Does not throw.
+   ~interprocess_upgradable_mutex();
+
+   //Exclusive locking
+
+   //!Effects: The calling thread tries to obtain exclusive ownership of the mutex,
+   //!   and if another thread has exclusive, sharable or upgradable ownership of
+   //!   the mutex, it waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   without waiting. If no other thread has exclusive, sharable or upgradable
+   //!   ownership of the mutex this succeeds.
+   //!Returns: If it can acquire exclusive ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive, sharable or
+   //!   upgradable ownership of the mutex or abs_time is reached. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The calling thread releases the exclusive ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock();
+
+   //Sharable locking
+
+   //!Effects: The calling thread tries to obtain sharable ownership of the mutex,
+   //!   and if another thread has exclusive ownership of the mutex,
+   //!   waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive ownership
+   //!   of the mutex this succeeds. 
+   //!Returns: If it can acquire sharable ownership immediately returns true. If it
+   //!   has to wait, returns false. 
+   //!Throws: interprocess_exception on error.
+   bool try_lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive
+   //!   ownership of the mutex or abs_time is reached. 
+   //!Returns: If acquires sharable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_sharable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The calling thread releases the sharable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_sharable();
+
+   //Upgradable locking
+
+   //!Effects: The calling thread tries to obtain upgradable ownership of the mutex,
+   //!   and if another thread has exclusive or upgradable ownership of the mutex,
+   //!   waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_upgradable();
+
+   //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive or upgradable ownership
+   //!   of the mutex this succeeds. 
+   //!Returns: If it can acquire upgradable ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock_upgradable();
+
+   //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive or upgradable
+   //!   ownership of the mutex or abs_time is reached.
+   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_upgradable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The calling thread releases the upgradable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable();
+
+   //Demotions
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The thread atomically releases exclusive ownership and acquires
+   //!   upgradable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_and_lock_upgradable();
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The thread atomically releases exclusive ownership and acquires
+   //!   sharable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_and_lock_sharable();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and acquires
+   //!   sharable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable_and_lock_sharable();
+
+   //Promotions
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and acquires
+   //!   exclusive ownership. This operation will block until all threads with
+   //!   sharable ownership release their sharable lock. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable_and_lock();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and tries to
+   //!   acquire exclusive ownership. This operation will fail if there are threads
+   //!   with sharable ownership, but it will maintain upgradable ownership. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_upgradable_and_lock();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and tries to acquire
+   //!   exclusive ownership, waiting if necessary until abs_time. This operation will
+   //!   fail if there are threads with sharable ownership or timeout reaches, but it
+   //!   will maintain upgradable ownership. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error. */
+   bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The thread atomically releases sharable ownership and tries to acquire
+   //!   exclusive ownership. This operation will fail if there are threads with sharable
+   //!   or upgradable ownership, but it will maintain sharable ownership.
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_sharable_and_lock();
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The thread atomically releases sharable ownership and tries to acquire
+   //!   upgradable ownership. This operation will fail if there are threads with sharable
+   //!   or upgradable ownership, but it will maintain sharable ownership. 
+   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_sharable_and_lock_upgradable();
+
+   /// @cond
+   private:
+   typedef scoped_lock<interprocess_mutex> scoped_lock_t;
+
+   //Pack all the control data in a word to be able
+   //to use atomic instructions in the future
+   struct control_word_t
+   {
+      unsigned exclusive_in         : 1;
+      unsigned upgradable_in        : 1;
+      unsigned num_upr_shar         : sizeof(unsigned)*CHAR_BIT-2;
+   }                       m_ctrl;
+
+   interprocess_mutex      m_mut;
+   interprocess_condition  m_first_gate;
+   interprocess_condition  m_second_gate;
+
+   private:
+   //Rollback structures for exceptions or failure return values
+   struct exclusive_rollback
+   {
+      exclusive_rollback(control_word_t         &ctrl
+                        ,interprocess_condition &first_gate)
+         :  mp_ctrl(&ctrl), m_first_gate(first_gate)
+      {}
+
+      void release()
+      {  mp_ctrl = 0;   }
+
+      ~exclusive_rollback()
+      {
+         if(mp_ctrl){
+            mp_ctrl->exclusive_in = 0;
+            m_first_gate.notify_all();
+         }
+      }
+      control_word_t          *mp_ctrl;
+      interprocess_condition  &m_first_gate;
+   };
+
+   struct upgradable_to_exclusive_rollback
+   {
+      upgradable_to_exclusive_rollback(control_word_t         &ctrl)
+         :  mp_ctrl(&ctrl)
+      {}
+
+      void release()
+      {  mp_ctrl = 0;   }
+
+      ~upgradable_to_exclusive_rollback()
+      {
+         if(mp_ctrl){
+            //Recover upgradable lock
+            mp_ctrl->upgradable_in = 1;
+            ++mp_ctrl->num_upr_shar;   
+            //Execute the second half of exclusive locking
+            mp_ctrl->exclusive_in = 0;
+         }
+      }
+      control_word_t          *mp_ctrl;
+   };
+
+   template<int Dummy>
+   struct base_constants_t
+   {
+      static const unsigned max_readers 
+         = ~(unsigned(3) << (sizeof(unsigned)*CHAR_BIT-2));
+   };
+   typedef base_constants_t<0> constants;
+   /// @endcond
+};
+
+/// @cond
+
+template <int Dummy>
+const unsigned interprocess_upgradable_mutex::base_constants_t<Dummy>::max_readers;
+
+inline interprocess_upgradable_mutex::interprocess_upgradable_mutex()
+{
+   this->m_ctrl.exclusive_in  = 0;
+   this->m_ctrl.upgradable_in = 0;
+   this->m_ctrl.num_upr_shar   = 0;
+}
+
+inline interprocess_upgradable_mutex::~interprocess_upgradable_mutex()
+{}
+
+inline void interprocess_upgradable_mutex::lock()
+{
+   scoped_lock_t lock(m_mut);
+
+   //The exclusive lock must block in the first gate
+   //if an exclusive or upgradable lock has been acquired
+   while (this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in){
+      this->m_first_gate.wait(lock);
+   }
+
+   //Mark that exclusive lock has been acquired
+   this->m_ctrl.exclusive_in = 1;
+
+   //Prepare rollback
+   exclusive_rollback rollback(this->m_ctrl, this->m_first_gate);
+
+   //Now wait until all readers are gone
+   while (this->m_ctrl.num_upr_shar){
+      this->m_second_gate.wait(lock);
+   }
+   rollback.release();
+}
+
+inline bool interprocess_upgradable_mutex::try_lock()
+{
+   scoped_lock_t lock(m_mut, try_to_lock);
+
+   //If we can't lock or any has there is any exclusive, upgradable 
+   //or sharable mark return false;
+   if(!lock.owns() 
+      || this->m_ctrl.exclusive_in 
+      || this->m_ctrl.num_upr_shar){
+      return false;
+   }
+   this->m_ctrl.exclusive_in = 1;
+   return true;
+}
+
+inline bool interprocess_upgradable_mutex::timed_lock
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   scoped_lock_t lock(m_mut, abs_time);
+   if(!lock.owns())   return false;
+
+   //The exclusive lock must block in the first gate
+   //if an exclusive or upgradable lock has been acquired
+   while (this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in){
+      if(!this->m_first_gate.timed_wait(lock, abs_time))
+         return !(this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in);
+   }
+
+   //Mark that exclusive lock has been acquired
+   this->m_ctrl.exclusive_in = 1;
+
+   //Prepare rollback
+   exclusive_rollback rollback(this->m_ctrl, this->m_first_gate);
+
+   //Now wait until all readers are gone
+   while (this->m_ctrl.num_upr_shar){
+      if(!this->m_second_gate.timed_wait(lock, abs_time)){
+         return !(this->m_ctrl.num_upr_shar);
+      }
+   }
+   rollback.release();
+   return true;
+}
+
+inline void interprocess_upgradable_mutex::unlock()
+{
+   scoped_lock_t lock(m_mut);
+   this->m_ctrl.exclusive_in = 0;
+   this->m_first_gate.notify_all();
+}
+
+//Upgradable locking
+
+inline void interprocess_upgradable_mutex::lock_upgradable()
+{
+   scoped_lock_t lock(m_mut);
+
+   //The upgradable lock must block in the first gate
+   //if an exclusive or upgradable lock has been acquired
+   //or there are too many sharable locks
+   while(this->m_ctrl.exclusive_in || this->m_ctrl.upgradable_in
+         || this->m_ctrl.num_upr_shar == constants::max_readers){
+      this->m_first_gate.wait(lock);
+   }
+
+   //Mark that upgradable lock has been acquired
+   //And add upgradable to the sharable count
+   this->m_ctrl.upgradable_in = 1;
+   ++this->m_ctrl.num_upr_shar;
+}
+
+inline bool interprocess_upgradable_mutex::try_lock_upgradable()
+{
+   scoped_lock_t lock(m_mut, try_to_lock);
+
+   //The upgradable lock must fail
+   //if an exclusive or upgradable lock has been acquired
+   //or there are too many sharable locks
+   if(!lock.owns() 
+      || this->m_ctrl.exclusive_in 
+      || this->m_ctrl.upgradable_in 
+      || this->m_ctrl.num_upr_shar == constants::max_readers){
+      return false;
+   }
+
+   //Mark that upgradable lock has been acquired
+   //And add upgradable to the sharable count
+   this->m_ctrl.upgradable_in = 1;
+   ++this->m_ctrl.num_upr_shar;
+   return true;
+}
+
+inline bool interprocess_upgradable_mutex::timed_lock_upgradable
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_upgradable();
+      return true;
+   }
+   scoped_lock_t lock(m_mut, abs_time);
+   if(!lock.owns())   return false;
+
+   //The upgradable lock must block in the first gate
+   //if an exclusive or upgradable lock has been acquired
+   //or there are too many sharable locks
+   while(this->m_ctrl.exclusive_in 
+         || this->m_ctrl.upgradable_in
+         || this->m_ctrl.num_upr_shar == constants::max_readers){
+      if(!this->m_first_gate.timed_wait(lock, abs_time)){
+         return!(this->m_ctrl.exclusive_in 
+               || this->m_ctrl.upgradable_in
+               || this->m_ctrl.num_upr_shar == constants::max_readers);
+      }
+   }
+
+   //Mark that upgradable lock has been acquired
+   //And add upgradable to the sharable count
+   this->m_ctrl.upgradable_in = 1;
+   ++this->m_ctrl.num_upr_shar;
+   return true;
+}
+
+inline void interprocess_upgradable_mutex::unlock_upgradable()
+{
+   scoped_lock_t lock(m_mut);
+   //Mark that upgradable lock has been acquired
+   //And add upgradable to the sharable count
+   this->m_ctrl.upgradable_in = 0;
+   --this->m_ctrl.num_upr_shar;
+   this->m_first_gate.notify_all();
+}
+
+//Sharable locking
+
+inline void interprocess_upgradable_mutex::lock_sharable()
+{
+   scoped_lock_t lock(m_mut);
+
+   //The sharable lock must block in the first gate
+   //if an exclusive lock has been acquired
+   //or there are too many sharable locks
+   while(this->m_ctrl.exclusive_in
+        || this->m_ctrl.num_upr_shar == constants::max_readers){
+      this->m_first_gate.wait(lock);
+   }
+
+   //Increment sharable count
+   ++this->m_ctrl.num_upr_shar;
+}
+
+inline bool interprocess_upgradable_mutex::try_lock_sharable()
+{
+   scoped_lock_t lock(m_mut, try_to_lock);
+
+   //The sharable lock must fail
+   //if an exclusive lock has been acquired
+   //or there are too many sharable locks
+   if(!lock.owns()
+      || this->m_ctrl.exclusive_in
+      || this->m_ctrl.num_upr_shar == constants::max_readers){
+      return false;
+   }
+
+   //Increment sharable count
+   ++this->m_ctrl.num_upr_shar;
+   return true;
+}
+
+inline bool interprocess_upgradable_mutex::timed_lock_sharable
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_sharable();
+      return true;
+   }
+   scoped_lock_t lock(m_mut, abs_time);
+   if(!lock.owns())   return false;
+
+   //The sharable lock must block in the first gate
+   //if an exclusive lock has been acquired
+   //or there are too many sharable locks
+   while (this->m_ctrl.exclusive_in
+         || this->m_ctrl.num_upr_shar == constants::max_readers){
+      if(!this->m_first_gate.timed_wait(lock, abs_time)){
+         return!(this->m_ctrl.exclusive_in
+               || this->m_ctrl.num_upr_shar == constants::max_readers);
+      }
+   }
+
+   //Increment sharable count
+   ++this->m_ctrl.num_upr_shar;
+   return true;
+}
+
+inline void interprocess_upgradable_mutex::unlock_sharable()
+{
+   scoped_lock_t lock(m_mut);
+   //Decrement sharable count
+   --this->m_ctrl.num_upr_shar;
+   if (this->m_ctrl.num_upr_shar == 0){
+      this->m_second_gate.notify_one();
+   }
+   //Check if there are blocked sharables because of
+   //there were too many sharables
+   else if(this->m_ctrl.num_upr_shar == (constants::max_readers-1)){
+      this->m_first_gate.notify_all();
+   }
+}
+
+//Downgrading
+
+inline void interprocess_upgradable_mutex::unlock_and_lock_upgradable()
+{
+   scoped_lock_t lock(m_mut);
+   //Unmark it as exclusive
+   this->m_ctrl.exclusive_in     = 0;
+   //Mark it as upgradable
+   this->m_ctrl.upgradable_in    = 1;
+   //The sharable count should be 0 so increment it
+   this->m_ctrl.num_upr_shar   = 1;
+   //Notify readers that they can enter
+   m_first_gate.notify_all();
+}
+
+inline void interprocess_upgradable_mutex::unlock_and_lock_sharable()
+{
+   scoped_lock_t lock(m_mut);
+   //Unmark it as exclusive
+   this->m_ctrl.exclusive_in   = 0;
+   //The sharable count should be 0 so increment it
+   this->m_ctrl.num_upr_shar   = 1;
+   //Notify readers that they can enter
+   m_first_gate.notify_all();
+}
+
+inline void interprocess_upgradable_mutex::unlock_upgradable_and_lock_sharable()
+{
+   scoped_lock_t lock(m_mut);
+   //Unmark it as upgradable (we don't have to decrement count)
+   this->m_ctrl.upgradable_in    = 0;
+   //Notify readers/upgradable that they can enter
+   m_first_gate.notify_all();
+}
+
+//Upgrading
+
+inline void interprocess_upgradable_mutex::unlock_upgradable_and_lock()
+{
+   scoped_lock_t lock(m_mut);
+   //Simulate unlock_upgradable() without
+   //notifying sharables.
+   this->m_ctrl.upgradable_in = 0;
+   --this->m_ctrl.num_upr_shar;   
+   //Execute the second half of exclusive locking
+   this->m_ctrl.exclusive_in = 1;
+
+   //Prepare rollback
+   upgradable_to_exclusive_rollback rollback(m_ctrl);
+
+   while (this->m_ctrl.num_upr_shar){
+      this->m_second_gate.wait(lock);
+   }
+   rollback.release();
+}
+
+inline bool interprocess_upgradable_mutex::try_unlock_upgradable_and_lock()
+{
+   scoped_lock_t lock(m_mut, try_to_lock);
+   //Check if there are no readers
+   if(!lock.owns()
+      || this->m_ctrl.num_upr_shar != 1){
+      return false;
+   }
+   //Now unlock upgradable and mark exclusive
+   this->m_ctrl.upgradable_in = 0;
+   --this->m_ctrl.num_upr_shar;   
+   this->m_ctrl.exclusive_in = 1;
+   return true;
+}
+
+inline bool interprocess_upgradable_mutex::timed_unlock_upgradable_and_lock
+   (const boost::posix_time::ptime &abs_time)
+{
+   scoped_lock_t lock(m_mut, abs_time);
+   if(!lock.owns())   return false;
+
+   //Simulate unlock_upgradable() without
+   //notifying sharables.
+   this->m_ctrl.upgradable_in = 0;
+   --this->m_ctrl.num_upr_shar;   
+   //Execute the second half of exclusive locking
+   this->m_ctrl.exclusive_in = 1;
+
+   //Prepare rollback
+   upgradable_to_exclusive_rollback rollback(m_ctrl);
+
+   while (this->m_ctrl.num_upr_shar){
+      if(!this->m_second_gate.timed_wait(lock, abs_time)){
+         return !(this->m_ctrl.num_upr_shar);
+      }
+   }
+   rollback.release();
+   return true;
+}
+
+inline bool interprocess_upgradable_mutex::try_unlock_sharable_and_lock()
+{
+   scoped_lock_t lock(m_mut, try_to_lock);
+
+   //If we can't lock or any has there is any exclusive, upgradable 
+   //or sharable mark return false;
+   if(!lock.owns() 
+      || this->m_ctrl.exclusive_in 
+      || this->m_ctrl.upgradable_in
+      || this->m_ctrl.num_upr_shar != 1){
+      return false;
+   }
+   this->m_ctrl.exclusive_in = 1;
+   this->m_ctrl.num_upr_shar = 0;
+   return true;
+}
+
+inline bool interprocess_upgradable_mutex::try_unlock_sharable_and_lock_upgradable()
+{
+   scoped_lock_t lock(m_mut, try_to_lock);
+
+   //The upgradable lock must fail
+   //if an exclusive or upgradable lock has been acquired
+   if(!lock.owns()
+      || this->m_ctrl.exclusive_in 
+      || this->m_ctrl.upgradable_in){
+      return false;
+   }
+
+   //Mark that upgradable lock has been acquired
+   this->m_ctrl.upgradable_in = 1;
+   return true;
+}
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_UPGRADABLE_MUTEX_HPP
diff --git a/boost/interprocess/sync/lock_options.hpp b/boost/interprocess/sync/lock_options.hpp
new file mode 100644
index 0000000000..74f3399a4c
--- /dev/null
+++ b/boost/interprocess/sync/lock_options.hpp
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_LOCK_OPTIONS_HPP
+#define BOOST_INTERPROCESS_LOCK_OPTIONS_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+//!\file
+//!Describes the lock options with associated with interprocess_mutex lock constructors.
+
+namespace boost {
+
+namespace posix_time
+{  class ptime;   }
+
+namespace interprocess {
+
+//!Type to indicate to a mutex lock constructor that must not lock the mutex.
+struct defer_lock_type{};
+//!Type to indicate to a mutex lock constructor that must try to lock the mutex.
+struct try_to_lock_type {};
+//!Type to indicate to a mutex lock constructor that the mutex is already locked.
+struct accept_ownership_type{};
+
+//!An object indicating that the locking
+//!must be deferred.
+static const defer_lock_type      defer_lock      = defer_lock_type();
+
+//!An object indicating that a try_lock()
+//!operation must be executed.
+static const try_to_lock_type     try_to_lock    = try_to_lock_type();
+
+//!An object indicating that the ownership of lockable
+//!object must be accepted by the new owner.
+static const accept_ownership_type  accept_ownership = accept_ownership_type();
+
+} // namespace interprocess {
+} // namespace boost{
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_LOCK_OPTIONS_HPP
diff --git a/boost/interprocess/sync/mutex_family.hpp b/boost/interprocess/sync/mutex_family.hpp
new file mode 100644
index 0000000000..a9215e24fe
--- /dev/null
+++ b/boost/interprocess/sync/mutex_family.hpp
@@ -0,0 +1,56 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_MUTEX_FAMILY_HPP
+#define BOOST_INTERPROCESS_MUTEX_FAMILY_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/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
+#include <boost/interprocess/sync/null_mutex.hpp>
+
+//!\file
+//!Describes a shared interprocess_mutex family fit algorithm used to allocate objects in shared memory.
+
+namespace boost {
+
+namespace interprocess {
+
+//!Describes interprocess_mutex family to use with Interprocess framework 
+//!based on boost::interprocess synchronization objects.
+struct mutex_family
+{
+   typedef boost::interprocess::interprocess_mutex                 mutex_type;
+   typedef boost::interprocess::interprocess_recursive_mutex       recursive_mutex_type;
+};
+
+//!Describes interprocess_mutex family to use with Interprocess frameworks 
+//!based on null operation synchronization objects.
+struct null_mutex_family
+{
+   typedef boost::interprocess::null_mutex                   mutex_type;
+   typedef boost::interprocess::null_mutex                   recursive_mutex_type;
+};
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_MUTEX_FAMILY_HPP
+
+
diff --git a/boost/interprocess/sync/named_condition.hpp b/boost/interprocess/sync/named_condition.hpp
new file mode 100644
index 0000000000..c5529eda6c
--- /dev/null
+++ b/boost/interprocess/sync/named_condition.hpp
@@ -0,0 +1,172 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NAMED_CONDITION_HPP
+#define BOOST_INTERPROCESS_NAMED_CONDITION_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/shm/named_condition.hpp>
+
+//!\file
+//!Describes a named condition class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+/// @endcond
+
+//! A global condition variable that can be created by name.
+//! This condition variable is designed to work with named_mutex and
+//! can't be placed in shared memory or memory mapped files.
+class named_condition
+{
+   /// @cond
+   //Non-copyable
+   named_condition();
+   named_condition(const named_condition &);
+   named_condition &operator=(const named_condition &);
+   /// @endcond
+   public:
+   //!Creates a global condition with a name.
+   //!If the condition can't be created throws interprocess_exception
+   named_condition(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global condition with a name. 
+   //!If the condition is created, this call is equivalent to
+   //!named_condition(create_only_t, ... )
+   //!If the condition is already created, this call is equivalent
+   //!named_condition(open_only_t, ... )
+   //!Does not throw
+   named_condition(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global condition with a name if that condition is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   named_condition(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~named_condition();
+
+   //!If there is a thread waiting on *this, change that 
+   //!thread's state to ready. Otherwise there is no effect.*/
+   void notify_one();
+
+   //!Change the state of all threads waiting on *this to ready.
+   //!If there are no waiting threads, notify_all() has no effect.
+   void notify_all();
+
+   //!Releases the lock on the named_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), and then reacquires the lock.
+   template <typename L>
+   void wait(L& lock);
+
+   //!The same as:
+   //!while (!pred()) wait(lock)
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred);
+
+   //!Releases the lock on the named_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), or until time abs_time is reached, 
+   //!and then reacquires the lock.
+   //!Returns: false if time abs_time is reached, otherwise true.
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time);
+
+   //!The same as:   while (!pred()) { 
+   //!                  if (!timed_wait(lock, abs_time)) return pred(); 
+   //!               } return true;
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred);
+
+   //!Erases a named condition from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   ipcdetail::shm_named_condition m_cond;
+
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction()
+   {  ipcdetail::interprocess_tester::dont_close_on_destruction(m_cond); }
+   /// @endcond
+};
+
+/// @cond
+
+inline named_condition::~named_condition()
+{}
+
+inline named_condition::named_condition(create_only_t, const char *name, const permissions &perm)
+   :  m_cond(create_only_t(), name, perm)
+{}
+
+inline named_condition::named_condition(open_or_create_t, const char *name, const permissions &perm)
+   :  m_cond(open_or_create_t(), name, perm)
+{}
+
+inline named_condition::named_condition(open_only_t, const char *name)
+   :  m_cond(open_only_t(), name)
+{}
+
+inline void named_condition::notify_one()
+{  m_cond.notify_one();  }
+
+inline void named_condition::notify_all()
+{  m_cond.notify_all();  }
+
+template <typename L>
+inline void named_condition::wait(L& lock)
+{  m_cond.wait(lock);  }
+
+template <typename L, typename Pr>
+inline void named_condition::wait(L& lock, Pr pred)
+{  m_cond.wait(lock, pred);  }
+
+template <typename L>
+inline bool named_condition::timed_wait
+   (L& lock, const boost::posix_time::ptime &abs_time)
+{  return m_cond.timed_wait(lock, abs_time);  }
+
+template <typename L, typename Pr>
+inline bool named_condition::timed_wait
+   (L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+{  return m_cond.timed_wait(lock, abs_time, pred);  }
+
+inline bool named_condition::remove(const char *name)
+{  return ipcdetail::shm_named_condition::remove(name); }
+
+/// @endcond
+
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_NAMED_CONDITION_HPP
diff --git a/boost/interprocess/sync/named_mutex.hpp b/boost/interprocess/sync/named_mutex.hpp
new file mode 100644
index 0000000000..3e56b81794
--- /dev/null
+++ b/boost/interprocess/sync/named_mutex.hpp
@@ -0,0 +1,163 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NAMED_MUTEX_HPP
+#define BOOST_INTERPROCESS_NAMED_MUTEX_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+#if defined(BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+#include <boost/interprocess/sync/posix/named_mutex.hpp>
+#else
+#include <boost/interprocess/sync/shm/named_mutex.hpp>
+#endif
+
+//!\file
+//!Describes a named mutex class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+class named_condition;
+
+//!A mutex with a global name, so it can be found from different 
+//!processes. This mutex can't be placed in shared memory, and
+//!each process should have it's own named_mutex.
+class named_mutex
+{
+   /// @cond
+
+   //Non-copyable
+   named_mutex();
+   named_mutex(const named_mutex &);
+   named_mutex &operator=(const named_mutex &);
+   friend class named_condition;
+   /// @endcond
+
+   public:
+   //!Creates a global interprocess_mutex with a name.
+   //!Throws interprocess_exception on error.
+   named_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global mutex with a name. 
+   //!If the mutex is created, this call is equivalent to
+   //!named_mutex(create_only_t, ... )
+   //!If the mutex is already created, this call is equivalent
+   //!named_mutex(open_only_t, ... )
+   //!Does not throw
+   named_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global mutex with a name if that mutex is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   named_mutex(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~named_mutex();
+
+   //!Unlocks a previously locked
+   //!interprocess_mutex.
+   void unlock();
+
+   //!Locks interprocess_mutex, sleeps when interprocess_mutex is already locked.
+   //!Throws interprocess_exception if a severe error is found
+   void lock();
+
+   //!Tries to lock the interprocess_mutex, returns false when interprocess_mutex 
+   //!is already locked, returns true when success.
+   //!Throws interprocess_exception if a severe error is found
+   bool try_lock();
+
+   //!Tries to lock the interprocess_mutex until time abs_time,
+   //!Returns false when timeout expires, returns true when locks.
+   //!Throws interprocess_exception if a severe error is found
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Erases a named mutex from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   #if defined(BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+   typedef ipcdetail::posix_named_mutex   impl_t;
+   impl_t m_mut;
+   #else
+   typedef ipcdetail::shm_named_mutex     impl_t;
+   impl_t m_mut;
+   public:
+   interprocess_mutex *mutex() const
+   {  return m_mut.mutex(); }
+   #endif
+
+   /// @endcond
+};
+
+/// @cond
+
+inline named_mutex::named_mutex(create_only_t, const char *name, const permissions &perm)
+   :  m_mut(create_only_t(), name, perm)
+{}
+
+inline named_mutex::named_mutex(open_or_create_t, const char *name, const permissions &perm)
+   :  m_mut(open_or_create_t(), name, perm)
+{}
+
+inline named_mutex::named_mutex(open_only_t, const char *name)
+   :  m_mut(open_only_t(), name)
+{}
+
+inline void named_mutex::dont_close_on_destruction()
+{  ipcdetail::interprocess_tester::dont_close_on_destruction(m_mut); }
+
+inline named_mutex::~named_mutex()
+{}
+
+inline void named_mutex::lock()
+{  m_mut.lock();  }
+
+inline void named_mutex::unlock()
+{  m_mut.unlock();  }
+
+inline bool named_mutex::try_lock()
+{  return m_mut.try_lock();  }
+
+inline bool named_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{  return m_mut.timed_lock(abs_time);  }
+
+inline bool named_mutex::remove(const char *name)
+{  return impl_t::remove(name);   }
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_NAMED_MUTEX_HPP
diff --git a/boost/interprocess/sync/named_recursive_mutex.hpp b/boost/interprocess/sync/named_recursive_mutex.hpp
new file mode 100644
index 0000000000..28768cea6f
--- /dev/null
+++ b/boost/interprocess/sync/named_recursive_mutex.hpp
@@ -0,0 +1,154 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NAMED_RECURSIVE_MUTEX_HPP
+#define BOOST_INTERPROCESS_NAMED_RECURSIVE_MUTEX_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/sync/shm/named_recursive_mutex.hpp>
+
+//!\file
+//!Describes a named named_recursive_mutex class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+/// @endcond
+
+//!A recursive mutex with a global name, so it can be found from different 
+//!processes. This mutex can't be placed in shared memory, and
+//!each process should have it's own named_recursive_mutex.
+class named_recursive_mutex
+{
+   /// @cond
+   //Non-copyable
+   named_recursive_mutex();
+   named_recursive_mutex(const named_recursive_mutex &);
+   named_recursive_mutex &operator=(const named_recursive_mutex &);
+   /// @endcond
+   public:
+
+   //!Creates a global recursive_mutex with a name.
+   //!If the recursive_mutex can't be created throws interprocess_exception
+   named_recursive_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global recursive_mutex with a name. 
+   //!If the recursive_mutex is created, this call is equivalent to
+   //!named_recursive_mutex(create_only_t, ... )
+   //!If the recursive_mutex is already created, this call is equivalent
+   //!named_recursive_mutex(open_only_t, ... )
+   //!Does not throw
+   named_recursive_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global recursive_mutex with a name if that recursive_mutex is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   named_recursive_mutex(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~named_recursive_mutex();
+
+   //!Unlocks a previously locked
+   //!named_recursive_mutex.
+   void unlock();
+
+   //!Locks named_recursive_mutex, sleeps when named_recursive_mutex is already locked.
+   //!Throws interprocess_exception if a severe error is found.
+   void lock();
+
+   //!Tries to lock the named_recursive_mutex, returns false when named_recursive_mutex 
+   //!is already locked, returns true when success.
+   //!Throws interprocess_exception if a severe error is found.
+   bool try_lock();
+
+   //!Tries to lock the named_recursive_mutex until time abs_time,
+   //!Returns false when timeout expires, returns true when locks.
+   //!Throws interprocess_exception if a severe error is found
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Erases a named recursive mutex
+   //!from the system
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   typedef ipcdetail::shm_named_recursive_mutex impl_t;
+   impl_t m_mut;
+
+   /// @endcond
+};
+
+/// @cond
+
+inline named_recursive_mutex::~named_recursive_mutex()
+{}
+
+inline void named_recursive_mutex::dont_close_on_destruction()
+{  ipcdetail::interprocess_tester::dont_close_on_destruction(m_mut);  }
+
+inline named_recursive_mutex::named_recursive_mutex(create_only_t, const char *name, const permissions &perm)
+   :  m_mut  (create_only, name, perm)
+{}
+
+inline named_recursive_mutex::named_recursive_mutex(open_or_create_t, const char *name, const permissions &perm)
+   :  m_mut  (open_or_create, name, perm)
+{}
+
+inline named_recursive_mutex::named_recursive_mutex(open_only_t, const char *name)
+   :  m_mut   (open_only, name)
+{}
+
+inline void named_recursive_mutex::lock()
+{  m_mut.lock();  }
+
+inline void named_recursive_mutex::unlock()
+{  m_mut.unlock();  }
+
+inline bool named_recursive_mutex::try_lock()
+{  return m_mut.try_lock();  }
+
+inline bool named_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   return m_mut.timed_lock(abs_time);
+}
+
+inline bool named_recursive_mutex::remove(const char *name)
+{  return impl_t::remove(name); }
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_NAMED_RECURSIVE_MUTEX_HPP
diff --git a/boost/interprocess/sync/named_semaphore.hpp b/boost/interprocess/sync/named_semaphore.hpp
new file mode 100644
index 0000000000..33e06964f9
--- /dev/null
+++ b/boost/interprocess/sync/named_semaphore.hpp
@@ -0,0 +1,168 @@
+ //////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NAMED_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_NAMED_SEMAPHORE_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+#if defined(BOOST_INTERPROCESS_NAMED_SEMAPHORE_USES_POSIX_SEMAPHORES)
+#include <boost/interprocess/sync/posix/named_semaphore.hpp>
+#else
+#include <boost/interprocess/sync/shm/named_semaphore.hpp>
+#endif
+
+//!\file
+//!Describes a named semaphore class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+//!A semaphore with a global name, so it can be found from different 
+//!processes. Allows several resource sharing patterns and efficient 
+//!acknowledgment mechanisms.
+class named_semaphore
+{
+   /// @cond
+
+   //Non-copyable
+   named_semaphore();
+   named_semaphore(const named_semaphore &);
+   named_semaphore &operator=(const named_semaphore &);
+   /// @endcond
+
+   public:
+   //!Creates a global semaphore with a name, and an initial count. 
+   //!If the semaphore can't be created throws interprocess_exception
+   named_semaphore(create_only_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());
+
+   //!Opens or creates a global semaphore with a name, and an initial count. 
+   //!If the semaphore is created, this call is equivalent to
+   //!named_semaphore(create_only_t, ...)
+   //!If the semaphore is already created, this call is equivalent to
+   //!named_semaphore(open_only_t, ... )
+   //!and initialCount is ignored.
+   named_semaphore(open_or_create_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());
+
+   //!Opens a global semaphore with a name if that semaphore is previously.
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   named_semaphore(open_only_t, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~named_semaphore();
+
+   //!Increments the semaphore count. If there are processes/threads blocked waiting
+   //!for the semaphore, then one of these processes will return successfully from
+   //!its wait function. If there is an error an interprocess_exception exception is thrown.
+   void post();
+
+   //!Decrements the semaphore. If the semaphore value is not greater than zero,
+   //!then the calling process/thread blocks until it can decrement the counter. 
+   //!If there is an error an interprocess_exception exception is thrown.
+   void wait();
+
+   //!Decrements the semaphore if the semaphore's value is greater than zero
+   //!and returns true. If the value is not greater than zero returns false.
+   //!If there is an error an interprocess_exception exception is thrown.
+   bool try_wait();
+
+   //!Decrements the semaphore if the semaphore's value is greater
+   //!than zero and returns true. Otherwise, waits for the semaphore
+   //!to the posted or the timeout expires. If the timeout expires, the
+   //!function returns false. If the semaphore is posted the function
+   //!returns true. If there is an error throws sem_exception
+   bool timed_wait(const boost::posix_time::ptime &abs_time);
+
+   //!Erases a named semaphore from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   #if defined(BOOST_INTERPROCESS_NAMED_SEMAPHORE_USES_POSIX_SEMAPHORES)
+      typedef ipcdetail::posix_named_semaphore  impl_t;
+   #else
+      typedef ipcdetail::shm_named_semaphore    impl_t;
+   #endif
+   impl_t m_sem;
+   /// @endcond
+};
+
+/// @cond
+
+inline named_semaphore::named_semaphore
+   (create_only_t, const char *name, unsigned int initialCount, const permissions &perm)
+   :  m_sem(create_only, name, initialCount, perm)
+{}
+
+inline named_semaphore::named_semaphore
+   (open_or_create_t, const char *name, unsigned int initialCount, const permissions &perm)
+   :  m_sem(open_or_create, name, initialCount, perm)
+{}
+
+inline named_semaphore::named_semaphore(open_only_t, const char *name)
+   :  m_sem(open_only, name)
+{}
+
+inline named_semaphore::~named_semaphore()
+{}
+
+inline void named_semaphore::dont_close_on_destruction()
+{  ipcdetail::interprocess_tester::dont_close_on_destruction(m_sem);  }
+
+inline void named_semaphore::wait()
+{  m_sem.wait();  }
+
+inline void named_semaphore::post()
+{  m_sem.post();  }
+
+inline bool named_semaphore::try_wait()
+{  return m_sem.try_wait();  }
+
+inline bool named_semaphore::timed_wait(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->wait();
+      return true;
+   }
+   return m_sem.timed_wait(abs_time);
+}
+
+inline bool named_semaphore::remove(const char *name)
+{  return impl_t::remove(name);   }
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_NAMED_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/named_upgradable_mutex.hpp b/boost/interprocess/sync/named_upgradable_mutex.hpp
new file mode 100644
index 0000000000..61c6bb4086
--- /dev/null
+++ b/boost/interprocess/sync/named_upgradable_mutex.hpp
@@ -0,0 +1,372 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_named_upgradable_mutex_HPP
+#define BOOST_INTERPROCESS_named_upgradable_mutex_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+//!\file
+//!Describes a named upgradable mutex class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+/// @endcond
+
+class named_condition;
+
+//!A upgradable mutex with a global name, so it can be found from different 
+//!processes. This mutex can't be placed in shared memory, and
+//!each process should have it's own named upgradable mutex.
+class named_upgradable_mutex
+{
+   /// @cond
+   //Non-copyable
+   named_upgradable_mutex();
+   named_upgradable_mutex(const named_upgradable_mutex &);
+   named_upgradable_mutex &operator=(const named_upgradable_mutex &);
+   friend class named_condition;
+   /// @endcond
+   public:
+
+   //!Creates a global upgradable mutex with a name. 
+   //!If the upgradable mutex can't be created throws interprocess_exception
+   named_upgradable_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global upgradable mutex with a name, and an initial count. 
+   //!If the upgradable mutex is created, this call is equivalent to
+   //!named_upgradable_mutex(create_only_t, ...)
+   //!If the upgradable mutex is already created, this call is equivalent to
+   //!named_upgradable_mutex(open_only_t, ... ).
+   named_upgradable_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global upgradable mutex with a name if that upgradable mutex
+   //!is previously.
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   named_upgradable_mutex(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~named_upgradable_mutex();
+
+   //Exclusive locking
+
+   //!Effects: The calling thread tries to obtain exclusive ownership of the mutex,
+   //!   and if another thread has exclusive, sharable or upgradable ownership of
+   //!   the mutex, it waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   without waiting. If no other thread has exclusive, sharable or upgradable
+   //!   ownership of the mutex this succeeds.
+   //!Returns: If it can acquire exclusive ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive, sharable or
+   //!   upgradable ownership of the mutex or abs_time is reached. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The calling thread releases the exclusive ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock();
+
+   //Sharable locking
+
+   //!Effects: The calling thread tries to obtain sharable ownership of the mutex,
+   //!   and if another thread has exclusive ownership of the mutex,
+   //!   waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive ownership
+   //!   of the mutex this succeeds. 
+   //!Returns: If it can acquire sharable ownership immediately returns true. If it
+   //!   has to wait, returns false. 
+   //!Throws: interprocess_exception on error.
+   bool try_lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive
+   //!   ownership of the mutex or abs_time is reached. 
+   //!Returns: If acquires sharable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_sharable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The calling thread releases the sharable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_sharable();
+
+   //Upgradable locking
+
+   //!Effects: The calling thread tries to obtain upgradable ownership of the mutex,
+   //!   and if another thread has exclusive or upgradable ownership of the mutex,
+   //!   waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_upgradable();
+
+   //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive or upgradable ownership
+   //!   of the mutex this succeeds. 
+   //!Returns: If it can acquire upgradable ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock_upgradable();
+
+   //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive or upgradable
+   //!   ownership of the mutex or abs_time is reached.
+   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_upgradable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The calling thread releases the upgradable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable();
+
+   //Demotions
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The thread atomically releases exclusive ownership and acquires
+   //!   upgradable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_and_lock_upgradable();
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The thread atomically releases exclusive ownership and acquires
+   //!   sharable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_and_lock_sharable();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and acquires
+   //!   sharable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable_and_lock_sharable();
+
+   //Promotions
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and acquires
+   //!   exclusive ownership. This operation will block until all threads with
+   //!   sharable ownership release it. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable_and_lock();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and tries to
+   //!   acquire exclusive ownership. This operation will fail if there are threads
+   //!   with sharable ownership, but it will maintain upgradable ownership. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_upgradable_and_lock();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and tries to acquire
+   //!   exclusive ownership, waiting if necessary until abs_time. This operation will
+   //!   fail if there are threads with sharable ownership or timeout reaches, but it
+   //!   will maintain upgradable ownership. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The thread atomically releases sharable ownership and tries to acquire
+   //!   exclusive ownership. This operation will fail if there are threads with sharable
+   //!   or upgradable ownership, but it will maintain sharable ownership.
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_sharable_and_lock();
+
+   bool try_unlock_sharable_and_lock_upgradable();
+
+   //!Erases a named upgradable mutex from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   interprocess_upgradable_mutex *mutex() const
+   {  return static_cast<interprocess_upgradable_mutex*>(m_shmem.get_user_address()); }
+
+   ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::named_creation_functor<interprocess_upgradable_mutex> construct_func_t;
+   /// @endcond
+};
+
+/// @cond
+
+inline named_upgradable_mutex::~named_upgradable_mutex()
+{}
+
+inline named_upgradable_mutex::named_upgradable_mutex
+   (create_only_t, const char *name, const permissions &perm)
+   :  m_shmem  (create_only
+               ,name
+               ,sizeof(interprocess_upgradable_mutex) +
+                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoCreate)
+               ,perm)
+{}
+
+inline named_upgradable_mutex::named_upgradable_mutex
+   (open_or_create_t, const char *name, const permissions &perm)
+   :  m_shmem  (open_or_create
+               ,name
+               ,sizeof(interprocess_upgradable_mutex) +
+                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoOpenOrCreate)
+               ,perm)
+{}
+
+inline named_upgradable_mutex::named_upgradable_mutex
+   (open_only_t, const char *name)
+   :  m_shmem  (open_only
+               ,name
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoOpen))
+{}
+
+inline void named_upgradable_mutex::dont_close_on_destruction()
+{  ipcdetail::interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+inline void named_upgradable_mutex::lock()
+{  this->mutex()->lock();  }
+
+inline void named_upgradable_mutex::unlock()
+{  this->mutex()->unlock();  }
+
+inline bool named_upgradable_mutex::try_lock()
+{  return this->mutex()->try_lock();  }
+
+inline bool named_upgradable_mutex::timed_lock
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   return this->mutex()->timed_lock(abs_time);
+}
+
+inline void named_upgradable_mutex::lock_upgradable()
+{  this->mutex()->lock_upgradable();  }
+
+inline void named_upgradable_mutex::unlock_upgradable()
+{  this->mutex()->unlock_upgradable();  }
+
+inline bool named_upgradable_mutex::try_lock_upgradable()
+{  return this->mutex()->try_lock_upgradable();  }
+
+inline bool named_upgradable_mutex::timed_lock_upgradable
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_upgradable();
+      return true;
+   }
+   return this->mutex()->timed_lock_upgradable(abs_time);
+}
+
+inline void named_upgradable_mutex::lock_sharable()
+{  this->mutex()->lock_sharable();  }
+
+inline void named_upgradable_mutex::unlock_sharable()
+{  this->mutex()->unlock_sharable();  }
+
+inline bool named_upgradable_mutex::try_lock_sharable()
+{  return this->mutex()->try_lock_sharable();  }
+
+inline bool named_upgradable_mutex::timed_lock_sharable
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_sharable();
+      return true;
+   }
+   return this->mutex()->timed_lock_sharable(abs_time);
+}
+
+inline void named_upgradable_mutex::unlock_and_lock_upgradable()
+{  this->mutex()->unlock_and_lock_upgradable();  }
+
+inline void named_upgradable_mutex::unlock_and_lock_sharable()
+{  this->mutex()->unlock_and_lock_sharable();  }
+
+inline void named_upgradable_mutex::unlock_upgradable_and_lock_sharable()
+{  this->mutex()->unlock_upgradable_and_lock_sharable();  }
+
+inline void named_upgradable_mutex::unlock_upgradable_and_lock()
+{  this->mutex()->unlock_upgradable_and_lock();  }
+
+inline bool named_upgradable_mutex::try_unlock_upgradable_and_lock()
+{  return this->mutex()->try_unlock_upgradable_and_lock();  }
+
+inline bool named_upgradable_mutex::timed_unlock_upgradable_and_lock
+   (const boost::posix_time::ptime &abs_time)
+{  return this->mutex()->timed_unlock_upgradable_and_lock(abs_time);  }
+
+inline bool named_upgradable_mutex::try_unlock_sharable_and_lock()
+{  return this->mutex()->try_unlock_sharable_and_lock();  }
+
+inline bool named_upgradable_mutex::try_unlock_sharable_and_lock_upgradable()
+{  return this->mutex()->try_unlock_sharable_and_lock_upgradable();  }
+
+inline bool named_upgradable_mutex::remove(const char *name)
+{  return shared_memory_object::remove(name); }
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_named_upgradable_mutex_HPP
diff --git a/boost/interprocess/sync/null_mutex.hpp b/boost/interprocess/sync/null_mutex.hpp
new file mode 100644
index 0000000000..afe444ed3f
--- /dev/null
+++ b/boost/interprocess/sync/null_mutex.hpp
@@ -0,0 +1,147 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NULL_MUTEX_HPP
+#define BOOST_INTERPROCESS_NULL_MUTEX_HPP
+
+#if (defined _MSC_VER) && (_MSC_VER >= 1200)
+#  pragma once
+#endif
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+
+//!\file
+//!Describes null_mutex classes
+
+namespace boost {
+
+namespace posix_time
+{  class ptime;   }
+
+namespace interprocess {
+
+//!Implements a mutex that simulates a mutex without doing any operation and
+//!simulates a successful operation.
+class null_mutex
+{
+   /// @cond
+   null_mutex(const null_mutex&);
+   null_mutex &operator= (const null_mutex&);
+   /// @endcond
+   public:
+
+   //!Constructor.
+   //!Empty.
+   null_mutex(){}
+
+   //!Destructor.
+   //!Empty.
+   ~null_mutex(){}
+
+   //!Simulates a mutex lock() operation. Empty function.
+   void lock(){}
+
+   //!Simulates a mutex try_lock() operation.
+   //!Equivalent to "return true;"
+   bool try_lock()
+   {  return true;   }
+
+   //!Simulates a mutex timed_lock() operation.
+   //!Equivalent to "return true;"
+   bool timed_lock(const boost::posix_time::ptime &)
+   {  return true;   }
+
+   //!Simulates a mutex unlock() operation.
+   //!Empty function.
+   void unlock(){}
+
+   //!Simulates a mutex lock_sharable() operation.
+   //!Empty function.
+   void lock_sharable(){}
+
+   //!Simulates a mutex try_lock_sharable() operation.
+   //!Equivalent to "return true;"
+   bool try_lock_sharable()
+   {  return true;   }
+
+   //!Simulates a mutex timed_lock_sharable() operation.
+   //!Equivalent to "return true;"
+   bool timed_lock_sharable(const boost::posix_time::ptime &)
+   {  return true;   }
+
+   //!Simulates a mutex unlock_sharable() operation.
+   //!Empty function.
+   void unlock_sharable(){}
+
+   //!Simulates a mutex lock_upgradable() operation.
+   //!Empty function.
+   void lock_upgradable(){}
+
+   //!Simulates a mutex try_lock_upgradable() operation.
+   //!Equivalent to "return true;"
+   bool try_lock_upgradable()
+   {  return true;   }
+
+   //!Simulates a mutex timed_lock_upgradable() operation.
+   //!Equivalent to "return true;"
+   bool timed_lock_upgradable(const boost::posix_time::ptime &)
+   {  return true;   }
+
+   //!Simulates a mutex unlock_upgradable() operation.
+   //!Empty function.
+   void unlock_upgradable(){}
+
+   //!Simulates unlock_and_lock_upgradable().
+   //!Empty function.
+   void unlock_and_lock_upgradable(){}
+
+   //!Simulates unlock_and_lock_sharable().
+   //!Empty function.
+   void unlock_and_lock_sharable(){}
+
+   //!Simulates unlock_upgradable_and_lock_sharable().
+   //!Empty function.
+   void unlock_upgradable_and_lock_sharable(){}
+
+   //Promotions
+
+   //!Simulates unlock_upgradable_and_lock().
+   //!Empty function.
+   void unlock_upgradable_and_lock(){}
+
+   //!Simulates try_unlock_upgradable_and_lock().
+   //!Equivalent to "return true;"
+   bool try_unlock_upgradable_and_lock()
+   {  return true;   }
+
+   //!Simulates timed_unlock_upgradable_and_lock().
+   //!Equivalent to "return true;"
+   bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &)
+   {  return true;   }
+
+   //!Simulates try_unlock_sharable_and_lock().
+   //!Equivalent to "return true;"
+   bool try_unlock_sharable_and_lock()
+   {  return true;   }
+
+   //!Simulates try_unlock_sharable_and_lock_upgradable().
+   //!Equivalent to "return true;"
+   bool try_unlock_sharable_and_lock_upgradable()
+   {  return true;   }
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_NULL_MUTEX_HPP
diff --git a/boost/interprocess/sync/posix/condition.hpp b/boost/interprocess/sync/posix/condition.hpp
new file mode 100644
index 0000000000..213e4ce8b5
--- /dev/null
+++ b/boost/interprocess/sync/posix/condition.hpp
@@ -0,0 +1,191 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_POSIX_CONDITION_HPP
+#define BOOST_INTERPROCESS_POSIX_CONDITION_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 <pthread.h>
+#include <errno.h>   
+#include <boost/interprocess/sync/posix/pthread_helpers.hpp>
+#include <boost/interprocess/sync/posix/ptime_to_timespec.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/posix/mutex.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class posix_condition
+{
+   //Non-copyable
+   posix_condition(const posix_condition &);
+   posix_condition &operator=(const posix_condition &);
+
+   public:
+   //!Constructs a posix_condition. On error throws interprocess_exception.
+   posix_condition();
+
+   //!Destroys *this
+   //!liberating system resources.
+   ~posix_condition();
+
+   //!If there is a thread waiting on *this, change that 
+   //!thread's state to ready. Otherwise there is no effect.
+   void notify_one();
+
+   //!Change the state of all threads waiting on *this to ready.
+   //!If there are no waiting threads, notify_all() has no effect.
+   void notify_all();
+
+   //!Releases the lock on the posix_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), and then reacquires the lock.
+   template <typename L>
+   void wait(L& lock)
+   {
+      if (!lock)
+         throw lock_exception();
+      this->do_wait(*lock.mutex());
+   }
+
+   //!The same as:
+   //!while (!pred()) wait(lock)
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred)
+   {
+      if (!lock)
+         throw lock_exception();
+
+      while (!pred())
+         this->do_wait(*lock.mutex());
+   }
+
+   //!Releases the lock on the posix_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), or until time abs_time is reached, 
+   //!and then reacquires the lock.
+   //!Returns: false if time abs_time is reached, otherwise true.
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock);
+         return true;
+      }
+      if (!lock)
+            throw lock_exception();
+      return this->do_timed_wait(abs_time, *lock.mutex());
+   }
+
+   //!The same as:   while (!pred()) { 
+   //!                  if (!timed_wait(lock, abs_time)) return pred(); 
+   //!               } return true;
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock, pred);
+         return true;
+      }
+      if (!lock)
+            throw lock_exception();
+      while (!pred()){
+         if (!this->do_timed_wait(abs_time, *lock.mutex()))
+            return pred();
+      }
+
+      return true;
+   }
+
+
+   void do_wait(posix_mutex &mut);
+
+   bool do_timed_wait(const boost::posix_time::ptime &abs_time, posix_mutex &mut);
+
+   private:
+   pthread_cond_t   m_condition;
+};
+
+inline posix_condition::posix_condition()
+{
+   int res;
+   pthread_condattr_t cond_attr;
+   res = pthread_condattr_init(&cond_attr);
+   if(res != 0){
+      throw interprocess_exception("pthread_condattr_init failed");
+   }
+   res = pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED);
+   if(res != 0){
+      pthread_condattr_destroy(&cond_attr);
+      throw interprocess_exception(res);
+   }
+   res = pthread_cond_init(&m_condition, &cond_attr);
+   pthread_condattr_destroy(&cond_attr);
+   if(res != 0){
+      throw interprocess_exception(res);
+   }
+}
+
+inline posix_condition::~posix_condition()
+{
+    int res = 0;
+    res = pthread_cond_destroy(&m_condition);
+    BOOST_ASSERT(res == 0);
+}
+
+inline void posix_condition::notify_one()
+{
+    int res = 0;
+    res = pthread_cond_signal(&m_condition);
+    BOOST_ASSERT(res == 0);
+}
+
+inline void posix_condition::notify_all()
+{
+    int res = 0;
+    res = pthread_cond_broadcast(&m_condition);
+    BOOST_ASSERT(res == 0);
+}
+
+inline void posix_condition::do_wait(posix_mutex &mut)
+{
+   pthread_mutex_t* pmutex = &mut.m_mut;
+   int res = 0;
+   res = pthread_cond_wait(&m_condition, pmutex);
+   BOOST_ASSERT(res == 0);
+}
+
+inline bool posix_condition::do_timed_wait
+   (const boost::posix_time::ptime &abs_time, posix_mutex &mut)
+{
+   timespec ts = ptime_to_timespec(abs_time);
+   pthread_mutex_t* pmutex = &mut.m_mut;
+   int res = 0;
+   res = pthread_cond_timedwait(&m_condition, pmutex, &ts);
+   BOOST_ASSERT(res == 0 || res == ETIMEDOUT);
+
+   return res != ETIMEDOUT;
+}
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_POSIX_CONDITION_HPP
diff --git a/boost/interprocess/sync/posix/mutex.hpp b/boost/interprocess/sync/posix/mutex.hpp
new file mode 100644
index 0000000000..22e2ec04b9
--- /dev/null
+++ b/boost/interprocess/sync/posix/mutex.hpp
@@ -0,0 +1,152 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Parts of the pthread code come from Boost Threads code:
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_DETAIL_POSIX_MUTEX_HPP
+#define BOOST_INTERPROCESS_DETAIL_POSIX_MUTEX_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 <pthread.h>
+#include <errno.h>   
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/sync/posix/ptime_to_timespec.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/sync/posix/pthread_helpers.hpp>
+
+#ifndef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+#  include <boost/interprocess/detail/os_thread_functions.hpp>
+#endif
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class posix_condition;
+
+class posix_mutex
+{
+   posix_mutex(const posix_mutex &);
+   posix_mutex &operator=(const posix_mutex &);
+   public:
+
+   posix_mutex();
+   ~posix_mutex();
+
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   void unlock();
+
+   friend class posix_condition;
+
+   private:
+   pthread_mutex_t   m_mut;
+};
+
+inline posix_mutex::posix_mutex()
+{
+   mutexattr_wrapper mut_attr;
+   mutex_initializer mut(m_mut, mut_attr);
+   mut.release();
+}
+
+inline posix_mutex::~posix_mutex() 
+{
+   int res = pthread_mutex_destroy(&m_mut);
+   BOOST_ASSERT(res  == 0);(void)res;
+}
+
+inline void posix_mutex::lock()
+{
+   if (pthread_mutex_lock(&m_mut) != 0) 
+      throw lock_exception();
+}
+
+inline bool posix_mutex::try_lock()
+{
+   int res = pthread_mutex_trylock(&m_mut);
+   if (!(res == 0 || res == EBUSY))
+      throw lock_exception();
+   return res == 0;
+}
+
+inline bool posix_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   #ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+
+   timespec ts = ptime_to_timespec(abs_time);
+   int res = pthread_mutex_timedlock(&m_mut, &ts);
+   if (res != 0 && res != ETIMEDOUT)
+      throw lock_exception();
+   return res == 0;
+
+   #else //BOOST_INTERPROCESS_POSIX_TIMEOUTS
+
+   //Obtain current count and target time
+   boost::posix_time::ptime now = microsec_clock::universal_time();
+
+   do{
+      if(this->try_lock()){
+         break;
+      }
+      now = microsec_clock::universal_time();
+
+      if(now >= abs_time){
+         return false;
+      }
+      // relinquish current time slice
+     thread_yield();
+   }while (true);
+   return true;
+
+   #endif   //BOOST_INTERPROCESS_POSIX_TIMEOUTS
+}
+
+inline void posix_mutex::unlock()
+{
+   int res = 0;
+   res = pthread_mutex_unlock(&m_mut);
+   BOOST_ASSERT(res == 0);
+}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_POSIX_MUTEX_HPP
diff --git a/boost/interprocess/sync/posix/named_mutex.hpp b/boost/interprocess/sync/posix/named_mutex.hpp
new file mode 100644
index 0000000000..931c731eff
--- /dev/null
+++ b/boost/interprocess/sync/posix/named_mutex.hpp
@@ -0,0 +1,116 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_POSIX_NAMED_MUTEX_HPP
+#define BOOST_INTERPROCESS_POSIX_NAMED_MUTEX_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+#include <boost/interprocess/sync/posix/named_semaphore.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class named_condition;
+
+class posix_named_mutex
+{
+   /// @cond
+
+   posix_named_mutex();
+   posix_named_mutex(const posix_named_mutex &);
+   posix_named_mutex &operator=(const posix_named_mutex &);
+   friend class named_condition;
+   /// @endcond
+
+   public:
+   posix_named_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   posix_named_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   posix_named_mutex(open_only_t open_only, const char *name);
+
+   ~posix_named_mutex();
+
+   void unlock();
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class interprocess_tester;
+   void dont_close_on_destruction();
+
+   posix_named_semaphore m_sem;
+   /// @endcond
+};
+
+/// @cond
+
+inline posix_named_mutex::posix_named_mutex(create_only_t, const char *name, const permissions &perm)
+   :  m_sem(create_only, name, 1, perm)
+{}
+
+inline posix_named_mutex::posix_named_mutex(open_or_create_t, const char *name, const permissions &perm)
+   :  m_sem(open_or_create, name, 1, perm)
+{}
+
+inline posix_named_mutex::posix_named_mutex(open_only_t, const char *name)
+   :  m_sem(open_only, name)
+{}
+
+inline void posix_named_mutex::dont_close_on_destruction()
+{  interprocess_tester::dont_close_on_destruction(m_sem);  }
+
+inline posix_named_mutex::~posix_named_mutex()
+{}
+
+inline void posix_named_mutex::lock()
+{  m_sem.wait();  }
+
+inline void posix_named_mutex::unlock()
+{  m_sem.post();  }
+
+inline bool posix_named_mutex::try_lock()
+{  return m_sem.try_wait();  }
+
+inline bool posix_named_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   return m_sem.timed_wait(abs_time);
+}
+
+inline bool posix_named_mutex::remove(const char *name)
+{  return posix_named_semaphore::remove(name);   }
+
+/// @endcond
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_POSIX_NAMED_MUTEX_HPP
diff --git a/boost/interprocess/sync/posix/named_semaphore.hpp b/boost/interprocess/sync/posix/named_semaphore.hpp
new file mode 100644
index 0000000000..f0327a4618
--- /dev/null
+++ b/boost/interprocess/sync/posix/named_semaphore.hpp
@@ -0,0 +1,84 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_POSIX_NAMED_CONDITION_HPP
+#define BOOST_INTERPROCESS_POSIX_NAMED_CONDITION_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/interprocess/sync/posix/semaphore_wrapper.hpp>
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+/// @endcond
+
+namespace ipcdetail {
+
+class posix_named_semaphore
+{
+   posix_named_semaphore();
+   posix_named_semaphore(const posix_named_semaphore&);
+   posix_named_semaphore &operator= (const posix_named_semaphore &);
+
+   public:
+   posix_named_semaphore
+      (create_only_t, const char *name, unsigned int initialCount, const permissions &perm = permissions())
+   {  semaphore_open(mp_sem, DoCreate, name, initialCount, perm);   }
+
+   posix_named_semaphore(open_or_create_t, const char *name, unsigned int initialCount, const permissions &perm = permissions())
+   {  semaphore_open(mp_sem, DoOpenOrCreate, name, initialCount, perm);   }
+
+   posix_named_semaphore(open_only_t, const char *name)
+   {  semaphore_open(mp_sem, DoOpen, name);   }
+
+   ~posix_named_semaphore()
+   {
+      if(mp_sem != BOOST_INTERPROCESS_POSIX_SEM_FAILED)
+         semaphore_close(mp_sem);
+   }
+
+   void post()
+   {  semaphore_post(mp_sem); }
+
+   void wait()
+   {  semaphore_wait(mp_sem); }
+
+   bool try_wait()
+   {  return semaphore_try_wait(mp_sem); }
+
+   bool timed_wait(const boost::posix_time::ptime &abs_time)
+   {  return semaphore_timed_wait(mp_sem, abs_time); }
+
+   static bool remove(const char *name)
+   {  return semaphore_unlink(name);   }
+
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction()
+   {  mp_sem = BOOST_INTERPROCESS_POSIX_SEM_FAILED; }
+
+   sem_t      *mp_sem;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_POSIX_NAMED_CONDITION_HPP
diff --git a/boost/interprocess/sync/posix/pthread_helpers.hpp b/boost/interprocess/sync/posix/pthread_helpers.hpp
new file mode 100644
index 0000000000..c09ce200cf
--- /dev/null
+++ b/boost/interprocess/sync/posix/pthread_helpers.hpp
@@ -0,0 +1,168 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_PTHREAD_HELPERS_HPP
+#define BOOST_INTERPROCESS_PTHREAD_HELPERS_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 <pthread.h>
+#include <errno.h>   
+#include <boost/interprocess/exceptions.hpp>   
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail{
+
+   #if defined BOOST_INTERPROCESS_POSIX_PROCESS_SHARED
+
+   //!Makes pthread_mutexattr_t cleanup easy when using exceptions
+   struct mutexattr_wrapper 
+   {
+      //!Constructor
+      mutexattr_wrapper(bool recursive = false)
+      {
+         if(pthread_mutexattr_init(&m_attr)!=0 ||
+            pthread_mutexattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0 ||
+             (recursive &&
+              pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE)!= 0 ))
+            throw interprocess_exception("pthread_mutexattr_xxxx failed");
+      }
+
+      //!Destructor
+     ~mutexattr_wrapper()  {  pthread_mutexattr_destroy(&m_attr);  }
+
+      //!This allows using mutexattr_wrapper as pthread_mutexattr_t
+      operator pthread_mutexattr_t&()  {  return m_attr;  }
+
+      pthread_mutexattr_t m_attr;
+   };
+
+   //!Makes pthread_condattr_t cleanup easy when using exceptions
+   struct condattr_wrapper 
+   {
+      //!Constructor
+      condattr_wrapper()
+      {
+         if(pthread_condattr_init(&m_attr)!=0 ||
+            pthread_condattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0)
+            throw interprocess_exception("pthread_condattr_xxxx failed");
+      }
+
+      //!Destructor
+     ~condattr_wrapper() { pthread_condattr_destroy(&m_attr); }
+
+      //!This allows using condattr_wrapper as pthread_condattr_t
+      operator pthread_condattr_t&(){  return m_attr;  }
+
+      pthread_condattr_t m_attr;
+   };
+
+   //!Makes initialized pthread_mutex_t cleanup easy when using exceptions
+   class mutex_initializer
+   {
+    public:
+      //!Constructor. Takes interprocess_mutex attributes to initialize the interprocess_mutex
+      mutex_initializer(pthread_mutex_t &mut, pthread_mutexattr_t &mut_attr)
+      : mp_mut(&mut)
+      {
+         if(pthread_mutex_init(mp_mut, &mut_attr) != 0)
+            throw interprocess_exception("pthread_mutex_init failed");
+      }
+
+     ~mutex_initializer() {  if(mp_mut) pthread_mutex_destroy(mp_mut);  }
+
+      void release() {mp_mut = 0; }
+
+    private:     
+      pthread_mutex_t *mp_mut;
+   };
+
+   //!Makes initialized pthread_cond_t cleanup easy when using exceptions
+   class condition_initializer
+   {
+    public:
+      condition_initializer(pthread_cond_t &cond, pthread_condattr_t &cond_attr) 
+      : mp_cond(&cond)
+      {
+         if(pthread_cond_init(mp_cond, &cond_attr)!= 0)
+            throw interprocess_exception("pthread_cond_init failed");
+      }
+
+     ~condition_initializer()   {  if(mp_cond) pthread_cond_destroy(mp_cond);  }
+
+      void release()       { mp_cond = 0; }
+
+    private:   
+      pthread_cond_t *mp_cond;
+   };
+
+   #endif   //   #if defined BOOST_INTERPROCESS_POSIX_PROCESS_SHARED
+
+   #if defined(BOOST_INTERPROCESS_POSIX_BARRIERS) && defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED)
+
+   //!Makes pthread_barrierattr_t cleanup easy when using exceptions
+   struct barrierattr_wrapper 
+   {
+      //!Constructor
+      barrierattr_wrapper()
+      {
+         if(pthread_barrierattr_init(&m_attr)!=0 ||
+            pthread_barrierattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0)
+            throw interprocess_exception("pthread_barrierattr_xxx failed");
+      }
+
+      //!Destructor
+     ~barrierattr_wrapper()  {  pthread_barrierattr_destroy(&m_attr);  }
+
+      //!This allows using mutexattr_wrapper as pthread_barrierattr_t
+      operator pthread_barrierattr_t&()  {  return m_attr;  }
+
+      pthread_barrierattr_t m_attr;
+   };
+
+   //!Makes initialized pthread_barrier_t cleanup easy when using exceptions
+   class barrier_initializer
+   {
+    public:
+      //!Constructor. Takes barrier attributes to initialize the barrier
+      barrier_initializer(pthread_barrier_t &mut, 
+                          pthread_barrierattr_t &mut_attr, 
+                          int count)
+      : mp_barrier(&mut)
+      {
+         if(pthread_barrier_init(mp_barrier, &mut_attr, count) != 0)
+            throw interprocess_exception("pthread_barrier_init failed");
+      }
+
+     ~barrier_initializer() {  if(mp_barrier) pthread_barrier_destroy(mp_barrier);  }
+
+      void release() {mp_barrier = 0; }
+
+    private:     
+      pthread_barrier_t *mp_barrier;
+   };
+
+   #endif   //#if defined(BOOST_INTERPROCESS_POSIX_BARRIERS) && defined(BOOST_INTERPROCESS_POSIX_PROCESS_SHARED)
+
+}//namespace ipcdetail
+
+}//namespace interprocess
+
+}//namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif //ifdef BOOST_INTERPROCESS_PTHREAD_HELPERS_HPP
diff --git a/boost/interprocess/sync/posix/ptime_to_timespec.hpp b/boost/interprocess/sync/posix/ptime_to_timespec.hpp
new file mode 100644
index 0000000000..7d787353bd
--- /dev/null
+++ b/boost/interprocess/sync/posix/ptime_to_timespec.hpp
@@ -0,0 +1,38 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_PTIME_TO_TIMESPEC_HPP
+#define BOOST_INTERPROCESS_DETAIL_PTIME_TO_TIMESPEC_HPP
+
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+namespace boost {
+
+namespace interprocess {
+
+namespace ipcdetail {
+
+inline timespec ptime_to_timespec (const boost::posix_time::ptime &tm)
+{
+   const boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
+   boost::posix_time::time_duration duration (tm - epoch);
+   timespec ts;
+   ts.tv_sec  = duration.total_seconds();
+   ts.tv_nsec = duration.total_nanoseconds() % 1000000000;
+   return ts;
+}
+
+}  //namespace ipcdetail {
+
+}  //namespace interprocess {
+
+}  //namespace boost {
+
+#endif   //ifndef BOOST_INTERPROCESS_DETAIL_PTIME_TO_TIMESPEC_HPP
diff --git a/boost/interprocess/sync/posix/recursive_mutex.hpp b/boost/interprocess/sync/posix/recursive_mutex.hpp
new file mode 100644
index 0000000000..baa670fa9a
--- /dev/null
+++ b/boost/interprocess/sync/posix/recursive_mutex.hpp
@@ -0,0 +1,142 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Parts of the pthread code come from Boost Threads code:
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_DETAIL_POSIX_RECURSIVE_MUTEX_HPP
+#define BOOST_INTERPROCESS_DETAIL_POSIX_RECURSIVE_MUTEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#include <pthread.h>
+#include <errno.h>   
+#include <boost/interprocess/sync/posix/pthread_helpers.hpp>
+#include <boost/interprocess/sync/posix/ptime_to_timespec.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#ifndef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+#  include <boost/interprocess/detail/os_thread_functions.hpp>
+#endif
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class posix_recursive_mutex
+{
+   posix_recursive_mutex(const posix_recursive_mutex &);
+   posix_recursive_mutex &operator=(const posix_recursive_mutex &);
+   public:
+
+   posix_recursive_mutex();
+   ~posix_recursive_mutex();
+
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   void unlock();
+
+   private:
+   pthread_mutex_t   m_mut;
+};
+
+inline posix_recursive_mutex::posix_recursive_mutex()
+{
+   mutexattr_wrapper mut_attr(true);
+   mutex_initializer mut(m_mut, mut_attr);
+   mut.release();
+}
+
+inline posix_recursive_mutex::~posix_recursive_mutex()
+{
+   int res = pthread_mutex_destroy(&m_mut);
+   BOOST_ASSERT(res == 0);(void)res;
+}
+
+inline void posix_recursive_mutex::lock()
+{
+   if (pthread_mutex_lock(&m_mut) != 0) 
+      throw lock_exception();
+}
+
+inline bool posix_recursive_mutex::try_lock()
+{
+   int res = pthread_mutex_trylock(&m_mut);
+   if (!(res == 0 || res == EBUSY))
+      throw lock_exception();
+   return res == 0;
+}
+
+inline bool posix_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   #ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+
+   timespec ts = ptime_to_timespec(abs_time);
+   int res = pthread_mutex_timedlock(&m_mut, &ts);
+   if (res != 0 && res != ETIMEDOUT)
+      throw lock_exception();
+   return res == 0;
+
+   #else //BOOST_INTERPROCESS_POSIX_TIMEOUTS
+
+   //Obtain current count and target time
+   boost::posix_time::ptime now = microsec_clock::universal_time();
+
+   do{
+      if(this->try_lock()){
+         break;
+      }
+      now = microsec_clock::universal_time();
+
+      if(now >= abs_time){
+         return false;
+      }
+      // relinquish current time slice
+     thread_yield();
+   }while (true);
+   return true;
+
+   #endif   //BOOST_INTERPROCESS_POSIX_TIMEOUTS
+}
+
+inline void posix_recursive_mutex::unlock()
+{
+   int res = 0;
+   res = pthread_mutex_unlock(&m_mut);
+   BOOST_ASSERT(res == 0);
+}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_DETAIL_POSIX_RECURSIVE_MUTEX_HPP
diff --git a/boost/interprocess/sync/posix/semaphore.hpp b/boost/interprocess/sync/posix/semaphore.hpp
new file mode 100644
index 0000000000..b7f62cc42d
--- /dev/null
+++ b/boost/interprocess/sync/posix/semaphore.hpp
@@ -0,0 +1,63 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_POSIX_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_POSIX_SEMAPHORE_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/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/posix/semaphore_wrapper.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class posix_semaphore
+{
+   posix_semaphore();
+   posix_semaphore(const posix_semaphore&);
+   posix_semaphore &operator= (const posix_semaphore &);
+
+   public:
+   posix_semaphore(unsigned int initialCount)
+   {  semaphore_init(&m_sem, initialCount);  }
+
+   ~posix_semaphore()
+   {  semaphore_destroy(&m_sem);  }
+
+   void post()
+   {  semaphore_post(&m_sem); }
+
+   void wait()
+   {  semaphore_wait(&m_sem); }
+
+   bool try_wait()
+   {  return semaphore_try_wait(&m_sem); }
+
+   bool timed_wait(const boost::posix_time::ptime &abs_time)
+   {  return semaphore_timed_wait(&m_sem, abs_time); }
+
+   private:
+   sem_t       m_sem;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_INTERPROCESS_POSIX_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/posix/semaphore_wrapper.hpp b/boost/interprocess/sync/posix/semaphore_wrapper.hpp
new file mode 100644
index 0000000000..1aeef47662
--- /dev/null
+++ b/boost/interprocess/sync/posix/semaphore_wrapper.hpp
@@ -0,0 +1,211 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_POSIX_SEMAPHORE_WRAPPER_HPP
+#define BOOST_INTERPROCESS_POSIX_SEMAPHORE_WRAPPER_HPP
+
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/detail/tmp_dir_helpers.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+#include <fcntl.h>      //O_CREAT, O_*... 
+#include <unistd.h>     //close
+#include <string>       //std::string
+#include <semaphore.h>  //sem_* family, SEM_VALUE_MAX
+#include <sys/stat.h>   //mode_t, S_IRWXG, S_IRWXO, S_IRWXU,
+#include <boost/assert.hpp>
+
+#ifdef SEM_FAILED
+#define BOOST_INTERPROCESS_POSIX_SEM_FAILED (reinterpret_cast<sem_t*>(SEM_FAILED))
+#else
+#define BOOST_INTERPROCESS_POSIX_SEM_FAILED (reinterpret_cast<sem_t*>(-1))
+#endif
+
+#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+#include <boost/interprocess/sync/posix/ptime_to_timespec.hpp>
+#else
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#endif
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+inline bool semaphore_open
+   (sem_t *&handle, create_enum_t type, const char *origname, 
+    unsigned int count = 0, const permissions &perm = permissions())
+{
+   std::string name;
+   #ifndef BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SEMAPHORES
+   add_leading_slash(origname, name);
+   #else
+   create_tmp_and_clean_old_and_get_filename(origname, name);
+   #endif
+
+   //Create new mapping
+   int oflag = 0;
+   switch(type){
+      case DoOpen:
+      {
+         //No addition
+         handle = ::sem_open(name.c_str(), oflag);
+      }
+      break;
+      case DoOpenOrCreate:
+      case DoCreate:
+      {
+         while(1){
+            oflag = (O_CREAT | O_EXCL);
+            handle = ::sem_open(name.c_str(), oflag, perm.get_permissions(), count);
+            if(handle != BOOST_INTERPROCESS_POSIX_SEM_FAILED){
+               //We can't change semaphore permissions!
+               //::fchmod(handle, perm.get_permissions());
+               break;
+            }
+            else if(errno == EEXIST && type == DoOpenOrCreate){
+               oflag = 0;
+               if( (handle = ::sem_open(name.c_str(), oflag)) != BOOST_INTERPROCESS_POSIX_SEM_FAILED
+                   || (errno != ENOENT) ){
+                  break;
+               }
+            }
+            else{
+               break;
+            }
+         }
+      }
+      break;
+      default:
+      {
+         error_info err(other_error);
+         throw interprocess_exception(err);
+      }
+   }
+
+   //Check for error
+   if(handle == BOOST_INTERPROCESS_POSIX_SEM_FAILED){
+      throw interprocess_exception(error_info(errno));
+   }
+
+   return true;
+}
+
+inline void semaphore_close(sem_t *handle)
+{
+   int ret = sem_close(handle);
+   if(ret != 0){  
+      BOOST_ASSERT(0);
+   }
+}
+
+inline bool semaphore_unlink(const char *semname)
+{
+   try{
+      std::string sem_str;
+      #ifndef BOOST_INTERPROCESS_FILESYSTEM_BASED_POSIX_SEMAPHORES
+      add_leading_slash(semname, sem_str);
+      #else
+      tmp_filename(semname, sem_str);
+      #endif
+      return 0 == sem_unlink(sem_str.c_str());
+   }
+   catch(...){
+      return false;
+   }
+}
+
+inline void semaphore_init(sem_t *handle, unsigned int initialCount)
+{
+   int ret = sem_init(handle, 1, initialCount);
+   //According to SUSV3 version 2003 edition, the return value of a successful
+   //sem_init call is not defined, but -1 is returned on failure.
+   //In the future, a successful call might be required to return 0.
+   if(ret == -1){
+      throw interprocess_exception(system_error_code());
+   }
+}
+
+inline void semaphore_destroy(sem_t *handle)
+{
+   int ret = sem_destroy(handle);
+   if(ret != 0){  
+      BOOST_ASSERT(0);
+   }
+}
+
+inline void semaphore_post(sem_t *handle)
+{
+   int ret = sem_post(handle);
+   if(ret != 0){
+      throw interprocess_exception(system_error_code());
+   }
+}
+
+inline void semaphore_wait(sem_t *handle)
+{
+   int ret = sem_wait(handle);
+   if(ret != 0){
+      throw interprocess_exception(system_error_code());
+   }
+}
+
+inline bool semaphore_try_wait(sem_t *handle)
+{
+   int res = sem_trywait(handle);
+   if(res == 0)
+      return true;
+   if(system_error_code() == EAGAIN){
+      return false;
+   }
+   throw interprocess_exception(system_error_code());
+   return false;
+}
+
+inline bool semaphore_timed_wait(sem_t *handle, const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      semaphore_wait(handle);
+      return true;
+   }
+   #ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+   timespec tspec = ptime_to_timespec(abs_time);
+   for (;;){
+      int res = sem_timedwait(handle, &tspec);
+      if(res == 0)
+         return true;
+      if (res > 0){
+         //buggy glibc, copy the returned error code to errno
+         errno = res;
+      }
+      if(system_error_code() == ETIMEDOUT){
+         return false;
+      }
+      throw interprocess_exception(system_error_code());
+   }
+   return false;
+   #else //#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+   boost::posix_time::ptime now;
+   do{
+      if(semaphore_try_wait(handle))
+         return true;
+      thread_yield();
+   }while((now = microsec_clock::universal_time()) < abs_time);
+   return false;
+   #endif   //#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
+}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_INTERPROCESS_POSIX_SEMAPHORE_WRAPPER_HPP
diff --git a/boost/interprocess/sync/scoped_lock.hpp b/boost/interprocess/sync/scoped_lock.hpp
new file mode 100644
index 0000000000..bfef63a30a
--- /dev/null
+++ b/boost/interprocess/sync/scoped_lock.hpp
@@ -0,0 +1,372 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This interface is inspired by Howard Hinnant's lock proposal.
+// http://home.twcny.rr.com/hinnant/cpp_extensions/threads_move.html
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_SCOPED_LOCK_HPP
+#define BOOST_INTERPROCESS_SCOPED_LOCK_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/sync/lock_options.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+//!\file
+//!Describes the scoped_lock class.
+
+namespace boost {
+namespace interprocess {
+
+
+//!scoped_lock is meant to carry out the tasks for locking, unlocking, try-locking
+//!and timed-locking (recursive or not) for the Mutex. The Mutex need not supply all
+//!of this functionality. If the client of scoped_lock<Mutex> does not use
+//!functionality which the Mutex does not supply, no harm is done. Mutex ownership
+//!transfer is supported through the syntax of move semantics. Ownership transfer
+//!is allowed both by construction and assignment. The scoped_lock does not support
+//!copy semantics. A compile time error results if copy construction or copy
+//!assignment is attempted. Mutex ownership can also be moved from an
+//!upgradable_lock and sharable_lock via constructor. In this role, scoped_lock
+//!shares the same functionality as a write_lock.
+template <class Mutex>
+class scoped_lock
+{
+   /// @cond
+   private:
+   typedef scoped_lock<Mutex> this_type;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_lock)
+   typedef bool this_type::*unspecified_bool_type;
+   /// @endcond
+   public:
+
+   typedef Mutex mutex_type;
+
+   //!Effects: Default constructs a scoped_lock.
+   //!Postconditions: owns() == false and mutex() == 0.
+   scoped_lock()
+      : mp_mutex(0), m_locked(false)
+   {}
+
+   //!Effects: m.lock().
+   //!Postconditions: owns() == true and mutex() == &m.
+   //!Notes: The constructor will take ownership of the mutex. If another thread
+   //!   already owns the mutex, this thread will block until the mutex is released.
+   //!   Whether or not this constructor handles recursive locking depends upon the mutex.
+   explicit scoped_lock(mutex_type& m)
+      : mp_mutex(&m), m_locked(false)
+   {  mp_mutex->lock();   m_locked = true;  }
+
+   //!Postconditions: owns() == false, and mutex() == &m.
+   //!Notes: The constructor will not take ownership of the mutex. There is no effect
+   //!   required on the referenced mutex.
+   scoped_lock(mutex_type& m, defer_lock_type)
+      : mp_mutex(&m), m_locked(false)
+   {}
+
+   //!Postconditions: owns() == true, and mutex() == &m.
+   //!Notes: The constructor will suppose that the mutex is already locked. There
+   //!   is no effect required on the referenced mutex.
+   scoped_lock(mutex_type& m, accept_ownership_type)
+      : mp_mutex(&m), m_locked(true)
+   {}
+
+   //!Effects: m.try_lock(). 
+   //!Postconditions: mutex() == &m. owns() == the return value of the
+   //!   m.try_lock() executed within the constructor.
+   //!Notes: The constructor will take ownership of the mutex if it can do
+   //!   so without waiting. Whether or not this constructor handles recursive
+   //!   locking depends upon the mutex. If the mutex_type does not support try_lock,
+   //!   this constructor will fail at compile time if instantiated, but otherwise
+   //!   have no effect.
+   scoped_lock(mutex_type& m, try_to_lock_type)
+      : mp_mutex(&m), m_locked(mp_mutex->try_lock())
+   {}
+
+   //!Effects: m.timed_lock(abs_time). 
+   //!Postconditions: mutex() == &m. owns() == the return value of the
+   //!   m.timed_lock(abs_time) executed within the constructor.
+   //!Notes: The constructor will take ownership of the mutex if it can do
+   //!   it until abs_time is reached. Whether or not this constructor
+   //!   handles recursive locking depends upon the mutex. If the mutex_type
+   //!   does not support try_lock, this constructor will fail at compile
+   //!   time if instantiated, but otherwise have no effect.
+   scoped_lock(mutex_type& m, const boost::posix_time::ptime& abs_time)
+      : mp_mutex(&m), m_locked(mp_mutex->timed_lock(abs_time))
+   {}
+
+   //!Postconditions: mutex() == the value scop.mutex() had before the
+   //!   constructor executes. s1.mutex() == 0. owns() == the value of
+   //!   scop.owns() before the constructor executes. scop.owns().
+   //!Notes: If the scop scoped_lock owns the mutex, ownership is moved
+   //!   to thisscoped_lock with no blocking. If the scop scoped_lock does not
+   //!   own the mutex, then neither will this scoped_lock. Only a moved
+   //!   scoped_lock's will match this signature. An non-moved scoped_lock
+   //!   can be moved with the expression: "boost::move(lock);". This
+   //!   constructor does not alter the state of the mutex, only potentially
+   //!   who owns it.
+   scoped_lock(BOOST_RV_REF(scoped_lock) scop)
+      : mp_mutex(0), m_locked(scop.owns())
+   {  mp_mutex = scop.release(); }
+
+   //!Effects: If upgr.owns() then calls unlock_upgradable_and_lock() on the
+   //!   referenced mutex. upgr.release() is called. 
+   //!Postconditions: mutex() == the value upgr.mutex() had before the construction.
+   //!   upgr.mutex() == 0. owns() == upgr.owns() before the construction.
+   //!   upgr.owns() == false after the construction.
+   //!Notes: If upgr is locked, this constructor will lock this scoped_lock while
+   //!   unlocking upgr. If upgr is unlocked, then this scoped_lock will be
+   //!   unlocked as well. Only a moved upgradable_lock's will match this
+   //!   signature. An non-moved upgradable_lock can be moved with
+   //!   the expression: "boost::move(lock);" This constructor may block if
+   //!   other threads hold a sharable_lock on this mutex (sharable_lock's can
+   //!   share ownership with an upgradable_lock).
+   template<class T>
+   explicit scoped_lock(BOOST_RV_REF(upgradable_lock<T>) upgr
+      , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      upgradable_lock<mutex_type> &u_lock = upgr;
+      if(u_lock.owns()){
+         u_lock.mutex()->unlock_upgradable_and_lock();
+         m_locked = true;
+      }
+      mp_mutex = u_lock.release();
+   }
+
+   //!Effects: If upgr.owns() then calls try_unlock_upgradable_and_lock() on the
+   //!referenced mutex:
+   //!   a)if try_unlock_upgradable_and_lock() returns true then mutex() obtains
+   //!      the value from upgr.release() and owns() is set to true. 
+   //!   b)if try_unlock_upgradable_and_lock() returns false then upgr is
+   //!      unaffected and this scoped_lock construction as the same effects as  
+   //!      a default construction. 
+   //!   c)Else upgr.owns() is false. mutex() obtains the value from upgr.release()
+   //!      and owns() is set to false 
+   //!Notes: This construction will not block. It will try to obtain mutex
+   //!   ownership from upgr immediately, while changing the lock type from a
+   //!   "read lock" to a "write lock". If the "read lock" isn't held in the
+   //!   first place, the mutex merely changes type to an unlocked "write lock".
+   //!   If the "read lock" is held, then mutex transfer occurs only if it can
+   //!   do so in a non-blocking manner.
+   template<class T>
+   scoped_lock(BOOST_RV_REF(upgradable_lock<T>) upgr, try_to_lock_type
+         , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      upgradable_lock<mutex_type> &u_lock = upgr;
+      if(u_lock.owns()){
+         if((m_locked = u_lock.mutex()->try_unlock_upgradable_and_lock()) == true){
+            mp_mutex = u_lock.release();
+         }
+      }
+      else{
+         u_lock.release();
+      }
+   }
+
+   //!Effects: If upgr.owns() then calls timed_unlock_upgradable_and_lock(abs_time)
+   //!   on the referenced mutex:
+   //!   a)if timed_unlock_upgradable_and_lock(abs_time) returns true then mutex()
+   //!      obtains the value from upgr.release() and owns() is set to true. 
+   //!   b)if timed_unlock_upgradable_and_lock(abs_time) returns false then upgr
+   //!      is unaffected and this scoped_lock construction as the same effects
+   //!      as a default construction.
+   //!   c)Else upgr.owns() is false. mutex() obtains the value from upgr.release()
+   //!      and owns() is set to false 
+   //!Notes: This construction will not block. It will try to obtain mutex ownership
+   //!   from upgr immediately, while changing the lock type from a "read lock" to a
+   //!   "write lock". If the "read lock" isn't held in the first place, the mutex
+   //!   merely changes type to an unlocked "write lock". If the "read lock" is held,
+   //!   then mutex transfer occurs only if it can do so in a non-blocking manner.
+   template<class T>
+   scoped_lock(BOOST_RV_REF(upgradable_lock<T>) upgr, boost::posix_time::ptime &abs_time
+               , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      upgradable_lock<mutex_type> &u_lock = upgr;
+      if(u_lock.owns()){
+         if((m_locked = u_lock.mutex()->timed_unlock_upgradable_and_lock(abs_time)) == true){
+            mp_mutex = u_lock.release();
+         }
+      }
+      else{
+         u_lock.release();
+      }
+   }
+
+   //!Effects: If shar.owns() then calls try_unlock_sharable_and_lock() on the
+   //!referenced mutex. 
+   //!   a)if try_unlock_sharable_and_lock() returns true then mutex() obtains
+   //!      the value from shar.release() and owns() is set to true. 
+   //!   b)if try_unlock_sharable_and_lock() returns false then shar is
+   //!      unaffected and this scoped_lock construction has the same
+   //!      effects as a default construction. 
+   //!   c)Else shar.owns() is false. mutex() obtains the value from
+   //!      shar.release() and owns() is set to false 
+   //!Notes: This construction will not block. It will try to obtain mutex
+   //!   ownership from shar immediately, while changing the lock type from a
+   //!   "read lock" to a "write lock". If the "read lock" isn't held in the
+   //!   first place, the mutex merely changes type to an unlocked "write lock".
+   //!   If the "read lock" is held, then mutex transfer occurs only if it can
+   //!   do so in a non-blocking manner.
+   template<class T>
+   scoped_lock(BOOST_RV_REF(sharable_lock<T>) shar, try_to_lock_type
+      , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      sharable_lock<mutex_type> &s_lock = shar;
+      if(s_lock.owns()){
+         if((m_locked = s_lock.mutex()->try_unlock_sharable_and_lock()) == true){
+            mp_mutex = s_lock.release();
+         }
+      }
+      else{
+         s_lock.release();
+      }
+   }
+
+   //!Effects: if (owns()) mp_mutex->unlock().
+   //!Notes: The destructor behavior ensures that the mutex lock is not leaked.*/
+   ~scoped_lock()
+   {
+      try{  if(m_locked && mp_mutex)   mp_mutex->unlock();  }
+      catch(...){}
+   }
+
+   //!Effects: If owns() before the call, then unlock() is called on mutex().
+   //!   *this gets the state of scop and scop gets set to a default constructed state. 
+   //!Notes: With a recursive mutex it is possible that both this and scop own
+   //!   the same mutex before the assignment. In this case, this will own the
+   //!   mutex after the assignment (and scop will not), but the mutex's lock
+   //!   count will be decremented by one.
+   scoped_lock &operator=(BOOST_RV_REF(scoped_lock) scop)
+   {  
+      if(this->owns())
+         this->unlock();
+      m_locked = scop.owns();
+      mp_mutex = scop.release();
+      return *this;
+   }
+
+   //!Effects: If mutex() == 0 or if already locked, throws a lock_exception()
+   //!   exception. Calls lock() on the referenced mutex.
+   //!Postconditions: owns() == true.
+   //!Notes: The scoped_lock changes from a state of not owning the mutex, to
+   //!   owning the mutex, blocking if necessary.
+   void lock()
+   {
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      mp_mutex->lock();
+      m_locked = true;
+   }
+
+   //!Effects: If mutex() == 0 or if already locked, throws a lock_exception()
+   //!   exception. Calls try_lock() on the referenced mutex. 
+   //!Postconditions: owns() == the value returned from mutex()->try_lock().
+   //!Notes: The scoped_lock changes from a state of not owning the mutex, to
+   //!   owning the mutex, but only if blocking was not required. If the
+   //!   mutex_type does not support try_lock(), this function will fail at
+   //!   compile time if instantiated, but otherwise have no effect.*/
+   bool try_lock()
+   {
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      m_locked = mp_mutex->try_lock();
+      return m_locked;
+   }
+
+   //!Effects: If mutex() == 0 or if already locked, throws a lock_exception()
+   //!   exception. Calls timed_lock(abs_time) on the referenced mutex.
+   //!Postconditions: owns() == the value returned from mutex()-> timed_lock(abs_time).
+   //!Notes: The scoped_lock changes from a state of not owning the mutex, to
+   //!   owning the mutex, but only if it can obtain ownership by the specified
+   //!   time. If the mutex_type does not support timed_lock (), this function
+   //!   will fail at compile time if instantiated, but otherwise have no effect.*/
+   bool timed_lock(const boost::posix_time::ptime& abs_time)
+   {
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      m_locked = mp_mutex->timed_lock(abs_time);
+      return m_locked;
+   }
+
+   //!Effects: If mutex() == 0 or if not locked, throws a lock_exception()
+   //!   exception. Calls unlock() on the referenced mutex.
+   //!Postconditions: owns() == false.
+   //!Notes: The scoped_lock changes from a state of owning the mutex, to not
+   //!   owning the mutex.*/
+   void unlock()
+   {
+      if(!mp_mutex || !m_locked)
+         throw lock_exception();
+      mp_mutex->unlock();
+      m_locked = false;
+   }
+
+   //!Effects: Returns true if this scoped_lock has acquired
+   //!the referenced mutex.
+   bool owns() const
+   {  return m_locked && mp_mutex;  }
+
+   //!Conversion to bool.
+   //!Returns owns().
+   operator unspecified_bool_type() const
+   {  return m_locked? &this_type::m_locked : 0;   }
+
+   //!Effects: Returns a pointer to the referenced mutex, or 0 if
+   //!there is no mutex to reference.
+   mutex_type* mutex() const
+   {  return  mp_mutex;  }
+
+   //!Effects: Returns a pointer to the referenced mutex, or 0 if there is no
+   //!   mutex to reference.
+   //!Postconditions: mutex() == 0 and owns() == false.
+   mutex_type* release()
+   {
+      mutex_type *mut = mp_mutex;
+      mp_mutex = 0;
+      m_locked = false;
+      return mut;
+   }
+ 
+   //!Effects: Swaps state with moved lock. 
+   //!Throws: Nothing.
+   void swap( scoped_lock<mutex_type> &other)
+   {
+      std::swap(mp_mutex, other.mp_mutex);
+      std::swap(m_locked, other.m_locked);
+   }
+
+   /// @cond
+   private:
+   mutex_type *mp_mutex; 
+   bool        m_locked;
+   /// @endcond
+};
+
+} // namespace interprocess
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_SCOPED_LOCK_HPP
diff --git a/boost/interprocess/sync/sharable_lock.hpp b/boost/interprocess/sync/sharable_lock.hpp
new file mode 100644
index 0000000000..c8b7c1d26e
--- /dev/null
+++ b/boost/interprocess/sync/sharable_lock.hpp
@@ -0,0 +1,305 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This interface is inspired by Howard Hinnant's lock proposal.
+// http://home.twcny.rr.com/hinnant/cpp_extensions/threads_move.html
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_SHARABLE_LOCK_HPP
+#define BOOST_INTERPROCESS_SHARABLE_LOCK_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/sync/lock_options.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+//!\file
+//!Describes the upgradable_lock class that serves to acquire the upgradable
+//!lock of a mutex.
+
+namespace boost {
+namespace interprocess {
+
+
+//!sharable_lock is meant to carry out the tasks for sharable-locking
+//!(such as read-locking), unlocking, try-sharable-locking and timed-sharable-locking
+//!(recursive or not) for the Mutex. The Mutex need not supply all of this
+//!functionality. If the client of sharable_lock<Mutex> does not use functionality which
+//!the Mutex does not supply, no harm is done. Mutex ownership can be shared among
+//!sharable_locks, and a single upgradable_lock. sharable_lock does not support
+//!copy semantics. But sharable_lock supports ownership transfer from an sharable_lock,
+//!upgradable_lock and scoped_lock via transfer_lock syntax.*/
+template <class SharableMutex>
+class sharable_lock
+{
+   public:
+   typedef SharableMutex mutex_type;
+   /// @cond
+   private:
+   typedef sharable_lock<SharableMutex> this_type;
+   explicit sharable_lock(scoped_lock<mutex_type>&);
+   typedef bool this_type::*unspecified_bool_type;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(sharable_lock)
+   /// @endcond
+   public:
+
+   //!Effects: Default constructs a sharable_lock.
+   //!Postconditions: owns() == false and mutex() == 0.
+   sharable_lock()
+      : mp_mutex(0), m_locked(false)
+   {}
+
+   //!Effects: m.lock_sharable().
+   //!Postconditions: owns() == true and mutex() == &m. 
+   //!Notes: The constructor will take sharable-ownership of the mutex. If
+   //!   another thread already owns the mutex with exclusive ownership
+   //!   (scoped_lock), this thread will block until the mutex is released.
+   //!   If another thread owns the mutex with sharable or upgradable ownership,
+   //!   then no blocking will occur. Whether or not this constructor handles
+   //!   recursive locking depends upon the mutex.
+   explicit sharable_lock(mutex_type& m)
+      : mp_mutex(&m), m_locked(false)
+   {  mp_mutex->lock_sharable();   m_locked = true;  }
+
+   //!Postconditions: owns() == false, and mutex() == &m.
+   //!Notes: The constructor will not take ownership of the mutex. There is no effect
+   //!   required on the referenced mutex.
+   sharable_lock(mutex_type& m, defer_lock_type)
+      : mp_mutex(&m), m_locked(false)
+   {}
+
+   //!Postconditions: owns() == true, and mutex() == &m.
+   //!Notes: The constructor will suppose that the mutex is already sharable
+   //!   locked. There is no effect required on the referenced mutex.
+   sharable_lock(mutex_type& m, accept_ownership_type)
+      : mp_mutex(&m), m_locked(true)
+   {}
+
+   //!Effects: m.try_lock_sharable()
+   //!Postconditions: mutex() == &m. owns() == the return value of the
+   //!   m.try_lock_sharable() executed within the constructor.
+   //!Notes: The constructor will take sharable-ownership of the mutex if it
+   //!   can do so without waiting. Whether or not this constructor handles
+   //!   recursive locking depends upon the mutex. If the mutex_type does not
+   //!   support try_lock_sharable, this constructor will fail at compile
+   //!   time if instantiated, but otherwise have no effect.
+   sharable_lock(mutex_type& m, try_to_lock_type)
+      : mp_mutex(&m), m_locked(false)
+   {  m_locked = mp_mutex->try_lock_sharable();   }
+
+   //!Effects: m.timed_lock_sharable(abs_time) 
+   //!Postconditions: mutex() == &m. owns() == the return value of the
+   //!   m.timed_lock_sharable() executed within the constructor.
+   //!Notes: The constructor will take sharable-ownership of the mutex if it
+   //!   can do so within the time specified. Whether or not this constructor
+   //!   handles recursive locking depends upon the mutex. If the mutex_type
+   //!   does not support timed_lock_sharable, this constructor will fail at
+   //!   compile time if instantiated, but otherwise have no effect.
+   sharable_lock(mutex_type& m, const boost::posix_time::ptime& abs_time)
+      : mp_mutex(&m), m_locked(false)
+   {  m_locked = mp_mutex->timed_lock_sharable(abs_time);  }
+
+   //!Postconditions: mutex() == upgr.mutex(). owns() == the value of upgr.owns()
+   //!   before the construction. upgr.owns() == false after the construction.
+   //!Notes: If the upgr sharable_lock owns the mutex, ownership is moved to this
+   //!   sharable_lock with no blocking. If the upgr sharable_lock does not own the mutex, then
+   //!   neither will this sharable_lock. Only a moved sharable_lock's will match this
+   //!   signature. An non-moved sharable_lock can be moved with the expression:
+   //!   "boost::move(lock);". This constructor does not alter the state of the mutex,
+   //!   only potentially who owns it.
+   sharable_lock(BOOST_RV_REF(sharable_lock<mutex_type>) upgr)
+      : mp_mutex(0), m_locked(upgr.owns())
+   {  mp_mutex = upgr.release(); }
+
+   //!Effects: If upgr.owns() then calls unlock_upgradable_and_lock_sharable() on the
+   //!   referenced mutex.
+   //!Postconditions: mutex() == the value upgr.mutex() had before the construction.
+   //!   upgr.mutex() == 0 owns() == the value of upgr.owns() before construction.
+   //!   upgr.owns() == false after the construction. 
+   //!Notes: If upgr is locked, this constructor will lock this sharable_lock while
+   //!   unlocking upgr. Only a moved sharable_lock's will match this
+   //!   signature. An non-moved upgradable_lock can be moved with the expression:
+   //!   "boost::move(lock);".*/
+   template<class T>
+   sharable_lock(BOOST_RV_REF(upgradable_lock<T>) upgr
+      , typename ipcdetail::enable_if< ipcdetail::is_same<T, SharableMutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      upgradable_lock<mutex_type> &u_lock = upgr;
+      if(u_lock.owns()){
+         u_lock.mutex()->unlock_upgradable_and_lock_sharable();
+         m_locked = true;
+      }
+      mp_mutex = u_lock.release();
+   }
+
+   //!Effects: If scop.owns() then calls unlock_and_lock_sharable() on the
+   //!   referenced mutex.
+   //!Postconditions: mutex() == the value scop.mutex() had before the construction.
+   //!   scop.mutex() == 0 owns() == scop.owns() before the constructor. After the
+   //!   construction, scop.owns() == false.
+   //!Notes: If scop is locked, this constructor will transfer the exclusive ownership
+   //!   to a sharable-ownership of this sharable_lock. 
+   //!   Only a moved scoped_lock's will match this
+   //!   signature. An non-moved scoped_lock can be moved with the expression:
+   //!   "boost::move(lock);".
+   template<class T>
+   sharable_lock(BOOST_RV_REF(scoped_lock<T>) scop
+               , typename ipcdetail::enable_if< ipcdetail::is_same<T, SharableMutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      scoped_lock<mutex_type> &e_lock = scop;
+      if(e_lock.owns()){
+         e_lock.mutex()->unlock_and_lock_sharable();
+         m_locked = true;
+      }
+      mp_mutex = e_lock.release();
+   }
+
+   //!Effects: if (owns()) mp_mutex->unlock_sharable().
+   //!Notes: The destructor behavior ensures that the mutex lock is not leaked.
+   ~sharable_lock()
+   {
+      try{
+         if(m_locked && mp_mutex)   mp_mutex->unlock_sharable();
+      }
+      catch(...){}
+   }
+
+   //!Effects: If owns() before the call, then unlock_sharable() is called on mutex().
+   //!   *this gets the state of upgr and upgr gets set to a default constructed state. 
+   //!Notes: With a recursive mutex it is possible that both this and upgr own the mutex
+   //!   before the assignment. In this case, this will own the mutex after the assignment
+   //!   (and upgr will not), but the mutex's lock count will be decremented by one.
+   sharable_lock &operator=(BOOST_RV_REF(sharable_lock<mutex_type>) upgr)
+   {  
+      if(this->owns())
+         this->unlock();
+      m_locked = upgr.owns();
+      mp_mutex = upgr.release();
+      return *this;
+   }
+
+   //!Effects: If mutex() == 0 or already locked, throws a lock_exception()
+   //!   exception. Calls lock_sharable() on the referenced mutex.
+   //!Postconditions: owns() == true.
+   //!Notes: The sharable_lock changes from a state of not owning the
+   //!   mutex, to owning the mutex, blocking if necessary.
+   void lock()
+   {  
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      mp_mutex->lock_sharable();
+      m_locked = true;
+   }
+
+   //!Effects: If mutex() == 0 or already locked, throws a lock_exception()
+   //!   exception. Calls try_lock_sharable() on the referenced mutex.
+   //!Postconditions: owns() == the value returned from
+   //!   mutex()->try_lock_sharable().
+   //!Notes: The sharable_lock changes from a state of not owning the mutex,
+   //!   to owning the mutex, but only if blocking was not required. If the
+   //!   mutex_type does not support try_lock_sharable(), this function will
+   //!   fail at compile time if instantiated, but otherwise have no effect.
+   bool try_lock()
+   {  
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      m_locked = mp_mutex->try_lock_sharable();
+      return m_locked;
+   }
+
+   //!Effects: If mutex() == 0 or already locked, throws a lock_exception()
+   //!   exception. Calls timed_lock_sharable(abs_time) on the referenced mutex.
+   //!Postconditions: owns() == the value returned from
+   //!   mutex()->timed_lock_sharable(elps_time).
+   //!Notes: The sharable_lock changes from a state of not owning the mutex,
+   //!   to owning the mutex, but only if it can obtain ownership within the
+   //!   specified time interval. If the mutex_type does not support
+   //!   timed_lock_sharable(), this function will fail at compile time if
+   //!   instantiated, but otherwise have no effect.
+   bool timed_lock(const boost::posix_time::ptime& abs_time)
+   {  
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      m_locked = mp_mutex->timed_lock_sharable(abs_time);
+      return m_locked;
+   }
+
+   //!Effects: If mutex() == 0 or not locked, throws a lock_exception() exception.
+   //!   Calls unlock_sharable() on the referenced mutex.
+   //!Postconditions: owns() == false.
+   //!Notes: The sharable_lock changes from a state of owning the mutex, to
+   //!   not owning the mutex.
+   void unlock()
+   {
+      if(!mp_mutex || !m_locked)
+         throw lock_exception();
+      mp_mutex->unlock_sharable();
+      m_locked = false;
+   }
+
+   //!Effects: Returns true if this scoped_lock has
+   //!acquired the referenced mutex.
+   bool owns() const
+   {  return m_locked && mp_mutex;  }
+
+   //!Conversion to bool.
+   //!Returns owns().
+   operator unspecified_bool_type() const
+   {  return m_locked? &this_type::m_locked : 0;   }
+
+   //!Effects: Returns a pointer to the referenced mutex, or 0 if
+   //!there is no mutex to reference.
+   mutex_type* mutex() const
+   {  return  mp_mutex;  }
+
+   //!Effects: Returns a pointer to the referenced mutex, or 0 if there is no
+   //!   mutex to reference.
+   //!Postconditions: mutex() == 0 and owns() == false.
+   mutex_type* release()
+   {
+      mutex_type *mut = mp_mutex;
+      mp_mutex = 0;
+      m_locked = false;
+      return mut;
+   }
+
+   //!Effects: Swaps state with moved lock. 
+   //!Throws: Nothing.
+   void swap(sharable_lock<mutex_type> &other)
+   {
+      std::swap(mp_mutex, other.mp_mutex);
+      std::swap(m_locked, other.m_locked);
+   }
+
+   /// @cond
+   private:
+   mutex_type *mp_mutex;
+   bool        m_locked;
+   /// @endcond
+};
+
+} // namespace interprocess
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_SHARABLE_LOCK_HPP
diff --git a/boost/interprocess/sync/shm/named_condition.hpp b/boost/interprocess/sync/shm/named_condition.hpp
new file mode 100644
index 0000000000..0d67c25757
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_condition.hpp
@@ -0,0 +1,379 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SHM_NAMED_CONDITION_HPP
+#define BOOST_INTERPROCESS_SHM_NAMED_CONDITION_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/static_assert.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/sync/interprocess_condition.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+#include <boost/interprocess/sync/named_mutex.hpp>
+#include <boost/interprocess/permissions.hpp>
+#if defined BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#endif
+
+
+//!\file
+//!Describes process-shared variables interprocess_condition class
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+/// @endcond
+
+//! A global condition variable that can be created by name.
+//! This condition variable is designed to work with named_mutex and
+//! can't be placed in shared memory or memory mapped files.
+class shm_named_condition
+{
+   /// @cond
+   //Non-copyable
+   shm_named_condition();
+   shm_named_condition(const shm_named_condition &);
+   shm_named_condition &operator=(const shm_named_condition &);
+   /// @endcond
+   public:
+   //!Creates a global condition with a name.
+   //!If the condition can't be created throws interprocess_exception
+   shm_named_condition(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global condition with a name. 
+   //!If the condition is created, this call is equivalent to
+   //!shm_named_condition(create_only_t, ... )
+   //!If the condition is already created, this call is equivalent
+   //!shm_named_condition(open_only_t, ... )
+   //!Does not throw
+   shm_named_condition(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global condition with a name if that condition is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   shm_named_condition(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~shm_named_condition();
+
+   //!If there is a thread waiting on *this, change that 
+   //!thread's state to ready. Otherwise there is no effect.*/
+   void notify_one();
+
+   //!Change the state of all threads waiting on *this to ready.
+   //!If there are no waiting threads, notify_all() has no effect.
+   void notify_all();
+
+   //!Releases the lock on the named_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), and then reacquires the lock.
+   template <typename L>
+   void wait(L& lock);
+
+   //!The same as:
+   //!while (!pred()) wait(lock)
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred);
+
+   //!Releases the lock on the named_mutex object associated with lock, blocks 
+   //!the current thread of execution until readied by a call to 
+   //!this->notify_one() or this->notify_all(), or until time abs_time is reached, 
+   //!and then reacquires the lock.
+   //!Returns: false if time abs_time is reached, otherwise true.
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time);
+
+   //!The same as:   while (!pred()) { 
+   //!                  if (!timed_wait(lock, abs_time)) return pred(); 
+   //!               } return true;
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred);
+
+   //!Erases a named condition from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+
+   struct condition_holder
+   {
+      interprocess_condition cond_;
+      //If named_mutex is implemented using semaphores
+      //we need to store an additional mutex
+      #if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+      interprocess_mutex mutex_;
+      #endif
+   };
+
+   interprocess_condition *condition() const
+   {  return &static_cast<condition_holder*>(m_shmem.get_user_address())->cond_; }
+
+   template <class Lock>
+   class lock_inverter
+   {
+      Lock &l_;
+      public:
+      lock_inverter(Lock &l)
+         :  l_(l)
+      {}
+      void lock()    {   l_.unlock();   }
+      void unlock()  {   l_.lock();     }
+   };
+
+   #if defined (BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+      interprocess_mutex *mutex() const
+      {  return &static_cast<condition_holder*>(m_shmem.get_user_address())->mutex_; }
+
+      template <class Lock>
+      void do_wait(Lock& lock)
+      {
+         //shm_named_condition only works with named_mutex
+         BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
+         
+         //lock internal before unlocking external to avoid race with a notifier
+         scoped_lock<interprocess_mutex>     internal_lock(*this->mutex());
+         lock_inverter<Lock> inverted_lock(lock);
+         scoped_lock<lock_inverter<Lock> >   external_unlock(inverted_lock);
+
+         //unlock internal first to avoid deadlock with near simultaneous waits
+         scoped_lock<interprocess_mutex>     internal_unlock;
+         internal_lock.swap(internal_unlock);
+         this->condition()->wait(internal_unlock);
+      }
+
+      template <class Lock>
+      bool do_timed_wait(Lock& lock, const boost::posix_time::ptime &abs_time)
+      {
+         //shm_named_condition only works with named_mutex
+         BOOST_STATIC_ASSERT((is_convertible<typename Lock::mutex_type&, named_mutex&>::value == true));
+         //lock internal before unlocking external to avoid race with a notifier  
+         scoped_lock<interprocess_mutex>     internal_lock(*this->mutex(), abs_time);  
+         if(!internal_lock) return false;
+         lock_inverter<Lock> inverted_lock(lock);  
+         scoped_lock<lock_inverter<Lock> >   external_unlock(inverted_lock);  
+
+         //unlock internal first to avoid deadlock with near simultaneous waits  
+         scoped_lock<interprocess_mutex>     internal_unlock;  
+         internal_lock.swap(internal_unlock);  
+         return this->condition()->timed_wait(internal_unlock, abs_time);  
+      }
+   #else
+      template<class Lock>
+      class lock_wrapper
+      {
+         typedef void (lock_wrapper::*unspecified_bool_type)();
+         public:
+
+         typedef interprocess_mutex mutex_type;
+
+         lock_wrapper(Lock &l)
+            : l_(l)
+         {}
+
+         mutex_type* mutex() const
+         {  return l_.mutex()->mutex();  }
+
+         void lock()    { l_.lock(); }
+
+         void unlock()  { l_.unlock(); }
+
+         operator unspecified_bool_type() const
+         {  return l_ ? &lock_wrapper::lock : 0;  }
+
+         private:
+         Lock &l_;
+      };
+   #endif
+
+   friend class boost::interprocess::ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   managed_open_or_create_impl<shared_memory_object> m_shmem;
+
+   template <class T, class Arg> friend class boost::interprocess::ipcdetail::named_creation_functor;
+   typedef boost::interprocess::ipcdetail::named_creation_functor<condition_holder> construct_func_t;
+   /// @endcond
+};
+
+/// @cond
+
+inline shm_named_condition::~shm_named_condition()
+{}
+
+inline shm_named_condition::shm_named_condition(create_only_t, const char *name, const permissions &perm)
+   :  m_shmem  (create_only
+               ,name
+               ,sizeof(condition_holder) +
+                  managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(DoCreate)
+               ,perm)
+{}
+
+inline shm_named_condition::shm_named_condition(open_or_create_t, const char *name, const permissions &perm)
+   :  m_shmem  (open_or_create
+               ,name
+               ,sizeof(condition_holder) +
+                  managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(DoOpenOrCreate)
+               ,perm)
+{}
+
+inline shm_named_condition::shm_named_condition(open_only_t, const char *name)
+   :  m_shmem  (open_only
+               ,name
+               ,read_write
+               ,0
+               ,construct_func_t(DoOpen))
+{}
+
+inline void shm_named_condition::dont_close_on_destruction()
+{  interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+#if defined(BOOST_INTERPROCESS_NAMED_MUTEX_USES_POSIX_SEMAPHORES)
+
+inline void shm_named_condition::notify_one()
+{
+   scoped_lock<interprocess_mutex> internal_lock(*this->mutex());
+   this->condition()->notify_one();
+}
+
+inline void shm_named_condition::notify_all()
+{
+   scoped_lock<interprocess_mutex> internal_lock(*this->mutex());
+   this->condition()->notify_all();
+}
+
+template <typename L>
+inline void shm_named_condition::wait(L& lock)
+{
+   if (!lock)
+      throw lock_exception();
+   this->do_wait(lock);
+}
+
+template <typename L, typename Pr>
+inline void shm_named_condition::wait(L& lock, Pr pred)
+{
+   if (!lock)
+      throw lock_exception();
+   while (!pred())
+      this->do_wait(lock);
+}
+
+template <typename L>
+inline bool shm_named_condition::timed_wait
+   (L& lock, const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->wait(lock);
+      return true;
+   }
+   if (!lock)
+      throw lock_exception();
+   return this->do_timed_wait(lock, abs_time);
+}
+
+template <typename L, typename Pr>
+inline bool shm_named_condition::timed_wait
+   (L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->wait(lock, pred);
+      return true;
+   }
+   if (!lock)
+      throw lock_exception();
+
+   while (!pred()){
+      if(!this->do_timed_wait(lock, abs_time)){
+         return pred();
+      }
+   }
+   return true;
+}
+
+#else
+
+inline void shm_named_condition::notify_one()
+{  this->condition()->notify_one();  }
+
+inline void shm_named_condition::notify_all()
+{  this->condition()->notify_all();  }
+
+template <typename L>
+inline void shm_named_condition::wait(L& lock)
+{
+   lock_wrapper<L> newlock(lock);
+   this->condition()->wait(newlock);
+}
+
+template <typename L, typename Pr>
+inline void shm_named_condition::wait(L& lock, Pr pred)
+{
+   lock_wrapper<L> newlock(lock);
+   this->condition()->wait(newlock, pred);
+}
+
+template <typename L>
+inline bool shm_named_condition::timed_wait
+   (L& lock, const boost::posix_time::ptime &abs_time)
+{
+   lock_wrapper<L> newlock(lock);
+   return this->condition()->timed_wait(newlock, abs_time);
+}
+
+template <typename L, typename Pr>
+inline bool shm_named_condition::timed_wait
+   (L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+{
+   lock_wrapper<L> newlock(lock);
+   return this->condition()->timed_wait(newlock, abs_time, pred);
+}
+
+#endif
+
+inline bool shm_named_condition::remove(const char *name)
+{  return shared_memory_object::remove(name); }
+
+/// @endcond
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_SHM_NAMED_CONDITION_HPP
diff --git a/boost/interprocess/sync/shm/named_creation_functor.hpp b/boost/interprocess/sync/shm/named_creation_functor.hpp
new file mode 100644
index 0000000000..11a1db1d6f
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_creation_functor.hpp
@@ -0,0 +1,68 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2011. 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_SYNC_NAMED_CREATION_FUNCTOR_HPP
+#define BOOST_INTERPROCESS_SYNC_NAMED_CREATION_FUNCTOR_HPP
+
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+struct named_creation_functor_no_arg{};
+
+template <class T, class Arg = named_creation_functor_no_arg>
+class named_creation_functor
+{
+   typedef named_creation_functor_no_arg no_arg_t;
+   public:
+   named_creation_functor(create_enum_t type, Arg arg = Arg())
+      :  m_creation_type(type), m_arg(arg){}
+
+   template<class ArgType>
+   void construct(void *address, typename enable_if_c<is_same<ArgType, no_arg_t>::value>::type * = 0) const
+   {  new(address)T; }
+
+   template<class ArgType>
+   void construct(void *address, typename enable_if_c<!is_same<ArgType, no_arg_t>::value>::type * = 0) const
+   {  new(address)T(m_arg); }
+
+   bool operator()(void *address, std::size_t, bool created) const
+   {   
+      switch(m_creation_type){
+         case DoOpen:
+            return true;
+         break;
+         case DoCreate:
+         case DoOpenOrCreate:
+            if(created){
+               construct<Arg>(address);
+            }
+            return true;
+         break;
+
+         default:
+            return false;
+         break;
+      }
+   }
+   private:
+   create_enum_t m_creation_type;
+   Arg m_arg;
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#endif   //BOOST_INTERPROCESS_SYNC_NAMED_CREATION_FUNCTOR_HPP
diff --git a/boost/interprocess/sync/shm/named_mutex.hpp b/boost/interprocess/sync/shm/named_mutex.hpp
new file mode 100644
index 0000000000..a71eb4fe68
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_mutex.hpp
@@ -0,0 +1,184 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SHM_NAMED_MUTEX_HPP
+#define BOOST_INTERPROCESS_SHM_NAMED_MUTEX_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+
+//!\file
+//!Describes a named mutex class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class named_condition;
+
+//!A mutex with a global name, so it can be found from different 
+//!processes. This mutex can't be placed in shared memory, and
+//!each process should have it's own named mutex.
+class shm_named_mutex
+{
+   /// @cond
+
+   //Non-copyable
+   shm_named_mutex();
+   shm_named_mutex(const shm_named_mutex &);
+   shm_named_mutex &operator=(const shm_named_mutex &);
+   friend class named_condition;
+   /// @endcond
+
+   public:
+   //!Creates a global interprocess_mutex with a name.
+   //!Throws interprocess_exception on error.
+   shm_named_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global mutex with a name. 
+   //!If the mutex is created, this call is equivalent to
+   //!shm_named_mutex(create_only_t, ... )
+   //!If the mutex is already created, this call is equivalent
+   //!shm_named_mutex(open_only_t, ... )
+   //!Does not throw
+   shm_named_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global mutex with a name if that mutex is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   shm_named_mutex(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~shm_named_mutex();
+
+   //!Unlocks a previously locked
+   //!interprocess_mutex.
+   void unlock();
+
+   //!Locks interprocess_mutex, sleeps when interprocess_mutex is already locked.
+   //!Throws interprocess_exception if a severe error is found
+   void lock();
+
+   //!Tries to lock the interprocess_mutex, returns false when interprocess_mutex 
+   //!is already locked, returns true when success.
+   //!Throws interprocess_exception if a severe error is found
+   bool try_lock();
+
+   //!Tries to lock the interprocess_mutex until time abs_time,
+   //!Returns false when timeout expires, returns true when locks.
+   //!Throws interprocess_exception if a severe error is found
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Erases a named mutex from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   interprocess_mutex *mutex() const
+   {  return static_cast<interprocess_mutex*>(m_shmem.get_user_address()); }
+
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::named_creation_functor<interprocess_mutex> construct_func_t;
+   /// @endcond
+};
+
+/// @cond
+
+inline void shm_named_mutex::dont_close_on_destruction()
+{  ipcdetail::interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+inline shm_named_mutex::~shm_named_mutex()
+{}
+
+inline shm_named_mutex::shm_named_mutex(create_only_t, const char *name, const permissions &perm)
+   :  m_shmem  (create_only
+               ,name
+               ,sizeof(interprocess_mutex) +
+                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoCreate)
+               ,perm)
+{}
+
+inline shm_named_mutex::shm_named_mutex(open_or_create_t, const char *name, const permissions &perm)
+   :  m_shmem  (open_or_create
+               ,name
+               ,sizeof(interprocess_mutex) +
+                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoOpenOrCreate)
+               ,perm)
+{}
+
+inline shm_named_mutex::shm_named_mutex(open_only_t, const char *name)
+   :  m_shmem  (open_only
+               ,name
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoOpen))
+{}
+
+inline void shm_named_mutex::lock()
+{  this->mutex()->lock();  }
+
+inline void shm_named_mutex::unlock()
+{  this->mutex()->unlock();  }
+
+inline bool shm_named_mutex::try_lock()
+{  return this->mutex()->try_lock();  }
+
+inline bool shm_named_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   return this->mutex()->timed_lock(abs_time);
+}
+
+inline bool shm_named_mutex::remove(const char *name)
+{  return shared_memory_object::remove(name); }
+
+/// @endcond
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_SHM_NAMED_MUTEX_HPP
diff --git a/boost/interprocess/sync/shm/named_recursive_mutex.hpp b/boost/interprocess/sync/shm/named_recursive_mutex.hpp
new file mode 100644
index 0000000000..461c97eb32
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_recursive_mutex.hpp
@@ -0,0 +1,175 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SHM_NAMED_RECURSIVE_MUTEX_HPP
+#define BOOST_INTERPROCESS_SHM_NAMED_RECURSIVE_MUTEX_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+//!\file
+//!Describes a named shm_named_recursive_mutex class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+/// @cond
+class interprocess_tester;
+/// @endcond
+
+class shm_named_recursive_mutex
+{
+   /// @cond
+   //Non-copyable
+   shm_named_recursive_mutex();
+   shm_named_recursive_mutex(const shm_named_recursive_mutex &);
+   shm_named_recursive_mutex &operator=(const shm_named_recursive_mutex &);
+   /// @endcond
+   public:
+
+   //!Creates a global recursive_mutex with a name.
+   //!If the recursive_mutex can't be created throws interprocess_exception
+   shm_named_recursive_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global recursive_mutex with a name. 
+   //!If the recursive_mutex is created, this call is equivalent to
+   //!shm_named_recursive_mutex(create_only_t, ... )
+   //!If the recursive_mutex is already created, this call is equivalent
+   //!shm_named_recursive_mutex(open_only_t, ... )
+   //!Does not throw
+   shm_named_recursive_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global recursive_mutex with a name if that recursive_mutex is previously
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   shm_named_recursive_mutex(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~shm_named_recursive_mutex();
+
+   //!Unlocks a previously locked
+   //!shm_named_recursive_mutex.
+   void unlock();
+
+   //!Locks shm_named_recursive_mutex, sleeps when shm_named_recursive_mutex is already locked.
+   //!Throws interprocess_exception if a severe error is found.
+   void lock();
+
+   //!Tries to lock the shm_named_recursive_mutex, returns false when shm_named_recursive_mutex 
+   //!is already locked, returns true when success.
+   //!Throws interprocess_exception if a severe error is found.
+   bool try_lock();
+
+   //!Tries to lock the shm_named_recursive_mutex until time abs_time,
+   //!Returns false when timeout expires, returns true when locks.
+   //!Throws interprocess_exception if a severe error is found
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Erases a named recursive mutex
+   //!from the system
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class interprocess_tester;
+   void dont_close_on_destruction();
+
+   interprocess_recursive_mutex *mutex() const
+   {  return static_cast<interprocess_recursive_mutex*>(m_shmem.get_user_address()); }
+
+   managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef named_creation_functor<interprocess_recursive_mutex> construct_func_t;
+   /// @endcond
+};
+
+inline shm_named_recursive_mutex::~shm_named_recursive_mutex()
+{}
+
+inline void shm_named_recursive_mutex::dont_close_on_destruction()
+{  interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+inline shm_named_recursive_mutex::shm_named_recursive_mutex(create_only_t, const char *name, const permissions &perm)
+   :  m_shmem  (create_only
+               ,name
+               ,sizeof(interprocess_recursive_mutex) +
+                  managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(DoCreate)
+               ,perm)
+{}
+
+inline shm_named_recursive_mutex::shm_named_recursive_mutex(open_or_create_t, const char *name, const permissions &perm)
+   :  m_shmem  (open_or_create
+               ,name
+               ,sizeof(interprocess_recursive_mutex) +
+                  managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(DoOpenOrCreate)
+               ,perm)
+{}
+
+inline shm_named_recursive_mutex::shm_named_recursive_mutex(open_only_t, const char *name)
+   :  m_shmem  (open_only
+               ,name
+               ,read_write
+               ,0
+               ,construct_func_t(DoOpen))
+{}
+
+inline void shm_named_recursive_mutex::lock()
+{  this->mutex()->lock();  }
+
+inline void shm_named_recursive_mutex::unlock()
+{  this->mutex()->unlock();  }
+
+inline bool shm_named_recursive_mutex::try_lock()
+{  return this->mutex()->try_lock();  }
+
+inline bool shm_named_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   return this->mutex()->timed_lock(abs_time);
+}
+
+inline bool shm_named_recursive_mutex::remove(const char *name)
+{  return shared_memory_object::remove(name); }
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_SHM_NAMED_RECURSIVE_MUTEX_HPP
diff --git a/boost/interprocess/sync/shm/named_semaphore.hpp b/boost/interprocess/sync/shm/named_semaphore.hpp
new file mode 100644
index 0000000000..c6d3830db5
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_semaphore.hpp
@@ -0,0 +1,141 @@
+ //////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_SHM_NAMED_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_SHM_NAMED_SEMAPHORE_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <boost/interprocess/detail/interprocess_tester.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/sync/interprocess_semaphore.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class shm_named_semaphore
+{
+   /// @cond
+
+   //Non-copyable
+   shm_named_semaphore();
+   shm_named_semaphore(const shm_named_semaphore &);
+   shm_named_semaphore &operator=(const shm_named_semaphore &);
+   /// @endcond
+
+   public:
+   shm_named_semaphore(create_only_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());
+
+   shm_named_semaphore(open_or_create_t, const char *name, unsigned int initialCount, const permissions &perm = permissions());
+
+   shm_named_semaphore(open_only_t, const char *name);
+
+   ~shm_named_semaphore();
+
+   void post();
+   void wait();
+   bool try_wait();
+   bool timed_wait(const boost::posix_time::ptime &abs_time);
+
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class interprocess_tester;
+   void dont_close_on_destruction();
+
+   interprocess_semaphore *semaphore() const
+   {  return static_cast<interprocess_semaphore*>(m_shmem.get_user_address()); }
+
+   managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef named_creation_functor<interprocess_semaphore, int> construct_func_t;
+   /// @endcond
+};
+
+inline shm_named_semaphore::~shm_named_semaphore()
+{}
+
+inline void shm_named_semaphore::dont_close_on_destruction()
+{  interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+inline shm_named_semaphore::shm_named_semaphore
+   (create_only_t, const char *name, unsigned int initialCount, const permissions &perm)
+   :  m_shmem  (create_only
+               ,name
+               ,sizeof(interprocess_semaphore) +
+                  managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(DoCreate, initialCount)
+               ,perm)
+{}
+
+inline shm_named_semaphore::shm_named_semaphore
+   (open_or_create_t, const char *name, unsigned int initialCount, const permissions &perm)
+   :  m_shmem  (open_or_create
+               ,name
+               ,sizeof(interprocess_semaphore) +
+                  managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(DoOpenOrCreate, initialCount)
+               ,perm)
+{}
+
+inline shm_named_semaphore::shm_named_semaphore
+   (open_only_t, const char *name)
+   :  m_shmem  (open_only
+               ,name
+               ,read_write
+               ,0
+               ,construct_func_t(DoOpen, 0))
+{}
+
+inline void shm_named_semaphore::post()
+{  semaphore()->post();   }
+
+inline void shm_named_semaphore::wait()
+{  semaphore()->wait();   }
+
+inline bool shm_named_semaphore::try_wait()
+{  return semaphore()->try_wait();   }
+
+inline bool shm_named_semaphore::timed_wait(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->wait();
+      return true;
+   }
+   return semaphore()->timed_wait(abs_time);
+}
+
+inline bool shm_named_semaphore::remove(const char *name)
+{  return shared_memory_object::remove(name); }
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_SHM_NAMED_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/shm/named_upgradable_mutex.hpp b/boost/interprocess/sync/shm/named_upgradable_mutex.hpp
new file mode 100644
index 0000000000..338fa98f7d
--- /dev/null
+++ b/boost/interprocess/sync/shm/named_upgradable_mutex.hpp
@@ -0,0 +1,372 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_NAMED_UPGRADABLE_MUTEX_HPP
+#define BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_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/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/detail/managed_open_or_create_impl.hpp>
+#include <boost/interprocess/sync/interprocess_upgradable_mutex.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/shm/named_creation_functor.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+//!\file
+//!Describes a named upgradable mutex class for inter-process synchronization
+
+namespace boost {
+namespace interprocess {
+
+/// @cond
+namespace ipcdetail{ class interprocess_tester; }
+/// @endcond
+
+class named_condition;
+
+//!A upgradable mutex with a global name, so it can be found from different 
+//!processes. This mutex can't be placed in shared memory, and
+//!each process should have it's own named upgradable mutex.
+class named_upgradable_mutex
+{
+   /// @cond
+   //Non-copyable
+   named_upgradable_mutex();
+   named_upgradable_mutex(const named_upgradable_mutex &);
+   named_upgradable_mutex &operator=(const named_upgradable_mutex &);
+   friend class named_condition;
+   /// @endcond
+   public:
+
+   //!Creates a global upgradable mutex with a name. 
+   //!If the upgradable mutex can't be created throws interprocess_exception
+   named_upgradable_mutex(create_only_t create_only, const char *name, const permissions &perm = permissions());
+
+   //!Opens or creates a global upgradable mutex with a name, and an initial count. 
+   //!If the upgradable mutex is created, this call is equivalent to
+   //!named_upgradable_mutex(create_only_t, ...)
+   //!If the upgradable mutex is already created, this call is equivalent to
+   //!named_upgradable_mutex(open_only_t, ... ).
+   named_upgradable_mutex(open_or_create_t open_or_create, const char *name, const permissions &perm = permissions());
+
+   //!Opens a global upgradable mutex with a name if that upgradable mutex
+   //!is previously.
+   //!created. If it is not previously created this function throws
+   //!interprocess_exception.
+   named_upgradable_mutex(open_only_t open_only, const char *name);
+
+   //!Destroys *this and indicates that the calling process is finished using
+   //!the resource. The destructor function will deallocate
+   //!any system resources allocated by the system for use by this process for
+   //!this resource. The resource can still be opened again calling
+   //!the open constructor overload. To erase the resource from the system
+   //!use remove().
+   ~named_upgradable_mutex();
+
+   //Exclusive locking
+
+   //!Effects: The calling thread tries to obtain exclusive ownership of the mutex,
+   //!   and if another thread has exclusive, sharable or upgradable ownership of
+   //!   the mutex, it waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   without waiting. If no other thread has exclusive, sharable or upgradable
+   //!   ownership of the mutex this succeeds.
+   //!Returns: If it can acquire exclusive ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock();
+
+   //!Effects: The calling thread tries to acquire exclusive ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive, sharable or
+   //!   upgradable ownership of the mutex or abs_time is reached. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The calling thread releases the exclusive ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock();
+
+   //Sharable locking
+
+   //!Effects: The calling thread tries to obtain sharable ownership of the mutex,
+   //!   and if another thread has exclusive ownership of the mutex,
+   //!   waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive ownership
+   //!   of the mutex this succeeds. 
+   //!Returns: If it can acquire sharable ownership immediately returns true. If it
+   //!   has to wait, returns false. 
+   //!Throws: interprocess_exception on error.
+   bool try_lock_sharable();
+
+   //!Effects: The calling thread tries to acquire sharable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive
+   //!   ownership of the mutex or abs_time is reached. 
+   //!Returns: If acquires sharable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_sharable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The calling thread releases the sharable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_sharable();
+
+   //Upgradable locking
+
+   //!Effects: The calling thread tries to obtain upgradable ownership of the mutex,
+   //!   and if another thread has exclusive or upgradable ownership of the mutex,
+   //!   waits until it can obtain the ownership.
+   //!Throws: interprocess_exception on error.
+   void lock_upgradable();
+
+   //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
+   //!   without waiting. If no other thread has exclusive or upgradable ownership
+   //!   of the mutex this succeeds. 
+   //!Returns: If it can acquire upgradable ownership immediately returns true.
+   //!   If it has to wait, returns false.
+   //!Throws: interprocess_exception on error.
+   bool try_lock_upgradable();
+
+   //!Effects: The calling thread tries to acquire upgradable ownership of the mutex
+   //!   waiting if necessary until no other thread has exclusive or upgradable
+   //!   ownership of the mutex or abs_time is reached.
+   //!Returns: If acquires upgradable ownership, returns true. Otherwise returns false. 
+   //!Throws: interprocess_exception on error.
+   bool timed_lock_upgradable(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The calling thread releases the upgradable ownership of the mutex. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable();
+
+   //Demotions
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The thread atomically releases exclusive ownership and acquires
+   //!   upgradable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_and_lock_upgradable();
+
+   //!Precondition: The thread must have exclusive ownership of the mutex. 
+   //!Effects: The thread atomically releases exclusive ownership and acquires
+   //!   sharable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_and_lock_sharable();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and acquires
+   //!   sharable ownership. This operation is non-blocking. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable_and_lock_sharable();
+
+   //Promotions
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and acquires
+   //!   exclusive ownership. This operation will block until all threads with
+   //!   sharable ownership release it. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   void unlock_upgradable_and_lock();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and tries to
+   //!   acquire exclusive ownership. This operation will fail if there are threads
+   //!   with sharable ownership, but it will maintain upgradable ownership. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false.
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_upgradable_and_lock();
+
+   //!Precondition: The thread must have upgradable ownership of the mutex. 
+   //!Effects: The thread atomically releases upgradable ownership and tries to acquire
+   //!   exclusive ownership, waiting if necessary until abs_time. This operation will
+   //!   fail if there are threads with sharable ownership or timeout reaches, but it
+   //!   will maintain upgradable ownership. 
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &abs_time);
+
+   //!Precondition: The thread must have sharable ownership of the mutex. 
+   //!Effects: The thread atomically releases sharable ownership and tries to acquire
+   //!   exclusive ownership. This operation will fail if there are threads with sharable
+   //!   or upgradable ownership, but it will maintain sharable ownership.
+   //!Returns: If acquires exclusive ownership, returns true. Otherwise returns false. 
+   //!Throws: An exception derived from interprocess_exception on error.
+   bool try_unlock_sharable_and_lock();
+
+   bool try_unlock_sharable_and_lock_upgradable();
+
+   //!Erases a named upgradable mutex from the system.
+   //!Returns false on error. Never throws.
+   static bool remove(const char *name);
+
+   /// @cond
+   private:
+   friend class ipcdetail::interprocess_tester;
+   void dont_close_on_destruction();
+
+   interprocess_upgradable_mutex *mutex() const
+   {  return static_cast<interprocess_upgradable_mutex*>(m_shmem.get_user_address()); }
+
+   ipcdetail::managed_open_or_create_impl<shared_memory_object> m_shmem;
+   typedef ipcdetail::named_creation_functor<interprocess_upgradable_mutex> construct_func_t;
+   /// @endcond
+};
+
+/// @cond
+
+inline named_upgradable_mutex::~named_upgradable_mutex()
+{}
+
+inline named_upgradable_mutex::named_upgradable_mutex
+   (create_only_t, const char *name, const permissions &perm)
+   :  m_shmem  (create_only
+               ,name
+               ,sizeof(interprocess_upgradable_mutex) +
+                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoCreate)
+               ,perm)
+{}
+
+inline named_upgradable_mutex::named_upgradable_mutex
+   (open_or_create_t, const char *name, const permissions &perm)
+   :  m_shmem  (open_or_create
+               ,name
+               ,sizeof(interprocess_upgradable_mutex) +
+                  ipcdetail::managed_open_or_create_impl<shared_memory_object>::
+                     ManagedOpenOrCreateUserOffset
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoOpenOrCreate)
+               ,perm)
+{}
+
+inline named_upgradable_mutex::named_upgradable_mutex
+   (open_only_t, const char *name)
+   :  m_shmem  (open_only
+               ,name
+               ,read_write
+               ,0
+               ,construct_func_t(ipcdetail::DoOpen))
+{}
+
+inline void named_upgradable_mutex::dont_close_on_destruction()
+{  ipcdetail::interprocess_tester::dont_close_on_destruction(m_shmem);  }
+
+inline void named_upgradable_mutex::lock()
+{  this->mutex()->lock();  }
+
+inline void named_upgradable_mutex::unlock()
+{  this->mutex()->unlock();  }
+
+inline bool named_upgradable_mutex::try_lock()
+{  return this->mutex()->try_lock();  }
+
+inline bool named_upgradable_mutex::timed_lock
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   return this->mutex()->timed_lock(abs_time);
+}
+
+inline void named_upgradable_mutex::lock_upgradable()
+{  this->mutex()->lock_upgradable();  }
+
+inline void named_upgradable_mutex::unlock_upgradable()
+{  this->mutex()->unlock_upgradable();  }
+
+inline bool named_upgradable_mutex::try_lock_upgradable()
+{  return this->mutex()->try_lock_upgradable();  }
+
+inline bool named_upgradable_mutex::timed_lock_upgradable
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_upgradable();
+      return true;
+   }
+   return this->mutex()->timed_lock_upgradable(abs_time);
+}
+
+inline void named_upgradable_mutex::lock_sharable()
+{  this->mutex()->lock_sharable();  }
+
+inline void named_upgradable_mutex::unlock_sharable()
+{  this->mutex()->unlock_sharable();  }
+
+inline bool named_upgradable_mutex::try_lock_sharable()
+{  return this->mutex()->try_lock_sharable();  }
+
+inline bool named_upgradable_mutex::timed_lock_sharable
+   (const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock_sharable();
+      return true;
+   }
+   return this->mutex()->timed_lock_sharable(abs_time);
+}
+
+inline void named_upgradable_mutex::unlock_and_lock_upgradable()
+{  this->mutex()->unlock_and_lock_upgradable();  }
+
+inline void named_upgradable_mutex::unlock_and_lock_sharable()
+{  this->mutex()->unlock_and_lock_sharable();  }
+
+inline void named_upgradable_mutex::unlock_upgradable_and_lock_sharable()
+{  this->mutex()->unlock_upgradable_and_lock_sharable();  }
+
+inline void named_upgradable_mutex::unlock_upgradable_and_lock()
+{  this->mutex()->unlock_upgradable_and_lock();  }
+
+inline bool named_upgradable_mutex::try_unlock_upgradable_and_lock()
+{  return this->mutex()->try_unlock_upgradable_and_lock();  }
+
+inline bool named_upgradable_mutex::timed_unlock_upgradable_and_lock
+   (const boost::posix_time::ptime &abs_time)
+{  return this->mutex()->timed_unlock_upgradable_and_lock(abs_time);  }
+
+inline bool named_upgradable_mutex::try_unlock_sharable_and_lock()
+{  return this->mutex()->try_unlock_sharable_and_lock();  }
+
+inline bool named_upgradable_mutex::try_unlock_sharable_and_lock_upgradable()
+{  return this->mutex()->try_unlock_sharable_and_lock_upgradable();  }
+
+inline bool named_upgradable_mutex::remove(const char *name)
+{  return shared_memory_object::remove(name); }
+
+/// @endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_NAMED_UPGRADABLE_MUTEX_HPP
diff --git a/boost/interprocess/sync/spin/condition.hpp b/boost/interprocess/sync/spin/condition.hpp
new file mode 100644
index 0000000000..5a37d9be2d
--- /dev/null
+++ b/boost/interprocess/sync/spin/condition.hpp
@@ -0,0 +1,295 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_SPIN_CONDITION_HPP
+#define BOOST_INTERPROCESS_DETAIL_SPIN_CONDITION_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/sync/spin/mutex.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/move/move.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class spin_condition
+{
+   spin_condition(const spin_condition &);
+   spin_condition &operator=(const spin_condition &);
+   public:
+   spin_condition();
+   ~spin_condition();
+
+   void notify_one();
+   void notify_all();
+
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock);
+         return true;
+      }
+      if (!lock)
+         throw lock_exception();
+      return this->do_timed_wait(abs_time, *lock.mutex());
+   }
+
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock, pred);
+         return true;
+      }
+      if (!lock)
+         throw lock_exception();
+      while (!pred()){
+         if (!this->do_timed_wait(abs_time, *lock.mutex()))
+            return pred();
+      }
+      return true;
+   }
+
+   template <typename L>
+   void wait(L& lock)
+   {
+      if (!lock)
+         throw lock_exception();
+      do_wait(*lock.mutex());
+   }
+
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred)
+   {
+      if (!lock)
+         throw lock_exception();
+
+      while (!pred())
+         do_wait(*lock.mutex());
+   }
+
+   template<class InterprocessMutex>
+   void do_wait(InterprocessMutex &mut);
+
+   template<class InterprocessMutex>
+   bool do_timed_wait(const boost::posix_time::ptime &abs_time, InterprocessMutex &mut);
+
+   private:
+   template<class InterprocessMutex>
+   bool do_timed_wait(bool tout_enabled, const boost::posix_time::ptime &abs_time, InterprocessMutex &mut);
+
+   enum { SLEEP = 0, NOTIFY_ONE, NOTIFY_ALL };
+   spin_mutex  m_enter_mut;
+   volatile boost::uint32_t    m_command;
+   volatile boost::uint32_t    m_num_waiters;
+   void notify(boost::uint32_t command);
+};
+
+inline spin_condition::spin_condition()
+{
+   //Note that this class is initialized to zero.
+   //So zeroed memory can be interpreted as an initialized
+   //condition variable
+   m_command      = SLEEP;
+   m_num_waiters  = 0;
+}
+
+inline spin_condition::~spin_condition()
+{  
+   //Trivial destructor
+}
+
+inline void spin_condition::notify_one()
+{
+   this->notify(NOTIFY_ONE);
+}
+
+inline void spin_condition::notify_all()
+{
+   this->notify(NOTIFY_ALL);
+}
+
+inline void spin_condition::notify(boost::uint32_t command)
+{
+   //This mutex guarantees that no other thread can enter to the 
+   //do_timed_wait method logic, so that thread count will be
+   //constant until the function writes a NOTIFY_ALL command.
+   //It also guarantees that no other notification can be signaled 
+   //on this spin_condition before this one ends
+   m_enter_mut.lock();
+
+   //Return if there are no waiters
+   if(!atomic_read32(&m_num_waiters)) { 
+      m_enter_mut.unlock();
+      return;
+   }
+
+   //Notify that all threads should execute wait logic
+   while(SLEEP != atomic_cas32(const_cast<boost::uint32_t*>(&m_command), command, SLEEP)){
+      thread_yield();
+   }
+/*
+   //Wait until the threads are woken
+   while(SLEEP != atomic_cas32(const_cast<boost::uint32_t*>(&m_command), 0)){
+      thread_yield();
+   }
+*/
+   //The enter mutex will rest locked until the last waiting thread unlocks it
+}
+
+template<class InterprocessMutex>
+inline void spin_condition::do_wait(InterprocessMutex &mut)
+{
+   this->do_timed_wait(false, boost::posix_time::ptime(), mut);
+}
+
+template<class InterprocessMutex>
+inline bool spin_condition::do_timed_wait
+   (const boost::posix_time::ptime &abs_time, InterprocessMutex &mut)
+{
+   return this->do_timed_wait(true, abs_time, mut);
+}
+
+template<class InterprocessMutex>
+inline bool spin_condition::do_timed_wait(bool tout_enabled,
+                                     const boost::posix_time::ptime &abs_time, 
+                                     InterprocessMutex &mut)
+{
+   boost::posix_time::ptime now = microsec_clock::universal_time();
+   
+   if(tout_enabled){
+      if(now >= abs_time) return false;
+   }
+
+   typedef boost::interprocess::scoped_lock<spin_mutex> InternalLock;
+   //The enter mutex guarantees that while executing a notification, 
+   //no other thread can execute the do_timed_wait method. 
+   {
+      //---------------------------------------------------------------
+      InternalLock lock;
+      if(tout_enabled){
+         InternalLock dummy(m_enter_mut, abs_time);
+         lock = boost::move(dummy);
+      }
+      else{
+         InternalLock dummy(m_enter_mut);
+         lock = boost::move(dummy);
+      }
+
+      if(!lock)
+         return false;
+      //---------------------------------------------------------------
+      //We increment the waiting thread count protected so that it will be
+      //always constant when another thread enters the notification logic.
+      //The increment marks this thread as "waiting on spin_condition"
+      atomic_inc32(const_cast<boost::uint32_t*>(&m_num_waiters));
+
+      //We unlock the external mutex atomically with the increment
+      mut.unlock();
+   }
+
+   //By default, we suppose that no timeout has happened
+   bool timed_out  = false, unlock_enter_mut= false;
+   
+   //Loop until a notification indicates that the thread should 
+   //exit or timeout occurs
+   while(1){
+      //The thread sleeps/spins until a spin_condition commands a notification
+      //Notification occurred, we will lock the checking mutex so that
+      while(atomic_read32(&m_command) == SLEEP){
+         thread_yield();
+
+         //Check for timeout
+         if(tout_enabled){
+            now = microsec_clock::universal_time();
+
+            if(now >= abs_time){
+               //If we can lock the mutex it means that no notification
+               //is being executed in this spin_condition variable
+               timed_out = m_enter_mut.try_lock();
+
+               //If locking fails, indicates that another thread is executing
+               //notification, so we play the notification game
+               if(!timed_out){
+                  //There is an ongoing notification, we will try again later
+                  continue;
+               }
+               //No notification in execution, since enter mutex is locked. 
+               //We will execute time-out logic, so we will decrement count, 
+               //release the enter mutex and return false.
+               break;
+            }
+         }
+      }
+
+      //If a timeout occurred, the mutex will not execute checking logic
+      if(tout_enabled && timed_out){
+         //Decrement wait count
+         atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
+         unlock_enter_mut = true;
+         break;
+      }
+      else{
+         boost::uint32_t result = atomic_cas32
+                        (const_cast<boost::uint32_t*>(&m_command), SLEEP, NOTIFY_ONE);
+         if(result == SLEEP){
+            //Other thread has been notified and since it was a NOTIFY one
+            //command, this thread must sleep again
+            continue;
+         }
+         else if(result == NOTIFY_ONE){
+            //If it was a NOTIFY_ONE command, only this thread should  
+            //exit. This thread has atomically marked command as sleep before
+            //so no other thread will exit.
+            //Decrement wait count.
+            unlock_enter_mut = true;
+            atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
+            break;
+         }
+         else{
+            //If it is a NOTIFY_ALL command, all threads should return 
+            //from do_timed_wait function. Decrement wait count. 
+            unlock_enter_mut = 1 == atomic_dec32(const_cast<boost::uint32_t*>(&m_num_waiters));
+            //Check if this is the last thread of notify_all waiters
+            //Only the last thread will release the mutex
+            if(unlock_enter_mut){
+               atomic_cas32(const_cast<boost::uint32_t*>(&m_command), SLEEP, NOTIFY_ALL);
+            }
+            break;
+         }
+      }
+   }
+
+   //Unlock the enter mutex if it is a single notification, if this is 
+   //the last notified thread in a notify_all or a timeout has occurred
+   if(unlock_enter_mut){
+      m_enter_mut.unlock();
+   }
+
+   //Lock external again before returning from the method
+   mut.lock();
+   return !timed_out;
+}
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_SPIN_CONDITION_HPP
diff --git a/boost/interprocess/sync/spin/interprocess_barrier.hpp b/boost/interprocess/sync/spin/interprocess_barrier.hpp
new file mode 100644
index 0000000000..f8ee09948d
--- /dev/null
+++ b/boost/interprocess/sync/spin/interprocess_barrier.hpp
@@ -0,0 +1,46 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include<boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+
+namespace boost {
+namespace interprocess {
+
+inline barrier::barrier(unsigned int count)
+   : m_threshold(count), m_count(count), m_generation(0)
+{
+   if (count == 0)
+      throw std::invalid_argument("count cannot be zero.");
+}
+
+inline barrier::~barrier(){}
+
+inline bool barrier::wait()
+{
+   scoped_lock<interprocess_mutex> lock(m_mutex);
+   unsigned int gen = m_generation;
+
+   if (--m_count == 0){
+      m_generation++;
+      m_count = m_threshold;
+      m_cond.notify_all();
+      return true;
+   }
+
+   while (gen == m_generation){
+      m_cond.wait(lock);
+   }
+   return false;
+}
+
+}  //namespace interprocess {
+}  //namespace boost {
diff --git a/boost/interprocess/sync/spin/mutex.hpp b/boost/interprocess/sync/spin/mutex.hpp
new file mode 100644
index 0000000000..ef0b47d95a
--- /dev/null
+++ b/boost/interprocess/sync/spin/mutex.hpp
@@ -0,0 +1,114 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_SPIN_MUTEX_HPP
+#define BOOST_INTERPROCESS_DETAIL_SPIN_MUTEX_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/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/assert.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class spin_mutex
+{
+   spin_mutex(const spin_mutex &);
+   spin_mutex &operator=(const spin_mutex &);
+   public:
+
+   spin_mutex();
+   ~spin_mutex();
+
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   void unlock();
+   void take_ownership(){};
+   private:
+   volatile boost::uint32_t m_s;
+};
+
+inline spin_mutex::spin_mutex() 
+   : m_s(0) 
+{
+   //Note that this class is initialized to zero.
+   //So zeroed memory can be interpreted as an
+   //initialized mutex
+}
+
+inline spin_mutex::~spin_mutex() 
+{
+   //Trivial destructor
+}
+
+inline void spin_mutex::lock(void)
+{
+   do{
+      boost::uint32_t prev_s = ipcdetail::atomic_cas32(const_cast<boost::uint32_t*>(&m_s), 1, 0);
+
+      if (m_s == 1 && prev_s == 0){
+            break;
+      }
+      // relinquish current timeslice
+      ipcdetail::thread_yield();
+   }while (true);
+}
+
+inline bool spin_mutex::try_lock(void)
+{
+   boost::uint32_t prev_s = ipcdetail::atomic_cas32(const_cast<boost::uint32_t*>(&m_s), 1, 0);   
+   return m_s == 1 && prev_s == 0;
+}
+
+inline bool spin_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   //Obtain current count and target time
+   boost::posix_time::ptime now = microsec_clock::universal_time();
+
+   do{
+      if(this->try_lock()){
+         break;
+      }
+      now = microsec_clock::universal_time();
+
+      if(now >= abs_time){
+         return false;
+      }
+      // relinquish current time slice
+     ipcdetail::thread_yield();
+   }while (true);
+
+   return true;
+}
+
+inline void spin_mutex::unlock(void)
+{  ipcdetail::atomic_cas32(const_cast<boost::uint32_t*>(&m_s), 0, 1);   }
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_SPIN_MUTEX_HPP
diff --git a/boost/interprocess/sync/spin/recursive_mutex.hpp b/boost/interprocess/sync/spin/recursive_mutex.hpp
new file mode 100644
index 0000000000..05ad65eac0
--- /dev/null
+++ b/boost/interprocess/sync/spin/recursive_mutex.hpp
@@ -0,0 +1,175 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Parts of the pthread code come from Boost Threads code:
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (C) 2001-2003
+// William E. Kempf
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_DETAIL_SPIN_RECURSIVE_MUTEX_HPP
+#define BOOST_INTERPROCESS_DETAIL_SPIN_RECURSIVE_MUTEX_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/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/atomic.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/interprocess/sync/spin/mutex.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class spin_recursive_mutex
+{
+   spin_recursive_mutex(const spin_recursive_mutex &);
+   spin_recursive_mutex &operator=(const spin_recursive_mutex &);
+   public:
+
+   spin_recursive_mutex();
+   ~spin_recursive_mutex();
+
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   void unlock();
+   void take_ownership();
+   private:
+   spin_mutex     m_mutex;
+   unsigned int   m_nLockCount;
+   volatile ipcdetail::OS_systemwide_thread_id_t   m_nOwner;
+   volatile boost::uint32_t m_s;
+};
+
+inline spin_recursive_mutex::spin_recursive_mutex() 
+   : m_nLockCount(0), m_nOwner(ipcdetail::get_invalid_systemwide_thread_id()){}
+
+inline spin_recursive_mutex::~spin_recursive_mutex(){}
+
+inline void spin_recursive_mutex::lock()
+{
+   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
+   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   handle_t old_id;
+   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
+   if(ipcdetail::equal_systemwide_thread_id(thr_id , old_id)){
+      if((unsigned int)(m_nLockCount+1) == 0){
+         //Overflow, throw an exception
+         throw interprocess_exception("boost::interprocess::spin_recursive_mutex recursive lock overflow");
+      } 
+      ++m_nLockCount;
+   }
+   else{
+      m_mutex.lock();
+      ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+      m_nLockCount = 1;
+   }
+}
+
+inline bool spin_recursive_mutex::try_lock()
+{
+   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
+   handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   handle_t old_id;
+   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
+   if(ipcdetail::equal_systemwide_thread_id(thr_id , old_id)) {  // we own it
+      if((unsigned int)(m_nLockCount+1) == 0){
+         //Overflow, throw an exception
+         throw interprocess_exception("boost::interprocess::spin_recursive_mutex recursive lock overflow");
+      } 
+      ++m_nLockCount;
+      return true;
+   }
+   if(m_mutex.try_lock()){
+      ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+      m_nLockCount = 1;
+      return true;
+   }
+   return false;
+}
+
+inline bool spin_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   handle_t old_id;
+   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
+   if(ipcdetail::equal_systemwide_thread_id(thr_id , old_id)) {  // we own it
+      if((unsigned int)(m_nLockCount+1) == 0){
+         //Overflow, throw an exception
+         throw interprocess_exception("boost::interprocess::spin_recursive_mutex recursive lock overflow");
+      } 
+      ++m_nLockCount;
+      return true;
+   }
+   if(m_mutex.timed_lock(abs_time)){
+      ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+      m_nLockCount = 1;
+      return true;
+   }
+   return false;
+}
+
+inline void spin_recursive_mutex::unlock()
+{
+   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
+   handle_t old_id;
+   ipcdetail::systemwide_thread_id_copy(m_nOwner, old_id);
+   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   (void)old_id;
+   (void)thr_id;
+   BOOST_ASSERT(ipcdetail::equal_systemwide_thread_id(thr_id, old_id));
+   --m_nLockCount;
+   if(!m_nLockCount){
+      const handle_t new_id(ipcdetail::get_invalid_systemwide_thread_id());
+      ipcdetail::systemwide_thread_id_copy(new_id, m_nOwner);
+      m_mutex.unlock();
+   }
+}
+
+inline void spin_recursive_mutex::take_ownership()
+{
+   typedef ipcdetail::OS_systemwide_thread_id_t handle_t;
+   this->m_nLockCount = 1;
+   const handle_t thr_id(ipcdetail::get_current_systemwide_thread_id());
+   ipcdetail::systemwide_thread_id_copy(thr_id, m_nOwner);
+}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_SPIN_RECURSIVE_MUTEX_HPP
diff --git a/boost/interprocess/sync/spin/semaphore.hpp b/boost/interprocess/sync/spin/semaphore.hpp
new file mode 100644
index 0000000000..1b8cac35aa
--- /dev/null
+++ b/boost/interprocess/sync/spin/semaphore.hpp
@@ -0,0 +1,110 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_SPIN_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_DETAIL_SPIN_SEMAPHORE_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/interprocess/detail/atomic.hpp>
+#include <boost/interprocess/detail/os_thread_functions.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class spin_semaphore
+{
+   spin_semaphore(const spin_semaphore &);
+   spin_semaphore &operator=(const spin_semaphore &);
+
+   public:
+   spin_semaphore(unsigned int initialCount);
+   ~spin_semaphore();
+
+   void post();
+   void wait();
+   bool try_wait();
+   bool timed_wait(const boost::posix_time::ptime &abs_time);
+
+//   int get_count() const;
+   private:
+   volatile boost::uint32_t m_count;
+};
+
+
+inline spin_semaphore::~spin_semaphore()
+{}
+
+inline spin_semaphore::spin_semaphore(unsigned int initialCount)
+{  ipcdetail::atomic_write32(&this->m_count, boost::uint32_t(initialCount));  }
+
+inline void spin_semaphore::post()
+{
+   ipcdetail::atomic_inc32(&m_count);
+}
+
+inline void spin_semaphore::wait()
+{
+   while(!ipcdetail::atomic_add_unless32(&m_count, boost::uint32_t(-1), boost::uint32_t(0))){
+      while(ipcdetail::atomic_read32(&m_count) == 0){
+         ipcdetail::thread_yield();
+      }
+   }
+}
+
+inline bool spin_semaphore::try_wait()
+{
+   return ipcdetail::atomic_add_unless32(&m_count, boost::uint32_t(-1), boost::uint32_t(0));
+}
+
+inline bool spin_semaphore::timed_wait(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->wait();
+      return true;
+   }
+   //Obtain current count and target time
+   boost::posix_time::ptime now(microsec_clock::universal_time());
+
+   do{
+      if(this->try_wait()){
+         break;
+      }
+      now = microsec_clock::universal_time();
+
+      if(now >= abs_time){
+         return this->try_wait();
+      }
+      // relinquish current time slice
+      ipcdetail::thread_yield();
+   }while (true);
+   return true;
+}
+
+
+//inline int spin_semaphore::get_count() const
+//{
+   //return (int)ipcdetail::atomic_read32(&m_count);
+//}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_SPIN_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/upgradable_lock.hpp b/boost/interprocess/sync/upgradable_lock.hpp
new file mode 100644
index 0000000000..93c2ed6bc4
--- /dev/null
+++ b/boost/interprocess/sync/upgradable_lock.hpp
@@ -0,0 +1,309 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This interface is inspired by Howard Hinnant's lock proposal.
+// http://home.twcny.rr.com/hinnant/cpp_extensions/threads_move.html
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_UPGRADABLE_LOCK_HPP
+#define BOOST_INTERPROCESS_UPGRADABLE_LOCK_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/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/sync/lock_options.hpp>
+#include <boost/interprocess/detail/mpl.hpp>
+#include <boost/interprocess/detail/type_traits.hpp>
+
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+//!\file
+//!Describes the upgradable_lock class that serves to acquire the upgradable
+//!lock of a mutex.
+
+namespace boost {
+namespace interprocess {
+
+//!upgradable_lock is meant to carry out the tasks for read-locking, unlocking,
+//!try-read-locking and timed-read-locking (recursive or not) for the Mutex.
+//!Additionally the upgradable_lock can transfer ownership to a scoped_lock
+//!using transfer_lock syntax. The Mutex need not supply all of the functionality.
+//!If the client of upgradable_lock<Mutex> does not use functionality which the
+//!Mutex does not supply, no harm is done. Mutex ownership can be shared among
+//!read_locks, and a single upgradable_lock. upgradable_lock does not support
+//!copy semantics. However upgradable_lock supports ownership transfer from
+//!a upgradable_locks or scoped_locks via transfer_lock syntax.
+template <class UpgradableMutex>
+class upgradable_lock
+{
+   public:
+   typedef UpgradableMutex mutex_type;
+   /// @cond
+   private:
+   typedef upgradable_lock<UpgradableMutex> this_type;
+   explicit upgradable_lock(scoped_lock<mutex_type>&);
+   typedef bool this_type::*unspecified_bool_type;
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(upgradable_lock)
+   /// @endcond
+   public:
+
+   //!Effects: Default constructs a upgradable_lock.
+   //!Postconditions: owns() == false and mutex() == 0.
+   upgradable_lock()
+      : mp_mutex(0), m_locked(false)
+   {}
+
+   explicit upgradable_lock(mutex_type& m)
+      : mp_mutex(&m), m_locked(false)
+   {  mp_mutex->lock_upgradable();   m_locked = true;  }
+
+   //!Postconditions: owns() == false, and mutex() == &m.
+   //!Notes: The constructor will not take ownership of the mutex. There is no effect
+   //!   required on the referenced mutex.
+   upgradable_lock(mutex_type& m, defer_lock_type)
+      : mp_mutex(&m), m_locked(false)
+   {}
+
+   //!Postconditions: owns() == true, and mutex() == &m.
+   //!Notes: The constructor will suppose that the mutex is already upgradable
+   //!   locked. There is no effect required on the referenced mutex.
+   upgradable_lock(mutex_type& m, accept_ownership_type)
+      : mp_mutex(&m), m_locked(true)
+   {}
+
+   //!Effects: m.try_lock_upgradable(). 
+   //!Postconditions: mutex() == &m. owns() == the return value of the
+   //!   m.try_lock_upgradable() executed within the constructor.
+   //!Notes: The constructor will take upgradable-ownership of the mutex
+   //!   if it can do so without waiting. Whether or not this constructor
+   //!   handles recursive locking depends upon the mutex. If the mutex_type
+   //!   does not support try_lock_upgradable, this constructor will fail at
+   //!   compile time if instantiated, but otherwise have no effect.
+   upgradable_lock(mutex_type& m, try_to_lock_type)
+      : mp_mutex(&m), m_locked(false)
+   {  m_locked = mp_mutex->try_lock_upgradable();   }
+
+   //!Effects: m.timed_lock_upgradable(abs_time) 
+   //!Postconditions: mutex() == &m. owns() == the return value of the
+   //!   m.timed_lock_upgradable() executed within the constructor.
+   //!Notes: The constructor will take upgradable-ownership of the mutex if it
+   //!   can do so within the time specified. Whether or not this constructor
+   //!   handles recursive locking depends upon the mutex. If the mutex_type
+   //!   does not support timed_lock_upgradable, this constructor will fail
+   //!   at compile time if instantiated, but otherwise have no effect.
+   upgradable_lock(mutex_type& m, const boost::posix_time::ptime& abs_time)
+      : mp_mutex(&m), m_locked(false)
+   {  m_locked = mp_mutex->timed_lock_upgradable(abs_time);  }
+
+   //!Effects: No effects on the underlying mutex.
+   //!Postconditions: mutex() == the value upgr.mutex() had before the
+   //!   construction. upgr.mutex() == 0. owns() == upgr.owns() before the
+   //!   construction. upgr.owns() == false.
+   //!Notes: If upgr is locked, this constructor will lock this upgradable_lock
+   //!   while unlocking upgr. If upgr is unlocked, then this upgradable_lock will
+   //!   be unlocked as well. Only a moved upgradable_lock's will match this
+   //!   signature. An non-moved upgradable_lock can be moved with the
+   //!   expression: "boost::move(lock);". This constructor does not alter the
+   //!   state of the mutex, only potentially who owns it.
+   upgradable_lock(BOOST_RV_REF(upgradable_lock<mutex_type>) upgr)
+      : mp_mutex(0), m_locked(upgr.owns())
+   {  mp_mutex = upgr.release(); }
+
+   //!Effects: If scop.owns(), m_.unlock_and_lock_upgradable(). 
+   //!Postconditions: mutex() == the value scop.mutex() had before the construction.
+   //!   scop.mutex() == 0. owns() == scop.owns() before the constructor. After the
+   //!   construction, scop.owns() == false.
+   //!Notes: If scop is locked, this constructor will transfer the exclusive-ownership
+   //!   to an upgradable-ownership of this upgradable_lock.
+   //!   Only a moved sharable_lock's will match this
+   //!   signature. An non-moved sharable_lock can be moved with the
+   //!   expression: "boost::move(lock);".
+   template<class T>
+   upgradable_lock(BOOST_RV_REF(scoped_lock<T>) scop
+                  , typename ipcdetail::enable_if< ipcdetail::is_same<T, UpgradableMutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      scoped_lock<mutex_type> &u_lock = scop;
+      if(u_lock.owns()){
+         u_lock.mutex()->unlock_and_lock_upgradable();
+         m_locked = true;
+      }
+      mp_mutex = u_lock.release();
+   }
+
+   //!Effects: If shar.owns() then calls try_unlock_sharable_and_lock_upgradable()
+   //!   on the referenced mutex. 
+   //!   a)if try_unlock_sharable_and_lock_upgradable() returns true then mutex()
+   //!      obtains the value from shar.release() and owns() is set to true. 
+   //!   b)if try_unlock_sharable_and_lock_upgradable() returns false then shar is
+   //!      unaffected and this upgradable_lock construction has the same
+   //!      effects as a default construction. 
+   //!   c)Else shar.owns() is false. mutex() obtains the value from shar.release()
+   //!      and owns() is set to false.
+   //!Notes: This construction will not block. It will try to obtain mutex
+   //!   ownership from shar immediately, while changing the lock type from a
+   //!   "read lock" to an "upgradable lock". If the "read lock" isn't held
+   //!   in the first place, the mutex merely changes type to an unlocked
+   //!   "upgradable lock". If the "read lock" is held, then mutex transfer
+   //!   occurs only if it can do so in a non-blocking manner.
+   template<class T>
+   upgradable_lock( BOOST_RV_REF(sharable_lock<T>) shar, try_to_lock_type
+                  , typename ipcdetail::enable_if< ipcdetail::is_same<T, UpgradableMutex> >::type * = 0)
+      : mp_mutex(0), m_locked(false)
+   {
+      sharable_lock<mutex_type> &s_lock = shar;
+      if(s_lock.owns()){
+         if((m_locked = s_lock.mutex()->try_unlock_sharable_and_lock_upgradable()) == true){
+            mp_mutex = s_lock.release();
+         }
+      }
+      else{
+         s_lock.release();
+      }
+   }
+
+   //!Effects: if (owns()) m_->unlock_upgradable().
+   //!Notes: The destructor behavior ensures that the mutex lock is not leaked.
+   ~upgradable_lock()
+   {
+      try{
+         if(m_locked && mp_mutex)   mp_mutex->unlock_upgradable();
+      }
+      catch(...){}
+   }
+
+   //!Effects: If owns(), then unlock_upgradable() is called on mutex().
+   //!   *this gets the state of upgr and upgr gets set to a default constructed state.
+   //!Notes: With a recursive mutex it is possible that both this and upgr own the
+   //!   mutex before the assignment. In this case, this will own the mutex
+   //!   after the assignment (and upgr will not), but the mutex's upgradable lock
+   //!   count will be decremented by one.
+   upgradable_lock &operator=(BOOST_RV_REF(upgradable_lock) upgr)
+   {
+      if(this->owns())
+         this->unlock();
+      m_locked = upgr.owns();
+      mp_mutex = upgr.release();
+      return *this;
+   }
+
+   //!Effects: If mutex() == 0 or if already locked, throws a lock_exception()
+   //!   exception. Calls lock_upgradable() on the referenced mutex.
+   //!Postconditions: owns() == true.
+   //!Notes: The sharable_lock changes from a state of not owning the mutex,
+   //!   to owning the mutex, blocking if necessary.
+   void lock()
+   {  
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      mp_mutex->lock_upgradable();
+      m_locked = true;
+   }
+
+   //!Effects: If mutex() == 0 or if already locked, throws a lock_exception()
+   //!   exception. Calls try_lock_upgradable() on the referenced mutex.
+   //!Postconditions: owns() == the value returned from
+   //!   mutex()->try_lock_upgradable().
+   //!Notes: The upgradable_lock changes from a state of not owning the mutex,
+   //!   to owning the mutex, but only if blocking was not required. If the
+   //!   mutex_type does not support try_lock_upgradable(), this function will
+   //!   fail at compile time if instantiated, but otherwise have no effect.
+   bool try_lock()
+   {  
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      m_locked = mp_mutex->try_lock_upgradable();
+      return m_locked;
+   }
+
+   //!Effects: If mutex() == 0 or if already locked, throws a lock_exception()
+   //!   exception. Calls timed_lock_upgradable(abs_time) on the referenced mutex.
+   //!Postconditions: owns() == the value returned from
+   //!   mutex()->timed_lock_upgradable(abs_time).
+   //!Notes: The upgradable_lock changes from a state of not owning the mutex,
+   //!   to owning the mutex, but only if it can obtain ownership within the
+   //!   specified time. If the mutex_type does not support
+   //!   timed_lock_upgradable(abs_time), this function will fail at compile
+   //!   time if instantiated, but otherwise have no effect.
+   bool timed_lock(const boost::posix_time::ptime& abs_time)
+   {  
+      if(!mp_mutex || m_locked)
+         throw lock_exception();
+      m_locked = mp_mutex->timed_lock_upgradable(abs_time);
+      return m_locked;
+   }
+
+   //!Effects: If mutex() == 0 or if not locked, throws a lock_exception()
+   //!   exception. Calls unlock_upgradable() on the referenced mutex.
+   //!Postconditions: owns() == false.
+   //!Notes: The upgradable_lock changes from a state of owning the mutex,
+   //!   to not owning the mutex.
+   void unlock()
+   {
+      if(!mp_mutex || !m_locked)
+         throw lock_exception();
+      mp_mutex->unlock_upgradable();
+      m_locked = false;
+   }
+
+   //!Effects: Returns true if this scoped_lock has acquired the
+   //!referenced mutex.
+   bool owns() const
+   {  return m_locked && mp_mutex;  }
+
+   //!Conversion to bool.
+   //!Returns owns().
+   operator unspecified_bool_type() const
+   {  return m_locked? &this_type::m_locked : 0;   }
+
+   //!Effects: Returns a pointer to the referenced mutex, or 0 if
+   //!there is no mutex to reference.
+   mutex_type* mutex() const
+   {  return  mp_mutex;  }
+
+   //!Effects: Returns a pointer to the referenced mutex, or 0 if there is no
+   //!   mutex to reference.
+   //!Postconditions: mutex() == 0 and owns() == false.
+   mutex_type* release()
+   {
+      mutex_type *mut = mp_mutex;
+      mp_mutex = 0;
+      m_locked = false;
+      return mut;
+   }
+
+   //!Effects: Swaps state with moved lock. 
+   //!Throws: Nothing.
+   void swap(upgradable_lock<mutex_type> &other)
+   {
+      std::swap(mp_mutex, other.mp_mutex);
+      std::swap(m_locked, other.m_locked);
+   }
+
+   /// @cond
+   private:
+   mutex_type *mp_mutex;
+   bool        m_locked;
+   /// @endcond
+};
+
+} // namespace interprocess
+} // namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif // BOOST_INTERPROCESS_UPGRADABLE_LOCK_HPP
diff --git a/boost/interprocess/sync/windows/condition.hpp b/boost/interprocess/sync/windows/condition.hpp
new file mode 100644
index 0000000000..167b8730c3
--- /dev/null
+++ b/boost/interprocess/sync/windows/condition.hpp
@@ -0,0 +1,383 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_WINDOWS_CONDITION_HPP
+#define BOOST_INTERPROCESS_DETAIL_WINDOWS_CONDITION_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
+
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/sync/windows/semaphore.hpp>
+#include <boost/interprocess/sync/windows/mutex.hpp>
+#include <boost/cstdint.hpp>
+#include <limits>
+
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+// 
+// Condition variable algorithm taken from pthreads-win32 discussion.
+//
+// The algorithm was developed by Alexander Terekhov in colaboration with
+// Louis Thomas.
+// 
+//     Algorithm 8a / IMPL_SEM,UNBLOCK_STRATEGY == UNBLOCK_ALL
+//
+// semBlockLock - bin.semaphore
+// semBlockQueue - semaphore
+// mtxExternal - mutex or CS
+// mtxUnblockLock - mutex or CS
+// nWaitersGone - int
+// nWaitersBlocked - int
+// nWaitersToUnblock - int
+// 
+// wait( timeout ) {
+// 
+//   [auto: register int result          ]     // error checking omitted
+//   [auto: register int nSignalsWasLeft ]
+//   [auto: register int nWaitersWasGone ]
+// 
+//   sem_wait( semBlockLock );
+//   nWaitersBlocked++;
+//   sem_post( semBlockLock );
+// 
+//   unlock( mtxExternal );
+//   bTimedOut = sem_wait( semBlockQueue,timeout );
+// 
+//   lock( mtxUnblockLock );
+//   if ( 0 != (nSignalsWasLeft = nWaitersToUnblock) ) {
+//     if ( bTimedOut ) {                       // timeout (or canceled)
+//       if ( 0 != nWaitersBlocked ) {
+//         nWaitersBlocked--;
+//       }
+//       else {
+//         nWaitersGone++;                     // count spurious wakeups.
+//       }
+//     }
+//     if ( 0 == --nWaitersToUnblock ) {
+//       if ( 0 != nWaitersBlocked ) {
+//         sem_post( semBlockLock );           // open the gate.
+//         nSignalsWasLeft = 0;                // do not open the gate
+//                                             // below again.
+//       }
+//       else if ( 0 != (nWaitersWasGone = nWaitersGone) ) {
+//         nWaitersGone = 0;
+//       }
+//     }
+//   }
+//   else if ( INT_MAX/2 == ++nWaitersGone ) { // timeout/canceled or
+//                                             // spurious semaphore :-)
+//     sem_wait( semBlockLock );
+//     nWaitersBlocked -= nWaitersGone;     // something is going on here
+//                                          //  - test of timeouts? :-)
+//     sem_post( semBlockLock );
+//     nWaitersGone = 0;
+//   }
+//   unlock( mtxUnblockLock );
+// 
+//   if ( 1 == nSignalsWasLeft ) {
+//     if ( 0 != nWaitersWasGone ) {
+//       // sem_adjust( semBlockQueue,-nWaitersWasGone );
+//       while ( nWaitersWasGone-- ) {
+//         sem_wait( semBlockQueue );       // better now than spurious later
+//       }
+//     } sem_post( semBlockLock );          // open the gate
+//   }
+// 
+//   lock( mtxExternal );
+// 
+//   return ( bTimedOut ) ? ETIMEOUT : 0;
+// }
+// 
+// signal(bAll) {
+// 
+//   [auto: register int result         ]
+//   [auto: register int nSignalsToIssue]
+// 
+//   lock( mtxUnblockLock );
+// 
+//   if ( 0 != nWaitersToUnblock ) {        // the gate is closed!!!
+//     if ( 0 == nWaitersBlocked ) {        // NO-OP
+//       return unlock( mtxUnblockLock );
+//     }
+//     if (bAll) {
+//       nWaitersToUnblock += nSignalsToIssue=nWaitersBlocked;
+//       nWaitersBlocked = 0;
+//     }
+//     else {
+//       nSignalsToIssue = 1;
+//       nWaitersToUnblock++;
+//       nWaitersBlocked--;
+//     }
+//   }
+//   else if ( nWaitersBlocked > nWaitersGone ) { // HARMLESS RACE CONDITION!
+//     sem_wait( semBlockLock );                  // close the gate
+//     if ( 0 != nWaitersGone ) {
+//       nWaitersBlocked -= nWaitersGone;
+//       nWaitersGone = 0;
+//     }
+//     if (bAll) {
+//       nSignalsToIssue = nWaitersToUnblock = nWaitersBlocked;
+//       nWaitersBlocked = 0;
+//     }
+//     else {
+//       nSignalsToIssue = nWaitersToUnblock = 1;
+//       nWaitersBlocked--;
+//     }
+//   }
+//   else { // NO-OP
+//     return unlock( mtxUnblockLock );
+//   }
+// 
+//   unlock( mtxUnblockLock );
+//   sem_post( semBlockQueue,nSignalsToIssue );
+//   return result;
+// }
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class windows_condition
+{
+   windows_condition(const windows_condition &);
+   windows_condition &operator=(const windows_condition &);
+   public:
+   windows_condition();
+   ~windows_condition();
+
+   void notify_one();
+   void notify_all();
+
+   template <typename L>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock);
+         return true;
+      }
+      if (!lock)
+         throw lock_exception();
+      return this->do_timed_wait(abs_time, *lock.mutex());
+   }
+
+   template <typename L, typename Pr>
+   bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
+   {
+      if(abs_time == boost::posix_time::pos_infin){
+         this->wait(lock, pred);
+         return true;
+      }
+      if (!lock)
+         throw lock_exception();
+      while (!pred()){
+         if (!this->do_timed_wait(abs_time, *lock.mutex()))
+            return pred();
+      }
+      return true;
+   }
+
+   template <typename L>
+   void wait(L& lock)
+   {
+      if (!lock)
+         throw lock_exception();
+      do_wait(*lock.mutex());
+   }
+
+   template <typename L, typename Pr>
+   void wait(L& lock, Pr pred)
+   {
+      if (!lock)
+         throw lock_exception();
+
+      while (!pred())
+         do_wait(*lock.mutex());
+   }
+
+   template<class InterprocessMutex>
+   void do_wait(InterprocessMutex &mut);
+
+   template<class InterprocessMutex>
+   bool do_timed_wait(const boost::posix_time::ptime &abs_time, InterprocessMutex &mut);
+
+   private:
+
+   template<class InterprocessMutex>
+   bool do_timed_wait(bool timeout_enabled, const boost::posix_time::ptime &abs_time, InterprocessMutex &mut);
+   void do_signal    (bool broadcast);
+
+   boost::int32_t    m_nwaiters_blocked;
+   boost::int32_t    m_nwaiters_gone;
+   boost::int32_t    m_nwaiters_to_unblock;
+   windows_semaphore m_sem_block_queue;
+   windows_semaphore m_sem_block_lock;
+   windows_mutex     m_mtx_unblock_lock;
+};
+
+inline windows_condition::windows_condition()
+ : m_nwaiters_blocked(0)
+ , m_nwaiters_gone(0)
+ , m_nwaiters_to_unblock(0)
+ , m_sem_block_queue(0)
+ , m_sem_block_lock(1)
+ , m_mtx_unblock_lock()
+{}
+
+inline windows_condition::~windows_condition()
+{}
+
+inline void windows_condition::notify_one()
+{  this->do_signal(false);  }
+
+inline void windows_condition::notify_all()
+{  this->do_signal(true);  }
+
+inline void windows_condition::do_signal(bool broadcast)
+{
+   boost::int32_t nsignals_to_issue;
+
+   {
+      scoped_lock<windows_mutex> locker(m_mtx_unblock_lock);
+
+      if ( 0 != m_nwaiters_to_unblock ) {        // the gate is closed!!!
+         if ( 0 == m_nwaiters_blocked ) {        // NO-OP
+            //locker's destructor triggers m_mtx_unblock_lock.unlock() 
+            return;
+         }
+         if (broadcast) {
+            m_nwaiters_to_unblock += nsignals_to_issue = m_nwaiters_blocked;
+            m_nwaiters_blocked = 0;
+         }
+         else {
+            nsignals_to_issue = 1;
+            m_nwaiters_to_unblock++;
+            m_nwaiters_blocked--;
+         }
+      }
+      else if ( m_nwaiters_blocked > m_nwaiters_gone ) { // HARMLESS RACE CONDITION!
+         m_sem_block_lock.wait();                      // close the gate
+         if ( 0 != m_nwaiters_gone ) {
+            m_nwaiters_blocked -= m_nwaiters_gone;
+            m_nwaiters_gone = 0;
+         }
+         if (broadcast) {
+            nsignals_to_issue = m_nwaiters_to_unblock = m_nwaiters_blocked;
+            m_nwaiters_blocked = 0;
+         }
+         else {
+            nsignals_to_issue = m_nwaiters_to_unblock = 1;
+            m_nwaiters_blocked--;
+         }
+      }
+      else { // NO-OP
+         //locker's destructor triggers m_mtx_unblock_lock.unlock() 
+         return;
+      }
+      //locker's destructor triggers m_mtx_unblock_lock.unlock() 
+   }
+   m_sem_block_queue.post(nsignals_to_issue);
+}
+
+template<class InterprocessMutex>
+inline void windows_condition::do_wait(InterprocessMutex &mut)
+{  this->do_timed_wait(false, boost::posix_time::ptime(), mut);  }
+
+template<class InterprocessMutex>
+inline bool windows_condition::do_timed_wait
+   (const boost::posix_time::ptime &abs_time, InterprocessMutex &mut)
+{  return this->do_timed_wait(true, abs_time, mut);  }
+
+template<class InterprocessMutex>
+inline bool windows_condition::do_timed_wait
+   (bool tout_enabled, const boost::posix_time::ptime &abs_time, InterprocessMutex &mtxExternal)
+{
+   //Initialize to avoid warnings
+   boost::int32_t nsignals_was_left = 0;
+   boost::int32_t nwaiters_was_gone = 0;
+ 
+   m_sem_block_lock.wait();
+   ++m_nwaiters_blocked;
+   m_sem_block_lock.post();
+
+   struct scoped_unlock
+   {
+      InterprocessMutex & mut;
+      scoped_unlock(InterprocessMutex & m)
+         : mut(m)
+      {  m.unlock();  }
+
+      ~scoped_unlock()
+      {  mut.lock();  }
+   } unlocker(mtxExternal);
+ 
+
+   bool bTimedOut = tout_enabled ? !m_sem_block_queue.timed_wait(abs_time) : (m_sem_block_queue.wait(), false);
+ 
+   {
+      scoped_lock<windows_mutex> locker(m_mtx_unblock_lock);
+      if ( 0 != (nsignals_was_left = m_nwaiters_to_unblock) ) {
+         if ( bTimedOut ) {                       // timeout (or canceled)
+            if ( 0 != m_nwaiters_blocked ) {
+               m_nwaiters_blocked--;
+            }
+            else {
+               m_nwaiters_gone++;                     // count spurious wakeups.
+            }
+         }
+         if ( 0 == --m_nwaiters_to_unblock ) {
+            if ( 0 != m_nwaiters_blocked ) {
+               m_sem_block_lock.post();          // open the gate.
+               nsignals_was_left = 0;          // do not open the gate below again.
+            }
+            else if ( 0 != (nwaiters_was_gone = m_nwaiters_gone) ) {
+               m_nwaiters_gone = 0;
+            }
+         }
+      }
+      else if ( (std::numeric_limits<boost::int32_t>::max)()/2
+                == ++m_nwaiters_gone ) { // timeout/canceled or spurious semaphore :-)
+         m_sem_block_lock.wait();
+         m_nwaiters_blocked -= m_nwaiters_gone;       // something is going on here - test of timeouts? :-)
+         m_sem_block_lock.post();
+         m_nwaiters_gone = 0;
+      }
+      //locker's destructor triggers m_mtx_unblock_lock.unlock() 
+   }  
+ 
+   if ( 1 == nsignals_was_left ) {
+      if ( 0 != nwaiters_was_gone ) {
+         // sem_adjust( m_sem_block_queue,-nwaiters_was_gone );
+         while ( nwaiters_was_gone-- ) {
+            m_sem_block_queue.wait();       // better now than spurious later
+         }
+      }
+      m_sem_block_lock.post(); // open the gate
+   }
+ 
+   //mtxExternal.lock(); called from unlocker
+ 
+   return ( bTimedOut ) ? false : true;
+}
+
+}  //namespace ipcdetail
+}  //namespace interprocess
+}  //namespace boost
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_WINDOWS_CONDITION_HPP
diff --git a/boost/interprocess/sync/windows/mutex.hpp b/boost/interprocess/sync/windows/mutex.hpp
new file mode 100644
index 0000000000..5eca522339
--- /dev/null
+++ b/boost/interprocess/sync/windows/mutex.hpp
@@ -0,0 +1,137 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_WINDOWS_MUTEX_HPP
+#define BOOST_INTERPROCESS_DETAIL_WINDOWS_MUTEX_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/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/detail/win32_api.hpp>
+#include <boost/interprocess/detail/intermodule_singleton.hpp>
+#include <boost/interprocess/sync/windows/sync_utils.hpp>
+#include <boost/interprocess/exceptions.hpp>
+
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class windows_mutex
+{
+   windows_mutex(const windows_mutex &);
+   windows_mutex &operator=(const windows_mutex &);
+   public:
+
+   windows_mutex();
+   ~windows_mutex();
+
+   void lock();
+   bool try_lock();
+   bool timed_lock(const boost::posix_time::ptime &abs_time);
+   void unlock();
+   void take_ownership(){};
+
+   private:
+   const sync_id id_;
+};
+
+inline windows_mutex::windows_mutex() 
+   : id_()
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //Create mutex with the initial count
+   bool open_or_created;
+   handles.obtain_mutex(this->id_, &open_or_created);
+   //The mutex must be created, never opened
+   assert(open_or_created);
+   assert(open_or_created && winapi::get_last_error() != winapi::error_already_exists);
+   (void)open_or_created;
+}
+
+inline windows_mutex::~windows_mutex() 
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   handles.destroy_handle(this->id_);
+}
+
+inline void windows_mutex::lock(void)
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_mutex(this->id_);
+   unsigned long ret = winapi::wait_for_single_object(hnd, winapi::infinite_time);
+   if(ret == winapi::wait_failed){
+      error_info err(winapi::get_last_error());
+      throw interprocess_exception(err);
+   }
+}
+
+inline bool windows_mutex::try_lock(void)
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_mutex(this->id_);
+   unsigned long ret = winapi::wait_for_single_object(hnd, 0);
+   if(ret == winapi::wait_failed){
+      error_info err(winapi::get_last_error());
+      throw interprocess_exception(err);
+   }
+   return ret != winapi::wait_timeout;
+}
+
+inline bool windows_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->lock();
+      return true;
+   }
+   boost::posix_time::ptime now
+      = boost::posix_time::microsec_clock::universal_time();
+
+   unsigned long ms = (unsigned long)(abs_time-now).total_milliseconds();
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_mutex(this->id_);
+   unsigned long ret = winapi::wait_for_single_object(hnd, ms);
+   if(ret == winapi::wait_failed){
+      error_info err(winapi::get_last_error());
+      throw interprocess_exception(err);
+   }
+   return ret != winapi::wait_timeout;
+}
+
+inline void windows_mutex::unlock(void)
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_mutex(this->id_);
+   int ret = winapi::release_mutex(hnd);
+   (void)ret;
+   assert(ret);
+}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_WINDOWS_MUTEX_HPP
diff --git a/boost/interprocess/sync/windows/recursive_mutex.hpp b/boost/interprocess/sync/windows/recursive_mutex.hpp
new file mode 100644
index 0000000000..9565cb6fb4
--- /dev/null
+++ b/boost/interprocess/sync/windows/recursive_mutex.hpp
@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_WINDOWS_RECURSIVE_MUTEX_HPP
+#define BOOST_INTERPROCESS_DETAIL_WINDOWS_RECURSIVE_MUTEX_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/interprocess/sync/windows/mutex.hpp>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+//Windows mutex is already recursive
+class windows_recursive_mutex
+   : public windows_mutex
+{
+   windows_recursive_mutex(const windows_recursive_mutex &);
+   windows_recursive_mutex &operator=(const windows_recursive_mutex &);
+   public:
+   windows_recursive_mutex() : windows_mutex() {}
+};
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_WINDOWS_RECURSIVE_MUTEX_HPP
diff --git a/boost/interprocess/sync/windows/semaphore.hpp b/boost/interprocess/sync/windows/semaphore.hpp
new file mode 100644
index 0000000000..d5835ceec7
--- /dev/null
+++ b/boost/interprocess/sync/windows/semaphore.hpp
@@ -0,0 +1,137 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_WINDOWS_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_DETAIL_WINDOWS_SEMAPHORE_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/interprocess/detail/posix_time_types_wrk.hpp>
+#include <boost/interprocess/detail/win32_api.hpp>
+#include <boost/interprocess/detail/intermodule_singleton.hpp>
+#include <boost/interprocess/sync/windows/sync_utils.hpp>
+#include <boost/interprocess/exceptions.hpp>
+
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+class windows_semaphore
+{
+   windows_semaphore(const windows_semaphore &);
+   windows_semaphore &operator=(const windows_semaphore &);
+   public:
+
+   windows_semaphore(unsigned int initialCount);
+   ~windows_semaphore();
+
+   void post(long release_count = 1);
+   void wait();
+   bool try_wait();
+   bool timed_wait(const boost::posix_time::ptime &abs_time);
+
+   private:
+   const sync_id id_;
+};
+
+inline windows_semaphore::windows_semaphore(unsigned int initialCount) 
+   : id_()
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //Force smeaphore creation with the initial count
+   bool open_or_created;
+   handles.obtain_semaphore(this->id_, initialCount, &open_or_created);
+   //The semaphore must be created, never opened
+   assert(open_or_created);
+   assert(open_or_created && winapi::get_last_error() != winapi::error_already_exists);
+   (void)open_or_created;
+}
+
+inline windows_semaphore::~windows_semaphore() 
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   handles.destroy_handle(this->id_);
+}
+
+inline void windows_semaphore::wait(void)
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_semaphore(this->id_, 0);
+   unsigned long ret = winapi::wait_for_single_object(hnd, winapi::infinite_time);
+   if(ret == winapi::wait_failed){
+      error_info err(winapi::get_last_error());
+      throw interprocess_exception(err);
+   }
+}
+
+inline bool windows_semaphore::try_wait(void)
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_semaphore(this->id_, 0);
+   unsigned long ret = winapi::wait_for_single_object(hnd, 0);
+   if(ret == winapi::wait_failed){
+      error_info err(winapi::get_last_error());
+      throw interprocess_exception(err);
+   }
+   return ret != winapi::wait_timeout;
+}
+
+inline bool windows_semaphore::timed_wait(const boost::posix_time::ptime &abs_time)
+{
+   if(abs_time == boost::posix_time::pos_infin){
+      this->wait();
+      return true;
+   }
+   boost::posix_time::ptime now
+      = boost::posix_time::microsec_clock::universal_time();
+
+   unsigned long ms = (unsigned long)(abs_time-now).total_milliseconds();
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_semaphore(this->id_, 0);
+   unsigned long ret = winapi::wait_for_single_object(hnd, ms);
+   if(ret == winapi::wait_failed){
+      error_info err(winapi::get_last_error());
+      throw interprocess_exception(err);
+   }
+   return ret != winapi::wait_timeout;
+}
+
+inline void windows_semaphore::post(long release_count)
+{
+   sync_handles &handles =
+      intermodule_singleton<sync_handles>::get();
+   //This can throw
+   void *hnd = handles.obtain_semaphore(this->id_, 0);
+   long prev_count;
+   int ret = winapi::release_semaphore(hnd, release_count, &prev_count);
+   (void)ret;
+   assert(ret);
+}
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_WINDOWS_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/windows/sync_utils.hpp b/boost/interprocess/sync/windows/sync_utils.hpp
new file mode 100644
index 0000000000..89c4aeda0b
--- /dev/null
+++ b/boost/interprocess/sync/windows/sync_utils.hpp
@@ -0,0 +1,173 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_DETAIL_SYNC_UTILS_HPP
+#define BOOST_INTERPROCESS_DETAIL_SYNC_UTILS_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/interprocess/detail/win32_api.hpp>
+#include <boost/interprocess/sync/spin/mutex.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/unordered/unordered_map.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace interprocess {
+namespace ipcdetail {
+
+inline bool bytes_to_str(const void *mem, const std::size_t mem_length, char *out_str, std::size_t &out_length)
+{
+   const std::size_t need_mem = mem_length*2+1;
+   if(out_length < need_mem){
+      return false;
+   }
+
+   const char Characters [] =
+      { '0', '1', '2', '3', '4', '5', '6', '7'
+      , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+   std::size_t char_counter = 0;
+   const char *buf = (const char *)mem;
+   for(std::size_t i = 0; i != mem_length; ++i){
+      out_str[char_counter++] = Characters[(buf[i]&0xF0)>>4];
+      out_str[char_counter++] = Characters[(buf[i]&0x0F)];
+   }
+   out_str[char_counter] = 0;
+   return true;
+}
+
+struct sync_id
+{
+   sync_id()
+   {  winapi::query_performance_counter(&rand);  }
+
+   __int64 rand;
+
+   friend std::size_t hash_value(const sync_id &m)
+   {  return boost::hash_value(m.rand);  }
+
+   friend bool operator==(const sync_id &l, const sync_id &r)
+   {  return l.rand == r.rand;  }
+};
+/*
+#define BOOST_NO_LONG_LONG ss
+
+#if defined(BOOST_NO_LONG_LONG)
+
+#error "defined(BOOST_NO_LONG_LONG)"
+#else
+#error "NOT defined(BOOST_NO_LONG_LONG)"
+#endif
+*/
+class sync_handles
+{
+   public:
+   enum type { MUTEX, SEMAPHORE };
+
+   private:
+   typedef boost::unordered_map<sync_id, void*> map_type;
+   static const std::size_t LengthOfGlobal = sizeof("Global\\boost.ipc")-1;
+   static const std::size_t StrSize        = LengthOfGlobal + (sizeof(sync_id)*2+1);
+   typedef char NameBuf[StrSize];
+
+   void fill_name(NameBuf &name, const sync_id &id)
+   {
+      const char *n = "Global\\boost.ipc";
+      std::size_t i = 0;
+      do{
+         name[i] = n[i];
+         ++i;
+      } while(n[i]);
+      std::size_t len = sizeof(NameBuf) - LengthOfGlobal;
+      bytes_to_str(&id.rand, sizeof(id.rand), &name[LengthOfGlobal], len);
+   }
+
+   void erase_and_throw_if_error(void *hnd_val, const sync_id &id)
+   {
+      if(!hnd_val){
+         map_.erase(id);
+         error_info err(winapi::get_last_error());
+         throw interprocess_exception(err);
+      }
+   }
+
+   void* open_or_create_semaphore(const sync_id &id, unsigned int initial_count)
+   {
+      NameBuf name;
+      fill_name(name, id);
+      void *hnd_val = winapi::open_or_create_semaphore
+         (name, (long)initial_count, (long)(((unsigned long)(-1))>>1), unrestricted_security.get_attributes());
+      erase_and_throw_if_error(hnd_val, id);
+      return hnd_val;
+   }
+
+   void* open_or_create_mutex(const sync_id &id)
+   {
+      NameBuf name;
+      fill_name(name, id);
+      void *hnd_val = winapi::open_or_create_mutex
+            (name, false, unrestricted_security.get_attributes());
+      erase_and_throw_if_error(hnd_val, id);
+      return hnd_val;
+   }
+
+   public:
+   void *obtain_mutex(const sync_id &id, bool *popen_created = 0)
+   {
+      scoped_lock<spin_mutex> lock(mtx_);
+      void *&hnd_val = map_[id];
+      if(!hnd_val){
+         hnd_val = open_or_create_mutex(id);
+         if(popen_created) *popen_created = true;
+      }
+      return hnd_val;
+   }
+
+   void *obtain_semaphore(const sync_id &id, unsigned int initial_count, bool *popen_created = 0)
+   {
+      scoped_lock<spin_mutex> lock(mtx_);
+      void *&hnd_val = map_[id];
+      if(!hnd_val){
+         hnd_val = open_or_create_semaphore(id, initial_count);
+         if(popen_created) *popen_created = true;
+      }
+      return hnd_val;
+   }
+
+   void destroy_handle(const sync_id &id)
+   {
+      scoped_lock<spin_mutex> lock(mtx_);
+      map_type::iterator it = map_.find(id);
+      if(it != map_.end()){
+         winapi::close_handle(it->second);
+         map_.erase(it);
+      }
+   }
+
+   private:
+   winapi::interprocess_all_access_security unrestricted_security;
+   spin_mutex mtx_;
+   map_type map_;
+};
+
+
+}  //namespace ipcdetail {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_DETAIL_SYNC_UTILS_HPP
diff --git a/boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp b/boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp
new file mode 100644
index 0000000000..a0c3a91adf
--- /dev/null
+++ b/boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp
@@ -0,0 +1,193 @@
+/*
+ * Provide an simpler and easier to understand interface to the System V
+ * semaphore system calls.  There are 7 routines available to the user:
+ *
+ *      id = sem_create(key, initval);  # create with initial value or open
+ *      id = sem_open(key);             # open (must already exist)
+ *      sem_wait(id);                   # wait = P = down by 1
+ *      sem_signal(id);                 # signal = V = up by 1
+ *      sem_op(id, amount);             # wait   if (amount < 0)
+ *                                      # signal if (amount > 0)
+ *      sem_close(id);                  # close
+ *      sem_rm(id);                     # remove (delete)
+ *
+ * We create and use a 3-member set for the requested semaphore.
+ * The first member, [0], is the actual semaphore value, and the second
+ * member, [1], is a counter used to know when all processes have finished
+ * with the semaphore.  The counter is initialized to a large number,
+ * decremented on every create or open and incremented on every close.
+ * This way we can use the "adjust" feature provided by System V so that
+ * any process that exit's without calling sem_close() is accounted
+ * for.  It doesn't help us if the last process does this (as we have
+ * no way of getting control to remove the semaphore) but it will
+ * work if any process other than the last does an exit (intentional
+ * or unintentional).
+ * The third member, [2], of the semaphore set is used as a lock variable
+ * to avoid any race conditions in the sem_create() and sem_close()
+ * functions.
+ */
+
+#ifndef BOOST_INTERPROCESS_SYNC_XSI_ADVANCED_XSI_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_SYNC_XSI_ADVANCED_XSI_SEMAPHORE_HPP
+
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#include <errno.h>
+
+namespace boost {
+namespace interprocess {
+namespace xsi {
+
+// Create a semaphore with a specified initial value.
+// If the semaphore already exists, we don't initialize it (of course).
+// We return the semaphore ID if all OK, else -1.
+
+inline bool advanced_sem_open_or_create(::key_t key, int initval, int &semid, int perm)
+{
+   semid = -1;
+   int id, semval;
+   union semun {
+      int         val;
+      ::semid_ds *buf;
+      ushort     *array;
+   } semctl_arg;
+
+   if (key == IPC_PRIVATE)
+      return false; //not intended for private semaphores
+
+   else if (key == (::key_t) -1)
+      return false; //probably an ftok() error by caller
+
+   again:
+   if ((id = ::semget(key, 3, (perm & 0x01FF) | IPC_CREAT)) < 0)
+      return false;   //permission problem or tables full
+
+   // When the semaphore is created, we know that the value of all
+   // 3 members is 0.
+   // Get a lock on the semaphore by waiting for [2] to equal 0,
+   // then increment it.
+   //
+   // There is a race condition here.  There is a possibility that
+   // between the semget() above and the ::semop() below, another
+   // process can call our sem_close() function which can remove
+   // the semaphore if that process is the last one using it.
+   // Therefore, we handle the error condition of an invalid
+   // semaphore ID specially below, and if it does happen, we just
+   // go back and create it again.
+   struct sembuf op_lock[2] = {
+      {2, 0, 0},        // wait for [2] (lock) to equal 0
+      {2, 1, SEM_UNDO}  // then increment [2] to 1 - this locks it
+                        // UNDO to release the lock if processes exits
+                        // before explicitly unlocking
+   };
+
+   if (::semop(id, &op_lock[0], 2) < 0) {
+      if (errno == EINVAL)
+         goto again;
+   }
+
+   // Get the value of the process counter.  If it equals 0,
+   // then no one has initialized the semaphore yet.
+   if ((semval = ::semctl(id, 1, GETVAL, 0)) < 0)
+      return false;
+
+   if (semval == 0) {
+      // We could initialize by doing a SETALL, but that
+      // would clear the adjust value that we set when we
+      // locked the semaphore above.  Instead, we'll do 2
+      // system calls to initialize [0] and [1].
+      semctl_arg.val = initval;
+      if (::semctl(id, 0, SETVAL, semctl_arg) < 0)
+         return false;
+
+      semctl_arg.val = 1;
+      if (::semctl(id, 1, SETVAL, semctl_arg) < 0)
+         return false;
+   }
+
+   // Decrement the process counter and then release the lock.
+   struct sembuf op_unlock[1] = {
+      2, -1, 0/*SEM_UNDO*/ // decrement [2] (lock) back to 0
+   };
+
+   if (::semop(id, &op_unlock[0], 1) < 0)
+      return false;
+
+   semid = id;
+   return true;
+}
+
+// Open a semaphore that must already exist.
+// This function should be used, instead of sem_create(), if the caller
+// knows that the semaphore must already exist.  For example a client
+// from a client-server pair would use this, if its the server's
+// responsibility to create the semaphore.
+// We return the semaphore ID if all OK, else -1.
+/*
+inline bool advanced_sem_open(key_t key, int &semid)
+{
+   semid = -1;
+   if (key == IPC_PRIVATE)
+      return false; // not intended for private semaphores
+
+   else if (key == (::key_t) -1)
+      return false;  // probably an ftok() error by caller
+
+   if ((semid = ::semget(key, 3, 0)) < 0)
+      return false;     // doesn't exist, or tables full
+
+   // Decrement the process counter.  We don't need a lock
+   struct sembuf op_open[1] = {
+      1, -1, SEM_UNDO   // decrement [1] (proc counter) with undo on exit
+   };
+
+   if (::semop(id, &op_open[0], 1) < 0)
+      return false;
+
+   return true;
+}
+*/
+/****************************************************************************
+ * Remove a semaphore.
+ * This call is intended to be called by a server, for example,
+ * when it is being shut down, as we do an IPC_RMID on the semaphore,
+ * regardless whether other processes may be using it or not.
+ * Most other processes should use sem_close() below.
+ */
+
+inline bool advanced_sem_rm(int id)
+{
+   if (::semctl(id, 0, IPC_RMID, 0) < 0)
+      return false;
+   return true;
+}
+
+
+/****************************************************************************
+ * General semaphore operation.  Increment or decrement by a user-specified
+ * amount (positive or negative; amount can't be zero).
+ */
+
+inline bool advanced_sem_op(int id, int value, bool undo = true)
+{
+   ::sembuf op_op[1] = {
+      0, 99, 0 // decrement or increment [0] with undo on exit
+               // the 99 is set to the actual amount to add
+               // or subtract (positive or negative)
+   };
+   if(undo){
+      op_op[0].sem_flg = SEM_UNDO;
+   }
+   if ((op_op[0].sem_op = value) == 0)
+      return false;
+
+   if (::semop(id, &op_op[0], 1) < 0)
+      return false;
+   return true;
+}
+
+}  //namespace xsi {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#endif //BOOST_INTERPROCESS_SYNC_XSI_ADVANCED_XSI_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp b/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp
new file mode 100644
index 0000000000..266e7c5dac
--- /dev/null
+++ b/boost/interprocess/sync/xsi/simple_xsi_semaphore.hpp
@@ -0,0 +1,116 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2011. 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_SYNC_XSI_SIMPLE_XSI_SEMAPHORE_HPP
+#define BOOST_INTERPROCESS_SYNC_XSI_SIMPLE_XSI_SEMAPHORE_HPP
+
+/*
+ * Provide an simpler and easier to understand interface to the System V
+ * semaphore system calls.  There are 7 routines available to the user:
+ *
+ *      id = sem_create(key, initval);  # create with initial value or open
+ *      id = sem_open(key);             # open (must already exist)
+ *      sem_wait(id);                   # wait = P = down by 1
+ *      sem_signal(id);                 # signal = V = up by 1
+ *      sem_op(id, amount);             # wait   if (amount < 0)
+ *                                      # signal if (amount > 0)
+ *      sem_close(id);                  # close
+ *      sem_rm(id);                     # remove (delete)
+ *
+ * We create and use a 3-member set for the requested semaphore.
+ * The first member, [0], is the actual semaphore value, and the second
+ * member, [1], is a counter used to know when all processes have finished
+ * with the semaphore.  The counter is initialized to a large number,
+ * decremented on every create or open and incremented on every close.
+ * This way we can use the "adjust" feature provided by System V so that
+ * any process that exit's without calling sem_close() is accounted
+ * for.  It doesn't help us if the last process does this (as we have
+ * no way of getting control to remove the semaphore) but it will
+ * work if any process other than the last does an exit (intentional
+ * or unintentional).
+ * The third member, [2], of the semaphore set is used as a lock variable
+ * to avoid any race conditions in the sem_create() and sem_close()
+ * functions.
+ */
+
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#include <errno.h>
+
+namespace boost {
+namespace interprocess {
+namespace xsi {
+
+// Create a semaphore with a specified initial value.
+// If the semaphore already exists, we don't initialize it (of course).
+// We return the semaphore ID if all OK, else -1.
+
+inline bool simple_sem_open_or_create(::key_t key, int initval, int &semid, int perm)
+{
+   int id, semval;
+   semid = -1;
+
+   if (key == IPC_PRIVATE)
+      return false; //not intended for private semaphores
+
+   else if (key == (::key_t) -1)
+      return false; //probably an ftok() error by caller
+
+   again:
+   if ((id = ::semget(key, 1, (perm & 0x01FF) | IPC_CREAT)) < 0)
+      return false;   //permission problem or tables full
+
+   semid = id;
+   return true;
+}
+
+/****************************************************************************
+ * Remove a semaphore.
+ * This call is intended to be called by a server, for example,
+ * when it is being shut down, as we do an IPC_RMID on the semaphore,
+ * regardless whether other processes may be using it or not.
+ * Most other processes should use sem_close() below.
+ */
+
+inline bool simple_sem_rm(int id)
+{
+   if (::semctl(id, 0, IPC_RMID, 0) < 0)
+      return false;
+   return true;
+}
+
+
+/****************************************************************************
+ * General semaphore operation.  Increment or decrement by a user-specified
+ * amount (positive or negative; amount can't be zero).
+ */
+
+inline bool simple_sem_op(int id, int value, bool undo = true)
+{
+   ::sembuf op_op[1] = {
+      0, 99, 0 // decrement or increment [0] with undo on exit
+               // the 99 is set to the actual amount to add
+               // or subtract (positive or negative)
+   };
+   if(undo){
+      op_op[0].sem_flg = SEM_UNDO;
+   }
+   if ((op_op[0].sem_op = value) == 0)
+      return false;
+
+   if (::semop(id, &op_op[0], 1) < 0)
+      return false;
+   return true;
+}
+
+}  //namespace xsi {
+}  //namespace interprocess {
+}  //namespace boost {
+
+#endif //BOOST_INTERPROCESS_SYNC_XSI_SIMPLE_XSI_SEMAPHORE_HPP
diff --git a/boost/interprocess/sync/xsi/xsi_named_mutex.hpp b/boost/interprocess/sync/xsi/xsi_named_mutex.hpp
new file mode 100644
index 0000000000..3dffdcc2ed
--- /dev/null
+++ b/boost/interprocess/sync/xsi/xsi_named_mutex.hpp
@@ -0,0 +1,228 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2011. 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_XSI_XSI_NAMED_MUTEX_HPP
+#define BOOST_INTERPROCESS_XSI_XSI_NAMED_MUTEX_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+
+#if defined(BOOST_INTERPROCESS_WINDOWS)
+#error "This header can't be used in Windows operating systems"
+#endif
+
+#include <boost/move/move.hpp>
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/sync/xsi/basic_xsi_semaphore.hpp>
+#include <cstddef>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+#include <string>
+#include <boost/assert.hpp>
+
+//!\file
+//!Describes a class representing a xsi-based named_mutex.
+
+namespace boost {
+namespace interprocess {
+
+//!A class that wraps a XSI (System V)-based named semaphore
+//!that undoes the operation if the process crashes.
+class xsi_named_mutex
+{
+   /// @cond
+   //Non-copyable and non-assignable
+   xsi_named_mutex(xsi_named_mutex &);
+   xsi_named_mutex &operator=(xsi_named_mutex &);
+   /// @endcond
+
+   public:
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_named_mutex)
+
+   //!Default constructor.
+   //!Represents an empty xsi_named_mutex.
+   xsi_named_mutex();
+
+   //!Tries to create a new XSI-based named mutex with a key obtained from a call to ftok (with path
+   //!"path" and id "id"), and permissions "perm".
+   //!If the named mutex previously exists, it tries to open it.
+   //!Otherwise throws an error.
+   xsi_named_mutex(open_or_create_t, const char *path, boost::uint8_t id, int perm = 0666)
+   {  this->priv_open_or_create(ipcdetail::DoOpenOrCreate, path, id, perm);  }
+
+   //!Moves the ownership of "moved"'s named mutex to *this. 
+   //!After the call, "moved" does not represent any named mutex 
+   //!Does not throw
+   xsi_named_mutex(BOOST_RV_REF(xsi_named_mutex) moved)
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s named mutex to *this.
+   //!After the call, "moved" does not represent any named mutex. 
+   //!Does not throw
+   xsi_named_mutex &operator=(BOOST_RV_REF(xsi_named_mutex) moved)
+   {  
+      xsi_named_mutex tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps two xsi_named_mutex. Does not throw
+   void swap(xsi_named_mutex &other);
+
+   //!Destroys *this. The named mutex is still valid after
+   //!destruction. use remove() to destroy the named mutex.
+   ~xsi_named_mutex();
+
+   //!Returns the path used to construct the
+   //!named mutex.
+   const char *get_path() const;
+
+   //!Returns access
+   //!permissions
+   int get_permissions() const;
+
+   //!Returns the mapping handle.
+   //!Never throws
+   mapping_handle_t get_mapping_handle() const;
+
+   //!Erases a XSI-based named mutex from the system.
+   //!Returns false on error. Never throws
+   bool remove();
+
+   void lock();
+
+   void unlock();
+
+   /// @cond
+   private:
+
+   //!Closes a previously opened file mapping. Never throws.
+   void priv_close();
+
+   //!Closes a previously opened file mapping. Never throws.
+   bool priv_open_or_create( ipcdetail::create_enum_t type
+                           , const char *path
+                           , boost::uint8_t id
+                           , int perm);
+   int            m_semid;
+   key_t          m_key;
+   boost::uint8_t m_id;
+   int            m_perm;
+   std::string    m_path;
+   /// @endcond
+};
+
+/// @cond
+
+inline xsi_named_mutex::xsi_named_mutex() 
+   :  m_semid(-1), m_key(-1), m_id(0), m_perm(0), m_path()
+{}
+
+inline xsi_named_mutex::~xsi_named_mutex() 
+{  this->priv_close(); }
+
+inline const char *xsi_named_mutex::get_path() const
+{  return m_path.c_str(); }
+
+inline void xsi_named_mutex::swap(xsi_named_mutex &other)
+{
+   std::swap(m_key,   other.m_key);
+   std::swap(m_id,    other.m_id);
+   std::swap(m_semid, other.m_semid);
+   std::swap(m_perm,  other.m_perm);
+   m_path.swap(other.m_path);   
+}
+
+inline mapping_handle_t xsi_named_mutex::get_mapping_handle() const
+{  mapping_handle_t mhnd = { m_semid, true};   return mhnd;   }
+
+inline int xsi_named_mutex::get_permissions() const
+{  return m_perm; }
+
+inline bool xsi_named_mutex::priv_open_or_create
+   (ipcdetail::create_enum_t type, const char *path, boost::uint8_t id, int perm)
+{
+   key_t key;
+   if(path){
+      key  = ::ftok(path, id);
+      if(((key_t)-1) == key){
+         error_info err = system_error_code();
+         throw interprocess_exception(err);
+      }
+   }
+   else{
+      key = IPC_PRIVATE;
+   }
+
+   perm &= 0x01FF;
+
+   int semid;
+   if(!xsi::simple_sem_open_or_create(key, 1, semid, perm)){
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+
+   m_perm = perm;
+   m_semid = semid;
+   m_path = path ? path : "";
+   m_id   = id;
+   m_key  = key;
+
+   return true;
+}
+
+inline void xsi_named_mutex::priv_close()
+{
+}
+
+inline void xsi_named_mutex::lock()
+{
+   if(!xsi::simple_sem_op(m_semid, -1)){
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+}
+
+inline void xsi_named_mutex::unlock()
+{
+   bool success = xsi::simple_sem_op(m_semid, 1);
+   (void)success;
+   BOOST_ASSERT(success);
+}
+
+inline bool xsi_named_mutex::remove()
+{
+   if(m_semid != -1){
+      int ret = ::semctl(m_semid, IPC_RMID, 0);
+      if(-1 == ret)
+         return false;
+      //Now put it in default-constructed state
+      m_semid  = -1;
+      m_key    = -1;
+      m_id     = 0;
+      m_perm   = 0;
+      m_path.clear();
+   }
+   return false;
+}
+
+///@endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_XSI_XSI_NAMED_MUTEX_HPP
diff --git a/boost/interprocess/windows_shared_memory.hpp b/boost/interprocess/windows_shared_memory.hpp
new file mode 100644
index 0000000000..9a8b3f47dd
--- /dev/null
+++ b/boost/interprocess/windows_shared_memory.hpp
@@ -0,0 +1,232 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2011. 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_WINDOWS_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_WINDOWS_SHARED_MEMORY_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/interprocess/permissions.hpp>
+
+#if !defined(BOOST_INTERPROCESS_WINDOWS)
+#error "This header can only be used in Windows operating systems"
+#endif
+
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/win32_api.hpp>
+#include <cstddef>
+#include <boost/cstdint.hpp>
+#include <string>
+
+//!\file
+//!Describes a class representing a native windows shared memory.
+
+namespace boost {
+namespace interprocess {
+
+//!A class that wraps the native Windows shared memory
+//!that is implemented as a file mapping of the paging file.
+//!Unlike shared_memory_object, windows_shared_memory has
+//!no kernel persistence and the shared memory is destroyed
+//!when all processes destroy all their windows_shared_memory
+//!objects and mapped regions for the same shared memory
+//!or the processes end/crash.
+//!
+//!Warning: Windows native shared memory and interprocess portable
+//!shared memory (boost::interprocess::shared_memory_object)
+//!can't communicate between them.
+class windows_shared_memory
+{
+   /// @cond
+   //Non-copyable and non-assignable
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(windows_shared_memory)
+   /// @endcond
+
+   public:
+   //!Default constructor.
+   //!Represents an empty windows_shared_memory.
+   windows_shared_memory();
+
+   //!Creates a new native shared memory with name "name" and mode "mode",
+   //!with the access mode "mode".
+   //!If the file previously exists, throws an error.
+   windows_shared_memory(create_only_t, const char *name, mode_t mode, std::size_t size, const permissions& perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoCreate, name, mode, size, perm);  }
+
+   //!Tries to create a shared memory object with name "name" and mode "mode", with the
+   //!access mode "mode". If the file previously exists, it tries to open it with mode "mode".
+   //!Otherwise throws an error.
+   windows_shared_memory(open_or_create_t, const char *name, mode_t mode, std::size_t size, const permissions& perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoOpenOrCreate, name, mode, size, perm);  }
+
+   //!Tries to open a shared memory object with name "name", with the access mode "mode". 
+   //!If the file does not previously exist, it throws an error.
+   windows_shared_memory(open_only_t, const char *name, mode_t mode)
+   {  this->priv_open_or_create(ipcdetail::DoOpen, name, mode, 0, permissions());  }
+
+   //!Moves the ownership of "moved"'s shared memory object to *this. 
+   //!After the call, "moved" does not represent any shared memory object. 
+   //!Does not throw
+   windows_shared_memory(BOOST_RV_REF(windows_shared_memory) moved)
+      : m_handle(0)
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s shared memory to *this.
+   //!After the call, "moved" does not represent any shared memory. 
+   //!Does not throw
+   windows_shared_memory &operator=(BOOST_RV_REF(windows_shared_memory) moved)
+   {  
+      windows_shared_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps to shared_memory_objects. Does not throw
+   void swap(windows_shared_memory &other);
+
+   //!Destroys *this. All mapped regions are still valid after
+   //!destruction. When all mapped regions and windows_shared_memory
+   //!objects referring the shared memory are destroyed, the
+   //!operating system will destroy the shared memory.
+   ~windows_shared_memory();
+
+   //!Returns the name of the shared memory.
+   const char *get_name() const;
+
+   //!Returns access mode
+   mode_t get_mode() const;
+
+   //!Returns the mapping handle. Never throws
+   mapping_handle_t get_mapping_handle() const;
+
+   /// @cond
+   private:
+
+   //!Closes a previously opened file mapping. Never throws.
+   void priv_close();
+
+   //!Closes a previously opened file mapping. Never throws.
+   bool priv_open_or_create(ipcdetail::create_enum_t type, const char *filename, mode_t mode, std::size_t size, const permissions& perm = permissions());
+
+   void *         m_handle;
+   mode_t         m_mode;
+   std::string    m_name;
+   /// @endcond
+};
+
+/// @cond
+
+inline windows_shared_memory::windows_shared_memory() 
+   :  m_handle(0)
+{}
+
+inline windows_shared_memory::~windows_shared_memory() 
+{  this->priv_close(); }
+
+inline const char *windows_shared_memory::get_name() const
+{  return m_name.c_str(); }
+
+inline void windows_shared_memory::swap(windows_shared_memory &other)
+{  
+   std::swap(m_handle,  other.m_handle);
+   std::swap(m_mode,    other.m_mode);
+   m_name.swap(other.m_name);   
+}
+
+inline mapping_handle_t windows_shared_memory::get_mapping_handle() const
+{  mapping_handle_t mhnd = { m_handle, true};   return mhnd;   }
+
+inline mode_t windows_shared_memory::get_mode() const
+{  return m_mode; }
+
+inline bool windows_shared_memory::priv_open_or_create
+   (ipcdetail::create_enum_t type, const char *filename, mode_t mode, std::size_t size, const permissions& perm)
+{
+   m_name = filename ? filename : "";
+
+   unsigned long file_map_access = 0;
+   unsigned long map_access = 0;
+
+   switch(mode)
+   {
+      case read_only:
+         file_map_access   |= winapi::page_readonly;
+         map_access        |= winapi::file_map_read;
+      break;
+      case read_write:
+         file_map_access   |= winapi::page_readwrite;
+         map_access        |= winapi::file_map_write;
+      break;
+      case copy_on_write:
+         file_map_access   |= winapi::page_writecopy;
+         map_access        |= winapi::file_map_copy;
+      break;
+      default:
+         {
+            error_info err(mode_error);
+            throw interprocess_exception(err);
+         }
+      break;
+   }
+
+   switch(type){
+      case ipcdetail::DoOpen:
+         m_handle = winapi::open_file_mapping
+            (map_access, filename);
+      break;
+      case ipcdetail::DoCreate:
+      case ipcdetail::DoOpenOrCreate:
+      {
+         __int64 s = size;
+         unsigned long high_size(s >> 32), low_size((boost::uint32_t)s);
+         m_handle = winapi::create_file_mapping
+            ( winapi::invalid_handle_value, file_map_access, high_size, low_size, filename
+            , (winapi::interprocess_security_attributes*)perm.get_permissions());
+      }
+      break;
+      default:
+         {
+            error_info err = other_error;
+            throw interprocess_exception(err);
+         }
+   }
+
+   if(!m_handle || (type == ipcdetail::DoCreate && winapi::get_last_error() == winapi::error_already_exists)){
+      error_info err = system_error_code();
+      this->priv_close();
+      throw interprocess_exception(err);
+   }
+
+   m_mode = mode;
+   return true;
+}
+
+inline void windows_shared_memory::priv_close()
+{
+   if(m_handle){
+      winapi::close_handle(m_handle);
+      m_handle = 0;
+   }
+}
+
+///@endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_WINDOWS_SHARED_MEMORY_HPP
diff --git a/boost/interprocess/xsi_key.hpp b/boost/interprocess/xsi_key.hpp
new file mode 100644
index 0000000000..ffd4c498df
--- /dev/null
+++ b/boost/interprocess/xsi_key.hpp
@@ -0,0 +1,87 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009. 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_XSI_KEY_HPP
+#define BOOST_INTERPROCESS_XSI_KEY_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS)
+#error "This header can't be used in operating systems without XSI (System V) shared memory support"
+#endif
+
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <cstddef>
+#include <boost/cstdint.hpp>
+
+//!\file
+//!Describes a class representing a xsi key type.
+
+namespace boost {
+namespace interprocess {
+
+//!A class that wraps XSI (System V) key_t type.
+//!This type calculates key_t from path and id using ftok
+//!or sets key to IPC_PRIVATE using the default constructor.
+class xsi_key
+{
+   public:
+
+   //!Default constructor.
+   //!Represents a private xsi_key.
+   xsi_key()
+      : m_key(IPC_PRIVATE)
+   {}
+
+   //!Creates a new XSI  shared memory with a key obtained from a call to ftok (with path
+   //!"path" and id "id"), of size "size" and permissions "perm".
+   //!If the shared memory previously exists, throws an error.
+   xsi_key(const char *path, boost::uint8_t id)
+   {
+      key_t key;   
+      if(path){
+         key  = ::ftok(path, id);
+         if(((key_t)-1) == key){
+            error_info err = system_error_code();
+            throw interprocess_exception(err);
+         }
+      }
+      else{
+         key = IPC_PRIVATE;
+      }
+      m_key = key;
+   }
+
+   //!Returns the internal key_t value
+   key_t get_key() const
+   {  return m_key;  }
+
+   /// @cond
+   private:
+   key_t m_key;
+   /// @endcond
+};
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_XSI_KEY_HPP
diff --git a/boost/interprocess/xsi_shared_memory.hpp b/boost/interprocess/xsi_shared_memory.hpp
new file mode 100644
index 0000000000..3d09c77399
--- /dev/null
+++ b/boost/interprocess/xsi_shared_memory.hpp
@@ -0,0 +1,201 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009. 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_XSI_SHARED_MEMORY_HPP
+#define BOOST_INTERPROCESS_XSI_SHARED_MEMORY_HPP
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include <boost/interprocess/detail/workaround.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !defined(BOOST_INTERPROCESS_XSI_SHARED_MEMORY_OBJECTS)
+#error "This header can't be used in operating systems without XSI (System V) shared memory support"
+#endif
+
+#include <boost/interprocess/creation_tags.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/detail/utilities.hpp>
+#include <boost/move/move.hpp>
+#include <boost/interprocess/detail/os_file_functions.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/interprocess/exceptions.hpp>
+#include <boost/interprocess/xsi_key.hpp>
+#include <boost/interprocess/permissions.hpp>
+#include <sys/shm.h>
+#include <cstddef>
+#include <boost/cstdint.hpp>
+
+//!\file
+//!Describes a class representing a native xsi shared memory.
+
+namespace boost {
+namespace interprocess {
+
+//!A class that wraps XSI (System V) shared memory.
+//!Unlike shared_memory_object, xsi_shared_memory needs a valid
+//!xsi_key to identify a shared memory object.
+//!
+//!Warning: XSI shared memory and interprocess portable
+//!shared memory (boost::interprocess::shared_memory_object)
+//!can't communicate between them.
+class xsi_shared_memory
+{
+   /// @cond
+   //Non-copyable and non-assignable
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(xsi_shared_memory)
+   /// @endcond
+
+   public:
+   //!Default constructor.
+   //!Represents an empty xsi_shared_memory.
+   xsi_shared_memory();
+
+   //!Initializes *this with a shmid previously obtained (possibly from another process)
+   //!This lower-level initializer allows shared memory mapping without having a key.
+   xsi_shared_memory(open_only_t, int shmid)
+      : m_shmid (shmid)
+   {}
+
+   //!Creates a new XSI shared memory from 'key', with size "size" and permissions "perm".
+   //!If the shared memory previously exists, throws an error.
+   xsi_shared_memory(create_only_t, const xsi_key &key, std::size_t size, const permissions& perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoCreate, key, perm, size);  }
+
+   //!Opens an existing shared memory with identifier 'key' or creates a new XSI shared memory from
+   //!identifier 'key', with size "size" and permissions "perm".
+   xsi_shared_memory(open_or_create_t, const xsi_key &key, std::size_t size, const permissions& perm = permissions())
+   {  this->priv_open_or_create(ipcdetail::DoOpenOrCreate, key, perm, size);  }
+
+   //!Tries to open a XSI shared memory with identifier 'key'
+   //!If the shared memory does not previously exist, it throws an error.
+   xsi_shared_memory(open_only_t, const xsi_key &key)
+   {  this->priv_open_or_create(ipcdetail::DoOpen, key, permissions(), 0);  }
+
+   //!Moves the ownership of "moved"'s shared memory object to *this. 
+   //!After the call, "moved" does not represent any shared memory object. 
+   //!Does not throw
+   xsi_shared_memory(BOOST_RV_REF(xsi_shared_memory) moved)
+      : m_shmid(-1)
+   {  this->swap(moved);   }
+
+   //!Moves the ownership of "moved"'s shared memory to *this.
+   //!After the call, "moved" does not represent any shared memory. 
+   //!Does not throw
+   xsi_shared_memory &operator=(BOOST_RV_REF(xsi_shared_memory) moved)
+   {  
+      xsi_shared_memory tmp(boost::move(moved));
+      this->swap(tmp);
+      return *this;  
+   }
+
+   //!Swaps two xsi_shared_memorys. Does not throw
+   void swap(xsi_shared_memory &other);
+
+   //!Destroys *this. The shared memory won't be destroyed, just
+   //!this connection to it. Use remove() to destroy the shared memory.
+   ~xsi_shared_memory();
+
+   //!Returns the shared memory ID that
+   //!identifies the shared memory
+   int get_shmid() const;
+
+   //!Returns the mapping handle.
+   //!Never throws
+   mapping_handle_t get_mapping_handle() const;
+
+   //!Erases the XSI shared memory object identified by shmid
+   //!from the system.
+   //!Returns false on error. Never throws
+   static bool remove(int shmid);
+
+   /// @cond
+   private:
+
+   //!Closes a previously opened file mapping. Never throws.
+   bool priv_open_or_create( ipcdetail::create_enum_t type
+                           , const xsi_key &key
+                           , const permissions& perm
+                           , std::size_t size);
+   int            m_shmid;
+   /// @endcond
+};
+
+/// @cond
+
+inline xsi_shared_memory::xsi_shared_memory() 
+   :  m_shmid(-1)
+{}
+
+inline xsi_shared_memory::~xsi_shared_memory() 
+{}
+
+inline int xsi_shared_memory::get_shmid() const
+{  return m_shmid; }
+
+inline void xsi_shared_memory::swap(xsi_shared_memory &other)
+{
+   std::swap(m_shmid, other.m_shmid);
+}
+
+inline mapping_handle_t xsi_shared_memory::get_mapping_handle() const
+{  mapping_handle_t mhnd = { m_shmid, true};   return mhnd;   }
+
+inline bool xsi_shared_memory::priv_open_or_create
+   (ipcdetail::create_enum_t type, const xsi_key &key, const permissions& permissions, std::size_t size)
+{
+   int perm = permissions.get_permissions();
+   perm &= 0x01FF;
+   int shmflg = perm;
+
+   switch(type){
+      case ipcdetail::DoOpen:
+         shmflg |= 0;
+      break;
+      case ipcdetail::DoCreate:
+         shmflg |= IPC_CREAT | IPC_EXCL;
+      break;
+      case ipcdetail::DoOpenOrCreate:
+         shmflg |= IPC_CREAT;
+      break;
+      default:
+         {
+            error_info err = other_error;
+            throw interprocess_exception(err);
+         }
+   }
+
+   int ret = ::shmget(key.get_key(), size, shmflg);
+   int shmid = ret;
+   if((type == ipcdetail::DoOpen) && (-1 != ret)){
+      //Now get the size
+      ::shmid_ds xsi_ds;
+      ret = ::shmctl(ret, IPC_STAT, &xsi_ds);
+      size = xsi_ds.shm_segsz;
+   }
+   if(-1 == ret){
+      error_info err = system_error_code();
+      throw interprocess_exception(err);
+   }
+
+   m_shmid = shmid;
+   return true;
+}
+
+inline bool xsi_shared_memory::remove(int shmid)
+{  return -1 != ::shmctl(shmid, IPC_RMID, 0); }
+
+///@endcond
+
+}  //namespace interprocess {
+}  //namespace boost {
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif   //BOOST_INTERPROCESS_XSI_SHARED_MEMORY_HPP