Function reset [src]

Resets the arena allocator and frees all allocated memory. mode defines how the currently allocated memory is handled. See the variant documentation for ResetMode for the effects of each mode. The function will return whether the reset operation was successful or not. If the reallocation failed false is returned. The arena 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.

Prototype

pub fn reset(self: *ArenaAllocator, mode: ResetMode) bool

Parameters

self: *ArenaAllocatormode: ResetMode

Source

  pub fn reset(self: *ArenaAllocator, mode: ResetMode) bool {
    // Some words on the implementation:
    // The reset function can be implemented with two basic approaches:
    // - Counting how much bytes were allocated since the last reset, and storing that
    //   information in State. This will make reset fast and alloc only a teeny tiny bit
    //   slower.
    // - Counting how much bytes were allocated by iterating the chunk linked list. This
    //   will make reset slower, but alloc() keeps the same speed when reset() as if reset()
    //   would not exist.
    //
    // The second variant was chosen for implementation, as with more and more calls to reset(),
    // the function will get faster and faster. At one point, the complexity of the function
    // will drop to amortized O(1), as we're only ever having a single chunk that will not be
    // reallocated, and we're not even touching the backing allocator anymore.
    //
    // Thus, only the first hand full of calls to reset() will actually need to iterate the linked
    // list, all future calls are just taking the first node, and only resetting the `end_index`
    // value.
    const requested_capacity = switch (mode) {
        .retain_capacity => self.queryCapacity(),
        .retain_with_limit => |limit| @min(limit, self.queryCapacity()),
        .free_all => 0,
    };
    if (requested_capacity == 0) {
        // just reset when we don't have anything to reallocate
        self.deinit();
        self.state = State{};
        return true;
    }
    const total_size = requested_capacity + @sizeOf(BufNode);
    // Free all nodes except for the last one
    var it = self.state.buffer_list.first;
    const maybe_first_node = while (it) |node| {
        // this has to occur before the free because the free frees node
        const next_it = node.next;
        if (next_it == null)
            break node;
        const alloc_buf = @as([*]u8, @ptrCast(node))[0..node.data];
        self.child_allocator.rawFree(alloc_buf, BufNode_alignment, @returnAddress());
        it = next_it;
    } else null;
    std.debug.assert(maybe_first_node == null or maybe_first_node.?.next == null);
    // reset the state before we try resizing the buffers, so we definitely have reset the arena to 0.
    self.state.end_index = 0;
    if (maybe_first_node) |first_node| {
        self.state.buffer_list.first = first_node;
        // perfect, no need to invoke the child_allocator
        if (first_node.data == total_size)
            return true;
        const first_alloc_buf = @as([*]u8, @ptrCast(first_node))[0..first_node.data];
        if (self.child_allocator.rawResize(first_alloc_buf, BufNode_alignment, total_size, @returnAddress())) {
            // successful resize
            first_node.data = total_size;
        } else {
            // manual realloc
            const new_ptr = self.child_allocator.rawAlloc(total_size, BufNode_alignment, @returnAddress()) orelse {
                // we failed to preheat the arena properly, signal this to the user.
                return false;
            };
            self.child_allocator.rawFree(first_alloc_buf, BufNode_alignment, @returnAddress());
            const node: *BufNode = @ptrCast(@alignCast(new_ptr));
            node.* = .{ .data = total_size };
            self.state.buffer_list.first = node;
        }
    }
    return true;
}  