authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-10-22 13:19:22-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-10-22 13:19:22-04:00
logd8c067966fe88e15f9de5c42b83f1c5fbed550e4
treee37fd4eca4e4ce043d94bc5f6bdd19213d32996a
parentccc9ebf0bd60908f70bc84aa85600dc6514e4998
parenta8eb70c9d70e2cdff032fdf80b304d70b002b120
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #17400 from joadnacer/ringbuffer-optim

std.RingBuffer: Implement mem.copy read/write

3 files changed, 95 insertions(+), 10 deletions(-)

lib/std/RingBuffer.zig+91-2
...@@ -11,6 +11,7 @@...@@ -11,6 +11,7 @@
1111
12const Allocator = @import("std").mem.Allocator;12const Allocator = @import("std").mem.Allocator;
13const assert = @import("std").debug.assert;13const assert = @import("std").debug.assert;
14const copyForwards = @import("std").mem.copyForwards;
1415
15const RingBuffer = @This();16const RingBuffer = @This();
1617
...@@ -18,7 +19,7 @@ data: []u8,...@@ -18,7 +19,7 @@ data: []u8,
18read_index: usize,19read_index: usize,
19write_index: usize,20write_index: usize,
2021
21pub const Error = error{Full};22pub const Error = error{ Full, ReadLengthInvalid };
2223
23/// Allocate a new `RingBuffer`; `deinit()` should be called to free the buffer.24/// Allocate a new `RingBuffer`; `deinit()` should be called to free the buffer.
24pub fn init(allocator: Allocator, capacity: usize) Allocator.Error!RingBuffer {25pub fn init(allocator: Allocator, capacity: usize) Allocator.Error!RingBuffer {
...@@ -63,6 +64,7 @@ pub fn writeAssumeCapacity(self: *RingBuffer, byte: u8) void {...@@ -63,6 +64,7 @@ pub fn writeAssumeCapacity(self: *RingBuffer, byte: u8) void {
6364
64/// Write `bytes` into the ring buffer. Returns `error.Full` if the ring65/// Write `bytes` into the ring buffer. Returns `error.Full` if the ring
65/// buffer does not have enough space, without writing any data.66/// buffer does not have enough space, without writing any data.
67/// Uses memcpy and so `bytes` must not overlap ring buffer data.
66pub fn writeSlice(self: *RingBuffer, bytes: []const u8) Error!void {68pub fn writeSlice(self: *RingBuffer, bytes: []const u8) Error!void {
67 if (self.len() + bytes.len > self.data.len) return error.Full;69 if (self.len() + bytes.len > self.data.len) return error.Full;
68 self.writeSliceAssumeCapacity(bytes);70 self.writeSliceAssumeCapacity(bytes);
...@@ -70,8 +72,51 @@ pub fn writeSlice(self: *RingBuffer, bytes: []const u8) Error!void {...@@ -70,8 +72,51 @@ pub fn writeSlice(self: *RingBuffer, bytes: []const u8) Error!void {
7072
71/// Write `bytes` into the ring buffer. If there is not enough space, older73/// Write `bytes` into the ring buffer. If there is not enough space, older
72/// bytes will be overwritten.74/// bytes will be overwritten.
75/// Uses memcpy and so `bytes` must not overlap ring buffer data.
73pub fn writeSliceAssumeCapacity(self: *RingBuffer, bytes: []const u8) void {76pub fn writeSliceAssumeCapacity(self: *RingBuffer, bytes: []const u8) void {
74 for (bytes) |b| self.writeAssumeCapacity(b);77 const data_start = self.mask(self.write_index);
78 const part1_data_end = @min(data_start + bytes.len, self.data.len);
79 const part1_len = part1_data_end - data_start;
80 @memcpy(self.data[data_start..part1_data_end], bytes[0..part1_len]);
81
82 const remaining = bytes.len - part1_len;
83 const to_write = @min(remaining, remaining % self.data.len + self.data.len);
84 const part2_bytes_start = bytes.len - to_write;
85 const part2_bytes_end = @min(part2_bytes_start + self.data.len, bytes.len);
86 const part2_len = part2_bytes_end - part2_bytes_start;
87 @memcpy(self.data[0..part2_len], bytes[part2_bytes_start..part2_bytes_end]);
88 if (part2_bytes_end != bytes.len) {
89 const part3_len = bytes.len - part2_bytes_end;
90 @memcpy(self.data[0..part3_len], bytes[part2_bytes_end..bytes.len]);
91 }
92 self.write_index = self.mask2(self.write_index + bytes.len);
93}
94
95/// Write `bytes` into the ring buffer. Returns `error.Full` if the ring
96/// buffer does not have enough space, without writing any data.
97/// Uses copyForwards and can write slices from this RingBuffer into itself.
98pub fn writeSliceForwards(self: *RingBuffer, bytes: []const u8) Error!void {
99 if (self.len() + bytes.len > self.data.len) return error.Full;
100 self.writeSliceForwardsAssumeCapacity(bytes);
101}
102
103/// Write `bytes` into the ring buffer. If there is not enough space, older
104/// bytes will be overwritten.
105/// Uses copyForwards and can write slices from this RingBuffer into itself.
106pub fn writeSliceForwardsAssumeCapacity(self: *RingBuffer, bytes: []const u8) void {
107 const data_start = self.mask(self.write_index);
108 const part1_data_end = @min(data_start + bytes.len, self.data.len);
109 const part1_len = part1_data_end - data_start;
110 copyForwards(u8, self.data[data_start..], bytes[0..part1_len]);
111
112 const remaining = bytes.len - part1_len;
113 const to_write = @min(remaining, remaining % self.data.len + self.data.len);
114 const part2_bytes_start = bytes.len - to_write;
115 const part2_bytes_end = @min(part2_bytes_start + self.data.len, bytes.len);
116 copyForwards(u8, self.data[0..], bytes[part2_bytes_start..part2_bytes_end]);
117 if (part2_bytes_end != bytes.len)
118 copyForwards(u8, self.data[0..], bytes[part2_bytes_end..bytes.len]);
119 self.write_index = self.mask2(self.write_index + bytes.len);
75}120}
76121
77/// Consume a byte from the ring buffer and return it. Returns `null` if the122/// Consume a byte from the ring buffer and return it. Returns `null` if the
...@@ -90,6 +135,50 @@ pub fn readAssumeLength(self: *RingBuffer) u8 {...@@ -90,6 +135,50 @@ pub fn readAssumeLength(self: *RingBuffer) u8 {
90 return byte;135 return byte;
91}136}
92137
138/// Reads first `length` bytes written to the ring buffer into `dest`; Returns
139/// Error.ReadLengthInvalid if length greater than ring or dest length
140/// Uses memcpy and so `dest` must not overlap ring buffer data.
141pub fn readFirst(self: *RingBuffer, dest: []u8, length: usize) Error!void {
142 if (length > self.len() or length > dest.len) return error.ReadLengthInvalid;
143 self.readFirstAssumeLength(dest, length);
144}
145
146/// Reads first `length` bytes written to the ring buffer into `dest`;
147/// Asserts that length not greater than ring buffer or dest length
148/// Uses memcpy and so `dest` must not overlap ring buffer data.
149pub fn readFirstAssumeLength(self: *RingBuffer, dest: []u8, length: usize) void {
150 assert(length <= self.len() and length <= dest.len);
151 const data_start = self.mask(self.read_index);
152 const part1_data_end = @min(self.data.len, data_start + length);
153 const part1_len = part1_data_end - data_start;
154 const part2_len = length - part1_len;
155 @memcpy(dest[0..part1_len], self.data[data_start..part1_data_end]);
156 @memcpy(dest[part1_len..length], self.data[0..part2_len]);
157 self.read_index = self.mask2(self.read_index + length);
158}
159
160/// Reads last `length` bytes written to the ring buffer into `dest`; Returns
161/// Error.ReadLengthInvalid if length greater than ring or dest length
162/// Uses memcpy and so `dest` must not overlap ring buffer data.
163pub fn readLast(self: *RingBuffer, dest: []u8, length: usize) Error!void {
164 if (length > self.len() or length > dest.len) return error.ReadLengthInvalid;
165 self.readLastAssumeLength(dest, length);
166}
167
168/// Reads last `length` bytes written to the ring buffer into `dest`;
169/// Asserts that length not greater than ring buffer or dest length
170/// Uses memcpy and so `dest` must not overlap ring buffer data.
171pub fn readLastAssumeLength(self: *RingBuffer, dest: []u8, length: usize) void {
172 assert(length <= self.len() and length <= dest.len);
173 const data_start = self.mask(self.write_index + self.data.len - length);
174 const part1_data_end = @min(self.data.len, data_start + length);
175 const part1_len = part1_data_end - data_start;
176 const part2_len = length - part1_len;
177 @memcpy(dest[0..part1_len], self.data[data_start..part1_data_end]);
178 @memcpy(dest[part1_len..length], self.data[0..part2_len]);
179 self.write_index = if (self.write_index >= self.data_len) self.write_index - length else data_start;
180}
181
93/// Returns `true` if the ring buffer is empty and `false` otherwise.182/// Returns `true` if the ring buffer is empty and `false` otherwise.
94pub fn isEmpty(self: RingBuffer) bool {183pub fn isEmpty(self: RingBuffer) bool {
95 return self.write_index == self.read_index;184 return self.write_index == self.read_index;
lib/std/compress/zstandard.zig+1-3
...@@ -219,9 +219,7 @@ pub fn DecompressStream(...@@ -219,9 +219,7 @@ pub fn DecompressStream(
219 }219 }
220220
221 const size = @min(self.buffer.len(), buffer.len);221 const size = @min(self.buffer.len(), buffer.len);
222 for (0..size) |i| {222 self.buffer.readFirstAssumeLength(buffer, size);
223 buffer[i] = self.buffer.read().?;
224 }
225 if (self.state == .LastBlock and self.buffer.len() == 0) {223 if (self.state == .LastBlock and self.buffer.len() == 0) {
226 self.state = .NewFrame;224 self.state = .NewFrame;
227 self.allocator.free(self.literal_fse_buffer);225 self.allocator.free(self.literal_fse_buffer);
lib/std/compress/zstandard/decode/block.zig+3-5
...@@ -311,8 +311,8 @@ pub const DecodeState = struct {...@@ -311,8 +311,8 @@ pub const DecodeState = struct {
311 try self.decodeLiteralsRingBuffer(dest, sequence.literal_length);311 try self.decodeLiteralsRingBuffer(dest, sequence.literal_length);
312 const copy_start = dest.write_index + dest.data.len - sequence.offset;312 const copy_start = dest.write_index + dest.data.len - sequence.offset;
313 const copy_slice = dest.sliceAt(copy_start, sequence.match_length);313 const copy_slice = dest.sliceAt(copy_start, sequence.match_length);
314 for (copy_slice.first) |b| dest.writeAssumeCapacity(b);314 dest.writeSliceForwardsAssumeCapacity(copy_slice.first);
315 for (copy_slice.second) |b| dest.writeAssumeCapacity(b);315 dest.writeSliceForwardsAssumeCapacity(copy_slice.second);
316 self.written_count += sequence.match_length;316 self.written_count += sequence.match_length;
317 }317 }
318318
...@@ -723,9 +723,7 @@ pub fn decodeBlockRingBuffer(...@@ -723,9 +723,7 @@ pub fn decodeBlockRingBuffer(
723 },723 },
724 .rle => {724 .rle => {
725 if (src.len < 1) return error.MalformedRleBlock;725 if (src.len < 1) return error.MalformedRleBlock;
726 for (0..block_size) |_| {726 dest.writeSliceAssumeCapacity(src[0..block_size]);
727 dest.writeAssumeCapacity(src[0]);
728 }
729 consumed_count.* += 1;727 consumed_count.* += 1;
730 decode_state.written_count += block_size;728 decode_state.written_count += block_size;
731 return block_size;729 return block_size;