Fixes #247

Fix move semantics for cache-containing allocators

Author: igaztanaga

doc/interprocess.qbk

@@ -6783,6 +6783,13 @@ thank them:
 
 [section:release_notes Release Notes]
 
+[section:release_notes_boost_1_91_00 Boost 1.91 Release]
+
+* Fixed bugs:
+   * [@https://github.com/boostorg/interprocess/issues/247 GitHub #247 (['"destruction of move-constructed map using private_adaptive_pool triggers Assertion"])].
+
+[endsect]
+
 [section:release_notes_boost_1_90_00 Boost 1.90 Release]
 
 * Minor documentation fixes

include/boost/interprocess/allocators/cached_adaptive_pool.hpp

@@ -59,6 +59,7 @@ class cached_adaptive_pool_v1
             >
          , 1>
 {
+   BOOST_COPYABLE_AND_MOVABLE_ALT(cached_adaptive_pool_v1)
    public:
    typedef ipcdetail::cached_allocator_impl
          < T
@@ -91,6 +92,14 @@ class cached_adaptive_pool_v1
          <T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
       : base_t(other)
    {}
+
+   cached_adaptive_pool_v1(const cached_adaptive_pool_v1 &other)
+      : base_t(other)
+   {}
+
+   cached_adaptive_pool_v1(BOOST_RV_REF(cached_adaptive_pool_v1) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
 };
 
 }  //namespace ipcdetail{
@@ -148,6 +157,7 @@ class cached_adaptive_pool
             >
          , 2> base_t;
 
+   BOOST_COPYABLE_AND_MOVABLE_ALT(cached_adaptive_pool)
    public:
    typedef boost::interprocess::version_type<cached_adaptive_pool, 2>   version;
 
@@ -169,6 +179,14 @@ class cached_adaptive_pool
       : base_t(other)
    {}
 
+   cached_adaptive_pool(const cached_adaptive_pool &other)
+      : base_t(other)
+   {}
+
+   cached_adaptive_pool(BOOST_RV_REF(cached_adaptive_pool) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
+
    #else
    public:
    typedef implementation_defined::segment_manager       segment_manager;
@@ -212,6 +230,10 @@ class cached_adaptive_pool
    //!count of the associated node pool. Never throws
    cached_adaptive_pool(const cached_adaptive_pool &other);
 
+   //!Move constructor from other. Increments the reference
+   //!count of the associated node pool and captures the cache. Never throws
+   cached_adaptive_pool(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

include/boost/interprocess/allocators/cached_node_allocator.hpp

@@ -56,6 +56,7 @@ class cached_node_allocator_v1
             >
          , 1>
 {
+   BOOST_COPYABLE_AND_MOVABLE_ALT(cached_node_allocator_v1)
    public:
    typedef ipcdetail::cached_allocator_impl
          < T
@@ -86,6 +87,14 @@ class cached_node_allocator_v1
          <T2, SegmentManager, NodesPerBlock> &other)
       : base_t(other)
    {}
+
+   cached_node_allocator_v1(const cached_node_allocator_v1 &other)
+      : base_t(other)
+   {}
+
+   cached_node_allocator_v1(BOOST_RV_REF(cached_node_allocator_v1) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
 };
 
 }  //namespace ipcdetail{
@@ -120,6 +129,8 @@ class cached_node_allocator
             >
          , 2> base_t;
 
+   BOOST_COPYABLE_AND_MOVABLE_ALT(cached_node_allocator)
+
    public:
    typedef boost::interprocess::version_type<cached_node_allocator, 2>   version;
    typedef typename base_t::size_type size_type;
@@ -141,6 +152,14 @@ class cached_node_allocator
       : base_t(other)
    {}
 
+   cached_node_allocator(const cached_node_allocator & other)
+      : base_t(other)
+   {}
+
+   cached_node_allocator(BOOST_RV_REF(cached_node_allocator) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
+
    #else
    public:
    typedef implementation_defined::segment_manager       segment_manager;
@@ -184,6 +203,10 @@ class cached_node_allocator
    //!count of the associated node pool. Never throws
    cached_node_allocator(const cached_node_allocator &other);
 
+   //!Move constructor from other. Increments the reference
+   //!count of the associated node pool and captures the cache. Never throws
+   cached_node_allocator(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

include/boost/interprocess/allocators/detail/allocator_common.hpp

@@ -162,21 +162,34 @@ class cache_impl
    multiallocation_chain         m_cached_nodes;
    size_type                     m_max_cached_nodes;
 
+   BOOST_COPYABLE_AND_MOVABLE_ALT(cache_impl)
+
    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_cached_nodes()
       , m_max_cached_nodes(max_cached_nodes)
    {}
 
    cache_impl(const cache_impl &other)
       : mp_node_pool(other.get_node_pool())
+      , m_cached_nodes()
       , m_max_cached_nodes(other.get_max_cached_nodes())
    {
       mp_node_pool->inc_ref_count();
    }
 
+   cache_impl(BOOST_RV_REF(cache_impl) other)
+      : mp_node_pool(BOOST_MOVE_TO_LV(other).get_node_pool())
+      , m_cached_nodes()
+      , m_max_cached_nodes(BOOST_MOVE_TO_LV(other).get_max_cached_nodes())
+   {
+      mp_node_pool->inc_ref_count();
+      m_cached_nodes.swap(BOOST_MOVE_TO_LV(other).m_cached_nodes);
+   }
+
    ~cache_impl()
    {
       this->deallocate_all_cached_nodes();
@@ -565,6 +578,8 @@ class cached_allocator_impl
    typedef typename base_t::multiallocation_chain        multiallocation_chain;
    typedef typename base_t::value_type                   value_type;
 
+   BOOST_COPYABLE_AND_MOVABLE_ALT(cached_allocator_impl)
+
    public:
    static const std::size_t DEFAULT_MAX_CACHED_NODES = 64;
 
@@ -576,6 +591,10 @@ class cached_allocator_impl
       : m_cache(other.m_cache)
    {}
 
+   cached_allocator_impl(BOOST_RV_REF(cached_allocator_impl) other)
+      : m_cache(boost::move(BOOST_MOVE_TO_LV(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

include/boost/interprocess/allocators/private_adaptive_pool.hpp

@@ -129,6 +129,9 @@ class private_adaptive_pool_base
    };
 
    private:
+
+   BOOST_COPYABLE_AND_MOVABLE_ALT(private_adaptive_pool_base)
+
    //!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=
@@ -149,7 +152,14 @@ class private_adaptive_pool_base
       : m_node_pool(other.get_segment_manager())
    {}
 
-   //!Copy constructor from related private_adaptive_pool_base. Never throws.
+   //!Copy constructor from other private_adaptive_pool_base. Never throws
+   private_adaptive_pool_base(BOOST_RV_REF(private_adaptive_pool_base) other)
+      : m_node_pool(other.get_segment_manager())
+   {
+      m_node_pool.swap(BOOST_MOVE_TO_LV(other).m_node_pool);
+   }
+
+   //!Move constructor from related private_adaptive_pool_base. Never throws.
    template<class T2>
    private_adaptive_pool_base
       (const private_adaptive_pool_base
@@ -208,6 +218,7 @@ class private_adaptive_pool_v1
          , OverheadPercent
          >
 {
+   BOOST_COPYABLE_AND_MOVABLE_ALT(private_adaptive_pool_v1)
    public:
    typedef ipcdetail::private_adaptive_pool_base
          < 1, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> base_t;
@@ -227,6 +238,14 @@ class private_adaptive_pool_v1
       (const private_adaptive_pool_v1<T2, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> &other)
       : base_t(other)
    {}
+
+   private_adaptive_pool_v1(const private_adaptive_pool_v1 &other)
+      : base_t(other)
+   {}
+
+   private_adaptive_pool_v1(BOOST_RV_REF(private_adaptive_pool_v1) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
 };
 
 }  //namespace ipcdetail {
@@ -268,6 +287,8 @@ class private_adaptive_pool
    #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
    typedef ipcdetail::private_adaptive_pool_base
          < 2, T, SegmentManager, NodesPerBlock, MaxFreeBlocks, OverheadPercent> base_t;
+
+   BOOST_COPYABLE_AND_MOVABLE_ALT(private_adaptive_pool)
    public:
    typedef boost::interprocess::version_type<private_adaptive_pool, 2>   version;
 
@@ -288,6 +309,14 @@ class private_adaptive_pool
       : base_t(other)
    {}
 
+   private_adaptive_pool(const private_adaptive_pool &other)
+      : base_t(other)
+   {}
+
+   private_adaptive_pool(BOOST_RV_REF(private_adaptive_pool) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
+
    #else
    public:
    typedef implementation_defined::segment_manager       segment_manager;
@@ -332,6 +361,10 @@ class private_adaptive_pool
    //!count of the associated node pool. Never throws
    private_adaptive_pool(const private_adaptive_pool &other);
 
+   //!Move constructor from other. Increments the reference
+   //!count of the associated node pool and captures the cache. Never throws
+   private_adaptive_pool(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

include/boost/interprocess/allocators/private_node_allocator.hpp

@@ -59,6 +59,7 @@ class private_node_allocator_base
    , SegmentManager
    >
 {
+   BOOST_COPYABLE_AND_MOVABLE_ALT(private_node_allocator_base)
    public:
    //Segment manager
    typedef SegmentManager                                segment_manager;
@@ -141,6 +142,13 @@ class private_node_allocator_base
       : m_node_pool(other.get_segment_manager())
    {}
 
+   //!Move constructor from other private_node_allocator_base. Never throws
+   private_node_allocator_base(BOOST_RV_REF(private_node_allocator_base) other)
+      : m_node_pool(other.get_segment_manager())
+   {
+      m_node_pool.swap(BOOST_MOVE_TO_LV(other).m_node_pool);
+   }
+
    //!Copy constructor from related private_node_allocator_base. Never throws.
    template<class T2>
    private_node_allocator_base
@@ -196,6 +204,7 @@ class private_node_allocator_v1
          , NodesPerBlock
          >
 {
+   BOOST_COPYABLE_AND_MOVABLE_ALT(private_node_allocator_v1)
    public:
    typedef ipcdetail::private_node_allocator_base
          < 1, T, SegmentManager, NodesPerBlock> base_t;
@@ -215,6 +224,14 @@ class private_node_allocator_v1
       (const private_node_allocator_v1<T2, SegmentManager, NodesPerBlock> &other)
       : base_t(other)
    {}
+
+   private_node_allocator_v1(const private_node_allocator_v1 &other)
+      : base_t(other)
+   {}
+
+   private_node_allocator_v1(BOOST_RV_REF(private_node_allocator_v1) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
 };
 
 }  //namespace ipcdetail {
@@ -245,6 +262,8 @@ class private_node_allocator
    #ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
    typedef ipcdetail::private_node_allocator_base
          < 2, T, SegmentManager, NodesPerBlock> base_t;
+
+   BOOST_COPYABLE_AND_MOVABLE_ALT(private_node_allocator)
    public:
    typedef boost::interprocess::version_type<private_node_allocator, 2>   version;
 
@@ -265,6 +284,14 @@ class private_node_allocator
       : base_t(other)
    {}
 
+   private_node_allocator(const private_node_allocator &other)
+      : base_t(other)
+   {}
+
+   private_node_allocator(BOOST_RV_REF(private_node_allocator) other)
+      : base_t(BOOST_MOVE_BASE(base_t, other))
+   {}
+
    #else
    public:
    typedef implementation_defined::segment_manager       segment_manager;
@@ -309,6 +336,10 @@ class private_node_allocator
    //!count of the associated node pool. Never throws
    private_node_allocator(const private_node_allocator &other);
 
+   //!Move constructor from other. Increments the reference
+   //!count of the associated node pool and captures the cache. Never throws
+   private_node_allocator(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

test/adaptive_node_pool_test.cpp

@@ -25,3 +25,32 @@ int main ()
 
    return 0;
 }
+/*
+
+#include <boost/interprocess/allocators/private_adaptive_pool.hpp>
+#include <boost/interprocess/containers/map.hpp>
+#include <boost/interprocess/managed_heap_memory.hpp>
+#include <cstdint>
+
+typedef boost::interprocess::managed_heap_memory::segment_manager
+    segment_manager_t;
+
+typedef boost::interprocess::map<
+    uint32_t, uint32_t, std::less<uint32_t>,
+    boost::interprocess::private_adaptive_pool<
+        std::pair<const uint32_t, uint32_t>, segment_manager_t>>
+    mymap_t;
+
+int main() {
+  boost::interprocess::managed_heap_memory heap_mem(1u << 20);
+
+  {
+    mymap_t bbmap(heap_mem.get_segment_manager());
+
+    bbmap.emplace(1, 2);
+
+    mymap_t bbmap2(boost::move(bbmap));
+  } // <= CRASHES HERE
+
+  return 0;
+}*/

test/list_test.hpp

@@ -135,6 +135,11 @@ int list_test (bool copied_allocators_equal = true)
       stdlist->pop_front();
       if(!CheckEqualContainers(shmlist, stdlist)) return 1;
 
+      {
+         MyShmList m(boost::move(*shmlist));
+         *shmlist = boost::move(m);
+      }
+
       {
          IntType aux_vect[50];
          for(int i = 0; i < 50; ++i){