Add overalignment support for segment_manager allocation_command functions.

Author: igaztanaga

include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp

@@ -136,12 +136,12 @@ class memory_algorithm_common
    }
 
    static bool calculate_lcm_and_needs_backwards_lcmed
-      (size_type backwards_multiple, size_type received_size, size_type size_to_achieve,
+      (const size_type backwards_multiple, const size_type alignment, const size_type received_size, const 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 min = alignment;
       size_type needs_backwards;
       size_type needs_backwards_lcmed;
       size_type lcm_val;
@@ -171,39 +171,39 @@ class memory_algorithm_common
          return true;
       }
       //Check if it's multiple of alignment
-      else if((backwards_multiple & (Alignment - 1u)) == 0){
+      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);
+         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){
+      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)))
+         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){
+      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)))
+         //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){
+         if(0 != (remainder = ((needs_backwards_lcmed & (alignment-1))>>(alignment/8u)))){
+            if(backwards_multiple & alignment/2u){
                needs_backwards_lcmed += (remainder)*backwards_multiple;
             }
             else{
@@ -240,25 +240,118 @@ class memory_algorithm_common
       this_type::priv_allocate_many(memory_algo, elem_sizes, n_elements, sizeof_element, chain);
    }
 
-   static void* allocate_aligned
-      (MemoryAlgorithm * const memory_algo, const size_type nbytes, const size_type alignment)
+   static void* allocate_aligned(MemoryAlgorithm * const memory_algo, const size_type nbytes, const size_type alignment)
    {
-
       //Ensure power of 2
       const bool alignment_ok = (alignment & (alignment - 1u)) == 0;
-      if (!alignment_ok){
-         //Alignment is not power of two
-         BOOST_ASSERT(alignment_ok);
+      BOOST_ASSERT(alignment_ok);
+      if (BOOST_UNLIKELY(!alignment_ok)){
          return 0;
       }
-
-      if(alignment <= Alignment){
+      else if(alignment <= Alignment){
          size_type real_size = nbytes;
          void *ignore_reuse = 0;
-         return memory_algo->priv_allocate
-            (boost::interprocess::allocate_new, nbytes, real_size, ignore_reuse);
+         return memory_algo->priv_allocate(boost::interprocess::allocate_new, nbytes, real_size, ignore_reuse);
       }
+      else {
+         return priv_allocate_overaligned(memory_algo, nbytes, alignment);
+      }
+   }
+
+   static bool try_shrink
+      (MemoryAlgorithm *memory_algo, void *ptr
+      ,const size_type max_size, size_type &received_size)
+   {
+      size_type const preferred_size = 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, size_type &received_size)
+   {
+      size_type const preferred_size = 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, 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) & block_ctrl::size_mask;
+      BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
+
+      //We create the new block
+      block_ctrl *new_block = move_detail::force_ptr<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) & block_ctrl::size_mask;
+      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 void* priv_allocate_overaligned
+      (MemoryAlgorithm * const memory_algo, const size_type nbytes, const size_type alignment)
+   {
       //To fulfill user's request we need at least min_user_units
       size_type needed_units = user_buffer_ceil_units(nbytes);
       //However, there is a minimum allocation unit count (BlockCtrlUnits) to be able to deallocate the buffer,
@@ -357,7 +450,7 @@ class memory_algorithm_common
       //new block in the end.
       const size_type orig_second_units = orig_first_units - final_first_units;
       const size_type second_min_units = max_value( size_type(BlockCtrlUnits)
-                                                  , user_buffer_ceil_units(nbytes) + AllocatedCtrlUnits );
+                                                   , user_buffer_ceil_units(nbytes) + AllocatedCtrlUnits );
 
       //Check if we can create a new free block (of size BlockCtrlUnits) at the end of the segment
       if(orig_second_units >= (second_min_units + BlockCtrlUnits)){
@@ -390,97 +483,6 @@ class memory_algorithm_common
       return usr_buf;
    }
 
-   static bool try_shrink
-      (MemoryAlgorithm *memory_algo, void *ptr
-      ,const size_type max_size, size_type &received_size)
-   {
-      size_type const preferred_size = 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, size_type &received_size)
-   {
-      size_type const preferred_size = 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, 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) & block_ctrl::size_mask;
-      BOOST_ASSERT(block->m_size >= BlockCtrlUnits);
-
-      //We create the new block
-      block_ctrl *new_block = move_detail::force_ptr<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) & block_ctrl::size_mask;
-      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 void priv_allocate_many
       ( MemoryAlgorithm *memory_algo
       , const size_type *elem_sizes