refactor(utils): remove Tlsf::reallocate_inplace to reduce the porting effort

Author: yvt

src/r3_core/src/utils/alloc/rlsf/tlsf.rs

@@ -1211,292 +1211,20 @@ impl<'pool, FLBitmap: BinInteger, SLBitmap: BinInteger, const FLLEN: usize, cons
         FLBitmap: ~const BinInteger,
         SLBitmap: ~const BinInteger,
     {
-        // Safety: `ptr` is a previously allocated memory block with the same
-        //         alignment as `align`. This is upheld by the caller.
-        let block = Self::used_block_hdr_for_allocation(ptr, new_layout.align());
-
-        // Do this early so that the compiler can de-duplicate common
-        // subexpressions such as `block.as_ref().common.size - SIZE_USED`
         let old_size = Self::size_of_allocation(ptr, new_layout.align());
 
-        // First try to shrink or grow the block in-place (i.e., without
-        // allocating a whole new memory block).
-        if let Some(x) = self.reallocate_inplace(ptr, block, new_layout) {
-            return Some(x);
-        }
-
         // Allocate a whole new memory block
         let new_ptr = const_try!(self.allocate(new_layout));
 
         // Move the existing data into the new location
-        debug_assert!(new_layout.size() >= old_size);
-        core::ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_ptr(), old_size);
-
-        // Deallocate the old memory block.
-        self.deallocate(ptr, new_layout.align());
-
-        Some(new_ptr)
-    }
-
-    /// A subroutine of [`Self::reallocate`] that tries to reallocate a memory
-    /// block in-place.
-    #[inline]
-    const unsafe fn reallocate_inplace(
-        &mut self,
-        ptr: NonNull<u8>,
-        mut block: NonNull<UsedBlockHdr>,
-        new_layout: Layout,
-    ) -> Option<NonNull<u8>>
-    where
-        FLBitmap: ~const BinInteger,
-        SLBitmap: ~const BinInteger,
-    {
-        // The extra bytes consumed by the header and any padding
-        let overhead = ptr.as_ptr() as usize - block.as_ptr() as usize;
-
-        // Calculate the new block size. Fail if this causes an overflow.
-        // Failing at this point does not necessarily mean the whole process of
-        // reallocation has failed; a new place with a smaller overhead could be
-        // found later (whether there's actually such a situation or not is yet
-        // to be proven).
-        let new_size = const_try!(overhead.checked_add(new_layout.size()));
-        let new_size = const_try!(new_size.checked_add(GRANULARITY - 1)) & !(GRANULARITY - 1);
-
-        let old_size = block.as_ref().common.size - SIZE_USED;
-        debug_assert_eq!(old_size, block.as_ref().common.size & SIZE_SIZE_MASK);
-
-        // Shrinking
-        // ------------------------------------------------------------------
-
-        if new_size <= old_size {
-            if new_size == old_size {
-                // No size change
-            } else {
-                // Shrink the block, creating a new free block at the end
-                let shrink_by = old_size - new_size;
-
-                // We will create a new free block at this address
-                let mut new_free_block: NonNull<FreeBlockHdr> =
-                    NonNull::new_unchecked(block.cast::<u8>().as_ptr().add(new_size)).cast();
-                let mut new_free_block_size = shrink_by;
-
-                // If the next block is a free block...
-                let mut next_phys_block = block.as_ref().common.next_phys_block();
-                let next_phys_block_size_and_flags = next_phys_block.as_ref().size;
-                if (next_phys_block_size_and_flags & SIZE_USED) == 0 {
-                    let next_phys_block_size = next_phys_block_size_and_flags;
-                    debug_assert_eq!(
-                        next_phys_block_size,
-                        next_phys_block_size_and_flags & SIZE_SIZE_MASK
-                    );
-
-                    // Then we can merge this existing free block (`next_phys_block`)
-                    // into the new one (`new_free_block`).
-                    self.unlink_free_block(next_phys_block.cast(), next_phys_block_size);
-                    new_free_block_size += next_phys_block_size;
-
-                    let mut next_next_phys_block = next_phys_block.as_ref().next_phys_block();
-                    next_next_phys_block.as_mut().prev_phys_block = Some(new_free_block.cast());
-                } else {
-                    // We can't merge a used block (`next_phys_block`) and
-                    // a free block (`new_free_block`).
-                    next_phys_block.as_mut().prev_phys_block = Some(new_free_block.cast());
-                }
-
-                new_free_block.as_mut().common = BlockHdr {
-                    size: new_free_block_size,
-                    prev_phys_block: Some(block.cast()),
-                };
-                self.link_free_block(new_free_block, new_free_block_size);
-
-                block.as_mut().common.size = new_size | SIZE_USED;
-            }
-
-            return Some(ptr);
-        }
-
-        // In-place non-moving reallocation
-        // ------------------------------------------------------------------
-
-        debug_assert!(new_size > old_size);
-
-        let grow_by = new_size - old_size;
-        let next_phys_block = block.as_ref().common.next_phys_block();
-
-        // If we removed this block, there would be a continous free space of
-        // `moving_clearance` bytes, which is followed by `moving_clearance_end`
-        let mut moving_clearance = old_size;
-        let mut moving_clearance_end = next_phys_block;
-
-        // Grow into the next free block. Fail if there isn't such a block.
-        #[allow(clippy::never_loop)]
-        'nonmoving: loop {
-            let next_phys_block_size_and_flags = next_phys_block.as_ref().size;
-
-            // Fail it isn't a free block.
-            if (next_phys_block_size_and_flags & SIZE_USED) != 0 {
-                break 'nonmoving;
-            }
-
-            let mut next_phys_block_size = next_phys_block_size_and_flags;
-            debug_assert_eq!(
-                next_phys_block_size,
-                next_phys_block_size_and_flags & SIZE_SIZE_MASK
-            );
-
-            // Now we know it's really a free block.
-            let mut next_phys_block = next_phys_block.cast::<FreeBlockHdr>();
-            let mut next_next_phys_block = next_phys_block.as_ref().common.next_phys_block();
-
-            moving_clearance += next_phys_block_size;
-            moving_clearance_end = next_next_phys_block;
-
-            if grow_by > next_phys_block_size {
-                // Can't fit
-                break 'nonmoving;
-            }
-
-            self.unlink_free_block(next_phys_block, next_phys_block_size);
-
-            if grow_by < next_phys_block_size {
-                // Can fit and there's some slack. Create a free block to fill
-                // the slack.
-                next_phys_block_size -= grow_by;
-
-                next_phys_block =
-                    NonNull::new_unchecked(block.cast::<u8>().as_ptr().add(new_size)).cast();
-                next_phys_block.as_mut().common = BlockHdr {
-                    size: next_phys_block_size,
-                    prev_phys_block: Some(block.cast()),
-                };
-                self.link_free_block(next_phys_block, next_phys_block_size);
-
-                // Update `next_next_phys_block.prev_phys_block` accordingly
-                next_next_phys_block.as_mut().prev_phys_block = Some(next_phys_block.cast());
-            } else {
-                // Can fit exactly.
-                debug_assert_eq!(grow_by, next_phys_block_size);
-
-                // Update `next_next_phys_block.prev_phys_block` accordingly
-                next_next_phys_block.as_mut().prev_phys_block = Some(block.cast());
-            }
-
-            block.as_mut().common.size = new_size | SIZE_USED;
-
-            return Some(ptr);
-        }
-
-        // In-place moving reallocation
-        // ------------------------------------------------------------------
-
-        // The non-moving reallocation was failure. Now try the moving approach.
-        // I.e., grow into the previous free block as well.
-        // Get the previous block. If there isn't such a block, the moving
-        // approach will not improve the situation anyway, so return `None`.
-        let prev_phys_block = const_try!(block.as_ref().common.prev_phys_block);
-        let prev_phys_block_size_and_flags = prev_phys_block.as_ref().size;
-
-        // Fail it isn't a free block.
-        if (prev_phys_block_size_and_flags & SIZE_USED) != 0 {
-            return None;
-        }
-
-        let prev_phys_block_size = prev_phys_block_size_and_flags;
-        debug_assert_eq!(
-            prev_phys_block_size,
-            prev_phys_block_size_and_flags & SIZE_SIZE_MASK
-        );
-
-        // Now we know it's really a free block.
-        moving_clearance += prev_phys_block_size;
-
-        // Decide the starting address of the payload
-        let unaligned_ptr =
-            prev_phys_block.as_ptr() as *mut u8 as usize + mem::size_of::<UsedBlockHdr>();
-        let new_ptr = NonNull::new_unchecked(
-            ((unaligned_ptr + new_layout.align() - 1) & !(new_layout.align() - 1)) as *mut u8,
-        );
-
-        // Calculate the new block size
-        let new_overhead = new_ptr.as_ptr() as usize - prev_phys_block.as_ptr() as usize;
-        let new_size = const_try!(new_overhead.checked_add(new_layout.size()));
-        let new_size = const_try!(new_size.checked_add(GRANULARITY - 1)) & !(GRANULARITY - 1);
-        if new_size > moving_clearance {
-            // Can't fit
-            return None;
-        }
-
-        // Unlink the existing free blocks included in `moving_clearance`
-        self.unlink_free_block(prev_phys_block.cast(), prev_phys_block_size);
-        let next_phys_block_size_and_flags = next_phys_block.as_ref().size;
-        if (next_phys_block_size_and_flags & SIZE_USED) == 0 {
-            let next_phys_block_size = next_phys_block_size_and_flags;
-            debug_assert_eq!(
-                next_phys_block_size,
-                next_phys_block_size_and_flags & SIZE_SIZE_MASK
-            );
-            self.unlink_free_block(next_phys_block.cast(), next_phys_block_size);
-        }
-
-        // Move the existing data into the new memory block.
-        core::ptr::copy(
+        core::ptr::copy_nonoverlapping(
             ptr.as_ptr(),
             new_ptr.as_ptr(),
-            min_usize(new_layout.size(), old_size - overhead),
+            min_usize(old_size, new_layout.size()),
         );
 
-        // We'll replace `prev_phys_block` with a new used block.
-        let mut new_block = prev_phys_block.cast::<UsedBlockHdr>();
-
-        if new_size == moving_clearance {
-            // The allocation completely fills this free block.
-            // Update `prev_phys_block` accordingly
-            moving_clearance_end.as_mut().prev_phys_block = Some(new_block.cast());
-        } else {
-            // The allocation partially fills this free block. Create a new
-            // free block header at `new_block + new_size..new_block
-            // + moving_clearance`.
-            let mut new_free_block: NonNull<FreeBlockHdr> =
-                NonNull::new_unchecked(new_block.cast::<u8>().as_ptr().add(new_size)).cast();
-            let mut new_free_block_size = moving_clearance - new_size;
-
-            // If the following block (`moving_clearance_end`) is a free block...
-            let moving_clearance_end_size_and_flags = moving_clearance_end.as_ref().size;
-            if (moving_clearance_end_size_and_flags & SIZE_USED) == 0 {
-                let moving_clearance_end_size = moving_clearance_end_size_and_flags;
-                debug_assert_eq!(
-                    moving_clearance_end_size,
-                    moving_clearance_end_size_and_flags & SIZE_SIZE_MASK
-                );
-
-                // Then we should merge this existing free block (`moving_clearance_end`)
-                // into the new one (`new_free_block`).
-                self.unlink_free_block(moving_clearance_end.cast(), moving_clearance_end_size);
-                new_free_block_size += moving_clearance_end_size_and_flags;
-
-                let mut next_next_phys_block = moving_clearance_end.as_ref().next_phys_block();
-                next_next_phys_block.as_mut().prev_phys_block = Some(new_free_block.cast());
-            } else {
-                // We can't merge a used block (`moving_clearance_end`) and
-                // a free block (`new_free_block`).
-                moving_clearance_end.as_mut().prev_phys_block = Some(new_free_block.cast());
-            }
-
-            new_free_block.as_mut().common = BlockHdr {
-                size: new_free_block_size,
-                prev_phys_block: Some(new_block.cast()),
-            };
-            self.link_free_block(new_free_block, new_free_block_size);
-        }
-
-        // Turn `new_block` into a used memory block and initialize the used block
-        // header. `prev_phys_block` is already set.
-        new_block.as_mut().common.size = new_size | SIZE_USED;
-
-        // Place a header pointer (used by `used_block_hdr_for_allocation`)
-        if new_layout.align() >= GRANULARITY {
-            (*UsedBlockPad::get_for_allocation(new_ptr)).block_hdr = new_block;
-        }
+        // Deallocate the old memory block.
+        self.deallocate(ptr, new_layout.align());
 
         Some(new_ptr)
     }