mirror of
https://github.com/ziglang/zig.git
synced 2025-12-25 15:43:06 +00:00
5cd548e530
compiler_rt_lib and compiler_rt_obj are extracted from the generic JobQueue into simple boolean flags, and then handled explicitly inside performAllTheWork(). Introduced generic handling of allocation failure and made setMiscFailure not return a possible error. Building the compiler-rt static library now takes advantage of Compilation's ThreadPool. This introduced a problem, however, because now each of the object files of compiler-rt all perform AstGen for the full standard library and compiler-rt files. Even though all of them end up being cache hits except for the first ones, this is wasteful - O(N*M) where N is number of compilation units inside compiler-rt and M is the number of .zig files in the standard library and compiler-rt combined. More importantly, however, it causes a deadlock, because each thread interacts with a file system lock for doing AstGen on files, and threads end up waiting for each other. This will need to be handled with a process-level file caching system, or some other creative solution.
47 lines
1.2 KiB
Zig
47 lines
1.2 KiB
Zig
const std = @import("std");
|
|
const Atomic = std.atomic.Atomic;
|
|
const assert = std.debug.assert;
|
|
const WaitGroup = @This();
|
|
|
|
const is_waiting: usize = 1 << 0;
|
|
const one_pending: usize = 1 << 1;
|
|
|
|
state: Atomic(usize) = Atomic(usize).init(0),
|
|
event: std.Thread.ResetEvent = .{},
|
|
|
|
pub fn start(self: *WaitGroup) void {
|
|
const state = self.state.fetchAdd(one_pending, .Monotonic);
|
|
assert((state / one_pending) < (std.math.maxInt(usize) / one_pending));
|
|
}
|
|
|
|
pub fn finish(self: *WaitGroup) void {
|
|
const state = self.state.fetchSub(one_pending, .Release);
|
|
assert((state / one_pending) > 0);
|
|
|
|
if (state == (one_pending | is_waiting)) {
|
|
self.state.fence(.Acquire);
|
|
self.event.set();
|
|
}
|
|
}
|
|
|
|
pub fn wait(self: *WaitGroup) void {
|
|
var state = self.state.fetchAdd(is_waiting, .Acquire);
|
|
assert(state & is_waiting == 0);
|
|
|
|
if ((state / one_pending) > 0) {
|
|
self.event.wait();
|
|
}
|
|
}
|
|
|
|
pub fn reset(self: *WaitGroup) void {
|
|
self.state.store(0, .Monotonic);
|
|
self.event.reset();
|
|
}
|
|
|
|
pub fn isDone(wg: *WaitGroup) bool {
|
|
const state = wg.state.load(.Acquire);
|
|
assert(state & is_waiting == 0);
|
|
|
|
return (state / one_pending) == 0;
|
|
}
|