9c13e9b7ed
Before, allocator implementations had to provide `allocFn`, `reallocFn`, and `freeFn`. Now, they must provide only `reallocFn` and `shrinkFn`. Reallocating from a zero length slice is allocation, and shrinking to a zero length slice is freeing. When the new memory size is less than or equal to the previous allocation size, `reallocFn` now has the option to return `error.OutOfMemory` to indicate that the allocator would not be able to take advantage of the new size. For more details see #1306. This commit closes #1306. This commit paves the way to solving #2009. This commit also introduces a memory leak to all coroutines. There is an issue where a coroutine calls the function and it frees its own stack frame, but then the return value of `shrinkFn` is a slice, which is implemented as an sret struct. Writing to the return pointer causes invalid memory write. We could work around it by having a global helper function which has a void return type and calling that instead. But instead this hack will suffice until I rework coroutines to be non-allocating. Basically coroutines are not supported right now until they are reworked as in #1194.
58 lines
1.9 KiB
Zig
58 lines
1.9 KiB
Zig
const std = @import("../std.zig");
|
|
const mem = std.mem;
|
|
|
|
/// Allocator that fails after N allocations, useful for making sure out of
|
|
/// memory conditions are handled correctly.
|
|
pub const FailingAllocator = struct {
|
|
allocator: mem.Allocator,
|
|
index: usize,
|
|
fail_index: usize,
|
|
internal_allocator: *mem.Allocator,
|
|
allocated_bytes: usize,
|
|
freed_bytes: usize,
|
|
deallocations: usize,
|
|
|
|
pub fn init(allocator: *mem.Allocator, fail_index: usize) FailingAllocator {
|
|
return FailingAllocator{
|
|
.internal_allocator = allocator,
|
|
.fail_index = fail_index,
|
|
.index = 0,
|
|
.allocated_bytes = 0,
|
|
.freed_bytes = 0,
|
|
.deallocations = 0,
|
|
.allocator = mem.Allocator{
|
|
.reallocFn = realloc,
|
|
.shrinkFn = shrink,
|
|
},
|
|
};
|
|
}
|
|
|
|
fn realloc(allocator: *mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) ![]u8 {
|
|
const self = @fieldParentPtr(FailingAllocator, "allocator", allocator);
|
|
if (self.index == self.fail_index) {
|
|
return error.OutOfMemory;
|
|
}
|
|
const result = try self.internal_allocator.reallocFn(
|
|
self.internal_allocator,
|
|
old_mem,
|
|
old_align,
|
|
new_size,
|
|
new_align,
|
|
);
|
|
if (new_size <= old_mem.len) {
|
|
self.freed_bytes += old_mem.len - new_size;
|
|
} else {
|
|
self.allocated_bytes += new_size - old_mem.len;
|
|
}
|
|
self.deallocations += 1;
|
|
self.index += 1;
|
|
return result;
|
|
}
|
|
|
|
fn shrink(allocator: *mem.Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
|
|
const self = @fieldParentPtr(FailingAllocator, "allocator", allocator);
|
|
self.freed_bytes += old_mem.len - new_size;
|
|
return self.internal_allocator.shrinkFn(self.internal_allocator, old_mem, old_align, new_size, new_align);
|
|
}
|
|
};
|