     let newSlabSize = Self.slabSize(at: slabs.count)
     let newSlab = Slab.allocate(
       byteCount: newSlabSize, alignment: Self.SLAB_ALIGNMENT)
+    let pointer = newSlab.baseAddress!
+    current = (pointer, pointer.advanced(by: newSlabSize))
     slabs.append(newSlab)
-    currentPtr = newSlab.baseAddress!
-    endPtr = currentPtr!.advanced(by: newSlabSize)
+  }
+
+  /// Allocate 'byteCount' of memory from the current slab if available.
+  private func allocateFromCurrentSlab(
+    _ byteCount: Int,
+    _ alignment: Int
+  ) -> UnsafeMutableRawBufferPointer? {
+    guard let current = self.current else {
+      return nil
+    }
+
+    let aligned = current.pointer.alignedUp(toMultipleOf: alignment)
+    guard byteCount <= aligned.distance(to: current.end) else {
+      return nil
+    }
+
+    // Bump the pointer, and return the allocated buffer.
+    self.current = (aligned + byteCount, current.end)
+    return .init(start: aligned, count: byteCount)
   }
 
   /// Allocate 'byteCount' of memory.

  /// Clients should never call `deallocate()` on the returned buffer.
  public func allocate(byteCount: Int, alignment: Int) -> UnsafeMutableRawBufferPointer {

    precondition(alignment <= Self.SLAB_ALIGNMENT)
    guard byteCount > 0 else {
      return .init(start: nil, count: 0)
    }

  static private var SLAB_ALIGNMENT: Int = 8

  private var slabs: [Slab]
  /// Pair of pointers in the current slab.
  /// - pointer: Points to the next unused address in `slabs.last`.
  /// - end: Points to the end address of `slabs.last`. This is equivalent to
  ///        `slabs.last!.baseAddress! + slabs.last!.count`
  /// 'nil' if `slabs` is empty.
  private var current: (pointer: UnsafeMutableRawPointer,
                        end: UnsafeMutableRawPointer)?
  private var customSizeSlabs: [Slab]
  private var _totalBytesAllocated: Int

  public init() {
    slabs = []
    current = nil
    customSizeSlabs = []
    _totalBytesAllocated = 0
  }
