feat: Add optimized grow()/shrink() functions 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()) {
+            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, 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(),
+                            new_layout.size(),
+                        );
+                        self.deallocate(ptr, old_layout);
+                    }
+                    Ok(new_ptr)
+                }
+            }
+        }
+    }
 }
 
 impl AsRef<ngx_pool_t> for Pool {