tiny.gpalloc.large

1pub const Cache = struct {2    bins: [model.class_count]Bin = @as([model.class_count]Bin, @splat(.{})),3    cached_bytes: usize = 0,4    eviction_cursor: usize = 0,56    pub fn pop(self: *Cache, class: Class) ?[*]u8 {7        const ptr = self.bins[class.index].pop() orelse return null;8        self.cached_bytes -= class.size;9        return ptr;10    }1112    pub fn popAtLeast(self: *Cache, class: Class) ?Entry {13        const end_index = if (class.index < model.small_class_count)14            model.small_class_count15        else16            self.bins.len;17        var index = class.index;18        while (index < end_index) : (index += 1) {19            const cached_class = class_policy.classForIndex(index);20            const ptr = self.pop(cached_class) orelse continue;21            return .{ .class = cached_class, .ptr = ptr };22        }23        return null;24    }2526    pub fn push(27        self: *Cache,28        class: Class,29        ptr: [*]u8,30        byte_limit: usize,31        allocator: Allocator,32        ret_addr: usize,33    ) bool {34        if (class.size > byte_limit) return false;35        if (self.bins[class.index].count >= model.bin_capacity) return false;36        while (self.cached_bytes + class.size > byte_limit) {37            if (!self.evictOne(allocator, ret_addr)) return false;38        }39        if (!self.bins[class.index].push(ptr, model.bin_capacity)) return false;40        self.cached_bytes += class.size;41        return true;42    }4344    pub fn destroyAll(self: *Cache, allocator: Allocator, ret_addr: usize) void {45        for (&self.bins, 0..) |*bin, index| {46            const class_size = class_policy.sizeForIndex(index);47            while (bin.pop()) |ptr| {48                allocator.rawFree(ptr[0..class_policy.backingSizeForClassSize(class_size)], model.alignment, ret_addr);49            }50        }51        self.cached_bytes = 0;52        self.eviction_cursor = 0;53    }5455    fn evictOne(self: *Cache, allocator: Allocator, ret_addr: usize) bool {56        var offset: usize = 0;57        while (offset < self.bins.len) : (offset += 1) {58            const index = (self.eviction_cursor + offset) % self.bins.len;59            const class_size = class_policy.sizeForIndex(index);60            const ptr = self.bins[index].pop() orelse continue;61            self.cached_bytes -= class_size;62            self.eviction_cursor = (index + 1) % self.bins.len;63            allocator.rawFree(64                ptr[0..class_policy.backingSizeForClassSize(class_size)],65                model.alignment,66                ret_addr,67            );68            return true;69        }70        return false;71    }72};

1pub const Cache = struct {2    bins: [model.medium_class_count]Bin = @as([model.medium_class_count]Bin, @splat(.{})),3    cached_bytes: usize = 0,4    eviction_cursor: usize = 0,56    pub fn pop(self: *Cache, class: Class) ?[*]u8 {7        const ptr = self.bins[class.index].pop() orelse return null;8        self.cached_bytes -= class.size;9        return ptr;10    }1112    pub fn popAtLeast(self: *Cache, class: Class) ?Entry {13        var index = class.index;14        while (index < self.bins.len) : (index += 1) {15            const cached_class = class_policy.classForIndex(index);16            const ptr = self.pop(cached_class) orelse continue;17            return .{ .class = cached_class, .ptr = ptr };18        }19        return null;20    }2122    pub fn push(23        self: *Cache,24        class: Class,25        ptr: [*]u8,26        byte_limit: usize,27        allocator: Allocator,28        ret_addr: usize,29    ) bool {30        if (class.size > byte_limit) return false;31        if (self.bins[class.index].count >= model.bin_capacity) return false;32        while (self.cached_bytes + class.size > byte_limit) {33            if (!self.evictOne(allocator, ret_addr)) return false;34        }35        if (!self.bins[class.index].push(ptr, model.bin_capacity)) return false;36        self.cached_bytes += class.size;37        return true;38    }3940    pub fn destroyAll(self: *Cache, allocator: Allocator, ret_addr: usize) void {41        for (&self.bins, 0..) |*bin, index| {42            const class_size = class_policy.sizeForIndex(index);43            while (bin.pop()) |ptr| {44                allocator.rawFree(45                    ptr[0..class_policy.backingSizeForClassSize(class_size)],46                    model.alignment,47                    ret_addr,48                );49            }50        }51        self.cached_bytes = 0;52        self.eviction_cursor = 0;53    }5455    fn evictOne(self: *Cache, allocator: Allocator, ret_addr: usize) bool {56        var offset: usize = 0;57        while (offset < self.bins.len) : (offset += 1) {58            const index = (self.eviction_cursor + offset) % self.bins.len;59            const class_size = class_policy.sizeForIndex(index);60            const ptr = self.bins[index].pop() orelse continue;61            self.cached_bytes -= class_size;62            self.eviction_cursor = (index + 1) % self.bins.len;63            allocator.rawFree(64                ptr[0..class_policy.backingSizeForClassSize(class_size)],65                model.alignment,66                ret_addr,67            );68            return true;69        }70        return false;71    }72};

1pub fn backingSize(class: Class) usize {2    return backingSizeForClassSize(class.size);3}

1pub fn classFor(len: usize, requested_alignment: Alignment) ?Class {2    if (requested_alignment.toByteUnits() > size_class.min_alignment) return null;3    if (len > size_class.max_small_size and len <= model.max_small_cached_size) {4        const class_size = std.mem.alignForward(usize, len, model.class_step);5        if (class_size < model.min_cached_size or class_size > model.max_small_cached_size) return null;6        return .{7            .index = (class_size - model.min_cached_size) / model.class_step,8            .size = class_size,9        };10    }11    if (len >= model.min_huge_cached_size and len <= model.max_cached_size) {12        const class_size = std.mem.alignForward(usize, len, model.huge_class_step);13        if (class_size < model.min_huge_cached_size or class_size > model.max_cached_size) return null;14        return .{15            .index = model.small_class_count + (class_size - model.min_huge_cached_size) / model.huge_class_step,16            .size = class_size,17        };18    }19    return null;20}

1pub fn classForIndex(index: usize) Class {2    return .{3        .index = index,4        .size = sizeForIndex(index),5    };6}

1pub fn baseFromUserPointer(ptr: [*]u8) [*]u8 {2    return ptr - model.header_size;3}

1pub fn classFromHeader(header: *const Header) ?Class {2    if (header.magic != model.header_magic) return null;3    if (header.class_index >= model.class_count) return null;4    return class_policy.classForIndex(header.class_index);5}

1pub fn headerFromUserPointer(ptr: [*]u8) *Header {2    return @ptrCast(@alignCast(ptr - model.header_size));3}

1pub fn initializeHeader(base: [*]u8, class: Class) [*]u8 {2    const header: *Header = @ptrCast(@alignCast(base));3    header.* = .{4        .magic = model.header_magic,5        .class_index = class.index,6    };7    return base + model.header_size;8}

1pub fn backingSize(class: Class) usize {2    return backingSizeForClassSize(class.size);3}

1pub fn classFor(len: usize, requested_alignment: Alignment) ?Class {2    if (requested_alignment.toByteUnits() > size_class.min_alignment) return null;3    if (len <= model.max_small_cached_size or len > model.max_medium_cached_size) return null;4    const class_size = std.mem.alignForward(usize, len, model.medium_class_step);5    if (class_size < model.min_medium_cached_size or class_size > model.max_medium_cached_size) return null;6    return .{7        .index = (class_size - model.min_medium_cached_size) / model.medium_class_step,8        .size = class_size,9    };10}

1pub fn baseFromUserPointer(ptr: [*]u8) [*]u8 {2    return ptr - model.header_size;3}

1pub fn classFromHeader(header: *const Header) ?Class {2    if (header.magic != model.medium_header_magic) return null;3    if (header.class_index >= model.medium_class_count) return null;4    return class_policy.classForIndex(header.class_index);5}

1pub fn headerFromUserPointer(ptr: [*]u8) *Header {2    return @ptrCast(@alignCast(ptr - model.header_size));3}

1pub fn initializeHeader(base: [*]u8, class: Class) [*]u8 {2    const header: *Header = @ptrCast(@alignCast(base));3    header.* = .{4        .magic = model.medium_header_magic,5        .class_index = class.index,6    };7    return base + model.header_size;8}

1const cache = @import("cache.zig");2const class = @import("class.zig");3const header = @import("header.zig");4const medium = @import("medium/root.zig");5pub const model = @import("model.zig");67pub const class_step = model.class_step;8pub const max_small_cached_size = model.max_small_cached_size;9pub const huge_class_step = model.huge_class_step;10pub const min_huge_cached_size = model.min_huge_cached_size;11pub const max_cached_size = model.max_cached_size;12pub const medium_class_step = model.medium_class_step;13pub const min_medium_cached_size = model.min_medium_cached_size;14pub const max_medium_cached_size = model.max_medium_cached_size;15pub const medium_default_limit_bytes = model.medium_default_limit_bytes;16pub const alignment = model.alignment;17pub const Class = model.Class;18pub const Entry = model.Entry;19pub const Header = model.Header;20pub const header_size = model.header_size;21pub const Cache = cache.Cache;22pub const MediumCache = medium.Cache;2324pub const backingSize = class.backingSize;25pub const baseFromUserPointer = header.baseFromUserPointer;26pub const classFor = class.classFor;27pub const classForIndex = class.classForIndex;28pub const classFromHeader = header.classFromHeader;29pub const headerFromUserPointer = header.headerFromUserPointer;30pub const initializeHeader = header.initializeHeader;31pub const initializeMediumHeader = medium.initializeHeader;32pub const mediumBackingSize = medium.backingSize;33pub const mediumBaseFromUserPointer = medium.baseFromUserPointer;34pub const mediumClassFor = medium.classFor;35pub const mediumClassFromHeader = medium.classFromHeader;36pub const mediumHeaderFromUserPointer = medium.headerFromUserPointer;

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