Allocate only once for preheating.

More uniform comments.

Author: two-horned

lib/std/heap/memory_pool.zig

@@ -39,22 +39,24 @@ pub fn MemoryPoolExtra(comptime Item: type, comptime pool_options: Options) type
     return struct {
         const Pool = @This();
 
-        /// Size of the memory pool items. This is not necessarily the same
-        /// as `@sizeOf(Item)` as the pool also uses the items for internal means.
+        /// Size of the memory pool items. This may be larger than `@sizeOf(Item)`
+        /// as the pool also uses the items for internal means.
         pub const item_size = @max(@sizeOf(Node), @sizeOf(Item));
 
         // This needs to be kept in sync with Node.
         const node_alignment: Alignment = .of(*anyopaque);
 
-        /// Alignment of the memory pool items. This is not necessarily the same
-        /// as `@alignOf(Item)` as the pool also uses the items for internal means.
+        /// Alignment of the memory pool items. This may be larger than `@alignOf(Item)`
+        /// as the pool also uses the items for internal means.
         pub const item_alignment: Alignment = node_alignment.max(pool_options.alignment orelse .of(Item));
 
-        const Node = struct {
-            next: ?*align(item_alignment.toByteUnits()) @This(),
-        };
-        const NodePtr = *align(item_alignment.toByteUnits()) Node;
-        const ItemPtr = *align(item_alignment.toByteUnits()) Item;
+        const Node = struct { next: ?*align(unit_al_bytes) @This() };
+        const Byte = std.meta.Int(.unsigned, std.mem.byte_size_in_bits);
+        const Unit = [item_alignment.forward(item_size)]Byte;
+        const unit_al_bytes = item_alignment.toByteUnits();
+
+        const ItemPtr = *align(unit_al_bytes) Item;
+        const NodePtr = *align(unit_al_bytes) Node;
 
         arena: std.heap.ArenaAllocator,
         free_list: ?NodePtr = null,
@@ -84,13 +86,11 @@ pub fn MemoryPoolExtra(comptime Item: type, comptime pool_options: Options) type
         /// This allows up to `size` active allocations before an
         /// `OutOfMemory` error might happen when calling `create()`.
         pub fn preheat(pool: *Pool, size: usize) MemoryPoolError!void {
-            var i: usize = 0;
-            while (i < size) : (i += 1) {
-                const raw_mem = try pool.allocNew();
-                const free_node = @as(NodePtr, @ptrCast(raw_mem));
-                free_node.* = Node{
-                    .next = pool.free_list,
-                };
+            const raw_mem = try pool.allocNew(size);
+            const uni_slc = raw_mem[0..size];
+            for (uni_slc) |*unit| {
+                const free_node: NodePtr = @ptrCast(unit);
+                free_node.next = pool.free_list;
                 pool.free_list = free_node;
             }
         }
@@ -119,15 +119,15 @@ pub fn MemoryPoolExtra(comptime Item: type, comptime pool_options: Options) type
 
         /// Creates a new item and adds it to the memory pool.
         pub fn create(pool: *Pool) !ItemPtr {
-            const node = if (pool.free_list) |item| blk: {
+            const node_ptr: NodePtr = if (pool.free_list) |item| blk: {
                 pool.free_list = item.next;
                 break :blk item;
             } else if (pool_options.growable)
-                @as(NodePtr, @ptrCast(try pool.allocNew()))
+                @ptrCast(try pool.allocNew(1))
             else
                 return error.OutOfMemory;
 
-            const ptr = @as(ItemPtr, @ptrCast(node));
+            const ptr: ItemPtr = @ptrCast(node_ptr);
             ptr.* = undefined;
             return ptr;
         }
@@ -136,17 +136,14 @@ pub fn MemoryPoolExtra(comptime Item: type, comptime pool_options: Options) type
         /// Only pass items to `ptr` that were previously created with `create()` of the same memory pool!
         pub fn destroy(pool: *Pool, ptr: ItemPtr) void {
             ptr.* = undefined;
-
-            const node = @as(NodePtr, @ptrCast(ptr));
-            node.* = Node{
-                .next = pool.free_list,
-            };
-            pool.free_list = node;
+            const node_ptr: NodePtr = @ptrCast(ptr);
+            node_ptr.next = pool.free_list;
+            pool.free_list = node_ptr;
         }
 
-        fn allocNew(pool: *Pool) MemoryPoolError!*align(item_alignment.toByteUnits()) [item_size]u8 {
-            const mem = try pool.arena.allocator().alignedAlloc(u8, item_alignment, item_size);
-            return mem[0..item_size]; // coerce slice to array pointer
+        fn allocNew(pool: *Pool, n: usize) MemoryPoolError![*]align(unit_al_bytes) Unit {
+            const mem = try pool.arena.allocator().alignedAlloc(Unit, item_alignment, n);
+            return mem.ptr;
         }
     };
 }