feat: add optimized grow()/shrink() functions to Allocator implementation for pool

If resizing is requested for the last allocation in the pool, it may be possible to adjust pool data and avoid any real allocations.

Author: ensh63

src/core/pool.rs

@@ -1,4 +1,5 @@
 use core::alloc::Layout;
+use core::cmp::Ordering;
 use core::ffi::c_void;
 use core::mem;
 use core::ptr::{self, NonNull};
@@ -67,6 +68,81 @@ unsafe impl Allocator for Pool {
             ngx_pfree(self.0.as_ptr(), ptr.as_ptr().cast());
         }
     }
+
+    unsafe fn grow(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        match new_layout.size().cmp(&old_layout.size()) {
+            Ordering::Less => Err(AllocError),
+            Ordering::Equal => Ok(NonNull::slice_from_raw_parts(ptr, new_layout.size())),
+            Ordering::Greater => {
+                // if `ptr` is the last allocation in the pool and there is enough room,
+                // it is possible to shift `last` pointer in the pool without any real allocation.
+                if ptr.byte_add(old_layout.size()).as_ptr() == self.as_ref().d.last
+                    && ptr.byte_add(new_layout.size()).as_ptr() <= self.as_ref().d.end
+                    && ptr.align_offset(new_layout.align()) == 0
+                {
+                    let pool = self.0.as_ptr();
+                    (*pool).d.last = (*pool)
+                        .d
+                        .last
+                        .byte_add(new_layout.size() - old_layout.size());
+                    Ok(NonNull::slice_from_raw_parts(ptr, new_layout.size()))
+                } else {
+                    let new_ptr = self.allocate(new_layout)?;
+                    unsafe {
+                        ptr::copy_nonoverlapping(
+                            ptr.as_ptr(),
+                            new_ptr.as_ptr().cast(),
+                            old_layout.size(),
+                        );
+                        self.deallocate(ptr, old_layout);
+                    }
+                    Ok(new_ptr)
+                }
+            }
+        }
+    }
+
+    unsafe fn shrink(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        match old_layout.size().cmp(&new_layout.size()) {
+            core::cmp::Ordering::Less => Err(AllocError),
+            core::cmp::Ordering::Equal => Ok(NonNull::slice_from_raw_parts(ptr, new_layout.size())),
+            core::cmp::Ordering::Greater => {
+                // if `ptr` is the last allocation in the pool, it is possible to shift `last`
+                // pointer in the pool without any real allocation.
+                if ptr.byte_add(old_layout.size()).as_ptr() == self.as_ref().d.last
+                    && ptr.align_offset(new_layout.align()) == 0
+                {
+                    let pool = self.0.as_ptr();
+                    (*pool).d.last = (*pool)
+                        .d
+                        .last
+                        .byte_sub(old_layout.size() - new_layout.size());
+                    Ok(NonNull::slice_from_raw_parts(ptr, new_layout.size()))
+                } else {
+                    let new_ptr = self.allocate(new_layout)?;
+                    unsafe {
+                        ptr::copy_nonoverlapping(
+                            ptr.as_ptr(),
+                            new_ptr.as_ptr().cast(),
+                            old_layout.size(),
+                        );
+                        self.deallocate(ptr, old_layout);
+                    }
+                    Ok(new_ptr)
+                }
+            }
+        }
+    }
 }
 
 impl AsRef<ngx_pool_t> for Pool {