| ... | ... | @@ -126,6 +126,21 @@ pub const Node = struct { |
| 126 | 126 | } |
| 127 | 127 | } |
| 128 | 128 | |
| 129 | /// Thread-safe. |
| 130 | pub fn setName(self: *Node, name: []const u8) void { |
| 131 | const progress = self.context; |
| 132 | progress.update_mutex.lock(); |
| 133 | defer progress.update_mutex.unlock(); |
| 134 | self.name = name; |
| 135 | if (self.parent) |parent| { |
| 136 | @atomicStore(?*Node, &parent.recently_updated_child, self, .Release); |
| 137 | if (parent.parent) |grand_parent| { |
| 138 | @atomicStore(?*Node, &grand_parent.recently_updated_child, parent, .Release); |
| 139 | } |
| 140 | if (progress.timer) |*timer| progress.maybeRefreshWithHeldLock(timer); |
| 141 | } |
| 142 | } |
| 143 | |
| 129 | 144 | /// Thread-safe. 0 means unknown. |
| 130 | 145 | pub fn setEstimatedTotalItems(self: *Node, count: usize) void { |
| 131 | 146 | @atomicStore(usize, &self.unprotected_estimated_total_items, count, .Monotonic); |
| ... | ... | @@ -174,16 +189,20 @@ pub fn maybeRefresh(self: *Progress) void { |
| 174 | 189 | if (self.timer) |*timer| { |
| 175 | 190 | if (!self.update_mutex.tryLock()) return; |
| 176 | 191 | defer self.update_mutex.unlock(); |
| 177 | | const now = timer.read(); |
| 178 | | if (now < self.initial_delay_ns) return; |
| 179 | | // TODO I have observed this to happen sometimes. I think we need to follow Rust's |
| 180 | | // lead and guarantee monotonically increasing times in the std lib itself. |
| 181 | | if (now < self.prev_refresh_timestamp) return; |
| 182 | | if (now - self.prev_refresh_timestamp < self.refresh_rate_ns) return; |
| 183 | | return self.refreshWithHeldLock(); |
| 192 | maybeRefreshWithHeldLock(self, timer); |
| 184 | 193 | } |
| 185 | 194 | } |
| 186 | 195 | |
| 196 | fn maybeRefreshWithHeldLock(self: *Progress, timer: *std.time.Timer) void { |
| 197 | const now = timer.read(); |
| 198 | if (now < self.initial_delay_ns) return; |
| 199 | // TODO I have observed this to happen sometimes. I think we need to follow Rust's |
| 200 | // lead and guarantee monotonically increasing times in the std lib itself. |
| 201 | if (now < self.prev_refresh_timestamp) return; |
| 202 | if (now - self.prev_refresh_timestamp < self.refresh_rate_ns) return; |
| 203 | return self.refreshWithHeldLock(); |
| 204 | } |
| 205 | |
| 187 | 206 | /// Updates the terminal and resets `self.next_refresh_timestamp`. Thread-safe. |
| 188 | 207 | pub fn refresh(self: *Progress) void { |
| 189 | 208 | if (!self.update_mutex.tryLock()) return; |
Andrew Kelley <andrew@ziglang.org> 2023-03-09 18:06:07-07:00
lib