tiny.gpalloc.page

1pub const FreeNode = extern struct {2    next: ?*FreeNode,3};

1pub const Page = struct {2    magic: u64,3    class_index: u16,4    block_size: u32,5    capacity: u16,6    live_count: u16,7    free_count: u16,8    next_unallocated: u16,9    block_area_offset: u16,10    mapping_base: [*]align(std.heap.page_size_min) u8,11    mapping_len: usize,12    discarded: bool,13    discarded_bytes: u32,14    free_list: ?*FreeNode,15    next_all: ?*Page,16    previous_all: ?*Page,17    next_partial: ?*Page,18    next_cached: ?*Page,1920    pub fn init(21        page: *Page,22        class_index: usize,23        mapping_base: [*]align(std.heap.page_size_min) u8,24        mapping_len: usize,25    ) void {26        const block_size = size_class.size(class_index);27        const block_alignment = size_class.blockAlignment(block_size);28        const block_area_offset = std.mem.alignForward(usize, @sizeOf(Page), block_alignment);29        const capacity = (page_size - block_area_offset) / block_size;30        assert(capacity > 0);31        assert(capacity <= std.math.maxInt(u16));3233        page.* = .{34            .magic = magic,35            .class_index = @intCast(class_index),36            .block_size = @intCast(block_size),37            .capacity = @intCast(capacity),38            .live_count = 0,39            .free_count = @intCast(capacity),40            .next_unallocated = 0,41            .block_area_offset = @intCast(block_area_offset),42            .mapping_base = mapping_base,43            .mapping_len = mapping_len,44            .discarded = false,45            .discarded_bytes = 0,46            .free_list = null,47            .next_all = null,48            .previous_all = null,49            .next_partial = null,50            .next_cached = null,51        };52    }5354    pub fn blockPtr(page: *Page, index: usize) [*]u8 {55        return page.blockArea() + index * page.block_size;56    }5758    fn blockArea(page: *Page) [*]u8 {59        return @as([*]u8, @ptrCast(page)) + page.block_area_offset;60    }6162    pub fn allocationSlice(page: *Page) []u8 {63        return @as([*]u8, @ptrCast(page))[0..page_size];64    }6566    pub fn mappingSlice(page: *Page) []align(std.heap.page_size_min) u8 {67        return page.mapping_base[0..page.mapping_len];68    }6970    pub fn mappedBytes(page: *Page) usize {71        return page.mapping_len;72    }7374    pub fn discardableSlice(page: *Page) ?[]align(std.heap.page_size_min) u8 {75        const start_offset = std.mem.alignForward(usize, page.block_area_offset, std.heap.page_size_min);76        if (start_offset >= page_size) return null;77        const start_addr = @intFromPtr(page) + start_offset;78        const ptr: [*]align(std.heap.page_size_min) u8 = @ptrFromInt(start_addr);79        return ptr[0 .. page_size - start_offset];80    }8182    pub fn allocate(page: *Page) [*]u8 {83        const ptr = if (page.free_list) |node| blk: {84            page.free_list = node.next;85            break :blk @as([*]u8, @ptrCast(node));86        } else blk: {87            assert(page.next_unallocated < page.capacity);88            const block = page.blockPtr(page.next_unallocated);89            page.next_unallocated += 1;90            break :blk block;91        };92        page.free_count -= 1;93        page.live_count += 1;94        return ptr;95    }9697    pub fn free(page: *Page, ptr: [*]u8) void {98        assert(page.magic == magic);99        assert(page.live_count > 0);100        const node: *FreeNode = @ptrCast(@alignCast(ptr));101        node.* = .{ .next = page.free_list };102        page.free_list = node;103        page.free_count += 1;104        page.live_count -= 1;105    }106};

1pub fn discardUnused(page: *Page) ?usize {2    if (page.discarded) return null;3    const discardable = page.discardableSlice() orelse return null;4    if (discardable.len == 0) return null;5    sys.memory.discard(discardable) catch return null;6    page.discarded = true;7    page.discarded_bytes = @intCast(discardable.len);8    page.free_list = null;9    page.next_unallocated = 0;10    return discardable.len;11}

1pub fn restoreDiscarded(page: *Page) ?usize {2    if (!page.discarded) return null;3    const discarded_bytes: usize = @intCast(page.discarded_bytes);4    page.free_list = null;5    page.next_unallocated = 0;6    page.discarded = false;7    page.discarded_bytes = 0;8    return discarded_bytes;9}

1pub fn createFromBacking(backing_allocator: Allocator, class_index: usize, ret_addr: usize) ?*Page {2    const memory = backing_allocator.rawAlloc(page_size, .fromByteUnits(page_size), ret_addr) orelse return null;3    const page: *Page = @ptrCast(@alignCast(memory));4    Page.init(page, class_index, @ptrCast(@alignCast(memory)), page_size);5    return page;6}

1pub fn createFromOs(class_index: usize) ?*Page {2    const mapping = sys.memory.mapAnonymous(page_size * 2, .{ .read = true, .write = true }) catch return null;3    const mapping_addr = @intFromPtr(mapping.ptr);4    const page_addr = std.mem.alignForward(usize, mapping_addr, page_size);5    const page_offset = page_addr - mapping_addr;6    const page_end = page_offset + page_size;7    std.debug.assert(page_end <= mapping.len);89    if (page_offset > 0) sys.memory.unmap(mapping[0..page_offset]);10    if (page_end < mapping.len) {11        const suffix: [*]align(std.heap.page_size_min) u8 = @ptrFromInt(mapping_addr + page_end);12        sys.memory.unmap(suffix[0 .. mapping.len - page_end]);13    }1415    const page: *Page = @ptrFromInt(page_addr);16    const page_mapping: [*]align(std.heap.page_size_min) u8 = @ptrFromInt(page_addr);17    Page.init(page, class_index, page_mapping, page_size);18    return page;19}

1pub fn destroyFromOs(page: *Page) void {2    const mapping = page.mappingSlice();3    page.magic = 0;4    sys.memory.unmap(mapping);5}

1pub fn destroyInBacking(backing_allocator: Allocator, page: *Page, ret_addr: usize) void {2    page.magic = 0;3    backing_allocator.rawFree(page.allocationSlice(), .fromByteUnits(page_size), ret_addr);4}

1pub fn fromBlock(ptr: [*]u8) *Page {2    const page_addr = std.mem.alignBackward(usize, @intFromPtr(ptr), page_size);3    return @ptrFromInt(page_addr);4}

1pub const magic: u64 = 0x5441_4c4c_4f43_0001;

1const lifecycle = @import("lifecycle.zig");2const mapping = @import("mapping.zig");3const model = @import("model.zig");45pub const magic = model.magic;6pub const FreeNode = model.FreeNode;7pub const Page = model.Page;89pub const createFromBacking = mapping.createFromBacking;10pub const createFromOs = mapping.createFromOs;11pub const destroyFromOs = mapping.destroyFromOs;12pub const destroyInBacking = mapping.destroyInBacking;13pub const discardUnused = lifecycle.discardUnused;14pub const fromBlock = mapping.fromBlock;15pub const restoreDiscarded = lifecycle.restoreDiscarded;

1pub const page = @import("page/root.zig");