authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-04-18 08:28:43-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-04-20 05:31:24-07:00
log99112b63bdeec512e164f289556b24fa1554a775
treea774fe70f74dec3f35430865eb3138ad3a317066
parent711bf55eaa643c3d05640bebbf3e4315477b8ed8

std.SegmentedList: breaking API changes

* Remove the Allocator field; instead it must be passed in as a parameter to any function that needs it. * Rename `push` to `append` and `pushMany` to `appendSlice` to match the conventions set by ArrayList.

1 files changed, 48 insertions(+), 58 deletions(-)

lib/std/segmented_list.zig+48-58
......@@ -61,16 +61,16 @@ const Allocator = std.mem.Allocator;
6161// shelf_size = prealloc * 2 ** (shelf_index + 1)
6262
6363/// This is a stack data structure where pointers to indexes have the same lifetime as the data structure
64/// itself, unlike ArrayList where push() invalidates all existing element pointers.
64/// itself, unlike ArrayList where append() invalidates all existing element pointers.
6565/// The tradeoff is that elements are not guaranteed to be contiguous. For that, use ArrayList.
6666/// Note however that most elements are contiguous, making this data structure cache-friendly.
6767///
6868/// Because it never has to copy elements from an old location to a new location, it does not require
6969/// its elements to be copyable, and it avoids wasting memory when backed by an ArenaAllocator.
70/// Note that the push() and pop() convenience methods perform a copy, but you can instead use
70/// Note that the append() and pop() convenience methods perform a copy, but you can instead use
7171/// addOne(), at(), setCapacity(), and shrinkCapacity() to avoid copying items.
7272///
73/// This data structure has O(1) push and O(1) pop.
73/// This data structure has O(1) append and O(1) pop.
7474///
7575/// It supports preallocated elements, making it especially well suited when the expected maximum
7676/// size is small. `prealloc_item_count` must be 0, or a power of 2.
......@@ -91,10 +91,9 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
9191 }
9292 };
9393
94 prealloc_segment: [prealloc_item_count]T,
95 dynamic_segments: [][*]T,
96 allocator: Allocator,
97 len: usize,
94 prealloc_segment: [prealloc_item_count]T = undefined,
95 dynamic_segments: [][*]T = &[_][*]T{},
96 len: usize = 0,
9897
9998 pub const prealloc_count = prealloc_item_count;
10099
......@@ -106,19 +105,9 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
106105 }
107106 }
108107
109 /// Deinitialize with `deinit`
110 pub fn init(allocator: Allocator) Self {
111 return Self{
112 .allocator = allocator,
113 .len = 0,
114 .prealloc_segment = undefined,
115 .dynamic_segments = &[_][*]T{},
116 };
117 }
118
119 pub fn deinit(self: *Self) void {
120 self.freeShelves(@intCast(ShelfIndex, self.dynamic_segments.len), 0);
121 self.allocator.free(self.dynamic_segments);
108 pub fn deinit(self: *Self, allocator: Allocator) void {
109 self.freeShelves(allocator, @intCast(ShelfIndex, self.dynamic_segments.len), 0);
110 allocator.free(self.dynamic_segments);
122111 self.* = undefined;
123112 }
124113
......@@ -131,14 +120,14 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
131120 return self.len;
132121 }
133122
134 pub fn push(self: *Self, item: T) !void {
135 const new_item_ptr = try self.addOne();
123 pub fn append(self: *Self, allocator: Allocator, item: T) Allocator.Error!void {
124 const new_item_ptr = try self.addOne(allocator);
136125 new_item_ptr.* = item;
137126 }
138127
139 pub fn pushMany(self: *Self, items: []const T) !void {
128 pub fn appendSlice(self: *Self, allocator: Allocator, items: []const T) Allocator.Error!void {
140129 for (items) |item| {
141 try self.push(item);
130 try self.append(allocator, item);
142131 }
143132 }
144133
......@@ -151,47 +140,48 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
151140 return result;
152141 }
153142
154 pub fn addOne(self: *Self) !*T {
143 pub fn addOne(self: *Self, allocator: Allocator) Allocator.Error!*T {
155144 const new_length = self.len + 1;
156 try self.growCapacity(new_length);
145 try self.growCapacity(allocator, new_length);
157146 const result = uncheckedAt(self, self.len);
158147 self.len = new_length;
159148 return result;
160149 }
161150
162151 /// Grows or shrinks capacity to match usage.
163 pub fn setCapacity(self: *Self, new_capacity: usize) !void {
152 /// TODO update this and related methods to match the conventions set by ArrayList
153 pub fn setCapacity(self: *Self, allocator: Allocator, new_capacity: usize) Allocator.Error!void {
164154 if (prealloc_item_count != 0) {
165155 if (new_capacity <= @as(usize, 1) << (prealloc_exp + @intCast(ShelfIndex, self.dynamic_segments.len))) {
166 return self.shrinkCapacity(new_capacity);
156 return self.shrinkCapacity(allocator, new_capacity);
167157 }
168158 }
169 return self.growCapacity(new_capacity);
159 return self.growCapacity(allocator, new_capacity);
170160 }
171161
172162 /// Only grows capacity, or retains current capacity
173 pub fn growCapacity(self: *Self, new_capacity: usize) !void {
163 pub fn growCapacity(self: *Self, allocator: Allocator, new_capacity: usize) Allocator.Error!void {
174164 const new_cap_shelf_count = shelfCount(new_capacity);
175165 const old_shelf_count = @intCast(ShelfIndex, self.dynamic_segments.len);
176166 if (new_cap_shelf_count > old_shelf_count) {
177 self.dynamic_segments = try self.allocator.realloc(self.dynamic_segments, new_cap_shelf_count);
167 self.dynamic_segments = try allocator.realloc(self.dynamic_segments, new_cap_shelf_count);
178168 var i = old_shelf_count;
179169 errdefer {
180 self.freeShelves(i, old_shelf_count);
181 self.dynamic_segments = self.allocator.shrink(self.dynamic_segments, old_shelf_count);
170 self.freeShelves(allocator, i, old_shelf_count);
171 self.dynamic_segments = allocator.shrink(self.dynamic_segments, old_shelf_count);
182172 }
183173 while (i < new_cap_shelf_count) : (i += 1) {
184 self.dynamic_segments[i] = (try self.allocator.alloc(T, shelfSize(i))).ptr;
174 self.dynamic_segments[i] = (try allocator.alloc(T, shelfSize(i))).ptr;
185175 }
186176 }
187177 }
188178
189179 /// Only shrinks capacity or retains current capacity
190 pub fn shrinkCapacity(self: *Self, new_capacity: usize) void {
180 pub fn shrinkCapacity(self: *Self, allocator: Allocator, new_capacity: usize) void {
191181 if (new_capacity <= prealloc_item_count) {
192182 const len = @intCast(ShelfIndex, self.dynamic_segments.len);
193 self.freeShelves(len, 0);
194 self.allocator.free(self.dynamic_segments);
183 self.freeShelves(allocator, len, 0);
184 allocator.free(self.dynamic_segments);
195185 self.dynamic_segments = &[_][*]T{};
196186 return;
197187 }
......@@ -203,8 +193,8 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
203193 return;
204194 }
205195
206 self.freeShelves(old_shelf_count, new_cap_shelf_count);
207 self.dynamic_segments = self.allocator.shrink(self.dynamic_segments, new_cap_shelf_count);
196 self.freeShelves(allocator, old_shelf_count, new_cap_shelf_count);
197 self.dynamic_segments = allocator.shrink(self.dynamic_segments, new_cap_shelf_count);
208198 }
209199
210200 pub fn shrink(self: *Self, new_len: usize) void {
......@@ -278,11 +268,11 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
278268 return list_index + prealloc_item_count - (@as(usize, 1) << ((prealloc_exp + 1) + shelf_index));
279269 }
280270
281 fn freeShelves(self: *Self, from_count: ShelfIndex, to_count: ShelfIndex) void {
271 fn freeShelves(self: *Self, allocator: Allocator, from_count: ShelfIndex, to_count: ShelfIndex) void {
282272 var i = from_count;
283273 while (i != to_count) {
284274 i -= 1;
285 self.allocator.free(self.dynamic_segments[i][0..shelfSize(i)]);
275 allocator.free(self.dynamic_segments[i][0..shelfSize(i)]);
286276 }
287277 }
288278
......@@ -367,24 +357,24 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
367357}
368358
369359test "basic usage" {
370 const a = std.testing.allocator;
371
372 try testSegmentedList(0, a);
373 try testSegmentedList(1, a);
374 try testSegmentedList(2, a);
375 try testSegmentedList(4, a);
376 try testSegmentedList(8, a);
377 try testSegmentedList(16, a);
360 try testSegmentedList(0);
361 try testSegmentedList(1);
362 try testSegmentedList(2);
363 try testSegmentedList(4);
364 try testSegmentedList(8);
365 try testSegmentedList(16);
378366}
379367
380fn testSegmentedList(comptime prealloc: usize, allocator: Allocator) !void {
381 var list = SegmentedList(i32, prealloc).init(allocator);
382 defer list.deinit();
368fn testSegmentedList(comptime prealloc: usize) !void {
369 const gpa = std.testing.allocator;
370
371 var list: SegmentedList(i32, prealloc) = .{};
372 defer list.deinit(gpa);
383373
384374 {
385375 var i: usize = 0;
386376 while (i < 100) : (i += 1) {
387 try list.push(@intCast(i32, i + 1));
377 try list.append(gpa, @intCast(i32, i + 1));
388378 try testing.expect(list.len == i + 1);
389379 }
390380 }
......@@ -413,21 +403,21 @@ fn testSegmentedList(comptime prealloc: usize, allocator: Allocator) !void {
413403 try testing.expect(list.pop().? == 100);
414404 try testing.expect(list.len == 99);
415405
416 try list.pushMany(&[_]i32{ 1, 2, 3 });
406 try list.appendSlice(gpa, &[_]i32{ 1, 2, 3 });
417407 try testing.expect(list.len == 102);
418408 try testing.expect(list.pop().? == 3);
419409 try testing.expect(list.pop().? == 2);
420410 try testing.expect(list.pop().? == 1);
421411 try testing.expect(list.len == 99);
422412
423 try list.pushMany(&[_]i32{});
413 try list.appendSlice(gpa, &[_]i32{});
424414 try testing.expect(list.len == 99);
425415
426416 {
427417 var i: i32 = 99;
428418 while (list.pop()) |item| : (i -= 1) {
429419 try testing.expect(item == i);
430 list.shrinkCapacity(list.len);
420 list.shrinkCapacity(gpa, list.len);
431421 }
432422 }
433423
......@@ -437,7 +427,7 @@ fn testSegmentedList(comptime prealloc: usize, allocator: Allocator) !void {
437427
438428 var i: i32 = 0;
439429 while (i < 100) : (i += 1) {
440 try list.push(i + 1);
430 try list.append(gpa, i + 1);
441431 control[@intCast(usize, i)] = i + 1;
442432 }
443433
......@@ -450,7 +440,7 @@ fn testSegmentedList(comptime prealloc: usize, allocator: Allocator) !void {
450440 try testing.expect(std.mem.eql(i32, control[50..], dest[50..]));
451441 }
452442
453 try list.setCapacity(0);
443 try list.setCapacity(gpa, 0);
454444}
455445
456446/// TODO look into why this std.math function was changed in