MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42802 0 0 Zig
Normal View History Raw
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
const std = @import("std.zig");
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const builtin = @import("builtin");
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
const testing = std.testing;
pub fn once(comptime f: fn () void) Once(f) {
return Once(f){};
}
/// An object that executes the function `f` just once.
std: improve std.once tests * fix UB when Thread.spawn fails, and we try to join uninitialized threads (through new `thread_count` variable). * make sure that the tests pins down synchronization guarantees: in the main thread, we can observe `1` due to synchronization from `Thread.join()`. To make sure that once uses Acq/Rel, and not just relaxed, we should also additionally check that each thread observes 1, regardless of whether it was the one to call once.
2024-04-15 13:57:41 +01:00
/// It is undefined behavior if `f` re-enters the same Once instance.
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
pub fn Once(comptime f: fn () void) type {
return struct {
done: bool = false,
organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty
2021-01-14 20:41:37 -07:00
mutex: std.Thread.Mutex = std.Thread.Mutex{},
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
/// 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()) void {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
if (@atomicLoad(bool, &self.done, .acquire))
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
return;
return self.callSlow();
}
fn callSlow(self: *@This()) void {
compiler,lib,test,langref: migrate `@setCold` to `@branchHint`
2024-08-24 16:16:53 +01:00
@branchHint(.cold);
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
std.Thread.Mutex: change API to lock() and unlock() This is a breaking change. Before, usage looked like this: ```zig const held = mutex.acquire(); defer held.release(); ``` Now it looks like this: ```zig mutex.lock(); defer mutex.unlock(); ``` The `Held` type was an idea to make mutexes slightly safer by making it more difficult to forget to release an aquired lock. However, this ultimately caused more problems than it solved, when any data structures needed to store a held mutex. Simplify everything by reducing the API down to the primitives: lock() and unlock(). Closes #8051 Closes #8246 Closes #10105
2021-11-09 18:27:12 -07:00
self.mutex.lock();
defer self.mutex.unlock();
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
// The first thread to acquire the mutex gets to run the initializer
if (!self.done) {
f();
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
@atomicStore(bool, &self.done, true, .release);
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
}
}
};
}
var global_number: i32 = 0;
var global_once = once(incr);
fn incr() void {
global_number += 1;
}
test "Once executes its function just once" {
if (builtin.single_threaded) {
global_once.call();
global_once.call();
} else {
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
var threads: [10]std.Thread = undefined;
std: improve std.once tests * fix UB when Thread.spawn fails, and we try to join uninitialized threads (through new `thread_count` variable). * make sure that the tests pins down synchronization guarantees: in the main thread, we can observe `1` due to synchronization from `Thread.join()`. To make sure that once uses Acq/Rel, and not just relaxed, we should also additionally check that each thread observes 1, regardless of whether it was the one to call once.
2024-04-15 13:57:41 +01:00
var thread_count: usize = 0;
defer for (threads[0..thread_count]) |handle| handle.join();
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (&threads) |*handle| {
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
handle.* = try std.Thread.spawn(.{}, struct {
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
fn thread_fn(x: u8) void {
fix code broken from previous commit
2021-06-19 21:10:22 -04:00
_ = x;
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
global_once.call();
std: improve std.once tests * fix UB when Thread.spawn fails, and we try to join uninitialized threads (through new `thread_count` variable). * make sure that the tests pins down synchronization guarantees: in the main thread, we can observe `1` due to synchronization from `Thread.join()`. To make sure that once uses Acq/Rel, and not just relaxed, we should also additionally check that each thread observes 1, regardless of whether it was the one to call once.
2024-04-15 13:57:41 +01:00
if (global_number != 1) @panic("memory ordering bug");
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
}
changes to accomodate std.Thread update
2021-06-19 21:31:43 -05:00
}.thread_fn, .{0});
std: improve std.once tests * fix UB when Thread.spawn fails, and we try to join uninitialized threads (through new `thread_count` variable). * make sure that the tests pins down synchronization guarantees: in the main thread, we can observe `1` due to synchronization from `Thread.join()`. To make sure that once uses Acq/Rel, and not just relaxed, we should also additionally check that each thread observes 1, regardless of whether it was the one to call once.
2024-04-15 13:57:41 +01:00
thread_count += 1;
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
}
}
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 1), global_number);
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.
2020-04-18 13:26:12 +02:00
}
Reference in New Issue Copy Permalink