allocgate: shrink is not guaranteed to succeed

Author: leecannon

lib/std/array_list.zig

@@ -96,7 +96,7 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
         /// The caller owns the returned memory. Empties this ArrayList.
         pub fn toOwnedSlice(self: *Self) Slice {
             const allocator = self.allocator;
-            const result = allocator.shrink(self.allocatedSlice(), self.items.len);
+            const result = allocator.realloc(self.allocatedSlice(), self.items.len) catch self.items;
             self.* = init(allocator);
             return result;
         }
@@ -477,7 +477,7 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
 
         /// The caller owns the returned memory. ArrayList becomes empty.
         pub fn toOwnedSlice(self: *Self, allocator: Allocator) Slice {
-            const result = allocator.shrink(self.allocatedSlice(), self.items.len);
+            const result = allocator.realloc(self.allocatedSlice(), self.items.len) catch self.items;
             self.* = Self{};
             return result;
         }

lib/std/build/OptionsStep.zig

@@ -350,5 +350,5 @@ test "OptionsStep" {
         \\
     , options.contents.items);
 
-    _ = try std.zig.parse(&arena.allocator, try options.contents.toOwnedSliceSentinel(0));
+    _ = try std.zig.parse(arena.allocator(), try options.contents.toOwnedSliceSentinel(0));
 }

lib/std/child_process.zig

@@ -1114,7 +1114,7 @@ pub fn createWindowsEnvBlock(allocator: mem.Allocator, env_map: *const BufMap) !
     i += 1;
     result[i] = 0;
     i += 1;
-    return allocator.shrink(result, i);
+    return allocator.realloc(result, i);
 }
 
 pub fn createNullDelimitedEnvMap(arena: mem.Allocator, env_map: *const std.BufMap) ![:null]?[*:0]u8 {

lib/std/debug.zig

@@ -936,7 +936,7 @@ fn readMachODebugInfo(allocator: mem.Allocator, macho_file: File) !ModuleDebugIn
     }
     assert(state == .oso_close);
 
-    const symbols = allocator.shrink(symbols_buf, symbol_index);
+    const symbols = try allocator.realloc(symbols_buf, symbol_index);
 
     // Even though lld emits symbols in ascending order, this debug code
     // should work for programs linked in any valid way.

lib/std/fs/path.zig

@@ -638,7 +638,7 @@ pub fn resolveWindows(allocator: Allocator, paths: []const []const u8) ![]u8 {
         result_index += 1;
     }
 
-    return allocator.shrink(result, result_index);
+    return allocator.realloc(result, result_index);
 }
 
 /// This function is like a series of `cd` statements executed one after another.
@@ -707,7 +707,7 @@ pub fn resolvePosix(allocator: Allocator, paths: []const []const u8) ![]u8 {
         result_index += 1;
     }
 
-    return allocator.shrink(result, result_index);
+    return allocator.realloc(result, result_index);
 }
 
 test "resolve" {
@@ -1174,7 +1174,7 @@ pub fn relativePosix(allocator: Allocator, from: []const u8, to: []const u8) ![]
         }
         if (to_rest.len == 0) {
             // shave off the trailing slash
-            return allocator.shrink(result, result_index - 1);
+            return allocator.realloc(result, result_index - 1);
         }
 
         mem.copy(u8, result[result_index..], to_rest);

lib/std/heap.zig

@@ -1116,11 +1116,11 @@ pub fn testAllocator(base_allocator: mem.Allocator) !void {
         allocator.destroy(item);
     }
 
-    slice = allocator.shrink(slice, 50);
+    slice = allocator.tryShrink(slice, 50) orelse return error.OutOfMemory; // this allocator does not support this shrink
     try testing.expect(slice.len == 50);
-    slice = allocator.shrink(slice, 25);
+    slice = allocator.tryShrink(slice, 25) orelse return error.OutOfMemory; // this allocator does not support this shrink
     try testing.expect(slice.len == 25);
-    slice = allocator.shrink(slice, 0);
+    slice = allocator.tryShrink(slice, 0) orelse return error.OutOfMemory; // this allocator does not support this shrink
     try testing.expect(slice.len == 0);
     slice = try allocator.realloc(slice, 10);
     try testing.expect(slice.len == 10);
@@ -1156,19 +1156,19 @@ pub fn testAllocatorAligned(base_allocator: mem.Allocator) !void {
         slice = try allocator.realloc(slice, 100);
         try testing.expect(slice.len == 100);
         // shrink
-        slice = allocator.shrink(slice, 10);
+        slice = allocator.tryShrink(slice, 10) orelse return error.OutOfMemory; // this allocator does not support this shrink
         try testing.expect(slice.len == 10);
         // go to zero
-        slice = allocator.shrink(slice, 0);
+        slice = allocator.tryShrink(slice, 0) orelse return error.OutOfMemory; // this allocator does not support this shrink
         try testing.expect(slice.len == 0);
         // realloc from zero
         slice = try allocator.realloc(slice, 100);
         try testing.expect(slice.len == 100);
         // shrink with shrink
-        slice = allocator.shrink(slice, 10);
+        slice = allocator.tryShrink(slice, 10) orelse return error.OutOfMemory; // this allocator does not support this shrink
         try testing.expect(slice.len == 10);
         // shrink to zero
-        slice = allocator.shrink(slice, 0);
+        slice = allocator.tryShrink(slice, 0) orelse return error.OutOfMemory; // this allocator does not support this shrink
         try testing.expect(slice.len == 0);
     }
 }
@@ -1190,13 +1190,13 @@ pub fn testAllocatorLargeAlignment(base_allocator: mem.Allocator) !void {
     var slice = try allocator.alignedAlloc(u8, large_align, 500);
     try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
 
-    slice = allocator.shrink(slice, 100);
+    slice = allocator.tryShrink(slice, 100) orelse return error.OutOfMemory; // this allocator does not support this shrink
     try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
 
     slice = try allocator.realloc(slice, 5000);
     try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
 
-    slice = allocator.shrink(slice, 10);
+    slice = allocator.tryShrink(slice, 10) orelse return error.OutOfMemory; // this allocator does not support this shrink
     try testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
 
     slice = try allocator.realloc(slice, 20000);

lib/std/heap/general_purpose_allocator.zig

@@ -735,8 +735,8 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
             old_align: u29,
             ret_addr: usize,
         ) void {
-            const held = self.mutex.acquire();
-            defer held.release();
+            self.mutex.lock();
+            defer self.mutex.unlock();
 
             assert(old_mem.len != 0);
 
@@ -850,7 +850,7 @@ pub fn GeneralPurposeAllocator(comptime config: Config) type {
             return true;
         }
 
-        fn alloc(self: Allocator, len: usize, ptr_align: u29, len_align: u29, ret_addr: usize) Error![]u8 {
+        fn alloc(self: *Self, len: usize, ptr_align: u29, len_align: u29, ret_addr: usize) Error![]u8 {
             self.mutex.lock();
             defer self.mutex.unlock();
 
@@ -1007,13 +1007,13 @@ test "shrink" {
 
     mem.set(u8, slice, 0x11);
 
-    slice = allocator.shrink(slice, 17);
+    slice = allocator.tryShrink(slice, 17) orelse unreachable; // GPA supports shrink
 
     for (slice) |b| {
         try std.testing.expect(b == 0x11);
     }
 
-    slice = allocator.shrink(slice, 16);
+    slice = allocator.tryShrink(slice, 16) orelse unreachable; // GPA supports shrink
 
     for (slice) |b| {
         try std.testing.expect(b == 0x11);
@@ -1069,7 +1069,7 @@ test "shrink large object to large object" {
     try std.testing.expect(slice[0] == 0x12);
     try std.testing.expect(slice[60] == 0x34);
 
-    slice = allocator.shrink(slice, page_size * 2 + 1);
+    slice = allocator.tryShrink(slice, page_size * 2 + 1) orelse unreachable; // GPA supports shrink
     try std.testing.expect(slice[0] == 0x12);
     try std.testing.expect(slice[60] == 0x34);
 
@@ -1202,7 +1202,7 @@ test "large object shrinks to small but allocation fails during shrink" {
 
     // Next allocation will fail in the backing allocator of the GeneralPurposeAllocator
 
-    slice = allocator.shrink(slice, 4);
+    slice = allocator.tryShrink(slice, 4) orelse unreachable; // GPA supports shrink
     try std.testing.expect(slice[0] == 0x12);
     try std.testing.expect(slice[3] == 0x34);
 }

lib/std/heap/log_to_writer_allocator.zig

@@ -94,7 +94,7 @@ test "LogToWriterAllocator" {
     const allocator = logToWriterAllocator(fixedBufferAllocator.allocator(), fbs.writer()).allocator();
 
     var a = try allocator.alloc(u8, 10);
-    a = allocator.shrink(a, 5);
+    a = allocator.tryShrink(a, 5) orelse return error.OutOfMemory; // this allocator does not support this shrink
     try std.testing.expect(a.len == 5);
     try std.testing.expect(allocator.resize(a, 20) == null);
     allocator.free(a);

lib/std/math/big/int.zig

@@ -1886,7 +1886,7 @@ pub const Const = struct {
         const limbs = try allocator.alloc(Limb, calcToStringLimbsBufferLen(self.limbs.len, base));
         defer allocator.free(limbs);
 
-        return allocator.shrink(string, self.toString(string, base, case, limbs));
+        return allocator.realloc(string, self.toString(string, base, case, limbs));
     }
 
     /// Converts self to a string in the requested base.