Use bump allocation in DRC free list and other improvements

* Avoid using a `BTreeMap` and use a cache-friendly `Vec` instead.
* When merging blocks in the free list, use linear search, only falling back to
  binary search when the free list is large.
* Add fast-path entry points that take a `u32` size directly that has already
  been rounded to the free list's alignment.

Altogether, this shaves off ~309B instructions retired (48%) from the benchmark
in #11141

Author: fitzgen

crates/wasmtime/proptest-regressions/runtime/vm/gc/enabled/free_list.txt

@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc b26e69fbaf46deb79652859039538e422818fd40b9afff63faa7aacbddecfd3d # shrinks to (capacity, ops) = (219544665809630458, [(10, Alloc(Layout { size: 193045289231815352, align: 8 (1 << 3) })), (10, Dealloc(Layout { size: 193045289231815352, align: 8 (1 << 3) }))])

crates/wasmtime/src/runtime/vm/gc/enabled/drc.rs

@@ -176,17 +176,21 @@ impl DrcHeap {
 
     fn dealloc(&mut self, gc_ref: VMGcRef) {
         let drc_ref = drc_ref(&gc_ref);
-        let size = self.index(drc_ref).object_size();
-        let layout = FreeList::layout(size);
+        let size = self.index(drc_ref).object_size;
+        let alloc_size = FreeList::aligned_size(size);
         let index = gc_ref.as_heap_index().unwrap();
 
         // Poison the freed memory so that any stale access is detectable.
         if cfg!(gc_zeal) {
             let index = usize::try_from(index.get()).unwrap();
-            self.heap_slice_mut()[index..][..layout.size()].fill(POISON);
+            let alloc_size = usize::try_from(alloc_size).unwrap();
+            self.heap_slice_mut()[index..][..alloc_size].fill(POISON);
         }
 
-        self.free_list.as_mut().unwrap().dealloc(index, layout);
+        self.free_list
+            .as_mut()
+            .unwrap()
+            .dealloc_fast(index, alloc_size);
     }
 
     /// Increment the ref count for the associated object.
@@ -921,6 +925,7 @@ unsafe impl GcHeap for DrcHeap {
     fn alloc_raw(&mut self, header: VMGcHeader, layout: Layout) -> Result<Result<VMGcRef, u64>> {
         debug_assert!(layout.size() >= core::mem::size_of::<VMDrcHeader>());
         debug_assert!(layout.align() >= core::mem::align_of::<VMDrcHeader>());
+        debug_assert!(FreeList::can_align_to(layout.align()));
         debug_assert_eq!(header.reserved_u26(), 0);
 
         // We must have trace info for every GC type that we allocate in this
@@ -934,8 +939,9 @@ unsafe impl GcHeap for DrcHeap {
         }
 
         let object_size = u32::try_from(layout.size()).unwrap();
+        let alloc_size = FreeList::aligned_size(object_size);
 
-        let gc_ref = match self.free_list.as_mut().unwrap().alloc(layout)? {
+        let gc_ref = match self.free_list.as_mut().unwrap().alloc_fast(alloc_size) {
             None => return Ok(Err(u64::try_from(layout.size()).unwrap())),
             Some(index) => VMGcRef::from_heap_index(index).unwrap(),
         };