const std = @import("std"); pub const Dir = struct { pub const path = struct { pub fn bufJoin(buf: []u8, paths: []const []const u8) ![]u8 { var fa: std.heap.FixedBufferAllocator = .init(buf); return try std.Io.Dir.path.join(fa.allocator(), paths); } pub fn bufJoinZ(buf: []u8, paths: []const []const u8) ![:0]u8 { var fa: std.heap.FixedBufferAllocator = .init(buf); return try std.Io.Dir.path.joinZ(fa.allocator(), paths); } }; pub fn readFileAlloc(dir: std.Io.Dir, io: std.Io, sub_path: []const u8, gpa: std.mem.Allocator, limit: std.Io.Limit) ![]u8 { const stat = try std.Io.Dir.statFile(dir, io, sub_path, .{}); const buffer = try gpa.alloc(u8, limit.minInt64(stat.size)); errdefer gpa.free(buffer); _ = try std.Io.Dir.readFile(.cwd(), io, sub_path, buffer); return buffer; } }; pub const LimitedGroup = struct { limit: usize, in_flight: std.atomic.Value(usize) = .init(0), group: std.Io.Group = .init, cond: std.Io.Condition = .init, mutex: std.Io.Mutex = .init, fn Wrapper(comptime function: anytype) type { return struct { fn wrapper(self: *LimitedGroup, io: std.Io, args: std.meta.ArgsTuple(@TypeOf(function))) std.Io.Cancelable!void { while (true) { var in_flight = self.in_flight.load(.acquire); while (in_flight < self.limit) { if (self.in_flight.cmpxchgWeak(in_flight, in_flight + 1, .release, .acquire)) |actual| { in_flight = actual; continue; } defer { self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); _ = self.in_flight.fetchSub(1, .release); self.cond.signal(io); } return @call(.auto, function, args); } try self.mutex.lock(io); defer self.mutex.unlock(io); while (self.in_flight.load(.acquire) >= self.limit) { try self.cond.wait(io, &self.mutex); } } } }; } pub fn init(limit: usize) LimitedGroup { return .{ .limit = limit }; } pub fn async(self: *LimitedGroup, io: std.Io, comptime function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) void { self.group.async(io, Wrapper(function).wrapper, .{ self, io, args }); } pub fn concurrent(self: *LimitedGroup, io: std.Io, comptime function: anytype, args: std.meta.ArgsTuple(@TypeOf(function))) std.Io.ConcurrentError!void { try self.group.concurrent(io, Wrapper(function).wrapper, .{ self, io, args }); } pub fn await(self: *LimitedGroup, io: std.Io) std.Io.Cancelable!void { try self.group.await(io); } pub fn cancel(self: *LimitedGroup, io: std.Io) void { self.group.cancel(io); } }; pub const AllocatingLimitedConcurrentGroup = struct { allocator: std.mem.Allocator, queue_buffer: []bool = &[_]bool{}, limit: usize, group: std.Io.Group = .init, queue: std.Io.Queue(bool) = undefined, pub fn init(allocator: std.mem.Allocator, limit: usize) std.mem.Allocator.Error!AllocatingLimitedConcurrentGroup { const buffer = try allocator.alloc(bool, limit); @memset(buffer, false); var self: AllocatingLimitedConcurrentGroup = .{ .allocator = allocator, .queue_buffer = buffer, .limit = limit, .group = .init, .queue = undefined, }; self.queue = std.Io.Queue(bool).init(self.queue_buffer); return self; } pub fn deinit(self: *AllocatingLimitedConcurrentGroup) void { self.allocator.free(self.queue_buffer); } pub fn concurrent( self: *AllocatingLimitedConcurrentGroup, io: std.Io, comptime function: anytype, args: std.meta.ArgsTuple(@TypeOf(function)), ) !void { self.queue.putOneUncancelable(io, true) catch unreachable; try self.group.concurrent(io, struct { fn wrapper( io_: std.Io, queue: *std.Io.Queue(bool), inner_args: std.meta.ArgsTuple(@TypeOf(function)), ) !void { defer _ = queue.getOneUncancelable(io_) catch unreachable; return @call(.auto, function, inner_args); } }.wrapper, .{ io, &self.queue, args }); } pub fn await(self: *AllocatingLimitedConcurrentGroup, io: std.Io) std.Io.Cancelable!void { try self.group.await(io); } pub fn cancel(self: *AllocatingLimitedConcurrentGroup, io: std.Io) void { self.group.cancel(io); } }; pub const Duration = struct { pub fn div(self: std.Io.Duration, rhs: u64) std.Io.Duration { return .fromNanoseconds(@divTrunc(self.nanoseconds, @as(i96, @intCast(rhs)))); } pub fn hz(self: std.Io.Duration) u64 { return @intCast(std.time.ns_per_s / self.nanoseconds); } pub fn hzFloat(self: std.Io.Duration) f64 { return (1 * std.time.ns_per_s) / @as(f64, @floatFromInt(self.nanoseconds)); } };