allocgate: change resize to return optional instead of error

Author: leecannon

lib/std/heap.zig

@@ -129,7 +129,7 @@ const CAllocator = struct {
         new_len: usize,
         len_align: u29,
         return_address: usize,
-    ) Allocator.Error!usize {
+    ) ?usize {
         _ = buf_align;
         _ = return_address;
         if (new_len <= buf.len) {
@@ -141,7 +141,7 @@ const CAllocator = struct {
                 return mem.alignAllocLen(full_len, new_len, len_align);
             }
         }
-        return error.OutOfMemory;
+        return null;
     }
 
     fn free(
@@ -205,13 +205,13 @@ fn rawCResize(
     new_len: usize,
     len_align: u29,
     ret_addr: usize,
-) Allocator.Error!usize {
+) ?usize {
     _ = old_align;
     _ = ret_addr;
     if (new_len <= buf.len) {
         return mem.alignAllocLen(buf.len, new_len, len_align);
     }
-    return error.OutOfMemory;
+    return null;
 }
 
 fn rawCFree(
@@ -361,7 +361,7 @@ const PageAllocator = struct {
         new_size: usize,
         len_align: u29,
         return_address: usize,
-    ) Allocator.Error!usize {
+    ) ?usize {
         _ = buf_align;
         _ = return_address;
         const new_size_aligned = mem.alignForward(new_size, mem.page_size);
@@ -387,7 +387,7 @@ const PageAllocator = struct {
             if (new_size_aligned <= old_size_aligned) {
                 return alignPageAllocLen(new_size_aligned, new_size, len_align);
             }
-            return error.OutOfMemory;
+            return null;
         }
 
         const buf_aligned_len = mem.alignForward(buf_unaligned.len, mem.page_size);
@@ -403,7 +403,7 @@ const PageAllocator = struct {
 
         // TODO: call mremap
         // TODO: if the next_mmap_addr_hint is within the remapped range, update it
-        return error.OutOfMemory;
+        return null;
     }
 
     fn free(_: *c_void, buf_unaligned: []u8, buf_align: u29, return_address: usize) void {
@@ -579,11 +579,11 @@ const WasmPageAllocator = struct {
         new_len: usize,
         len_align: u29,
         return_address: usize,
-    ) error{OutOfMemory}!usize {
+    ) ?usize {
         _ = buf_align;
         _ = return_address;
         const aligned_len = mem.alignForward(buf.len, mem.page_size);
-        if (new_len > aligned_len) return error.OutOfMemory;
+        if (new_len > aligned_len) return null;
         const current_n = nPages(aligned_len);
         const new_n = nPages(new_len);
         if (new_n != current_n) {
@@ -674,7 +674,7 @@ pub const HeapAllocator = switch (builtin.os.tag) {
             new_size: usize,
             len_align: u29,
             return_address: usize,
-        ) error{OutOfMemory}!usize {
+        ) ?usize {
             _ = buf_align;
             _ = return_address;
 
@@ -686,7 +686,7 @@ pub const HeapAllocator = switch (builtin.os.tag) {
                 os.windows.HEAP_REALLOC_IN_PLACE_ONLY,
                 @intToPtr(*c_void, root_addr),
                 amt,
-            ) orelse return error.OutOfMemory;
+            ) orelse return null;
             assert(new_ptr == @intToPtr(*c_void, root_addr));
             const return_len = init: {
                 if (len_align == 0) break :init new_size;
@@ -788,14 +788,13 @@ pub const FixedBufferAllocator = struct {
         new_size: usize,
         len_align: u29,
         return_address: usize,
-    ) Allocator.Error!usize {
+    ) ?usize {
         _ = buf_align;
         _ = return_address;
         assert(self.ownsSlice(buf)); // sanity check
 
         if (!self.isLastAllocation(buf)) {
-            if (new_size > buf.len)
-                return error.OutOfMemory;
+            if (new_size > buf.len) return null;
             return mem.alignAllocLen(buf.len, new_size, len_align);
         }
 
@@ -806,9 +805,8 @@ pub const FixedBufferAllocator = struct {
         }
 
         const add = new_size - buf.len;
-        if (add + self.end_index > self.buffer.len) {
-            return error.OutOfMemory;
-        }
+        if (add + self.end_index > self.buffer.len) return null;
+
         self.end_index += add;
         return new_size;
     }
@@ -891,7 +889,7 @@ pub fn StackFallbackAllocator(comptime size: usize) type {
             new_len: usize,
             len_align: u29,
             return_address: usize,
-        ) error{OutOfMemory}!usize {
+        ) ?usize {
             if (self.fixed_buffer_allocator.ownsPtr(buf.ptr)) {
                 return FixedBufferAllocator.resize(&self.fixed_buffer_allocator, buf, buf_align, new_len, len_align, return_address);
             } else {

lib/std/heap/arena_allocator.zig

@@ -78,26 +78,23 @@ pub const ArenaAllocator = struct {
 
             const bigger_buf_size = @sizeOf(BufNode) + new_end_index;
             // Try to grow the buffer in-place
-            cur_node.data = self.child_allocator.resize(cur_node.data, bigger_buf_size) catch |err| switch (err) {
-                error.OutOfMemory => {
-                    // Allocate a new node if that's not possible
-                    cur_node = try self.createNode(cur_buf.len, n + ptr_align);
-                    continue;
-                },
+            cur_node.data = self.child_allocator.resize(cur_node.data, bigger_buf_size) orelse {
+                // Allocate a new node if that's not possible
+                cur_node = try self.createNode(cur_buf.len, n + ptr_align);
+                continue;
             };
         }
     }
 
-    fn resize(self: *ArenaAllocator, buf: []u8, buf_align: u29, new_len: usize, len_align: u29, ret_addr: usize) Allocator.Error!usize {
+    fn resize(self: *ArenaAllocator, buf: []u8, buf_align: u29, new_len: usize, len_align: u29, ret_addr: usize) ?usize {
         _ = buf_align;
         _ = len_align;
         _ = ret_addr;
 
-        const cur_node = self.state.buffer_list.first orelse return error.OutOfMemory;
+        const cur_node = self.state.buffer_list.first orelse return null;
         const cur_buf = cur_node.data[@sizeOf(BufNode)..];
         if (@ptrToInt(cur_buf.ptr) + self.state.end_index != @ptrToInt(buf.ptr) + buf.len) {
-            if (new_len > buf.len)
-                return error.OutOfMemory;
+            if (new_len > buf.len) return null;
             return new_len;
         }
 
@@ -108,7 +105,7 @@ pub const ArenaAllocator = struct {
             self.state.end_index += new_len - buf.len;
             return new_len;
         } else {
-            return error.OutOfMemory;
+            return null;
         }
     }
 

lib/std/heap/general_purpose_allocator.zig

@@ -517,7 +517,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
             new_size: usize,
             len_align: u29,
             ret_addr: usize,
-        ) Error!usize {
+        ) ?usize {
             const entry = self.large_allocations.getEntry(@ptrToInt(old_mem.ptr)) orelse {
                 if (config.safety) {
                     @panic("Invalid free");
@@ -557,15 +557,15 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
             if (config.enable_memory_limit) {
                 const new_req_bytes = prev_req_bytes + new_size - entry.value_ptr.requested_size;
                 if (new_req_bytes > prev_req_bytes and new_req_bytes > self.requested_memory_limit) {
-                    return error.OutOfMemory;
+                    return null;
                 }
                 self.total_requested_bytes = new_req_bytes;
             }
             errdefer if (config.enable_memory_limit) {
                 self.total_requested_bytes = prev_req_bytes;
             };
 
-            const result_len = try self.backing_allocator.rawResize(old_mem, old_align, new_size, len_align, ret_addr);
+            const result_len = self.backing_allocator.rawResize(old_mem, old_align, new_size, len_align, ret_addr) orelse return null;
 
             if (config.enable_memory_limit) {
                 entry.value_ptr.requested_size = new_size;
@@ -650,7 +650,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
             new_size: usize,
             len_align: u29,
             ret_addr: usize,
-        ) Error!usize {
+        ) ?usize {
             self.mutex.lock();
             defer self.mutex.unlock();
 
@@ -705,7 +705,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
             if (config.enable_memory_limit) {
                 const new_req_bytes = prev_req_bytes + new_size - old_mem.len;
                 if (new_req_bytes > prev_req_bytes and new_req_bytes > self.requested_memory_limit) {
-                    return error.OutOfMemory;
+                    return null;
                 }
                 self.total_requested_bytes = new_req_bytes;
             }
@@ -726,7 +726,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
                 }
                 return new_size;
             }
-            return error.OutOfMemory;
+            return null;
         }
 
         fn free(
@@ -1065,7 +1065,7 @@ test "shrink large object to large object" {
     slice[0] = 0x12;
     slice[60] = 0x34;
 
-    slice = try allocator.resize(slice, page_size * 2 + 1);
+    slice = allocator.resize(slice, page_size * 2 + 1) orelse return;
     try std.testing.expect(slice[0] == 0x12);
     try std.testing.expect(slice[60] == 0x34);
 

lib/std/heap/log_to_writer_allocator.zig

@@ -45,22 +45,23 @@ pub fn LogToWriterAllocator(comptime Writer: type) type {
             new_len: usize,
             len_align: u29,
             ra: usize,
-        ) error{OutOfMemory}!usize {
+        ) ?usize {
             if (new_len <= buf.len) {
                 self.writer.print("shrink: {} to {}\n", .{ buf.len, new_len }) catch {};
             } else {
                 self.writer.print("expand: {} to {}", .{ buf.len, new_len }) catch {};
             }
+
             if (self.parent_allocator.rawResize(buf, buf_align, new_len, len_align, ra)) |resized_len| {
                 if (new_len > buf.len) {
                     self.writer.print(" success!\n", .{}) catch {};
                 }
                 return resized_len;
-            } else |e| {
-                std.debug.assert(new_len > buf.len);
-                self.writer.print(" failure!\n", .{}) catch {};
-                return e;
             }
+
+            std.debug.assert(new_len > buf.len);
+            self.writer.print(" failure!\n", .{}) catch {};
+            return null;
         }
 
         fn free(
@@ -95,7 +96,7 @@ test "LogToWriterAllocator" {
     var a = try allocator.alloc(u8, 10);
     a = allocator.shrink(a, 5);
     try std.testing.expect(a.len == 5);
-    try std.testing.expectError(error.OutOfMemory, allocator.resize(a, 20));
+    try std.testing.expect(allocator.resize(a, 20) == null);
     allocator.free(a);
 
     try std.testing.expectEqualSlices(u8,

lib/std/heap/logging_allocator.zig

@@ -77,7 +77,7 @@ pub fn ScopedLoggingAllocator(
             new_len: usize,
             len_align: u29,
             ra: usize,
-        ) error{OutOfMemory}!usize {
+        ) ?usize {
             if (self.parent_allocator.rawResize(buf, buf_align, new_len, len_align, ra)) |resized_len| {
                 if (new_len <= buf.len) {
                     logHelper(
@@ -94,15 +94,15 @@ pub fn ScopedLoggingAllocator(
                 }
 
                 return resized_len;
-            } else |err| {
-                std.debug.assert(new_len > buf.len);
-                logHelper(
-                    failure_log_level,
-                    "expand - failure: {s} - {} to {}, len_align: {}, buf_align: {}",
-                    .{ @errorName(err), buf.len, new_len, len_align, buf_align },
-                );
-                return err;
             }
+
+            std.debug.assert(new_len > buf.len);
+            logHelper(
+                failure_log_level,
+                "expand - failure - {} to {}, len_align: {}, buf_align: {}",
+                .{ buf.len, new_len, len_align, buf_align },
+            );
+            return null;
         }
 
         fn free(

lib/std/mem.zig

@@ -88,14 +88,14 @@ pub fn ValidationAllocator(comptime T: type) type {
             new_len: usize,
             len_align: u29,
             ret_addr: usize,
-        ) Allocator.Error!usize {
+        ) ?usize {
             assert(buf.len > 0);
             if (len_align != 0) {
                 assert(mem.isAlignedAnyAlign(new_len, len_align));
                 assert(new_len >= len_align);
             }
             const underlying = self.getUnderlyingAllocatorPtr();
-            const result = try underlying.rawResize(buf, buf_align, new_len, len_align, ret_addr);
+            const result = underlying.rawResize(buf, buf_align, new_len, len_align, ret_addr) orelse return null;
             if (len_align == 0) {
                 assert(result == new_len);
             } else {
@@ -188,7 +188,7 @@ test "Allocator.resize" {
         defer testing.allocator.free(values);
 
         for (values) |*v, i| v.* = @intCast(T, i);
-        values = try testing.allocator.resize(values, values.len + 10);
+        values = testing.allocator.resize(values, values.len + 10) orelse return error.OutOfMemory;
         try testing.expect(values.len == 110);
     }
 
@@ -203,7 +203,7 @@ test "Allocator.resize" {
         defer testing.allocator.free(values);
 
         for (values) |*v, i| v.* = @intToFloat(T, i);
-        values = try testing.allocator.resize(values, values.len + 10);
+        values = testing.allocator.resize(values, values.len + 10) orelse return error.OutOfMemory;
         try testing.expect(values.len == 110);
     }
 }