marler8997
commented
1 month ago Interesting stuff. I'm getting the same numbers on my macbook air and Windows desktop. I tested the performance on some older releases of zig down to 0.10.0 and found the fastest to be 0.11.0. I copied the implementation from 0.11.0 into the example and it takes about 60% of the time compared to the new implementation that goes through AnyWriter, still far off from the "no writer" benchmark which is around 8% of the time. In addition I wrote a theoretical MetaWriter which gets rid of writeFn altogether and instead queries the underlying Context type to call an appropriate function and I got it to about 15% of the runtime (about 2x slower than having no writer). Here's that code:
const std = @import("std");
pub fn main() !void {
const devnull = try std.fs.openFileAbsolute(
if (@import("builtin").os.tag == .windows) "\\\\.\\NUL" else "/dev/null",
.{ .mode = .write_only },
);
var timer = try std.time.Timer.start();
for (0 .. 10) |_| {
timer.reset();
try testNoWriter(devnull);
std.debug.print("No Writer: {}\n", .{std.fmt.fmtDuration(timer.read())});
timer.reset();
try testBufferedWriter(devnull);
std.debug.print("BufferedWriter: {}\n", .{std.fmt.fmtDuration(timer.read())});
timer.reset();
try testBufferedWriterZig_0_11_0(devnull);
std.debug.print("BufferedWriter(zig 0.11.0): {}\n", .{std.fmt.fmtDuration(timer.read())});
timer.reset();
try testBufferedWriterMeta(devnull);
std.debug.print("BufferedWriterMeta: {}\n", .{std.fmt.fmtDuration(timer.read())});
}
}
// Each example writes 1MiB to /dev/null, one byte at a time
// test today's buffered writer which goes through AnyWriter
fn testBufferedWriter(devnull: std.fs.File) !void {
var bufw = std.io.bufferedWriter(devnull.writer());
const w = bufw.writer();
for (0..1 << 20) |i| {
try w.writeByte(@truncate(i));
}
try bufw.flush();
}
// test buffered writer from 0.11.0 which didn't go through AnyWriter
fn testBufferedWriterZig_0_11_0(devnull: std.fs.File) !void {
var bufw = zig_0_11_0.BufferedWriter(4096, std.fs.File.Writer){ .unbuffered_writer = devnull.writer() };
const w = bufw.writer();
for (0..1 << 20) |i| {
try w.writeByte(@truncate(i));
}
try bufw.flush();
}
// test a theoretical writer interface that attempts to be as fast as having no writer
fn testBufferedWriterMeta(devnull: std.fs.File) !void {
var bufw = BufferedWriterMeta(4096, std.fs.File.Writer){ .unbuffered_writer = devnull.writer() };
const w = bufw.writer();
for (0..1 << 20) |i| {
try w.writeByte(@truncate(i));
}
try bufw.flush();
}
// test the performance we get without using any writer
fn testNoWriter(devnull: std.fs.File) !void {
var buf: [4096]u8 = undefined;
var idx: usize = 0;
const w = devnull.writer();
for (0..1 << 20) |i| {
buf[idx] = @truncate(i);
idx += 1;
if (idx >= buf.len) {
try w.writeAll(&buf);
idx = 0;
}
}
try w.writeAll(buf[0..idx]);
}
const mem = std.mem;
const assert = std.debug.assert;
// The old BufferedWriter from 0.11.0
const zig_0_11_0 = struct {
pub fn GenericWriter(
comptime Context: type,
comptime WriteError: type,
comptime writeFn: fn (context: Context, bytes: []const u8) WriteError!usize,
) type {
return struct {
context: Context,
const Self = @This();
pub const Error = WriteError;
pub fn write(self: Self, bytes: []const u8) Error!usize {
return writeFn(self.context, bytes);
}
pub fn writeAll(self: Self, bytes: []const u8) Error!void {
var index: usize = 0;
while (index != bytes.len) {
index += try self.write(bytes[index..]);
}
}
pub fn writeByte(self: Self, byte: u8) Error!void {
const array = [1]u8{byte};
return self.writeAll(&array);
}
};
}
pub fn BufferedWriter(comptime buffer_size: usize, comptime WriterType: type) type {
return struct {
unbuffered_writer: WriterType,
buf: [buffer_size]u8 = undefined,
end: usize = 0,
pub const Error = WriterType.Error;
pub const Writer = GenericWriter(*Self, Error, write);
const Self = @This();
pub fn flush(self: *Self) !void {
try self.unbuffered_writer.writeAll(self.buf[0..self.end]);
self.end = 0;
}
pub fn writer(self: *Self) Writer {
return .{ .context = self };
}
pub fn write(self: *Self, bytes: []const u8) Error!usize {
if (self.end + bytes.len > self.buf.len) {
try self.flush();
if (bytes.len > self.buf.len)
return self.unbuffered_writer.write(bytes);
}
const new_end = self.end + bytes.len;
@memcpy(self.buf[self.end..new_end], bytes);
self.end = new_end;
return bytes.len;
}
};
}
};
// An even more "generic" version of the old GenericWriter that allows the implementation
// to define even more custom implementation other that just a writeFn
pub fn MetaWriter(
comptime Context: type,
comptime WriteError: type,
) type {
return struct {
context: Context,
const Self = @This();
pub const Error = WriteError;
pub fn writeByte(self: Self, byte: u8) Error!void {
// An example of how MetaWriter could forward functions to different implementations
if (comptime @hasDecl(@typeInfo(Context).Pointer.child, "writeByte")) {
try self.context.writeByte(byte);
} else {
const buf = [_]u8{ byte };
const len = try self.context.write(&buf);
std.debug.assert(len == 1);
}
}
};
}
pub fn BufferedWriterMeta(comptime buffer_size: usize, comptime WriterType: type) type {
return struct {
unbuffered_writer: WriterType,
buf: [buffer_size]u8 = undefined,
end: usize = 0,
pub const Error = WriterType.Error;
pub const Writer = MetaWriter(*Self, Error);
const Self = @This();
pub fn flush(self: *Self) !void {
try self.unbuffered_writer.writeAll(self.buf[0..self.end]);
self.end = 0;
}
pub fn writer(self: *Self) Writer {
return .{ .context = self };
}
pub fn writeByte(self: *Self, b: u8) Error!void {
if (self.end == self.buf.len) {
try self.flush();
}
self.buf[self.end] = b;
self.end += 1;
}
pub fn write(self: *Self, bytes: []const u8) Error!usize {
if (self.end + bytes.len > self.buf.len) {
try self.flush();
if (bytes.len > self.buf.len)
return self.unbuffered_writer.write(bytes);
}
const new_end = self.end + bytes.len;
@memcpy(self.buf[self.end..new_end], bytes);
self.end = new_end;
return bytes.len;
}
};
}P.S. I'm fairly surprised that the LLVM optimizer isn't able to optimize AnyWriter into what the no writer example is doing. Seems like there's lots of room to improve optimization in Zig.
AndrewKraevskii
mlugg
ethernetsellout
castholm
nektro
gooncreeper
std.io.AnyWriter(and hencestd.io.GenericWriter, since that usesAnyWriterinternally) has a large amount of overhead in tight loops, as it hampers inlining.The following code snippet demonstrates an extreme case of the issue, but it comes up a lot in practice too:
EDIT (by @mlugg): the original numbers here were incorrect, since OP accidentally used
-Doptimizewithzig run. Accurate numbers from running this on my system are as follows:Using a custom buffering solution rather than
std.io.BufferedWriterresults in an approximately 2x speedup, simply by avoiding the overhead ofstd.io.AnyWriter.This pretty much defeats the whole point of having(EDIT @mlugg: this sentence was written based on incorrect performance numbers, which showed a wrongly exaggerated result.)BufferedWriterin the first place, sinceAnyWriterdestroys the good write performance it would otherwise provide.