mirror of
https://github.com/ziglang/zig.git
synced 2024-11-27 07:32:44 +00:00
f26dda2117
Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
318 lines
10 KiB
Zig
318 lines
10 KiB
Zig
//! This is intended to be merged into GeneralPurposeAllocator at some point.
|
|
|
|
const std = @import("../std.zig");
|
|
const builtin = @import("builtin");
|
|
const Allocator = std.mem.Allocator;
|
|
const mem = std.mem;
|
|
const assert = std.debug.assert;
|
|
const wasm = std.wasm;
|
|
const math = std.math;
|
|
|
|
comptime {
|
|
if (!builtin.target.isWasm()) {
|
|
@compileError("WasmPageAllocator is only available for wasm32 arch");
|
|
}
|
|
}
|
|
|
|
pub const vtable = Allocator.VTable{
|
|
.alloc = alloc,
|
|
.resize = resize,
|
|
.free = free,
|
|
};
|
|
|
|
pub const Error = Allocator.Error;
|
|
|
|
const max_usize = math.maxInt(usize);
|
|
const ushift = math.Log2Int(usize);
|
|
const bigpage_size = 64 * 1024;
|
|
const pages_per_bigpage = bigpage_size / wasm.page_size;
|
|
const bigpage_count = max_usize / bigpage_size;
|
|
|
|
/// Because of storing free list pointers, the minimum size class is 3.
|
|
const min_class = math.log2(math.ceilPowerOfTwoAssert(usize, 1 + @sizeOf(usize)));
|
|
const size_class_count = math.log2(bigpage_size) - min_class;
|
|
/// 0 - 1 bigpage
|
|
/// 1 - 2 bigpages
|
|
/// 2 - 4 bigpages
|
|
/// etc.
|
|
const big_size_class_count = math.log2(bigpage_count);
|
|
|
|
var next_addrs = [1]usize{0} ** size_class_count;
|
|
/// For each size class, points to the freed pointer.
|
|
var frees = [1]usize{0} ** size_class_count;
|
|
/// For each big size class, points to the freed pointer.
|
|
var big_frees = [1]usize{0} ** big_size_class_count;
|
|
|
|
fn alloc(ctx: *anyopaque, len: usize, log2_align: u8, return_address: usize) ?[*]u8 {
|
|
_ = ctx;
|
|
_ = return_address;
|
|
// Make room for the freelist next pointer.
|
|
const alignment = @as(usize, 1) << @as(Allocator.Log2Align, @intCast(log2_align));
|
|
const actual_len = @max(len +| @sizeOf(usize), alignment);
|
|
const slot_size = math.ceilPowerOfTwo(usize, actual_len) catch return null;
|
|
const class = math.log2(slot_size) - min_class;
|
|
if (class < size_class_count) {
|
|
const addr = a: {
|
|
const top_free_ptr = frees[class];
|
|
if (top_free_ptr != 0) {
|
|
const node = @as(*usize, @ptrFromInt(top_free_ptr + (slot_size - @sizeOf(usize))));
|
|
frees[class] = node.*;
|
|
break :a top_free_ptr;
|
|
}
|
|
|
|
const next_addr = next_addrs[class];
|
|
if (next_addr % wasm.page_size == 0) {
|
|
const addr = allocBigPages(1);
|
|
if (addr == 0) return null;
|
|
//std.debug.print("allocated fresh slot_size={d} class={d} addr=0x{x}\n", .{
|
|
// slot_size, class, addr,
|
|
//});
|
|
next_addrs[class] = addr + slot_size;
|
|
break :a addr;
|
|
} else {
|
|
next_addrs[class] = next_addr + slot_size;
|
|
break :a next_addr;
|
|
}
|
|
};
|
|
return @as([*]u8, @ptrFromInt(addr));
|
|
}
|
|
const bigpages_needed = bigPagesNeeded(actual_len);
|
|
const addr = allocBigPages(bigpages_needed);
|
|
return @as([*]u8, @ptrFromInt(addr));
|
|
}
|
|
|
|
fn resize(
|
|
ctx: *anyopaque,
|
|
buf: []u8,
|
|
log2_buf_align: u8,
|
|
new_len: usize,
|
|
return_address: usize,
|
|
) bool {
|
|
_ = ctx;
|
|
_ = return_address;
|
|
// We don't want to move anything from one size class to another, but we
|
|
// can recover bytes in between powers of two.
|
|
const buf_align = @as(usize, 1) << @as(Allocator.Log2Align, @intCast(log2_buf_align));
|
|
const old_actual_len = @max(buf.len + @sizeOf(usize), buf_align);
|
|
const new_actual_len = @max(new_len +| @sizeOf(usize), buf_align);
|
|
const old_small_slot_size = math.ceilPowerOfTwoAssert(usize, old_actual_len);
|
|
const old_small_class = math.log2(old_small_slot_size) - min_class;
|
|
if (old_small_class < size_class_count) {
|
|
const new_small_slot_size = math.ceilPowerOfTwo(usize, new_actual_len) catch return false;
|
|
return old_small_slot_size == new_small_slot_size;
|
|
} else {
|
|
const old_bigpages_needed = bigPagesNeeded(old_actual_len);
|
|
const old_big_slot_pages = math.ceilPowerOfTwoAssert(usize, old_bigpages_needed);
|
|
const new_bigpages_needed = bigPagesNeeded(new_actual_len);
|
|
const new_big_slot_pages = math.ceilPowerOfTwo(usize, new_bigpages_needed) catch return false;
|
|
return old_big_slot_pages == new_big_slot_pages;
|
|
}
|
|
}
|
|
|
|
fn free(
|
|
ctx: *anyopaque,
|
|
buf: []u8,
|
|
log2_buf_align: u8,
|
|
return_address: usize,
|
|
) void {
|
|
_ = ctx;
|
|
_ = return_address;
|
|
const buf_align = @as(usize, 1) << @as(Allocator.Log2Align, @intCast(log2_buf_align));
|
|
const actual_len = @max(buf.len + @sizeOf(usize), buf_align);
|
|
const slot_size = math.ceilPowerOfTwoAssert(usize, actual_len);
|
|
const class = math.log2(slot_size) - min_class;
|
|
const addr = @intFromPtr(buf.ptr);
|
|
if (class < size_class_count) {
|
|
const node = @as(*usize, @ptrFromInt(addr + (slot_size - @sizeOf(usize))));
|
|
node.* = frees[class];
|
|
frees[class] = addr;
|
|
} else {
|
|
const bigpages_needed = bigPagesNeeded(actual_len);
|
|
const pow2_pages = math.ceilPowerOfTwoAssert(usize, bigpages_needed);
|
|
const big_slot_size_bytes = pow2_pages * bigpage_size;
|
|
const node = @as(*usize, @ptrFromInt(addr + (big_slot_size_bytes - @sizeOf(usize))));
|
|
const big_class = math.log2(pow2_pages);
|
|
node.* = big_frees[big_class];
|
|
big_frees[big_class] = addr;
|
|
}
|
|
}
|
|
|
|
inline fn bigPagesNeeded(byte_count: usize) usize {
|
|
return (byte_count + (bigpage_size + (@sizeOf(usize) - 1))) / bigpage_size;
|
|
}
|
|
|
|
fn allocBigPages(n: usize) usize {
|
|
const pow2_pages = math.ceilPowerOfTwoAssert(usize, n);
|
|
const slot_size_bytes = pow2_pages * bigpage_size;
|
|
const class = math.log2(pow2_pages);
|
|
|
|
const top_free_ptr = big_frees[class];
|
|
if (top_free_ptr != 0) {
|
|
const node = @as(*usize, @ptrFromInt(top_free_ptr + (slot_size_bytes - @sizeOf(usize))));
|
|
big_frees[class] = node.*;
|
|
return top_free_ptr;
|
|
}
|
|
|
|
const page_index = @wasmMemoryGrow(0, pow2_pages * pages_per_bigpage);
|
|
if (page_index <= 0) return 0;
|
|
const addr = @as(u32, @intCast(page_index)) * wasm.page_size;
|
|
return addr;
|
|
}
|
|
|
|
const test_ally = Allocator{
|
|
.ptr = undefined,
|
|
.vtable = &vtable,
|
|
};
|
|
|
|
test "small allocations - free in same order" {
|
|
var list: [513]*u64 = undefined;
|
|
|
|
var i: usize = 0;
|
|
while (i < 513) : (i += 1) {
|
|
const ptr = try test_ally.create(u64);
|
|
list[i] = ptr;
|
|
}
|
|
|
|
for (list) |ptr| {
|
|
test_ally.destroy(ptr);
|
|
}
|
|
}
|
|
|
|
test "small allocations - free in reverse order" {
|
|
var list: [513]*u64 = undefined;
|
|
|
|
var i: usize = 0;
|
|
while (i < 513) : (i += 1) {
|
|
const ptr = try test_ally.create(u64);
|
|
list[i] = ptr;
|
|
}
|
|
|
|
i = list.len;
|
|
while (i > 0) {
|
|
i -= 1;
|
|
const ptr = list[i];
|
|
test_ally.destroy(ptr);
|
|
}
|
|
}
|
|
|
|
test "large allocations" {
|
|
const ptr1 = try test_ally.alloc(u64, 42768);
|
|
const ptr2 = try test_ally.alloc(u64, 52768);
|
|
test_ally.free(ptr1);
|
|
const ptr3 = try test_ally.alloc(u64, 62768);
|
|
test_ally.free(ptr3);
|
|
test_ally.free(ptr2);
|
|
}
|
|
|
|
test "very large allocation" {
|
|
try std.testing.expectError(error.OutOfMemory, test_ally.alloc(u8, math.maxInt(usize)));
|
|
}
|
|
|
|
test "realloc" {
|
|
var slice = try test_ally.alignedAlloc(u8, @alignOf(u32), 1);
|
|
defer test_ally.free(slice);
|
|
slice[0] = 0x12;
|
|
|
|
// This reallocation should keep its pointer address.
|
|
const old_slice = slice;
|
|
slice = try test_ally.realloc(slice, 2);
|
|
try std.testing.expect(old_slice.ptr == slice.ptr);
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
slice[1] = 0x34;
|
|
|
|
// This requires upgrading to a larger size class
|
|
slice = try test_ally.realloc(slice, 17);
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
try std.testing.expect(slice[1] == 0x34);
|
|
}
|
|
|
|
test "shrink" {
|
|
var slice = try test_ally.alloc(u8, 20);
|
|
defer test_ally.free(slice);
|
|
|
|
@memset(slice, 0x11);
|
|
|
|
try std.testing.expect(test_ally.resize(slice, 17));
|
|
slice = slice[0..17];
|
|
|
|
for (slice) |b| {
|
|
try std.testing.expect(b == 0x11);
|
|
}
|
|
|
|
try std.testing.expect(test_ally.resize(slice, 16));
|
|
slice = slice[0..16];
|
|
|
|
for (slice) |b| {
|
|
try std.testing.expect(b == 0x11);
|
|
}
|
|
}
|
|
|
|
test "large object - grow" {
|
|
var slice1 = try test_ally.alloc(u8, bigpage_size * 2 - 20);
|
|
defer test_ally.free(slice1);
|
|
|
|
const old = slice1;
|
|
slice1 = try test_ally.realloc(slice1, bigpage_size * 2 - 10);
|
|
try std.testing.expect(slice1.ptr == old.ptr);
|
|
|
|
slice1 = try test_ally.realloc(slice1, bigpage_size * 2);
|
|
slice1 = try test_ally.realloc(slice1, bigpage_size * 2 + 1);
|
|
}
|
|
|
|
test "realloc small object to large object" {
|
|
var slice = try test_ally.alloc(u8, 70);
|
|
defer test_ally.free(slice);
|
|
slice[0] = 0x12;
|
|
slice[60] = 0x34;
|
|
|
|
// This requires upgrading to a large object
|
|
const large_object_size = bigpage_size * 2 + 50;
|
|
slice = try test_ally.realloc(slice, large_object_size);
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
try std.testing.expect(slice[60] == 0x34);
|
|
}
|
|
|
|
test "shrink large object to large object" {
|
|
var slice = try test_ally.alloc(u8, bigpage_size * 2 + 50);
|
|
defer test_ally.free(slice);
|
|
slice[0] = 0x12;
|
|
slice[60] = 0x34;
|
|
|
|
try std.testing.expect(test_ally.resize(slice, bigpage_size * 2 + 1));
|
|
slice = slice[0 .. bigpage_size * 2 + 1];
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
try std.testing.expect(slice[60] == 0x34);
|
|
|
|
try std.testing.expect(test_ally.resize(slice, bigpage_size * 2 + 1));
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
try std.testing.expect(slice[60] == 0x34);
|
|
|
|
slice = try test_ally.realloc(slice, bigpage_size * 2);
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
try std.testing.expect(slice[60] == 0x34);
|
|
}
|
|
|
|
test "realloc large object to small object" {
|
|
var slice = try test_ally.alloc(u8, bigpage_size * 2 + 50);
|
|
defer test_ally.free(slice);
|
|
slice[0] = 0x12;
|
|
slice[16] = 0x34;
|
|
|
|
slice = try test_ally.realloc(slice, 19);
|
|
try std.testing.expect(slice[0] == 0x12);
|
|
try std.testing.expect(slice[16] == 0x34);
|
|
}
|
|
|
|
test "objects of size 1024 and 2048" {
|
|
const slice = try test_ally.alloc(u8, 1025);
|
|
const slice2 = try test_ally.alloc(u8, 3000);
|
|
|
|
test_ally.free(slice);
|
|
test_ally.free(slice2);
|
|
}
|
|
|
|
test "standard allocator tests" {
|
|
try std.heap.testAllocator(test_ally);
|
|
try std.heap.testAllocatorAligned(test_ally);
|
|
}
|