Reimplement managed_heap_memory to use overaligned capable operator new instead of a vector of chars, since the alignment required by a segment manager alignment might be bigger than the default one provided by mallo.c

Author: igaztanaga

include/boost/interprocess/detail/managed_memory_impl.hpp

@@ -226,31 +226,31 @@ class basic_managed_memory_impl
 
    //!Returns the base address of the memory in this process. Never throws.
    void *   get_address   () const
-   {   return reinterpret_cast<char*>(mp_header) - Offset; }
+   {   return mp_header ? reinterpret_cast<char*>(mp_header) - Offset : 0; }
 
    //!Returns the size of memory segment. Never throws.
    size_type   get_size   () const
-   {   return mp_header->get_size() + Offset;  }
+   {   return mp_header ? mp_header->get_size() + Offset : 0u;  }
 
    //!Returns the number of free bytes of the memory
    //!segment
    size_type get_free_memory() const
-   {  return mp_header->get_free_memory();  }
+   {  return mp_header ? mp_header->get_free_memory() : 0;  }
 
    //!Returns the result of "all_memory_deallocated()" function
    //!of the used memory algorithm
    bool all_memory_deallocated()
-   {   return mp_header->all_memory_deallocated(); }
+   {   return mp_header ? mp_header->all_memory_deallocated() : true; }
 
    //!Returns the result of "check_sanity()" function
    //!of the used memory algorithm
    bool check_sanity()
-   {   return mp_header->check_sanity(); }
+   {   return mp_header ? mp_header->check_sanity() : true; }
 
    //!Writes to zero free memory (memory not yet allocated) of
    //!the memory algorithm
    void zero_free_memory()
-   {   mp_header->zero_free_memory(); }
+   {   if (mp_header) 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.

include/boost/interprocess/managed_heap_memory.hpp

@@ -23,13 +23,14 @@
 #include <boost/interprocess/detail/workaround.hpp>
 #include <boost/interprocess/creation_tags.hpp>
 #include <boost/move/utility_core.hpp>
-#include <vector>
 #include <boost/interprocess/detail/managed_memory_impl.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>
+#include <boost/container/detail/operator_new_helpers.hpp>
+#include <cstring>
 
 //!\file
 //!Describes a named heap memory allocation user class.
@@ -73,10 +74,13 @@ class basic_managed_heap_memory
    //!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)){
+      void *const paddr =
+         boost::container::dtl::operator_new_raw_allocate(size, base_t::segment_manager::MemAlignment);
+
+      if(!base_t::create_impl(paddr, size)){
          this->priv_close();
+         boost::container::dtl::operator_delete_raw_deallocate(paddr, size, base_t::segment_manager::MemAlignment);
          throw interprocess_exception("Could not initialize heap in basic_managed_heap_memory constructor");
       }
    }
@@ -107,17 +111,27 @@ class basic_managed_heap_memory
       //If memory is reallocated, data will
       //be automatically copied
       BOOST_INTERPROCESS_TRY{
-        m_heapmem.resize(m_heapmem.size()+extra_bytes);
+         const std::size_t  old_sz  = this->base_t::get_size();
+         void * const old_ptr = this->base_t::get_address();
+         const std::size_t new_sz = old_sz + extra_bytes;
+         //This can throw
+         void * const new_ptr =
+            boost::container::dtl::operator_new_raw_allocate
+               (new_sz, base_t::segment_manager::MemAlignment);
+
+         //No-throw steps
+         std::memcpy(new_ptr, old_ptr, old_sz);
+         base_t::close_impl();
+         base_t::open_impl(new_ptr, old_sz);
+         base_t::grow(extra_bytes);
+         boost::container::dtl::operator_delete_raw_deallocate
+               (old_ptr, old_sz, base_t::segment_manager::MemAlignment);
       }
       BOOST_INTERPROCESS_CATCH(...){
          return false;
       }
       BOOST_INTERPROCESS_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;
    }
 
@@ -126,19 +140,21 @@ class basic_managed_heap_memory
    void swap(basic_managed_heap_memory &other) BOOST_NOEXCEPT
    {
       base_t::swap(other);
-      m_heapmem.swap(other.m_heapmem);
    }
 
    #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
    //!Frees resources. Never throws.
    void priv_close()
    {
+      void * const paddr   = this->base_t::get_address();
+      const std::size_t sz = this->base_t::get_size();
       base_t::destroy_impl();
-      std::vector<char>().swap(m_heapmem);
+      if(paddr)
+         boost::container::dtl::operator_delete_raw_deallocate
+            (paddr, sz, base_t::segment_manager::MemAlignment);
    }
 
-   std::vector<char>  m_heapmem;
    #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 

test/managed_heap_memory_test.cpp

@@ -0,0 +1,227 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-2025. 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/allocators/allocator.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/interprocess/managed_heap_memory.hpp>
+#include <cstdio>
+#include <string>
+#include "get_process_id_name.hpp"
+
+using namespace boost::interprocess;
+
+template <class CharT>
+struct filename_traits;
+
+template <>
+struct filename_traits<char>
+{
+
+   static const char* get()
+   {  return filename.c_str();  }
+
+   static std::string filename;
+};
+
+std::string filename_traits<char>::filename = get_filename();
+
+
+#ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES
+
+template <>
+struct filename_traits<wchar_t>
+{
+
+   static const wchar_t* get()
+   {  return filename.c_str();  }
+
+   static std::wstring filename;
+};
+
+std::wstring filename_traits<wchar_t>::filename = get_wfilename();
+
+#endif   //#ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES
+
+template<class CharT>
+int test_managed_heap_memory()
+{
+   const int MemSize          = 65536*10;
+
+   //STL compatible allocator object for heap
+   typedef allocator<int, managed_heap_memory::segment_manager>
+      allocator_int_t;
+   //A vector that uses that allocator
+   typedef boost::container::vector<int, allocator_int_t> MyVect;
+
+   {
+      const int max              = 100;
+      void *array[std::size_t(max)];
+      //Named allocate capable shared memory allocator
+      managed_heap_memory mheap(MemSize);
+
+      std::size_t i;
+      //Let's allocate some memory
+      for(i = 0; i < max; ++i){
+         array[std::ptrdiff_t(i)] = mheap.allocate(i+1u);
+      }
+
+      //Deallocate allocated memory
+      for(i = 0; i < max; ++i){
+         mheap.deallocate(array[std::ptrdiff_t(i)]);
+      }
+
+      //Construct the STL-like allocator with the segment manager
+      const allocator_int_t myallocator (mheap.get_segment_manager());
+
+      //Construct vector
+      MyVect *mheap_vect = mheap.construct<MyVect> ("MyVector") (myallocator);
+
+      //Test that vector can be found via name
+      if(mheap_vect != mheap.find<MyVect>("MyVector").first)
+         return -1;
+
+      //Destroy and check it is not present
+      mheap.destroy<MyVect> ("MyVector");
+      mheap_vect = 0;
+      if(0 != mheap.find<MyVect>("MyVector").first)
+         return -1;
+
+      //Construct a vector in the heap
+      mheap_vect = mheap.construct<MyVect> ("MyVector") (myallocator);
+
+      managed_heap_memory::size_type old_free_memory = mheap.get_free_memory();
+
+      //Now grow the file
+      mheap.grow(MemSize);
+
+      //Check vector is still there
+      mheap_vect = mheap.find<MyVect>("MyVector").first;
+      if(!mheap_vect)
+         return -1;
+
+      if(mheap.get_size() != (MemSize*2))
+         return -1;
+      if(mheap.get_free_memory() <= old_free_memory)
+         return -1;
+
+      //Destroy and check it is not present
+      mheap.destroy_ptr(mheap_vect);
+      mheap_vect = 0;
+      if(0 != mheap.find<MyVect>("MyVector").first)
+         return -1;
+
+      {
+         //Now test move semantics
+         managed_heap_memory original(1024u);
+         managed_heap_memory move_ctor(boost::move(original));
+         managed_heap_memory move_assign;
+         move_assign = boost::move(move_ctor);
+         move_assign.swap(original);
+      }
+   }
+
+   return 0;
+}
+
+int main ()
+{
+   int r;
+   r = test_managed_heap_memory<char>();
+   if(r) return r;
+   #ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES
+   r = test_managed_heap_memory<wchar_t>();
+   if(r) return r;
+   #endif
+   return 0;
+}
+
+/*
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006-2012. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/interprocess/detail/workaround.hpp>
+//[doc_managed_heap_memory
+#include <boost/container/list.hpp>
+#include <boost/interprocess/managed_heap_memory.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <cstddef>
+
+using namespace boost::interprocess;
+typedef boost::container::list<int, allocator<int, managed_heap_memory::segment_manager> >
+   MyList;
+
+int main ()
+{
+   //We will create a buffer of 1000 bytes to store a list
+   managed_heap_memory heap_memory(1000);
+
+   MyList * mylist = heap_memory.construct<MyList>("MyList")
+                        (heap_memory.get_segment_manager());
+
+   //Obtain handle, that identifies the list in the buffer
+   managed_heap_memory::handle_t list_handle = heap_memory.get_handle_from_address(mylist);
+
+   //Fill list until there is no more memory in the buffer
+   BOOST_INTERPROCESS_TRY{
+      while(1) {
+         mylist->insert(mylist->begin(), 0);
+      }
+   }
+   BOOST_INTERPROCESS_CATCH(const bad_alloc &){
+      //memory is full
+   } BOOST_INTERPROCESS_CATCH_END
+   //Let's obtain the size of the list
+   MyList::size_type old_size = mylist->size();
+   //<-
+   (void)old_size;
+   //->
+
+   //To make the list bigger, let's increase the heap buffer
+   //in 1000 bytes more.
+   heap_memory.grow(1000);
+
+   //If memory has been reallocated, the old pointer is invalid, so
+   //use previously obtained handle to find the new pointer.
+   mylist = static_cast<MyList *>
+               (heap_memory.get_address_from_handle(list_handle));
+
+   //Fill list until there is no more memory in the buffer
+   BOOST_INTERPROCESS_TRY{
+      while(1) {
+         mylist->insert(mylist->begin(), 0);
+      }
+   }
+   BOOST_INTERPROCESS_CATCH(const bad_alloc &){
+      //memory is full
+   } BOOST_INTERPROCESS_CATCH_END
+
+   //Let's obtain the new size of the list
+   MyList::size_type new_size = mylist->size();
+   //<-
+   (void)new_size;
+   //->
+
+   assert(new_size > old_size);
+
+   //Destroy list
+   heap_memory.destroy_ptr(mylist);
+
+   return 0;
+}
+//]
+*/
+