mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 06:13:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

MemoryPool: add unmanaged variants and make them the default

Browse Source
This commit is contained in:
Justus Klausecker 2025-08-13 19:13:43 +02:00 committed by Matthew Lugg
parent 250803661c
commit 4187d0e8fe
3 changed files with 283 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/compiler/resinator/source_mapping.zig
View File

@ -723,7 +723,7 @@ pub const SourceMappings = struct {
/// The default assumes that the first filename added is the root file.
/// The value should be set to the correct offset if that assumption does not hold.
root_filename_offset: u32 = 0,
source_node_pool: std.heap.MemoryPool(Sources.Node) = std.heap.MemoryPool(Sources.Node).init(std.heap.page_allocator),
source_node_pool: std.heap.MemoryPool(Sources.Node) = .empty,
end_line: usize = 0,
const sourceCompare = struct {
@ -742,7 +742,7 @@ pub const SourceMappings = struct {
pub fn deinit(self: *SourceMappings, allocator: Allocator) void {
self.files.deinit(allocator);
self.source_node_pool.deinit();
self.source_node_pool.deinit(std.heap.page_allocator);
}
/// Find the node that 'contains' the `line`, i.e. the node's start_line is
@ -823,7 +823,7 @@ pub const SourceMappings = struct {
.filename_offset = filename_offset,
};
var entry = self.sources.getEntryFor(key);
var new_node = try self.source_node_pool.create();
var new_node = try self.source_node_pool.create(std.heap.page_allocator);
new_node.key = key;
entry.set(new_node);
}
@ -869,7 +869,7 @@ pub const SourceMappings = struct {
.filename_offset = node.key.filename_offset,
};
var entry = self.sources.getEntryFor(key);
var new_node = try self.source_node_pool.create();
var new_node = try self.source_node_pool.create(std.heap.page_allocator);
new_node.key = key;
entry.set(new_node);
node = new_node;

18
lib/std/heap.zig
View File

@ -25,10 +25,20 @@ pub const GeneralPurposeAllocatorConfig = DebugAllocatorConfig;
/// Deprecated; to be removed after 0.14.0 is tagged.
pub const GeneralPurposeAllocator = DebugAllocator;
const memory_pool = @import("heap/memory_pool.zig");
pub const MemoryPool = memory_pool.MemoryPool;
pub const MemoryPoolAligned = memory_pool.MemoryPoolAligned;
pub const MemoryPoolExtra = memory_pool.MemoryPoolExtra;
/// A memory pool that can allocate objects of a single type very quickly.
/// Use this when you need to allocate a lot of objects of the same type,
/// because it outperforms general purpose allocators.
/// Functions that potentially allocate memory accept an `Allocator` parameter.
pub fn MemoryPool(comptime Item: type) type {
return memory_pool.Extra(Item, .{ .alignment = null });
}
pub const memory_pool = @import("heap/memory_pool.zig");
/// Deprecated; use `memory_pool.Aligned`.
pub const MemoryPoolAligned = memory_pool.Aligned;
/// Deprecated; use `memory_pool.Extra`.
pub const MemoryPoolExtra = memory_pool.Extra;
/// Deprecated; use `memory_pool.Options`.
pub const MemoryPoolOptions = memory_pool.Options;
/// TODO Utilize this on Windows.

320
lib/std/heap/memory_pool.zig
View File

@ -1,26 +1,26 @@
const std = @import("../std.zig");
const Allocator = std.mem.Allocator;
const Alignment = std.mem.Alignment;
const MemoryPool = std.heap.MemoryPool;
const debug_mode = @import("builtin").mode == .Debug;
pub const MemoryPoolError = error{OutOfMemory};
/// A memory pool that can allocate objects of a single type very quickly.
/// Use this when you need to allocate a lot of objects of the same type,
/// because It outperforms general purpose allocators.
pub fn MemoryPool(comptime Item: type) type {
return MemoryPoolAligned(Item, .of(Item));
/// Deprecated.
pub fn Managed(comptime Item: type) type {
return ExtraManaged(Item, .{ .alignment = null });
}
/// A memory pool that can allocate objects of a single type very quickly.
/// Use this when you need to allocate a lot of objects of the same type,
/// because It outperforms general purpose allocators.
pub fn MemoryPoolAligned(comptime Item: type, comptime alignment: Alignment) type {
if (@alignOf(Item) == comptime alignment.toByteUnits()) {
return MemoryPoolExtra(Item, .{});
} else {
return MemoryPoolExtra(Item, .{ .alignment = alignment });
/// because it outperforms general purpose allocators.
/// Allocated items are aligned to `alignment`-byte addresses or `@alignOf(Item)`
/// if `alignment` is `null`.
/// Functions that potentially allocate memory accept an `Allocator` parameter.
pub fn Aligned(comptime Item: type, comptime alignment: Alignment) type {
return Extra(Item, .{ .alignment = alignment });
}
/// Deprecated.
pub fn AlignedManaged(comptime Item: type, comptime alignment: Alignment) type {
return ExtraManaged(Item, .{ .alignment = alignment });
}
pub const Options = struct {
@ -34,64 +34,70 @@ pub const Options = struct {
/// A memory pool that can allocate objects of a single type very quickly.
/// Use this when you need to allocate a lot of objects of the same type,
/// because It outperforms general purpose allocators.
pub fn MemoryPoolExtra(comptime Item: type, comptime pool_options: Options) type {
/// because it outperforms general purpose allocators.
/// Functions that potentially allocate memory accept an `Allocator` parameter.
pub fn Extra(comptime Item: type, comptime pool_options: Options) type {
if (pool_options.alignment) |a| {
if (a.compare(.eq, .of(Item))) {
var new_options = pool_options;
new_options.alignment = null;
return Extra(Item, new_options);
}
}
return struct {
const Pool = @This();
arena_state: std.heap.ArenaAllocator.State,
free_list: std.SinglyLinkedList,
/// 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.
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.
pub const item_alignment: Alignment = node_alignment.max(pool_options.alignment orelse .of(Item));
pub const item_alignment: Alignment = .max(pool_options.alignment orelse .of(Item), .of(Node));
const Node = struct {
next: ?*align(item_alignment.toByteUnits()) @This(),
};
const NodePtr = *align(item_alignment.toByteUnits()) Node;
const Node = std.SinglyLinkedList.Node;
const ItemPtr = *align(item_alignment.toByteUnits()) Item;
arena: std.heap.ArenaAllocator,
free_list: ?NodePtr = null,
/// A MemoryPool containing no elements.
pub const empty: Pool = .{
.arena_state = .{},
.free_list = .{},
};
/// Creates a new memory pool.
pub fn init(allocator: std.mem.Allocator) Pool {
return .{ .arena = std.heap.ArenaAllocator.init(allocator) };
}
/// Creates a new memory pool and pre-allocates `initial_size` items.
/// This allows the up to `initial_size` active allocations before a
/// `OutOfMemory` error happens when calling `create()`.
pub fn initPreheated(allocator: std.mem.Allocator, initial_size: usize) MemoryPoolError!Pool {
var pool = init(allocator);
errdefer pool.deinit();
try pool.preheat(initial_size);
/// Creates a new memory pool and pre-allocates `num` items.
/// This allows up to `num` active allocations before an
/// `OutOfMemory` error might happen when calling `create()`.
pub fn initCapacity(allocator: Allocator, num: usize) Allocator.Error!Pool {
var pool: Pool = .empty;
errdefer pool.deinit(allocator);
try pool.addCapacity(allocator, num);
return pool;
}
/// Destroys the memory pool and frees all allocated memory.
pub fn deinit(pool: *Pool) void {
pool.arena.deinit();
pub fn deinit(pool: *Pool, allocator: Allocator) void {
pool.arena_state.promote(allocator).deinit();
pool.* = undefined;
}
/// Preheats the memory pool by pre-allocating `size` items.
/// 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,
pub fn toManaged(pool: Pool, allocator: Allocator) ExtraManaged(Item, pool_options) {
return .{
.allocator = allocator,
.unmanaged = pool,
};
pool.free_list = free_node;
}
/// Pre-allocates `num` items and adds them to the memory pool.
/// This allows at least `num` active allocations before an
/// `OutOfMemory` error might happen when calling `create()`.
pub fn addCapacity(pool: *Pool, allocator: Allocator, num: usize) Allocator.Error!void {
var i: usize = 0;
while (i < num) : (i += 1) {
const memory = try pool.allocNew(allocator);
pool.free_list.prepend(@ptrCast(memory));
}
}
@ -106,28 +112,29 @@ pub fn MemoryPoolExtra(comptime Item: type, comptime pool_options: Options) type
/// be slower.
///
/// NOTE: If `mode` is `free_all`, the function will always return `true`.
pub fn reset(pool: *Pool, mode: ResetMode) bool {
pub fn reset(pool: *Pool, allocator: Allocator, mode: ResetMode) bool {
// TODO: Potentially store all allocated objects in a list as well, allowing to
// just move them into the free list instead of actually releasing the memory.
const reset_successful = pool.arena.reset(mode);
var arena = pool.arena_state.promote(allocator);
defer pool.arena_state = arena.state;
pool.free_list = null;
const reset_successful = arena.reset(mode);
pool.free_list = .{};
return reset_successful;
}
/// 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: {
pool.free_list = item.next;
break :blk item;
} else if (pool_options.growable)
@as(NodePtr, @ptrCast(try pool.allocNew()))
/// `allocator` may be `undefined` if pool is not `growable`.
pub fn create(pool: *Pool, allocator: Allocator) Allocator.Error!ItemPtr {
const ptr: ItemPtr = if (pool.free_list.popFirst()) |node|
@ptrCast(@alignCast(node))
else if (pool_options.growable)
@ptrCast(try pool.allocNew(allocator))
else
return error.OutOfMemory;
const ptr = @as(ItemPtr, @ptrCast(node));
ptr.* = undefined;
return ptr;
}
@ -136,23 +143,121 @@ 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;
pool.free_list.prepend(@ptrCast(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, allocator: Allocator) Allocator.Error!*align(item_alignment.toByteUnits()) [item_size]u8 {
var arena = pool.arena_state.promote(allocator);
defer pool.arena_state = arena.state;
const memory = try arena.allocator().alignedAlloc(u8, item_alignment, item_size);
return memory[0..item_size];
}
};
}
/// Deprecated.
pub fn ExtraManaged(comptime Item: type, comptime pool_options: Options) type {
if (pool_options.alignment) |a| {
if (a.compare(.eq, .of(Item))) {
var new_options = pool_options;
new_options.alignment = null;
return ExtraManaged(Item, new_options);
}
}
return struct {
const Pool = @This();
allocator: Allocator,
unmanaged: Unmanaged,
pub const Unmanaged = Extra(Item, pool_options);
pub const item_size = Unmanaged.item_size;
pub const item_alignment = Unmanaged.item_alignment;
const ItemPtr = Unmanaged.ItemPtr;
/// Creates a new memory pool.
pub fn init(allocator: Allocator) Pool {
return Unmanaged.empty.toManaged(allocator);
}
/// Creates a new memory pool and pre-allocates `num` items.
/// This allows up to `num` active allocations before an
/// `OutOfMemory` error might happen when calling `create()`.
pub fn initCapacity(allocator: Allocator, num: usize) Allocator.Error!Pool {
return (try Unmanaged.initCapacity(allocator, num)).toManaged(allocator);
}
/// Destroys the memory pool and frees all allocated memory.
pub fn deinit(pool: *Pool) void {
pool.unmanaged.deinit(pool.allocator);
pool.* = undefined;
}
/// Pre-allocates `num` items and adds them to the memory pool.
/// This allows at least `num` active allocations before an
/// `OutOfMemory` error might happen when calling `create()`.
pub fn addCapacity(pool: *Pool, num: usize) Allocator.Error!void {
return pool.unmanaged.addCapacity(pool.allocator, num);
}
pub const ResetMode = Unmanaged.ResetMode;
/// Resets the memory pool and destroys all allocated items.
/// This can be used to batch-destroy all objects without invalidating the memory pool.
///
/// The function will return whether the reset operation was successful or not.
/// If the reallocation failed `false` is returned. The pool will still be fully
/// functional in that case, all memory is released. Future allocations just might
/// be slower.
///
/// NOTE: If `mode` is `free_all`, the function will always return `true`.
pub fn reset(pool: *Pool, mode: ResetMode) bool {
return pool.unmanaged.reset(pool.allocator, mode);
}
/// Creates a new item and adds it to the memory pool.
pub fn create(pool: *Pool) Allocator.Error!ItemPtr {
return pool.unmanaged.create(pool.allocator);
}
/// Destroys a previously created item.
/// Only pass items to `ptr` that were previously created with `create()` of the same memory pool!
pub fn destroy(pool: *Pool, ptr: ItemPtr) void {
return pool.unmanaged.destroy(ptr);
}
fn allocNew(pool: *Pool) Allocator.Error!*align(item_alignment) [item_size]u8 {
return pool.unmanaged.allocNew(pool.allocator);
}
};
}
test "basic" {
var pool = MemoryPool(u32).init(std.testing.allocator);
const a = std.testing.allocator;
{
var pool: MemoryPool(u32) = .empty;
defer pool.deinit(a);
const p1 = try pool.create(a);
const p2 = try pool.create(a);
const p3 = try pool.create(a);
// Assert uniqueness
try std.testing.expect(p1 != p2);
try std.testing.expect(p1 != p3);
try std.testing.expect(p2 != p3);
pool.destroy(p2);
const p4 = try pool.create(a);
// Assert memory reuse
try std.testing.expect(p2 == p4);
}
{
var pool: Managed(u32) = .init(std.testing.allocator);
defer pool.deinit();
const p1 = try pool.create();
@ -170,23 +275,53 @@ test "basic" {
// Assert memory reuse
try std.testing.expect(p2 == p4);
}
}
test "preheating (success)" {
var pool = try MemoryPool(u32).initPreheated(std.testing.allocator, 4);
test "initCapacity (success)" {
const a = std.testing.allocator;
{
var pool: MemoryPool(u32) = try .initCapacity(a, 4);
defer pool.deinit(a);
_ = try pool.create(a);
_ = try pool.create(a);
_ = try pool.create(a);
}
{
var pool: Managed(u32) = try .initCapacity(a, 4);
defer pool.deinit();
_ = try pool.create();
_ = try pool.create();
_ = try pool.create();
}
}
test "preheating (failure)" {
test "initCapacity (failure)" {
const failer = std.testing.failing_allocator;
try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initPreheated(failer, 5));
try std.testing.expectError(error.OutOfMemory, MemoryPool(u32).initCapacity(failer, 5));
try std.testing.expectError(error.OutOfMemory, Managed(u32).initCapacity(failer, 5));
}
test "growable" {
var pool = try MemoryPoolExtra(u32, .{ .growable = false }).initPreheated(std.testing.allocator, 4);
const a = std.testing.allocator;
{
var pool: Extra(u32, .{ .growable = false }) = try .initCapacity(a, 4);
defer pool.deinit(a);
_ = try pool.create(a);
_ = try pool.create(a);
_ = try pool.create(a);
_ = try pool.create(a);
try std.testing.expectError(error.OutOfMemory, pool.create(a));
}
{
var pool: ExtraManaged(u32, .{ .growable = false }) = try .initCapacity(a, 4);
defer pool.deinit();
_ = try pool.create();
@ -196,27 +331,50 @@ test "growable" {
try std.testing.expectError(error.OutOfMemory, pool.create());
}
}
test "greater than pointer default alignment" {
const Foo = struct {
data: u64 align(16),
};
const a = std.testing.allocator;
var pool = MemoryPool(Foo).init(std.testing.allocator);
{
var pool: MemoryPool(Foo) = .empty;
defer pool.deinit(a);
const foo: *Foo = try pool.create(a);
pool.destroy(foo);
}
{
var pool: Managed(Foo) = .init(a);
defer pool.deinit();
const foo: *Foo = try pool.create();
_ = foo;
pool.destroy(foo);
}
}
test "greater than pointer manual alignment" {
const Foo = struct {
data: u64,
};
const a = std.testing.allocator;
var pool = MemoryPoolAligned(Foo, .@"16").init(std.testing.allocator);
{
var pool: Aligned(Foo, .@"16") = .empty;
defer pool.deinit(a);
const foo: *align(16) Foo = try pool.create(a);
pool.destroy(foo);
}
{
var pool: AlignedManaged(Foo, .@"16") = .init(a);
defer pool.deinit();
const foo: *align(16) Foo = try pool.create();
_ = foo;
pool.destroy(foo);
}
}