| ... | ... | @@ -1386,6 +1386,109 @@ pub const Condition = struct { |
| 1386 | 1386 | } |
| 1387 | 1387 | }; |
| 1388 | 1388 | |
| 1389 | /// Logical boolean flag which can be set and unset and supports a "wait until set" operation. |
| 1390 | pub const Event = enum(u32) { |
| 1391 | unset, |
| 1392 | waiting, |
| 1393 | is_set, |
| 1394 | |
| 1395 | /// Returns whether the logical boolean is `true`. |
| 1396 | pub fn isSet(event: *const Event) bool { |
| 1397 | return switch (@atomicLoad(Event, event, .acquire)) { |
| 1398 | .unset, .waiting => false, |
| 1399 | .is_set => true, |
| 1400 | }; |
| 1401 | } |
| 1402 | |
| 1403 | /// Blocks until the logical boolean is `true`. |
| 1404 | pub fn wait(event: *Event, io: Io) Io.Cancelable!void { |
| 1405 | if (@cmpxchgStrong(Event, event, .unset, .waiting, .acquire, .acquire)) |prev| switch (prev) { |
| 1406 | .unset => unreachable, |
| 1407 | .waiting => {}, |
| 1408 | .is_set => return, |
| 1409 | }; |
| 1410 | errdefer { |
| 1411 | // Ideally we would restore the event back to `.unset` instead of `.waiting`, but there |
| 1412 | // might be other threads waiting on the event. In theory we could track the *number* of |
| 1413 | // waiting threads in the unused bits of the `Event`, but that has its own problem: the |
| 1414 | // waiters would wake up when a *new waiter* was added. So it's easiest to just leave |
| 1415 | // the state at `.waiting`---at worst it causes one redundant call to `futexWake`. |
| 1416 | } |
| 1417 | while (true) { |
| 1418 | try io.futexWait(Event, event, .waiting); |
| 1419 | switch (@atomicLoad(Event, event, .acquire)) { |
| 1420 | .unset => unreachable, // `reset` called before pending `wait` returned |
| 1421 | .waiting => continue, |
| 1422 | .is_set => return, |
| 1423 | } |
| 1424 | } |
| 1425 | } |
| 1426 | |
| 1427 | /// Same as `wait` except uninterruptible. |
| 1428 | pub fn waitUncancelable(event: *Event, io: Io) void { |
| 1429 | if (@cmpxchgStrong(Event, event, .unset, .waiting, .acquire, .acquire)) |prev| switch (prev) { |
| 1430 | .unset => unreachable, |
| 1431 | .waiting => {}, |
| 1432 | .is_set => return, |
| 1433 | }; |
| 1434 | while (true) { |
| 1435 | io.futexWaitUncancelable(Event, event, .waiting); |
| 1436 | switch (@atomicLoad(Event, event, .acquire)) { |
| 1437 | .unset => unreachable, // `reset` called before pending `wait` returned |
| 1438 | .waiting => continue, |
| 1439 | .is_set => return, |
| 1440 | } |
| 1441 | } |
| 1442 | } |
| 1443 | |
| 1444 | /// Blocks the calling thread until either the logical boolean is set, the timeout expires, or a |
| 1445 | /// spurious wakeup occurs. If the timeout expires or a spurious wakeup occurs, `error.Timeout` |
| 1446 | /// is returned. |
| 1447 | pub fn waitTimeout(event: *Event, io: Io, timeout: Timeout) (error{Timeout} || Cancelable)!void { |
| 1448 | if (@cmpxchgStrong(Event, event, .unset, .waiting, .acquire, .acquire)) |prev| switch (prev) { |
| 1449 | .unset => unreachable, |
| 1450 | .waiting => assert(!builtin.single_threaded), // invalid state |
| 1451 | .is_set => return, |
| 1452 | }; |
| 1453 | errdefer { |
| 1454 | // Ideally we would restore the event back to `.unset` instead of `.waiting`, but there |
| 1455 | // might be other threads waiting on the event. In theory we could track the *number* of |
| 1456 | // waiting threads in the unused bits of the `Event`, but that has its own problem: the |
| 1457 | // waiters would wake up when a *new waiter* was added. So it's easiest to just leave |
| 1458 | // the state at `.waiting`---at worst it causes one redundant call to `futexWake`. |
| 1459 | } |
| 1460 | io.futexWaitTimeout(Event, event, .waiting, timeout); |
| 1461 | switch (@atomicLoad(Event, event, .acquire)) { |
| 1462 | .unset => unreachable, // `reset` called before pending `wait` returned |
| 1463 | .waiting => return error.Timeout, |
| 1464 | .is_set => return, |
| 1465 | } |
| 1466 | } |
| 1467 | |
| 1468 | /// Sets the logical boolean to true, and hence unblocks any pending calls to `wait`. The |
| 1469 | /// logical boolean remains true until `reset` is called, so future calls to `set` have no |
| 1470 | /// semantic effect. |
| 1471 | /// |
| 1472 | /// Any memory accesses prior to a `set` call are "released", so that if this `set` call causes |
| 1473 | /// `isSet` to return `true` or a wait to finish, those tasks will be able to observe those |
| 1474 | /// memory accesses. |
| 1475 | pub fn set(e: *Event, io: Io) void { |
| 1476 | switch (@atomicRmw(Event, e, .Xchg, .is_set, .release)) { |
| 1477 | .unset, .is_set => {}, |
| 1478 | .waiting => io.futexWake(Event, e, std.math.maxInt(u32)), |
| 1479 | } |
| 1480 | } |
| 1481 | |
| 1482 | /// Sets the logical boolean to false. |
| 1483 | /// |
| 1484 | /// Assumes that there is no pending call to `wait` or `waitUncancelable`. |
| 1485 | /// |
| 1486 | /// However, concurrent calls to `isSet`, `set`, and `reset` are allowed. |
| 1487 | pub fn reset(e: *Event) void { |
| 1488 | @atomicStore(Event, e, .unset, .monotonic); |
| 1489 | } |
| 1490 | }; |
| 1491 | |
| 1389 | 1492 | pub const TypeErasedQueue = struct { |
| 1390 | 1493 | mutex: Mutex, |
| 1391 | 1494 | |
Matthew Lugg <mlugg@mlugg.co.uk> 2025-12-15 14:02:20+00:00
Commit is signed but in an unrecognized format.