const std = @import("std"); const builtin = @import("builtin"); pub const BoundedArray = @import("bounded_array.zig").BoundedArray; pub const BoundedArrayAligned = @import("bounded_array.zig").BoundedArrayAligned; pub const debug = @import("debug.zig"); pub const flags = @import("flags.zig"); pub const fmt = @import("fmt.zig"); pub const Io = @import("Io.zig"); pub const json = @import("json.zig"); pub const math = @import("math.zig"); pub const meta = @import("meta.zig"); pub const process = @import("process.zig"); pub const queue = @import("queue.zig"); pub const SegmentedList = @import("segmented_list.zig").SegmentedList; pub const time = @import("time.zig"); pub const unicode = @import("unicode.zig"); test { std.testing.refAllDecls(@This()); } pub inline fn stackSlice(comptime max_len: usize, T: type, len: usize) []T { debug.assert(len <= max_len, "stackSlice can only create a slice of up to {} elements, got: {}", .{ max_len, len }); var storage: [max_len]T = undefined; return storage[0..len]; } pub const noalloc: std.mem.Allocator = if (builtin.mode == .ReleaseFast) undefined else std.testing.failing_allocator; pub fn pinToCore(core_id: usize) void { if (builtin.os.tag == .linux) { const CPUSet = std.bit_set.ArrayBitSet(usize, std.os.linux.CPU_SETSIZE * @sizeOf(usize)); var set: CPUSet = .initEmpty(); set.set(core_id); std.os.linux.sched_setaffinity(0, @ptrCast(&set.masks)) catch {}; } } pub fn onceWithArgs(comptime f: anytype) OnceWithArgs(f) { return .{}; } /// An object that executes the function `f` just once. /// It is undefined behavior if `f` re-enters the same Once instance. pub fn OnceWithArgs(comptime f: anytype) type { const Args = std.meta.ArgsTuple(@TypeOf(f)); const Result = meta.FnResult(f); return struct { done: bool = false, mutex: std.Thread.Mutex = .{}, result: Result = undefined, /// Call the function `f`. /// If `call` is invoked multiple times `f` will be executed only the /// first time. /// The invocations are thread-safe. pub fn call(self: *@This(), args: Args) Result { if (@atomicLoad(bool, &self.done, .acquire)) return self.result; return self.callSlow(args); } fn callSlow(self: *@This(), args: Args) Result { @branchHint(.cold); self.mutex.lock(); defer self.mutex.unlock(); // The first thread to acquire the mutex gets to run the initializer if (!self.done) { self.result = @call(.auto, f, args); @atomicStore(bool, &self.done, true, .release); } return self.result; } }; }