MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42802 0 0 Zig
Normal View History Raw
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
//! This struct represents a kernel thread, and acts as a namespace for concurrency
//! primitives that operate on kernel threads. For concurrency primitives that support
//! both evented I/O and async I/O, see the respective names in the top level std namespace.
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
const std = @import("std.zig");
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
const builtin = @import("builtin");
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
const math = std.math;
std.Thread: more compile error fixes
2021-06-20 15:39:23 -05:00
const assert = std.debug.assert;
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
const target = builtin.target;
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const native_os = builtin.os.tag;
const posix = std.posix;
const windows = std.os.windows;
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
std.Thread.Futex addition (#9070) * std.Thread.Futex: implementation + tests * std.Thread.Futex: fix darwin compile errors * std.Thread.Futex: fix wait() documentation typo * std.Thread.Futex: fix darwin version check * std.Thread.Futex: remove unnecessary comptime keyword
2021-06-12 08:51:37 -05:00
pub const Futex = @import("Thread/Futex.zig");
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
pub const ResetEvent = @import("Thread/ResetEvent.zig");
pub const Mutex = @import("Thread/Mutex.zig");
pub const Semaphore = @import("Thread/Semaphore.zig");
pub const Condition = @import("Thread/Condition.zig");
update RwLock to use static initialization (#10838)
2022-02-08 23:35:48 -05:00
pub const RwLock = @import("Thread/RwLock.zig");
extract ThreadPool and WaitGroup from compiler to std lib
2023-02-13 13:39:06 -07:00
pub const Pool = @import("Thread/Pool.zig");
pub const WaitGroup = @import("Thread/WaitGroup.zig");
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
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
pub const use_pthreads = native_os != .windows and native_os != .wasi and builtin.link_libc;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
move std.time.sleep to std.Thread.sleep
2024-09-24 16:15:06 -07:00
/// Spurious wakeups are possible and no precision of timing is guaranteed.
pub fn sleep(nanoseconds: u64) void {
if (builtin.os.tag == .windows) {
const big_ms_from_ns = nanoseconds / std.time.ns_per_ms;
const ms = math.cast(windows.DWORD, big_ms_from_ns) orelse math.maxInt(windows.DWORD);
windows.kernel32.Sleep(ms);
return;
}
if (builtin.os.tag == .wasi) {
const w = std.os.wasi;
const userdata: w.userdata_t = 0x0123_45678;
const clock: w.subscription_clock_t = .{
.id = .MONOTONIC,
.timeout = nanoseconds,
.precision = 0,
.flags = 0,
};
const in: w.subscription_t = .{
.userdata = userdata,
.u = .{
.tag = .CLOCK,
.u = .{ .clock = clock },
},
};
var event: w.event_t = undefined;
var nevents: usize = undefined;
_ = w.poll_oneoff(&in, &event, 1, &nevents);
return;
}
if (builtin.os.tag == .uefi) {
const boot_services = std.os.uefi.system_table.boot_services.?;
const us_from_ns = nanoseconds / std.time.ns_per_us;
const us = math.cast(usize, us_from_ns) orelse math.maxInt(usize);
_ = boot_services.stall(us);
return;
}
const s = nanoseconds / std.time.ns_per_s;
const ns = nanoseconds % std.time.ns_per_s;
// Newer kernel ports don't have old `nanosleep()` and `clock_nanosleep()` has been around
// since Linux 2.6 and glibc 2.1 anyway.
if (builtin.os.tag == .linux) {
const linux = std.os.linux;
var req: linux.timespec = .{
.sec = std.math.cast(linux.time_t, s) orelse std.math.maxInt(linux.time_t),
.nsec = std.math.cast(linux.time_t, ns) orelse std.math.maxInt(linux.time_t),
};
var rem: linux.timespec = undefined;
while (true) {
switch (linux.E.init(linux.clock_nanosleep(.MONOTONIC, .{ .ABSTIME = false }, &req, &rem))) {
.SUCCESS => return,
.INTR => {
req = rem;
continue;
},
.FAULT,
.INVAL,
.OPNOTSUPP,
=> unreachable,
else => return,
}
}
}
posix.nanosleep(s, ns);
}
test sleep {
sleep(1);
}
std.Thread: another typo fix
2021-06-19 22:01:54 -05:00
const Thread = @This();
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const Impl = if (native_os == .windows)
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
WindowsThreadImpl
else if (use_pthreads)
PosixThreadImpl
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else if (native_os == .linux)
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
LinuxThreadImpl
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else if (native_os == .wasi)
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
WasiThreadImpl
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
else
std.Thread: more fixes
2021-06-26 13:00:54 -05:00
UnsupportedImpl;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
impl: Impl,
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
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
pub const max_name_len = switch (native_os) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
.linux => 15,
.windows => 31,
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => 63,
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
.netbsd => 31,
.freebsd => 15,
openbsd: fix thread name buffer size OpenBSD 7.3 changed its implementation of pthread_get_name_np/pthread_set_name_np to wrap new libc functions getthrname/setthrname and lowered the max buffer size from 32 to 24. This is not a backwards-compatible change because if we were to put in comptime version logic to use size 32 when target < 7.3 the binaries would be undefined when running on >= 7.3. It also could simply be that OpenBSD has a policy to not support older binaries running on newer releases? Regardless, the safest course is to simply use the smallest known buffer size. As an aside, this bug manifested as a "hung" std.Thread test because 7.3 pthread API never checks for error result when wrapping getthrname/setthrname. This is not a problem in std.Thread when we use the correct max buffer size because ERANGE/EINVAL become unreachable.
2023-04-10 19:06:39 -04:00
.openbsd => 23,
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
.dragonfly => 1023,
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 23:09:14 +11:00
.solaris, .illumos => 31,
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
// https://github.com/SerenityOS/serenity/blob/6b4c300353da49d3508b5442cf61da70bd04d757/Kernel/Tasks/Thread.h#L102
.serenity => 63,
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
else => 0,
};
pub const SetNameError = error{
NameTooLong,
Unsupported,
Unexpected,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
} || posix.PrctlError || posix.WriteError || std.fs.File.OpenError || std.fmt.BufPrintError;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
pub fn setName(self: Thread, name: []const u8) SetNameError!void {
if (name.len > max_name_len) return error.NameTooLong;
const name_with_terminator = blk: {
var name_buf: [max_name_len:0]u8 = undefined;
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(name_buf[0..name.len], name);
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
name_buf[name.len] = 0;
break :blk name_buf[0..name.len :0];
};
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (native_os) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
.linux => if (use_pthreads) {
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
if (self.getHandle() == std.c.pthread_self()) {
// Set the name of the calling thread (no thread id required).
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const err = try posix.prctl(.SET_NAME, .{@intFromPtr(name_with_terminator.ptr)});
switch (@as(posix.E, @enumFromInt(err))) {
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
.SUCCESS => return,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
}
} else {
const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
.SUCCESS => return,
.RANGE => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
}
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
} else {
var buf: [32]u8 = undefined;
const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
fs: Use `OpenMode` enum instead of read/write flags.
2022-01-29 13:52:08 +00:00
const file = try std.fs.cwd().openFile(path, .{ .mode = .write_only });
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
defer file.close();
try file.writer().writeAll(name);
housekeeping: return error.Unsupported Return error at end of std.Thread.setName/getName to simplify flow-control.
2021-10-07 14:31:06 -04:00
return;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
.windows => {
var buf: [max_name_len]u16 = undefined;
Fix handling of Windows (WTF-16) and WASI (UTF-8) paths Windows paths now use WTF-16 <-> WTF-8 conversion everywhere, which is lossless. Previously, conversion of ill-formed UTF-16 paths would either fail or invoke illegal behavior. WASI paths must be valid UTF-8, and the relevant function calls have been updated to handle the possibility of failure due to paths not being encoded/encodable as valid UTF-8. Closes #18694 Closes #1774 Closes #2565
2024-02-13 16:56:50 -08:00
const len = try std.unicode.wtf8ToWtf16Le(&buf, name);
math: make `cast` return optional instead of an error
2022-05-22 19:36:59 +04:30
const byte_len = math.cast(c_ushort, len * 2) orelse return error.NameTooLong;
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
// Note: NT allocates its own copy, no use-after-free here.
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const unicode_string = windows.UNICODE_STRING{
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
.Length = byte_len,
.MaximumLength = byte_len,
.Buffer = &buf,
};
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (windows.ntdll.NtSetInformationThread(
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
self.getHandle(),
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
.ThreadNameInformation,
&unicode_string,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
@sizeOf(windows.UNICODE_STRING),
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
)) {
.SUCCESS => return,
.NOT_IMPLEMENTED => return error.Unsupported,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |err| return windows.unexpectedStatus(err),
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => if (use_pthreads) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
// There doesn't seem to be a way to set the name for an arbitrary thread, only the current one.
if (self.getHandle() != std.c.pthread_self()) return error.Unsupported;
const err = std.c.pthread_setname_np(name_with_terminator.ptr);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => return,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
.serenity => if (use_pthreads) {
const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr);
switch (@as(posix.E, @enumFromInt(err))) {
.SUCCESS => return,
.NAMETOOLONG => unreachable,
.SRCH => unreachable,
else => |e| return posix.unexpectedErrno(e),
}
},
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 23:09:14 +11:00
.netbsd, .solaris, .illumos => if (use_pthreads) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr, null);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => return,
.INVAL => unreachable,
.SRCH => unreachable,
.NOMEM => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
.freebsd, .openbsd => if (use_pthreads) {
// Use pthread_set_name_np for FreeBSD because pthread_setname_np is FreeBSD 12.2+ only.
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
// TODO maybe revisit this if depending on FreeBSD 12.2+ is acceptable because
// pthread_setname_np can return an error.
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
std.c.pthread_set_name_np(self.getHandle(), name_with_terminator.ptr);
housekeeping: return error.Unsupported Return error at end of std.Thread.setName/getName to simplify flow-control.
2021-10-07 14:31:06 -04:00
return;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
.dragonfly => if (use_pthreads) {
const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
.SUCCESS => return,
.INVAL => unreachable,
.FAULT => unreachable,
.NAMETOOLONG => unreachable, // already checked
.SRCH => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
housekeeping: return error.Unsupported Return error at end of std.Thread.setName/getName to simplify flow-control.
2021-10-07 14:31:06 -04:00
else => {},
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
}
housekeeping: return error.Unsupported Return error at end of std.Thread.setName/getName to simplify flow-control.
2021-10-07 14:31:06 -04:00
return error.Unsupported;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
}
pub const GetNameError = error{
Unsupported,
Unexpected,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
} || posix.PrctlError || posix.ReadError || std.fs.File.OpenError || std.fmt.BufPrintError;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
Fix handling of Windows (WTF-16) and WASI (UTF-8) paths Windows paths now use WTF-16 <-> WTF-8 conversion everywhere, which is lossless. Previously, conversion of ill-formed UTF-16 paths would either fail or invoke illegal behavior. WASI paths must be valid UTF-8, and the relevant function calls have been updated to handle the possibility of failure due to paths not being encoded/encodable as valid UTF-8. Closes #18694 Closes #1774 Closes #2565
2024-02-13 16:56:50 -08:00
/// On Windows, the result is encoded as [WTF-8](https://simonsapin.github.io/wtf-8/).
/// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]const u8 {
buffer_ptr[max_name_len] = 0;
std: restrict mem.span() and mem.len() to sentinel terminated pointers These functions are currently footgunny when working with pointers to arrays and slices. They just return the stated length of the array/slice without iterating and looking for the first sentinel, even if the array/slice is a sentinel terminated type. From looking at the quite small list of places in the standard library/compiler that this change breaks existing code, the new code looks to be more readable in all cases. The usage of std.mem.span/len was totally unneeded in most of the cases affected by this breaking change. We could remove these functions entirely in favor of other existing functions in std.mem such as std.mem.sliceTo(), but that would be a somewhat nasty breaking change as std.mem.span() is very widely used for converting sentinel terminated pointers to slices. It is however not at all widely used for anything else. Therefore I think it is better to break these few non-standard and potentially incorrect usages of these functions now and at some later time, if deemed worthwhile, finally remove these functions. If we wait for at least a full release cycle so that everyone adapts to this change first, updating for the removal could be a simple find and replace without needing to worry about the semantics.
2023-01-22 16:40:00 +01:00
var buffer: [:0]u8 = buffer_ptr;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (native_os) {
std.Thread: drop is_gnu check I believe the reason we had that check in the first place was because for both `pthread_setname_np` and `pthread_getname_np` man says: ``` CONFORMING TO These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names. ``` However, this `is_gnu` check was never consistently applied; it was missing in `setName` in the Linux case. It is also missing on all other call sites for other platforms (macOS, iOS, et al.). Though, that could be because it may only apply to Linux. I think for a best-effort approach it is okay to drop this. It's probably less non-standard than man makes it out to be.
2023-02-24 20:58:09 +01:00
.linux => if (use_pthreads) {
if (self.getHandle() == std.c.pthread_self()) {
// Get the name of the calling thread (no thread id required).
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const err = try posix.prctl(.GET_NAME, .{@intFromPtr(buffer.ptr)});
switch (@as(posix.E, @enumFromInt(err))) {
std.Thread: drop is_gnu check I believe the reason we had that check in the first place was because for both `pthread_setname_np` and `pthread_getname_np` man says: ``` CONFORMING TO These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names. ``` However, this `is_gnu` check was never consistently applied; it was missing in `setName` in the Linux case. It is also missing on all other call sites for other platforms (macOS, iOS, et al.). Though, that could be because it may only apply to Linux. I think for a best-effort approach it is okay to drop this. It's probably less non-standard than man makes it out to be.
2023-02-24 20:58:09 +01:00
.SUCCESS => return std.mem.sliceTo(buffer, 0),
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std.Thread: drop is_gnu check I believe the reason we had that check in the first place was because for both `pthread_setname_np` and `pthread_getname_np` man says: ``` CONFORMING TO These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names. ``` However, this `is_gnu` check was never consistently applied; it was missing in `setName` in the Linux case. It is also missing on all other call sites for other platforms (macOS, iOS, et al.). Though, that could be because it may only apply to Linux. I think for a best-effort approach it is okay to drop this. It's probably less non-standard than man makes it out to be.
2023-02-24 20:58:09 +01:00
}
} else {
const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
std.Thread: drop is_gnu check I believe the reason we had that check in the first place was because for both `pthread_setname_np` and `pthread_getname_np` man says: ``` CONFORMING TO These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names. ``` However, this `is_gnu` check was never consistently applied; it was missing in `setName` in the Linux case. It is also missing on all other call sites for other platforms (macOS, iOS, et al.). Though, that could be because it may only apply to Linux. I think for a best-effort approach it is okay to drop this. It's probably less non-standard than man makes it out to be.
2023-02-24 20:58:09 +01:00
.SUCCESS => return std.mem.sliceTo(buffer, 0),
.RANGE => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std.Thread: drop is_gnu check I believe the reason we had that check in the first place was because for both `pthread_setname_np` and `pthread_getname_np` man says: ``` CONFORMING TO These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names. ``` However, this `is_gnu` check was never consistently applied; it was missing in `setName` in the Linux case. It is also missing on all other call sites for other platforms (macOS, iOS, et al.). Though, that could be because it may only apply to Linux. I think for a best-effort approach it is okay to drop this. It's probably less non-standard than man makes it out to be.
2023-02-24 20:58:09 +01:00
}
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
}
std.Thread: drop is_gnu check I believe the reason we had that check in the first place was because for both `pthread_setname_np` and `pthread_getname_np` man says: ``` CONFORMING TO These functions are nonstandard GNU extensions; hence the suffix "_np" (nonportable) in the names. ``` However, this `is_gnu` check was never consistently applied; it was missing in `setName` in the Linux case. It is also missing on all other call sites for other platforms (macOS, iOS, et al.). Though, that could be because it may only apply to Linux. I think for a best-effort approach it is okay to drop this. It's probably less non-standard than man makes it out to be.
2023-02-24 20:58:09 +01:00
} else {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
var buf: [32]u8 = undefined;
const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
const file = try std.fs.cwd().openFile(path, .{});
defer file.close();
const data_len = try file.reader().readAll(buffer_ptr[0 .. max_name_len + 1]);
return if (data_len >= 1) buffer[0 .. data_len - 1] else null;
},
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
.windows => {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const buf_capacity = @sizeOf(windows.UNICODE_STRING) + (@sizeOf(u16) * max_name_len);
var buf: [buf_capacity]u8 align(@alignOf(windows.UNICODE_STRING)) = undefined;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (windows.ntdll.NtQueryInformationThread(
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
self.getHandle(),
.ThreadNameInformation,
&buf,
buf_capacity,
null,
)) {
.SUCCESS => {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const string = @as(*const windows.UNICODE_STRING, @ptrCast(&buf));
Windows: Replace CreatePipe with ntdll implementation This implementation is now a direct replacement for the `kernel32` one. New bitflags for named pipes and other generic ones were added based on browsing the ReactOS sources. `UNICODE_STRING.Buffer` has also been changed to be nullable, as this is what makes the implementation work. This required some changes to places accesssing the buffer after a `SUCCESS`ful return, most notably `QueryObjectName` which even referred to it being nullable.
2024-03-12 21:13:13 +11:00
const len = std.unicode.wtf16LeToWtf8(buffer, string.Buffer.?[0 .. string.Length / 2]);
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
return if (len > 0) buffer[0..len] else null;
},
.NOT_IMPLEMENTED => return error.Unsupported,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |err| return windows.unexpectedStatus(err),
std.Thread(windows): use NT internals for name fns
2022-01-15 17:40:45 -06:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => if (use_pthreads) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => return std.mem.sliceTo(buffer, 0),
.SRCH => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
.serenity => if (use_pthreads) {
const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
switch (@as(posix.E, @enumFromInt(err))) {
.SUCCESS => return,
.NAMETOOLONG => unreachable,
.SRCH => unreachable,
.FAULT => unreachable,
else => |e| return posix.unexpectedErrno(e),
}
},
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 23:09:14 +11:00
.netbsd, .solaris, .illumos => if (use_pthreads) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => return std.mem.sliceTo(buffer, 0),
.INVAL => unreachable,
.SRCH => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
}
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
},
.freebsd, .openbsd => if (use_pthreads) {
// Use pthread_get_name_np for FreeBSD because pthread_getname_np is FreeBSD 12.2+ only.
// TODO maybe revisit this if depending on FreeBSD 12.2+ is acceptable because pthread_getname_np can return an error.
std.c.pthread_get_name_np(self.getHandle(), buffer.ptr, max_name_len + 1);
return std.mem.sliceTo(buffer, 0);
},
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
.dragonfly => if (use_pthreads) {
const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1);
std: fix pthread_{get,set}name_np return type ABI I believe this was accidentally broken when the E enum for errno values was introduces. These functions are quite the special case in that they return the error value directly rather than returning -1 and passing the error value through the errno variable. In any case, using a u16 as the return type at the ABI boundary where a c_int is expected is asking for trouble.
2024-06-15 22:22:11 +02:00
switch (@as(posix.E, @enumFromInt(err))) {
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
.SUCCESS => return std.mem.sliceTo(buffer, 0),
.INVAL => unreachable,
.FAULT => unreachable,
.SRCH => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |e| return posix.unexpectedErrno(e),
dragonfly: port std.Thread.setname/getname
2021-10-07 14:31:05 -04:00
}
},
housekeeping: return error.Unsupported Return error at end of std.Thread.setName/getName to simplify flow-control.
2021-10-07 14:31:06 -04:00
else => {},
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
}
housekeeping: return error.Unsupported Return error at end of std.Thread.setName/getName to simplify flow-control.
2021-10-07 14:31:06 -04:00
return error.Unsupported;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
}
std.Thread: make Id smaller where possible
2023-01-07 12:57:22 +01:00
/// Represents an ID per thread guaranteed to be unique only within a process.
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
pub const Id = switch (native_os) {
std.Thread: make Id smaller where possible
2023-01-07 12:57:22 +01:00
.linux,
.dragonfly,
.netbsd,
.freebsd,
.openbsd,
.haiku,
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
.wasi,
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
.serenity,
std.Thread: make Id smaller where possible
2023-01-07 12:57:22 +01:00
=> u32,
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => u64,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
.windows => windows.DWORD,
std.Thread: make Id smaller where possible
2023-01-07 12:57:22 +01:00
else => usize,
};
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
/// Returns the platform ID of the callers thread.
/// Attempts to use thread locals and avoid syscalls when possible.
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
pub fn getCurrentId() Id {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
return Impl.getCurrentId();
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
pub const CpuCountError = error{
PermissionDenied,
SystemResources,
bootstrap: fix build
2024-07-07 13:18:53 -04:00
Unsupported,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
Unexpected,
};
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
/// Returns the platforms view on the number of logical CPU cores available.
pub fn getCpuCount() CpuCountError!usize {
bootstrap: fix build
2024-07-07 13:18:53 -04:00
return try Impl.getCpuCount();
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
/// Configuration options for hints on how to spawn threads.
pub const SpawnConfig = struct {
// TODO compile-time call graph analysis to determine stack upper bound
// https://github.com/ziglang/zig/issues/157
/// Size in bytes of the Thread's stack
x86_64: fix crashes compiling the compiler and tests
2025-01-14 17:56:25 -05:00
stack_size: usize = default_stack_size,
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
/// The allocator to be used to allocate memory for the to-be-spawned thread
allocator: ?std.mem.Allocator = null,
x86_64: fix crashes compiling the compiler and tests
2025-01-14 17:56:25 -05:00
pub const default_stack_size = 16 * 1024 * 1024;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
};
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
pub const SpawnError = error{
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
/// A system-imposed limit on the number of threads was encountered.
/// There are a number of limits that may trigger this error:
/// * the RLIMIT_NPROC soft resource limit (set via setrlimit(2)),
/// which limits the number of processes and threads for a real
/// user ID, was reached;
/// * the kernel's system-wide limit on the number of processes and
/// threads, /proc/sys/kernel/threads-max, was reached (see
/// proc(5));
/// * the maximum number of PIDs, /proc/sys/kernel/pid_max, was
/// reached (see proc(5)); or
/// * the PID limit (pids.max) imposed by the cgroup "process num‐
/// ber" (PIDs) controller was reached.
ThreadQuotaExceeded,
/// The kernel cannot allocate sufficient memory to allocate a task structure
/// for the child, or to copy those parts of the caller's context that need to
/// be copied.
SystemResources,
/// Not enough userland memory to spawn the thread.
OutOfMemory,
/// `mlockall` is enabled, and the memory needed to spawn the thread
/// would exceed the limit.
LockedMemoryLimitExceeded,
Unexpected,
};
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
/// Spawns a new thread which executes `function` using `args` and returns a handle to the spawned thread.
doc: possible typo at `std.Thread.spawn` comment
2023-12-29 22:23:26 -03:00
/// `config` can be used as hints to the platform for how to spawn and execute the `function`.
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
/// The caller must eventually either call `join()` to wait for the thread to finish and free its resources
std.Thread.setName: use unused code I noticed a comment saying that the intent of a code's author was unclear. What happened is that the author forgot to put the check for whether the thread is the calling thread (`self.getHandle() == std.c.pthread_self()`) in the `if (use_pthreads)`. If the thread is the calling thread, we use `prctl` to set or get the thread's name and it does not take a thread id because it knows the id of the thread we're calling `getName` or `setName` from. I have found a source saying that using `pthread_setname_np` on either the calling thread or any other thread by thread id would work too (so we don't need to call `prctl`) but I was not sure if that is the case on all systems so we keep using `pthread_setname_np` if we have a specific thread that is not the thread we're calling from, and `prctl` otherwise.
2023-02-21 18:09:00 +01:00
/// or call `detach()` to excuse the caller from calling `join()` and have the thread clean up its resources on completion.
std.Thread: fix some typos
2021-06-20 09:56:30 -05:00
pub fn spawn(config: SpawnConfig, comptime function: anytype, args: anytype) SpawnError!Thread {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
if (builtin.single_threaded) {
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
@compileError("Cannot spawn thread when building in single-threaded mode");
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
std: Swap arguments in Thread.spawn Beside the new order being consistent with the ThreadPool API and making more sense, this shuffling allows to write the context argument type in terms of the startFn arguments, reducing the use of anytype (eg. less explicit casts when using comptime_int parameters, yay). Sorry for the breakage. Closes #8082
2021-02-28 10:01:55 +01:00
std.Thread: fix some typos
2021-06-20 09:56:30 -05:00
const impl = try Impl.spawn(config, function, args);
return Thread{ .impl = impl };
std: Swap arguments in Thread.spawn Beside the new order being consistent with the ThreadPool API and making more sense, this shuffling allows to write the context argument type in terms of the startFn arguments, reducing the use of anytype (eg. less explicit casts when using comptime_int parameters, yay). Sorry for the breakage. Closes #8082
2021-02-28 10:01:55 +01:00
}
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
/// Represents a kernel thread handle.
/// May be an integer or a pointer depending on the platform.
pub const Handle = Impl.ThreadHandle;
fix typo on Thread's getHandle docs
2022-02-25 13:38:30 -03:00
/// Returns the handle of this thread
std.Thread: another typo fix
2021-06-19 22:01:54 -05:00
pub fn getHandle(self: Thread) Handle {
return self.impl.getHandle();
}
/// Release the obligation of the caller to call `join()` and have the thread clean up its own resources on completion.
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
/// Once called, this consumes the Thread object and invoking any other functions on it is considered undefined behavior.
std.Thread: another typo fix
2021-06-19 22:01:54 -05:00
pub fn detach(self: Thread) void {
return self.impl.detach();
}
/// Waits for the thread to complete, then deallocates any resources created on `spawn()`.
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
/// Once called, this consumes the Thread object and invoking any other functions on it is considered undefined behavior.
std.Thread: another typo fix
2021-06-19 22:01:54 -05:00
pub fn join(self: Thread) void {
return self.impl.join();
}
std: rename `sched_yield` to `yield` and move it to `std.Thread`
2022-02-25 16:52:25 +05:30
pub const YieldError = error{
/// The system is not configured to allow yielding
SystemCannotYield,
};
/// Yields the current thread potentially allowing other threads to run.
pub fn yield() YieldError!void {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
if (native_os == .windows) {
std: rename `sched_yield` to `yield` and move it to `std.Thread`
2022-02-25 16:52:25 +05:30
// The return value has to do with how many other threads there are; it is not
// an error condition on Windows.
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
_ = windows.kernel32.SwitchToThread();
std: rename `sched_yield` to `yield` and move it to `std.Thread`
2022-02-25 16:52:25 +05:30
return;
}
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (posix.errno(posix.system.sched_yield())) {
std: rename `sched_yield` to `yield` and move it to `std.Thread`
2022-02-25 16:52:25 +05:30
.SUCCESS => return,
.NOSYS => return error.SystemCannotYield,
else => return error.SystemCannotYield,
}
}
std.Thread: another typo fix
2021-06-19 22:01:54 -05:00
/// State to synchronize detachment of spawner thread to spawned thread
riscv: workarounds for riscv threading
2024-07-26 14:03:20 -07:00
const Completion = std.atomic.Value(enum(if (builtin.zig_backend == .stage2_riscv64) u32 else u8) {
std.Thread: another typo fix
2021-06-19 22:01:54 -05:00
running,
detached,
completed,
});
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
/// Used by the Thread implementations to call the spawned function with the arguments.
fn callFn(comptime f: anytype, args: anytype) switch (Impl) {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
WindowsThreadImpl => windows.DWORD,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
LinuxThreadImpl => u8,
stage1, stage2: rename c_void to anyopaque (#10316) zig fmt now replaces c_void with anyopaque to make updating code easy.
2021-12-19 06:24:45 +01:00
PosixThreadImpl => ?*anyopaque,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
else => unreachable,
} {
const default_value = if (Impl == PosixThreadImpl) null else 0;
std: Extended type checks for Thread startFn return type
2024-06-01 15:04:02 -04:00
const bad_fn_ret = "expected return type of startFn to be 'u8', 'noreturn', '!noreturn', 'void', or '!void'";
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
switch (@typeInfo(@typeInfo(@TypeOf(f)).@"fn".return_type.?)) {
.noreturn => {
update usages of `@call`
2022-12-12 15:32:37 +02:00
@call(.auto, f, args);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.void => {
update usages of `@call`
2022-12-12 15:32:37 +02:00
@call(.auto, f, args);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
return default_value;
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.int => |info| {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
if (info.bits != 8) {
@compileError(bad_fn_ret);
}
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
update usages of `@call`
2022-12-12 15:32:37 +02:00
const status = @call(.auto, f, args);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
if (Impl != PosixThreadImpl) {
return status;
}
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
// pthreads don't support exit status, ignore value
return default_value;
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.error_union => |info| {
std: Extended type checks for Thread startFn return type
2024-06-01 15:04:02 -04:00
switch (info.payload) {
void, noreturn => {
@call(.auto, f, args) catch |err| {
std.debug.print("error: {s}\n", .{@errorName(err)});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
};
return default_value;
},
else => {
@compileError(bad_fn_ret);
},
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
},
else => {
@compileError(bad_fn_ret);
},
}
}
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
/// We can't compile error in the `Impl` switch statement as its eagerly evaluated.
/// So instead, we compile-error on the methods themselves for platforms which don't support threads.
std.Thread: more fixes
2021-06-26 13:00:54 -05:00
const UnsupportedImpl = struct {
pub const ThreadHandle = void;
std.Thread: make Id smaller where possible
2023-01-07 12:57:22 +01:00
fn getCurrentId() usize {
std.Thread: more fixes
2021-06-26 13:00:54 -05:00
return unsupported({});
}
fn getCpuCount() !usize {
return unsupported({});
}
fn spawn(config: SpawnConfig, comptime f: anytype, args: anytype) !Impl {
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
return unsupported(.{ config, f, args });
std.Thread: more fixes
2021-06-26 13:00:54 -05:00
}
fn getHandle(self: Impl) ThreadHandle {
return unsupported(self);
}
fn detach(self: Impl) void {
return unsupported(self);
}
fn join(self: Impl) void {
return unsupported(self);
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
}
std.Thread: more fixes
2021-06-26 13:00:54 -05:00
std: fix a bunch of typos The majority of these are in comments, some in doc comments which might affect the generated documentation, and a few in parameter names - nothing that should be breaking, however.
2023-04-30 18:02:08 +01:00
fn unsupported(unused: anytype) noreturn {
_ = unused;
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
@compileError("Unsupported operating system " ++ @tagName(native_os));
std.Thread: more fixes
2021-06-26 13:00:54 -05:00
}
};
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
const WindowsThreadImpl = struct {
pub const ThreadHandle = windows.HANDLE;
std.Thread: make Id smaller where possible
2023-01-07 12:57:22 +01:00
fn getCurrentId() windows.DWORD {
Replace some dynamic functions with static ones. PR [19271](https://github.com/ziglang/zig/pull/19271) added some static function implementations from kernel32, but some parts of the library still used the dynamically loaded versions.
2024-07-21 17:25:28 -03:00
return windows.GetCurrentThreadId();
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
fn getCpuCount() !usize {
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
// Faster than calling into GetSystemInfo(), even if amortized.
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
return windows.peb().NumberOfProcessors;
}
thread: *ThreadCompletion,
const ThreadCompletion = struct {
completion: Completion,
heap_ptr: windows.PVOID,
heap_handle: windows.HANDLE,
thread_handle: windows.HANDLE = undefined,
fn free(self: ThreadCompletion) void {
const status = windows.kernel32.HeapFree(self.heap_handle, 0, self.heap_ptr);
std.Thread: typo fixes 2
2021-06-22 11:27:58 -05:00
assert(status != 0);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
};
fn spawn(config: SpawnConfig, comptime f: anytype, args: anytype) !Impl {
const Args = @TypeOf(args);
const Instance = struct {
fn_args: Args,
thread: ThreadCompletion,
std.os.windows: Fix some incorrect callconv specifiers. Closes #21869.
2024-11-01 01:06:00 +01:00
fn entryFn(raw_ptr: windows.PVOID) callconv(.winapi) windows.DWORD {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const self: *@This() = @ptrCast(@alignCast(raw_ptr));
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
defer switch (self.thread.completion.swap(.completed, .seq_cst)) {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.running => {},
.completed => unreachable,
.detached => self.thread.free(),
};
return callFn(f, self.fn_args);
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
}
};
const heap_handle = windows.kernel32.GetProcessHeap() orelse return error.OutOfMemory;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
const alloc_bytes = @alignOf(Instance) + @sizeOf(Instance);
const alloc_ptr = windows.kernel32.HeapAlloc(heap_handle, 0, alloc_bytes) orelse return error.OutOfMemory;
errdefer assert(windows.kernel32.HeapFree(heap_handle, 0, alloc_ptr) != 0);
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const instance_bytes = @as([*]u8, @ptrCast(alloc_ptr))[0..alloc_bytes];
std.Thread: fix mutable ref of temporary The previous code is a compile error in stage2 as well as the upcoming lang spec.
2022-07-04 16:53:41 -07:00
var fba = std.heap.FixedBufferAllocator.init(instance_bytes);
const instance = fba.allocator().create(Instance) catch unreachable;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
instance.* = .{
.fn_args = args,
.thread = .{
.completion = Completion.init(.running),
.heap_ptr = alloc_ptr,
.heap_handle = heap_handle,
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
},
};
std.Thread: more compile error fixes
2021-06-20 15:39:23 -05:00
// Windows appears to only support SYSTEM_INFO.dwAllocationGranularity minimum stack size.
// Going lower makes it default to that specified in the executable (~1mb).
// Its also fine if the limit here is incorrect as stack size is only a hint.
math: make `cast` return optional instead of an error
2022-05-22 19:36:59 +04:30
var stack_size = std.math.cast(u32, config.stack_size) orelse std.math.maxInt(u32);
migration: std.math.{min, min3, max, max3} -> `@min` & `@max`
2023-06-02 22:02:45 -04:00
stack_size = @max(64 * 1024, stack_size);
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
std.Thread: uh more typo fixes
2021-06-20 17:12:28 -05:00
instance.thread.thread_handle = windows.kernel32.CreateThread(
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
null,
stack_size,
Instance.entryFn,
std/Thread: remove unnecessary `@ptrCast` (#17766)
2023-10-31 07:17:39 +03:00
instance,
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
0,
std.Thread: more compile error fixes
2021-06-20 15:39:23 -05:00
null,
) orelse {
Better implementation of GetLastError. (#20623) Instead of calling the dynamically loaded kernel32.GetLastError, we can extract it from the TEB. As shown by [Wine](https://github.com/wine-mirror/wine/blob/34b1606019982b71818780bc84b76460f650af31/include/winternl.h#L439), the last error lives at offset 0x34 of the TEB in 32-bit Windows and at offset 0x68 in 64-bit Windows.
2024-07-15 14:49:51 -03:00
const errno = windows.GetLastError();
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
return windows.unexpectedError(errno);
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
};
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
std.Thread: typo fixes 2
2021-06-22 11:27:58 -05:00
return Impl{ .thread = &instance.thread };
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn getHandle(self: Impl) ThreadHandle {
return self.thread.thread_handle;
}
fn detach(self: Impl) void {
windows.CloseHandle(self.thread.thread_handle);
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
switch (self.thread.completion.swap(.detached, .seq_cst)) {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.running => {},
.completed => self.thread.free(),
.detached => unreachable,
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
fn join(self: Impl) void {
windows.WaitForSingleObjectEx(self.thread.thread_handle, windows.INFINITE, false) catch unreachable;
windows.CloseHandle(self.thread.thread_handle);
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
assert(self.thread.completion.load(.seq_cst) == .completed);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
self.thread.free();
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
};
const PosixThreadImpl = struct {
const c = std.c;
pub const ThreadHandle = c.pthread_t;
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
fn getCurrentId() Id {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (native_os) {
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
.linux => {
return LinuxThreadImpl.getCurrentId();
},
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => {
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
var thread_id: u64 = undefined;
// Pass thread=null to get the current thread ID.
assert(c.pthread_threadid_np(null, &thread_id) == 0);
return thread_id;
},
.dragonfly => {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(u32, @bitCast(c.lwp_gettid()));
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
},
.netbsd => {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(u32, @bitCast(c._lwp_self()));
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
},
.freebsd => {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(u32, @bitCast(c.pthread_getthreadid_np()));
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
},
.openbsd => {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(u32, @bitCast(c.getthrid()));
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
},
.haiku => {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(u32, @bitCast(c.find_thread(null)));
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
},
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
.serenity => {
return @as(u32, @bitCast(c.pthread_self()));
},
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
else => {
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
return @intFromPtr(c.pthread_self());
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
},
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
fn getCpuCount() !usize {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (native_os) {
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
.linux => {
return LinuxThreadImpl.getCpuCount();
},
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.openbsd => {
var count: c_int = undefined;
var count_size: usize = @sizeOf(c_int);
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const mib = [_]c_int{ std.c.CTL.HW, std.c.HW.NCPUONLINE };
bsd: followup to std.posix extraction from std.os netbsd fix: - `Futex.zig:542:56: error: expected error union type, found 'c_int'` openbsd fix: - `emutls.zig:10:21: error: root struct of file 'os' has no member named 'abort'` - `Thread.zig:627:22: error: expected 6 argument(s), found 5`
2024-03-20 11:45:41 -04:00
posix.sysctl(&mib, &count, &count_size, null, 0) catch |err| switch (err) {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
error.NameTooLong, error.UnknownName => unreachable,
else => |e| return e,
};
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(usize, @intCast(count));
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
},
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
.solaris, .illumos, .serenity => {
Initial bringup of the Solaris/Illumos port
2021-08-31 22:21:23 +10:00
// The "proper" way to get the cpu count would be to query
// /dev/kstat via ioctls, and traverse a linked list for each
std: Add support for SerenityOS in various places Not nearly the entire downstream patchset but these are completely uncontroversial and known to work.
2025-03-10 22:48:21 +00:00
// cpu. (solaris, illumos)
const rc = c.sysconf(@intFromEnum(std.c._SC.NPROCESSORS_ONLN));
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
return switch (posix.errno(rc)) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
.SUCCESS => @as(usize, @intCast(rc)),
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |err| posix.unexpectedErrno(err),
Initial bringup of the Solaris/Illumos port
2021-08-31 22:21:23 +10:00
};
},
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.haiku => {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
var system_info: std.c.system_info = undefined;
const rc = std.c.get_system_info(&system_info); // always returns B_OK
return switch (posix.errno(rc)) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
.SUCCESS => @as(usize, @intCast(system_info.cpu_count)),
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |err| posix.unexpectedErrno(err),
updates for haiku stdc * add team_info, area_info * update signature for get_next_image_info * add error checks for haiku system calls * update and cleanup of haiku constants
2021-10-31 21:27:04 -05:00
};
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
},
else => {
var count: c_int = undefined;
var count_len: usize = @sizeOf(c_int);
std.Target: Remove functions that just wrap component functions. Functions like isMinGW() and isGnuLibC() have a good reason to exist: They look at multiple components of the target. But functions like isWasm(), isDarwin(), isGnu(), etc only exist to save 4-8 characters. I don't think this is a good enough reason to keep them, especially given that: * It's not immediately obvious to a reader whether target.isDarwin() means the same thing as target.os.tag.isDarwin() precisely because isMinGW() and similar functions *do* look at multiple components. * It's not clear where we would draw the line. The logical conclusion before this commit would be to also wrap Arch.isX86(), Os.Tag.isSolarish(), Abi.isOpenHarmony(), etc... this obviously quickly gets out of hand. * It's nice to just have a single correct way of doing something.
2025-01-24 03:45:38 +01:00
const name = if (comptime target.os.tag.isDarwin()) "hw.logicalcpu" else "hw.ncpu";
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.sysctlbynameZ(name, &count, &count_len, null, 0) catch |err| switch (err) {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
error.NameTooLong, error.UnknownName => unreachable,
else => |e| return e,
};
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return @as(usize, @intCast(count));
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
},
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
handle: ThreadHandle,
fn spawn(config: SpawnConfig, comptime f: anytype, args: anytype) !Impl {
const Args = @TypeOf(args);
const allocator = std.heap.c_allocator;
std.Thread: fix posix
2021-06-26 10:52:34 -05:00
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
const Instance = struct {
std.os.windows: Fix some incorrect callconv specifiers. Closes #21869.
2024-11-01 01:06:00 +01:00
fn entryFn(raw_arg: ?*anyopaque) callconv(.c) ?*anyopaque {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const args_ptr: *Args = @ptrCast(@alignCast(raw_arg));
std.Thread: fix posix
2021-06-26 10:52:34 -05:00
defer allocator.destroy(args_ptr);
return callFn(f, args_ptr.*);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
};
const args_ptr = try allocator.create(Args);
std.Thread: fix futex test + thread errors
2021-06-26 09:03:53 -05:00
args_ptr.* = args;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
errdefer allocator.destroy(args_ptr);
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
var attr: c.pthread_attr_t = undefined;
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
if (c.pthread_attr_init(&attr) != .SUCCESS) return error.SystemResources;
defer assert(c.pthread_attr_destroy(&attr) == .SUCCESS);
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
// Use the same set of parameters used by the libc-less impl.
Revert "std.Thread: refining stack size from platform minimum, changes more targetted towards platform like Linux/musl (#15791)" This reverts commit 41502c6aa53a3da31b276c23c4db74db7d04796b.
2023-07-31 10:54:35 -07:00
const stack_size = @max(config.stack_size, 16 * 1024);
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
assert(c.pthread_attr_setstacksize(&attr, stack_size) == .SUCCESS);
runtime page size detection heap.zig: define new default page sizes heap.zig: add min/max_page_size and their options lib/std/c: add miscellaneous declarations heap.zig: add pageSize() and its options switch to new page sizes, especially in GPA/stdlib mem.zig: remove page_size
2024-10-20 14:55:57 -07:00
assert(c.pthread_attr_setguardsize(&attr, std.heap.pageSize()) == .SUCCESS);
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
var handle: c.pthread_t = undefined;
std.Thread: more fixes
2021-06-25 12:43:03 -05:00
switch (c.pthread_create(
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
&handle,
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
&attr,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
Instance.entryFn,
std.Thread: fix off-by-one in PosixThreadImpl (#18711) by removing ZST special case
2024-01-29 17:07:21 +01:00
@ptrCast(args_ptr),
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
)) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => return Impl{ .handle = handle },
.AGAIN => return error.SystemResources,
.PERM => unreachable,
.INVAL => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |err| return posix.unexpectedErrno(err),
std.Thread: more typo fixes
2021-06-25 12:59:28 -05:00
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
fn getHandle(self: Impl) ThreadHandle {
return self.handle;
}
Revert "thread: simplify and remove useless return in spawn (#8621)" This reverts commit 77cb45f59f7b37c316af1762298d6032e2b130b5. Zig's error return traces will point to the return token if they happen to occur, so having multiple return statements makes those stack traces really helpful. This destroys debuggability.
2021-04-26 10:44:40 -07:00
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn detach(self: Impl) void {
switch (c.pthread_detach(self.handle)) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => {},
.INVAL => unreachable, // thread handle is not joinable
.SRCH => unreachable, // thread handle is invalid
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
else => unreachable,
}
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn join(self: Impl) void {
switch (c.pthread_join(self.handle, null)) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => {},
.INVAL => unreachable, // thread handle is not joinable (or another thread is already joining in)
.SRCH => unreachable, // thread handle is invalid
.DEADLK => unreachable, // two threads tried to join each other
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
else => unreachable,
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
};
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
const WasiThreadImpl = struct {
thread: *WasiThread,
pub const ThreadHandle = i32;
threadlocal var tls_thread_id: Id = 0;
const WasiThread = struct {
store allocator & remove global assembly We now store the original allocator that was used to allocate the memory required for the thread. This allocator can then be used in any cleanup functionality to ensure the memory is freed correctly. Secondly, we now use a function to set the stack pointer instead of generating a function using global assembly. This is a lot cleaner and more readable.
2023-06-21 21:43:11 +02:00
/// Thread ID
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
tid: std.atomic.Value(i32) = std.atomic.Value(i32).init(0),
store allocator & remove global assembly We now store the original allocator that was used to allocate the memory required for the thread. This allocator can then be used in any cleanup functionality to ensure the memory is freed correctly. Secondly, we now use a function to set the stack pointer instead of generating a function using global assembly. This is a lot cleaner and more readable.
2023-06-21 21:43:11 +02:00
/// Contains all memory which was allocated to bootstrap this thread, including:
/// - Guard page
/// - Stack
/// - TLS segment
/// - `Instance`
/// All memory is freed upon call to `join`
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
memory: []u8,
store allocator & remove global assembly We now store the original allocator that was used to allocate the memory required for the thread. This allocator can then be used in any cleanup functionality to ensure the memory is freed correctly. Secondly, we now use a function to set the stack pointer instead of generating a function using global assembly. This is a lot cleaner and more readable.
2023-06-21 21:43:11 +02:00
/// The allocator used to allocate the thread's memory,
/// which is also used during `join` to ensure clean-up.
allocator: std.mem.Allocator,
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
/// The current state of the thread.
state: State = State.init(.running),
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
};
/// A meta-data structure used to bootstrap a thread
const Instance = struct {
thread: WasiThread,
free allocated memory upon call `join` When `join` detects a thread has completed, it will free the allocated memory of the thread. For this we must first copy the allocator. This is required as the allocated memory holds a reference to the original allocator. If we free the memory, we would end up with UB as the allocator would free itself.
2023-06-22 19:53:07 +02:00
/// Contains the offset to the new __tls_base.
/// The offset starting from the memory's base.
tls_offset: usize,
/// Contains the offset to the stack for the newly spawned thread.
/// The offset is calculated starting from the memory's base.
stack_offset: usize,
/// Contains the raw pointer value to the wrapper which holds all arguments
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
/// for the callback.
raw_ptr: usize,
/// Function pointer to a wrapping function which will call the user's
/// function upon thread spawn. The above mentioned pointer will be passed
/// to this function pointer as its argument.
call_back: *const fn (usize) void,
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
/// When a thread is in `detached` state, we must free all of its memory
/// upon thread completion. However, as this is done while still within
/// the thread, we must first jump back to the main thread's stack or else
/// we end up freeing the stack that we're currently using.
original_stack_pointer: [*]u8,
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
};
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
const State = std.atomic.Value(enum(u8) { running, completed, detached });
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
fn getCurrentId() Id {
return tls_thread_id;
}
bootstrap: fix build
2024-07-07 13:18:53 -04:00
fn getCpuCount() error{Unsupported}!noreturn {
return error.Unsupported;
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
fn getHandle(self: Impl) ThreadHandle {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
return self.thread.tid.load(.seq_cst);
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
}
fn detach(self: Impl) void {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
switch (self.thread.state.swap(.detached, .seq_cst)) {
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
.running => {},
.completed => self.join(),
.detached => unreachable,
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
}
fn join(self: Impl) void {
free allocated memory upon call `join` When `join` detects a thread has completed, it will free the allocated memory of the thread. For this we must first copy the allocator. This is required as the allocated memory holds a reference to the original allocator. If we free the memory, we would end up with UB as the allocator would free itself.
2023-06-22 19:53:07 +02:00
defer {
// Create a copy of the allocator so we do not free the reference to the
// original allocator while freeing the memory.
var allocator = self.thread.allocator;
allocator.free(self.thread.memory);
}
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
var spin: u8 = 10;
while (true) {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
const tid = self.thread.tid.load(.seq_cst);
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
if (tid == 0) {
break;
}
if (spin > 0) {
spin -= 1;
std.atomic.spinLoopHint();
continue;
}
const result = asm (
free allocated memory upon call `join` When `join` detects a thread has completed, it will free the allocated memory of the thread. For this we must first copy the allocator. This is required as the allocated memory holds a reference to the original allocator. If we free the memory, we would end up with UB as the allocator would free itself.
2023-06-22 19:53:07 +02:00
\\ local.get %[ptr]
\\ local.get %[expected]
\\ i64.const -1 # infinite
\\ memory.atomic.wait32 0
\\ local.set %[ret]
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
: [ret] "=r" (-> u32),
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
: [ptr] "r" (&self.thread.tid.raw),
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
[expected] "r" (tid),
);
switch (result) {
0 => continue, // ok
1 => continue, // expected =! loaded
2 => unreachable, // timeout (infinite)
else => unreachable,
}
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
}
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
fn spawn(config: std.Thread.SpawnConfig, comptime f: anytype, args: anytype) SpawnError!WasiThreadImpl {
if (config.allocator == null) {
WASI-thread: panic if no allocator is given
2024-03-19 13:11:33 +01:00
@panic("an allocator is required to spawn a WASI thread");
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
// Wrapping struct required to hold the user-provided function arguments.
const Wrapper = struct {
args: @TypeOf(args),
fn entry(ptr: usize) void {
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
const w: *@This() = @ptrFromInt(ptr);
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
const bad_fn_ret = "expected return type of startFn to be 'u8', 'noreturn', 'void', or '!void'";
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
switch (@typeInfo(@typeInfo(@TypeOf(f)).@"fn".return_type.?)) {
.noreturn, .void => {
Fix WASI threads, again Properly call the entrypoint when it doesn't return an optional error, and use the per-thread copy of the arguments list.
2024-04-20 13:11:15 +02:00
@call(.auto, f, w.args);
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.int => |info| {
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
if (info.bits != 8) {
@compileError(bad_fn_ret);
}
Fix WASI threads, again Properly call the entrypoint when it doesn't return an optional error, and use the per-thread copy of the arguments list.
2024-04-20 13:11:15 +02:00
_ = @call(.auto, f, w.args); // WASI threads don't support exit status, ignore value
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
},
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
.error_union => |info| {
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
if (info.payload != void) {
@compileError(bad_fn_ret);
}
Fix WASI threads, again Properly call the entrypoint when it doesn't return an optional error, and use the per-thread copy of the arguments list.
2024-04-20 13:11:15 +02:00
@call(.auto, f, w.args) catch |err| {
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
std.debug.print("error: {s}\n", .{@errorName(err)});
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
};
},
else => {
@compileError(bad_fn_ret);
},
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
}
};
var stack_offset: usize = undefined;
var tls_offset: usize = undefined;
var wrapper_offset: usize = undefined;
var instance_offset: usize = undefined;
// Calculate the bytes we have to allocate to store all thread information, including:
// - The actual stack for the thread
// - The TLS segment
// - `Instance` - containing information about how to call the user's function.
const map_bytes = blk: {
store allocator & remove global assembly We now store the original allocator that was used to allocate the memory required for the thread. This allocator can then be used in any cleanup functionality to ensure the memory is freed correctly. Secondly, we now use a function to set the stack pointer instead of generating a function using global assembly. This is a lot cleaner and more readable.
2023-06-21 21:43:11 +02:00
// start with atleast a single page, which is used as a guard to prevent
// other threads clobbering our new thread.
// Unfortunately, WebAssembly has no notion of read-only segments, so this
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
// is only a best effort.
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
var bytes: usize = std.wasm.page_size;
bytes = std.mem.alignForward(usize, bytes, 16); // align stack to 16 bytes
stack_offset = bytes;
bytes += @max(std.wasm.page_size, config.stack_size);
bytes = std.mem.alignForward(usize, bytes, __tls_align());
tls_offset = bytes;
bytes += __tls_size();
bytes = std.mem.alignForward(usize, bytes, @alignOf(Wrapper));
wrapper_offset = bytes;
bytes += @sizeOf(Wrapper);
bytes = std.mem.alignForward(usize, bytes, @alignOf(Instance));
instance_offset = bytes;
bytes += @sizeOf(Instance);
bytes = std.mem.alignForward(usize, bytes, std.wasm.page_size);
break :blk bytes;
};
// Allocate the amount of memory required for all meta data.
const allocated_memory = try config.allocator.?.alloc(u8, map_bytes);
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
const wrapper: *Wrapper = @ptrCast(@alignCast(&allocated_memory[wrapper_offset]));
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
wrapper.* = .{ .args = args };
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
const instance: *Instance = @ptrCast(@alignCast(&allocated_memory[instance_offset]));
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
instance.* = .{
store allocator & remove global assembly We now store the original allocator that was used to allocate the memory required for the thread. This allocator can then be used in any cleanup functionality to ensure the memory is freed correctly. Secondly, we now use a function to set the stack pointer instead of generating a function using global assembly. This is a lot cleaner and more readable.
2023-06-21 21:43:11 +02:00
.thread = .{ .memory = allocated_memory, .allocator = config.allocator.? },
free allocated memory upon call `join` When `join` detects a thread has completed, it will free the allocated memory of the thread. For this we must first copy the allocator. This is required as the allocated memory holds a reference to the original allocator. If we free the memory, we would end up with UB as the allocator would free itself.
2023-06-22 19:53:07 +02:00
.tls_offset = tls_offset,
.stack_offset = stack_offset,
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
.raw_ptr = @intFromPtr(wrapper),
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
.call_back = &Wrapper.entry,
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
.original_stack_pointer = __get_stack_pointer(),
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
};
const tid = spawnWasiThread(instance);
// The specification says any value lower than 0 indicates an error.
// The values of such error are unspecified. WASI-Libc treats it as EAGAIN.
if (tid < 0) {
return error.SystemResources;
}
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
instance.thread.tid.store(tid, .seq_cst);
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
return .{ .thread = &instance.thread };
}
std.Thread: don't export wasi_thread_start in single-threaded mode
2024-12-15 20:51:46 -08:00
comptime {
if (!builtin.single_threaded) {
std.Thread: Fix wasi_thread_start() export to use a pointer. Closes #22518.
2025-01-18 11:33:31 +01:00
@export(&wasi_thread_start, .{ .name = "wasi_thread_start" });
default to single-threaded for WebAssembly When targeting WebAssembly, we default to building a single-threaded build as threads are still experimental. The user however can enable a multi- threaded build by specifying '-fno-single-threaded'. It's a compile-error to enable this flag, but not also enable shared-memory.
2023-06-26 19:10:34 +02:00
}
std.Thread: don't export wasi_thread_start in single-threaded mode
2024-12-15 20:51:46 -08:00
}
/// Called by the host environment after thread creation.
fn wasi_thread_start(tid: i32, arg: *Instance) callconv(.c) void {
comptime assert(!builtin.single_threaded);
free allocated memory upon call `join` When `join` detects a thread has completed, it will free the allocated memory of the thread. For this we must first copy the allocator. This is required as the allocated memory holds a reference to the original allocator. If we free the memory, we would end up with UB as the allocator would free itself.
2023-06-22 19:53:07 +02:00
__set_stack_pointer(arg.thread.memory.ptr + arg.stack_offset);
__wasm_init_tls(arg.thread.memory.ptr + arg.tls_offset);
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
@atomicStore(u32, &WasiThreadImpl.tls_thread_id, @intCast(tid), .seq_cst);
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
// Finished bootstrapping, call user's procedure.
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
arg.call_back(arg.raw_ptr);
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
switch (arg.thread.state.swap(.completed, .seq_cst)) {
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
.running => {
// reset the Thread ID
asm volatile (
\\ local.get %[ptr]
\\ i32.const 0
\\ i32.atomic.store 0
:
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
: [ptr] "r" (&arg.thread.tid.raw),
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
);
// Wake the main thread listening to this thread
asm volatile (
\\ local.get %[ptr]
\\ i32.const 1 # waiters
\\ memory.atomic.notify 0
\\ drop # no need to know the waiters
:
Unbreak support for WASI threads
2024-03-18 00:39:32 +01:00
: [ptr] "r" (&arg.thread.tid.raw),
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
);
},
.completed => unreachable,
.detached => {
// restore the original stack pointer so we can free the memory
// without having to worry about freeing the stack
__set_stack_pointer(arg.original_stack_pointer);
// Ensure a copy so we don't free the allocator reference itself
var allocator = arg.thread.allocator;
allocator.free(arg.thread.memory);
},
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
}
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
/// Asks the host to create a new thread for us.
/// Newly created thread will call `wasi_tread_start` with the thread ID as well
/// as the input `arg` that was provided to `spawnWasiThread`
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
const spawnWasiThread = @"thread-spawn";
std: implement `join` for WASI-threads We now reset the Thread ID to 0 and wake up the main thread listening for the thread to finish. We use inline assembly as we cannot use the stack to set the thread ID as it could possibly clobber any of the memory. Currently, we leak the memory that was allocated for the thread. We need to implement a way where we can clean up the memory without using the stack (as the stack is stored inside this same memory).
2023-06-21 21:44:53 +02:00
extern "wasi" fn @"thread-spawn"(arg: *Instance) i32;
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
/// Initializes the TLS data segment starting at `memory`.
/// This is a synthetic function, generated by the linker.
extern fn __wasm_init_tls(memory: [*]u8) void;
/// Returns a pointer to the base of the TLS data segment for the current thread
inline fn __tls_base() [*]u8 {
return asm (
\\ .globaltype __tls_base, i32
\\ global.get __tls_base
\\ local.set %[ret]
: [ret] "=r" (-> [*]u8),
);
}
/// Returns the size of the TLS segment
inline fn __tls_size() u32 {
return asm volatile (
\\ .globaltype __tls_size, i32, immutable
\\ global.get __tls_size
\\ local.set %[ret]
: [ret] "=r" (-> u32),
);
}
/// Returns the alignment of the TLS segment
inline fn __tls_align() u32 {
return asm (
\\ .globaltype __tls_align, i32, immutable
\\ global.get __tls_align
\\ local.set %[ret]
: [ret] "=r" (-> u32),
);
}
store allocator & remove global assembly We now store the original allocator that was used to allocate the memory required for the thread. This allocator can then be used in any cleanup functionality to ensure the memory is freed correctly. Secondly, we now use a function to set the stack pointer instead of generating a function using global assembly. This is a lot cleaner and more readable.
2023-06-21 21:43:11 +02:00
/// Allows for setting the stack pointer in the WebAssembly module.
inline fn __set_stack_pointer(addr: [*]u8) void {
asm volatile (
\\ local.get %[ptr]
\\ global.set __stack_pointer
:
: [ptr] "r" (addr),
);
}
std: implement `detach` for WASI-threads When a thread is detached from the main thread, we automatically cleanup any allocated memory. For this we first reset the stack-pointer to the original stack-pointer of the main-thread so we can safely clear the memory which also contains the thread's stack.
2023-06-23 19:14:55 +02:00
/// Returns the current value of the stack pointer
inline fn __get_stack_pointer() [*]u8 {
return asm (
\\ global.get __stack_pointer
\\ local.set %[stack_ptr]
: [stack_ptr] "=r" (-> [*]u8),
);
}
std: implement `Thread` `spawn` for WASI This implements a first version to spawn a WASI-thread. For a new thread to be created, we calculate the size required to store TLS, the new stack, and metadata. This size is then allocated using a user-provided allocator. After a new thread is spawn, the HOST will call into our bootstrap procedure. This bootstrap procedure will then initialize the TLS segment and set the newly spawned thread's TID. It will also set the stack pointer to the newly created stack to ensure we do not clobber the main thread's stack. When bootstrapping the thread is completed, we will call the user's function on this new thread.
2023-06-20 22:19:51 +02:00
};
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
const LinuxThreadImpl = struct {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const linux = std.os.linux;
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
pub const ThreadHandle = i32;
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
threadlocal var tls_thread_id: ?Id = null;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
std.Thread: add tests + getCurrentId() returns ints when possible
2021-06-20 07:38:26 -05:00
fn getCurrentId() Id {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
return tls_thread_id orelse {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const tid = @as(u32, @bitCast(linux.gettid()));
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
tls_thread_id = tid;
return tid;
};
}
fn getCpuCount() !usize {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const cpu_set = try posix.sched_getaffinity(0);
remove unnecessary cast
2024-10-27 09:40:56 +01:00
return posix.CPU_COUNT(cpu_set);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
}
thread: *ThreadCompletion,
const ThreadCompletion = struct {
completion: Completion = Completion.init(.running),
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
child_tid: std.atomic.Value(i32) = std.atomic.Value(i32).init(1),
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
parent_tid: i32 = undefined,
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
mapped: []align(std.heap.page_size_min) u8,
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
/// Calls `munmap(mapped.ptr, mapped.len)` then `exit(1)` without touching the stack (which lives in `mapped.ptr`).
/// Ported over from musl libc's pthread detached implementation:
/// https://github.com/ifduyue/musl/search?q=__unmapself
fn freeAndExit(self: *ThreadCompletion) noreturn {
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
switch (target.cpu.arch) {
all: rename i386 to x86
2022-10-07 21:24:44 +03:30
.x86 => asm volatile (
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ movl $91, %%eax # SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ movl %[ptr], %%ebx
\\ movl %[len], %%ecx
\\ int $128
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ movl $1, %%eax # SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ movl $0, %%ebx
\\ int $128
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
.x86_64 => asm volatile (
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ movq $11, %%rax # SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ syscall
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ movq $60, %%rax # SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ movq $1, %%rdi
\\ syscall
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "{rdi}" (@intFromPtr(self.mapped.ptr)),
std.Thread: fix freeAndExit on x86_64-linux (#12693) Previously, this function used incorrect registers for the munmap syscall, leading to detached threads not cleaning up. closes #12690 Co-authored-by: bxlr <biexelar@diroot.org>
2022-08-31 02:31:47 +00:00
[len] "{rsi}" (self.mapped.len),
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
.arm, .armeb, .thumb, .thumbeb => asm volatile (
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ mov r7, #91 // SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ mov r0, %[ptr]
\\ mov r1, %[len]
\\ svc 0
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ mov r7, #1 // SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ mov r0, #0
\\ svc 0
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
std.Target.Cpu.Arch: Remove the `aarch64_32` tag. This is a misfeature that we inherited from LLVM: * https://reviews.llvm.org/D61259 * https://reviews.llvm.org/D61939 (`aarch64_32` and `arm64_32` are equivalent.) I truly have no idea why this triple passed review in LLVM. It is, to date, the *only* tag in the architecture component that is not, in fact, an architecture. In reality, it is just an ILP32 ABI for AArch64 (*not* AArch32). The triples that use `aarch64_32` look like `aarch64_32-apple-watchos`. Yes, that triple is exactly what you think; it has no ABI component. They really, seriously did this. Since only Apple could come up with silliness like this, it should come as no surprise that no one else uses `aarch64_32`. Later on, a GNU ILP32 ABI for AArch64 was developed, and support was added to LLVM: * https://reviews.llvm.org/D94143 * https://reviews.llvm.org/D104931 Here, sanity seems to have prevailed, and a triple using this ABI looks like `aarch64-linux-gnu_ilp32` as you would expect. As can be seen from the diffs in this commit, there was plenty of confusion throughout the Zig codebase about what exactly `aarch64_32` was. So let's just remove it. In its place, we'll use `aarch64-watchos-ilp32`, `aarch64-linux-gnuilp32`, and so on. We'll then translate these appropriately when talking to LLVM. Hence, this commit adds the `ilp32` ABI tag (we already have `gnuilp32`).
2024-07-27 03:52:19 +02:00
.aarch64, .aarch64_be => asm volatile (
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ mov x8, #215 // SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ mov x0, %[ptr]
\\ mov x1, %[len]
\\ svc 0
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ mov x8, #93 // SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ mov x0, #0
\\ svc 0
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
std.Thread: Implement freeAndExit() for hexagon.
2024-08-18 02:29:54 +02:00
.hexagon => asm volatile (
\\ r6 = #215 // SYS_munmap
\\ r0 = %[ptr]
\\ r1 = %[len]
\\ trap0(#1)
\\ r6 = #93 // SYS_exit
\\ r0 = #0
\\ trap0(#1)
:
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
[len] "r" (self.mapped.len),
: "memory"
),
std.Thread: Explain apparently pointless mips instruction in freeAndExit(). https://git.musl-libc.org/cgit/musl/commit/?id=ce3688eca920aa77549323f84e21f33522397115
2024-08-12 04:10:27 +02:00
// We set `sp` to the address of the current function as a workaround for a Linux
// kernel bug that caused syscalls to return EFAULT if the stack pointer is invalid.
// The bug was introduced in 46e12c07b3b9603c60fc1d421ff18618241cb081 and fixed in
// 7928eb0370d1133d0d8cd2f5ddfca19c309079d5.
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
.mips, .mipsel => asm volatile (
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ move $sp, $25
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ li $2, 4091 # SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ move $4, %[ptr]
\\ move $5, %[len]
\\ syscall
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ li $2, 4001 # SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ li $4, 0
\\ syscall
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
.mips64, .mips64el => asm volatile (
std.Thread: Fix freeAndExit() syscall numbers for mips64. These just seem to have been copy/pasted from mips32.
2024-08-12 12:34:40 +02:00
\\ li $2, 5011 # SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ move $4, %[ptr]
\\ move $5, %[len]
\\ syscall
std.Thread: Fix freeAndExit() syscall numbers for mips64. These just seem to have been copy/pasted from mips32.
2024-08-12 12:34:40 +02:00
\\ li $2, 5058 # SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ li $4, 0
\\ syscall
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
.powerpc, .powerpcle, .powerpc64, .powerpc64le => asm volatile (
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ li 0, 91 # SYS_munmap
std.Thread: Fix freeAndExit() assembly for powerpc. Wrong source/destination register order.
2024-08-12 12:36:38 +02:00
\\ mr 3, %[ptr]
\\ mr 4, %[len]
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ sc
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ li 0, 1 # SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ li 3, 0
\\ sc
\\ blr
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
std.Thread: Merge riscv32/riscv64 assembly in freeAndExit().
2024-08-12 12:40:54 +02:00
.riscv32, .riscv64 => asm volatile (
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ li a7, 215 # SYS_munmap
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ mv a0, %[ptr]
\\ mv a1, %[len]
\\ ecall
std.Thread: Add some syscall comments to LinuxThreadImpl.ThreadCompletion.freeAndExit().
2024-07-20 05:34:25 +02:00
\\ li a7, 93 # SYS_exit
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
\\ mv a0, zero
\\ ecall
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
: "memory"
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
),
std.Thread: Implement freeAndExit() for s390x.
2024-08-18 02:22:25 +02:00
.s390x => asm volatile (
\\ lgr %%r2, %[ptr]
\\ lgr %%r3, %[len]
\\ svc 91 # SYS_munmap
\\ lghi %%r2, 0
\\ svc 1 # SYS_exit
:
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
[len] "r" (self.mapped.len),
: "memory"
),
std.Thread: Implement freeAndExit() for sparc32.
2024-08-18 02:02:47 +02:00
.sparc => asm volatile (
\\ # See sparc64 comments below.
\\ 1:
\\ cmp %%fp, 0
\\ beq 2f
\\ nop
\\ ba 1b
\\ restore
\\ 2:
std: Fix assembler comment syntax for sparc.
2024-09-05 09:37:09 +02:00
\\ mov 73, %%g1 // SYS_munmap
std.Thread: Implement freeAndExit() for sparc32.
2024-08-18 02:02:47 +02:00
\\ mov %[ptr], %%o0
\\ mov %[len], %%o1
\\ t 0x3 # ST_FLUSH_WINDOWS
\\ t 0x10
std: Fix assembler comment syntax for sparc.
2024-09-05 09:37:09 +02:00
\\ mov 1, %%g1 // SYS_exit
std.Thread: Implement freeAndExit() for sparc32.
2024-08-18 02:02:47 +02:00
\\ mov 0, %%o0
\\ t 0x10
:
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
[len] "r" (self.mapped.len),
: "memory"
),
target: Rename sparcv9 -> sparc64 Rename all references of sparcv9 to sparc64, to make Zig align more with other projects. Also, added new function to convert glibc arch name to Zig arch name, since it refers to the architecture as sparcv9. This is based on the suggestion by @kubkon in PR 11847. (https://github.com/ziglang/zig/pull/11487#pullrequestreview-963761757)
2022-05-13 22:59:06 +07:00
.sparc64 => asm volatile (
Add freeAndExit() implementation for Linux/SPARCv9
2021-07-30 21:45:28 +07:00
\\ # SPARCs really don't like it when active stack frames
\\ # is unmapped (it will result in a segfault), so we
\\ # force-deactivate it by running `restore` until
\\ # all frames are cleared.
std.Thread: Use zero exit code in freeAndExit() for sparc64.
2024-08-18 02:03:22 +02:00
\\ 1:
SPARCv9: Fix freeAndExit implementation This fixes the wrong branch target and register check. (https://github.com/ziglang/zig/issues/9801)
2021-09-27 21:00:07 +07:00
\\ cmp %%fp, 0
Add freeAndExit() implementation for Linux/SPARCv9
2021-07-30 21:45:28 +07:00
\\ beq 2f
Linux/SPARCv9: account for branch delay in freeAndExit()
2021-08-03 20:14:40 +07:00
\\ nop
SPARCv9: Fix freeAndExit implementation This fixes the wrong branch target and register check. (https://github.com/ziglang/zig/issues/9801)
2021-09-27 21:00:07 +07:00
\\ ba 1b
Add freeAndExit() implementation for Linux/SPARCv9
2021-07-30 21:45:28 +07:00
\\ restore
std.Thread: Use zero exit code in freeAndExit() for sparc64.
2024-08-18 02:03:22 +02:00
\\ 2:
std: Fix assembler comment syntax for sparc.
2024-09-05 09:37:09 +02:00
\\ mov 73, %%g1 // SYS_munmap
Add freeAndExit() implementation for Linux/SPARCv9
2021-07-30 21:45:28 +07:00
\\ mov %[ptr], %%o0
\\ mov %[len], %%o1
\\ # Flush register window contents to prevent background
\\ # memory access before unmapping the stack.
\\ flushw
\\ t 0x6d
std: Fix assembler comment syntax for sparc.
2024-09-05 09:37:09 +02:00
\\ mov 1, %%g1 // SYS_exit
std.Thread: Use zero exit code in freeAndExit() for sparc64.
2024-08-18 02:03:22 +02:00
\\ mov 0, %%o0
Add freeAndExit() implementation for Linux/SPARCv9
2021-07-30 21:45:28 +07:00
\\ t 0x6d
:
std: add loongarch64 support (#20915) Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
2024-08-09 08:30:57 +08:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
[len] "r" (self.mapped.len),
: "memory"
),
std.Thread: Use loongarch freeAndExit() implementation for loongarch32 too.
2024-10-16 01:06:27 +02:00
.loongarch32, .loongarch64 => asm volatile (
std: add loongarch64 support (#20915) Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
2024-08-09 08:30:57 +08:00
\\ or $a0, $zero, %[ptr]
\\ or $a1, $zero, %[len]
\\ ori $a7, $zero, 215 # SYS_munmap
\\ syscall 0 # call munmap
\\ ori $a0, $zero, 0
\\ ori $a7, $zero, 93 # SYS_exit
\\ syscall 0 # call exit
:
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
: [ptr] "r" (@intFromPtr(self.mapped.ptr)),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[len] "r" (self.mapped.len),
Add freeAndExit() implementation for Linux/SPARCv9
2021-07-30 21:45:28 +07:00
: "memory"
),
stage2: miscellaneous fixes for the branch * Breaking language change: inline assembly must use string literal syntax. This is in preparation for inline assembly improvements that involve more integration with the Zig language. This means we cannot rely on text substitution. * Liveness: properly handle inline assembly and function calls with more than 3 operands. - More than 35 operands is not yet supported. This is a low priority to implement. - This required implementation in codegen.zig as well. * Liveness: fix bug causing incorrect tomb bits. * Sema: enable switch expressions that are evaluated at compile-time. - Runtime switch instructions still need to be reworked in this branch. There was a TODO left here (by me) with a suggestion to do some bigger changes as part of the AIR memory reworking. Now that time has come and I plan to honor the suggestion in a future commit before merging this branch. * AIR printing: fix missing ')' on alive instructions. We're back to "hello world" working for the x86_64 backend.
2021-07-16 23:06:59 -07:00
else => |cpu_arch| @compileError("Unsupported linux arch: " ++ @tagName(cpu_arch)),
}
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
unreachable;
}
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
};
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn spawn(config: SpawnConfig, comptime f: anytype, args: anytype) !Impl {
runtime page size detection heap.zig: define new default page sizes heap.zig: add min/max_page_size and their options lib/std/c: add miscellaneous declarations heap.zig: add pageSize() and its options switch to new page sizes, especially in GPA/stdlib mem.zig: remove page_size
2024-10-20 14:55:57 -07:00
const page_size = std.heap.pageSize();
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
const Args = @TypeOf(args);
const Instance = struct {
fn_args: Args,
thread: ThreadCompletion,
std.os.windows: Fix some incorrect callconv specifiers. Closes #21869.
2024-11-01 01:06:00 +01:00
fn entryFn(raw_arg: usize) callconv(.c) u8 {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const self = @as(*@This(), @ptrFromInt(raw_arg));
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
defer switch (self.thread.completion.swap(.completed, .seq_cst)) {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.running => {},
.completed => unreachable,
std.Thread: move linux detach code to inline asm
2021-07-01 17:34:23 -05:00
.detached => self.thread.freeAndExit(),
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
};
return callFn(f, self.fn_args);
}
};
var guard_offset: usize = undefined;
var stack_offset: usize = undefined;
var tls_offset: usize = undefined;
var instance_offset: usize = undefined;
const map_bytes = blk: {
std.Thread: insert a missing `@alignCast` stage1 has a missing compile error for this situation.
2022-05-17 15:13:20 -07:00
var bytes: usize = page_size;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
guard_offset = bytes;
migration: std.math.{min, min3, max, max3} -> `@min` & `@max`
2023-06-02 22:02:45 -04:00
bytes += @max(page_size, config.stack_size);
mem: rename align*Generic to mem.align* Anecdote 1: The generic version is way more popular than the non-generic one in Zig codebase: git grep -w alignForward | wc -l 56 git grep -w alignForwardGeneric | wc -l 149 git grep -w alignBackward | wc -l 6 git grep -w alignBackwardGeneric | wc -l 15 Anecdote 2: In my project (turbonss) that does much arithmetic and alignment I exclusively use the Generic functions. Anecdote 3: we used only the Generic versions in the Macho Man's linker workshop.
2023-06-09 16:02:18 -07:00
bytes = std.mem.alignForward(usize, bytes, page_size);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
stack_offset = bytes;
std.os.linux.tls: Refactor and improve documentation. * Elaborate on the sub-variants of Variant I. * Clarify the use of the TCB term. * Rename a bunch of stuff to be more accurate/descriptive. * Follow Zig's style around namespacing more. * Use a structure for the ABI TCB. No functional change intended.
2024-07-23 00:57:25 +02:00
bytes = std.mem.alignForward(usize, bytes, linux.tls.area_desc.alignment);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
tls_offset = bytes;
std.os.linux.tls: Refactor and improve documentation. * Elaborate on the sub-variants of Variant I. * Clarify the use of the TCB term. * Rename a bunch of stuff to be more accurate/descriptive. * Follow Zig's style around namespacing more. * Use a structure for the ABI TCB. No functional change intended.
2024-07-23 00:57:25 +02:00
bytes += linux.tls.area_desc.size;
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
mem: rename align*Generic to mem.align* Anecdote 1: The generic version is way more popular than the non-generic one in Zig codebase: git grep -w alignForward | wc -l 56 git grep -w alignForwardGeneric | wc -l 149 git grep -w alignBackward | wc -l 6 git grep -w alignBackwardGeneric | wc -l 15 Anecdote 2: In my project (turbonss) that does much arithmetic and alignment I exclusively use the Generic functions. Anecdote 3: we used only the Generic versions in the Macho Man's linker workshop.
2023-06-09 16:02:18 -07:00
bytes = std.mem.alignForward(usize, bytes, @alignOf(Instance));
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
instance_offset = bytes;
bytes += @sizeOf(Instance);
mem: rename align*Generic to mem.align* Anecdote 1: The generic version is way more popular than the non-generic one in Zig codebase: git grep -w alignForward | wc -l 56 git grep -w alignForwardGeneric | wc -l 149 git grep -w alignBackward | wc -l 6 git grep -w alignBackwardGeneric | wc -l 15 Anecdote 2: In my project (turbonss) that does much arithmetic and alignment I exclusively use the Generic functions. Anecdote 3: we used only the Generic versions in the Macho Man's linker workshop.
2023-06-09 16:02:18 -07:00
bytes = std.mem.alignForward(usize, bytes, page_size);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
break :blk bytes;
};
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
// map all memory needed without read/write permissions
// to avoid committing the whole region right away
std.os: add missing mmap errors Man page for posix lists EMFILE, man page for linux ENFILE. Also posix says "The mmap() function adds an extra reference to the file associated with the file descriptor fildes which is not removed by a subsequent close() on that file descriptor. This reference is removed when there are no more mappings to the file." It sounds counter-intuitive, that a process limit but no system limit can be exceeeded. As far as I understand, fildes is only used for file descriptor backed mmaps.
2023-03-05 18:41:52 +01:00
// anonymous mapping ensures file descriptor limits are not exceeded
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const mapped = posix.mmap(
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
null,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
map_bytes,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.PROT.NONE,
std.os.linux.MAP: use a packed struct Introduces type safety to this constant. Eliminates one use of `usingnamespace`.
2024-02-06 21:12:11 -07:00
.{ .TYPE = .PRIVATE, .ANONYMOUS = true },
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
-1,
0,
) catch |err| switch (err) {
error.MemoryMappingNotSupported => unreachable,
error.AccessDenied => unreachable,
error.PermissionDenied => unreachable,
std.os: add missing mmap errors Man page for posix lists EMFILE, man page for linux ENFILE. Also posix says "The mmap() function adds an extra reference to the file associated with the file descriptor fildes which is not removed by a subsequent close() on that file descriptor. This reference is removed when there are no more mappings to the file." It sounds counter-intuitive, that a process limit but no system limit can be exceeeded. As far as I understand, fildes is only used for file descriptor backed mmaps.
2023-03-05 18:41:52 +01:00
error.ProcessFdQuotaExceeded => unreachable,
error.SystemFdQuotaExceeded => unreachable,
stdlib: handle EEXIST in mmap with FIXED_NOREPLACE. Fixes #21475
2025-02-22 15:07:44 -05:00
error.MappingAlreadyExists => unreachable,
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
else => |e| return e,
};
std.Thread: fix futex test + thread errors
2021-06-26 09:03:53 -05:00
assert(mapped.len >= map_bytes);
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
errdefer posix.munmap(mapped);
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
// map everything but the guard page as read/write
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.mprotect(
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
@alignCast(mapped[guard_offset..]),
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.PROT.READ | posix.PROT.WRITE,
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
) catch |err| switch (err) {
error.AccessDenied => unreachable,
else => |e| return e,
};
all: rename i386 to x86
2022-10-07 21:24:44 +03:30
// Prepare the TLS segment and prepare a user_desc struct when needed on x86
std.os.linux.tls: Refactor and improve documentation. * Elaborate on the sub-variants of Variant I. * Clarify the use of the TCB term. * Rename a bunch of stuff to be more accurate/descriptive. * Follow Zig's style around namespacing more. * Use a structure for the ABI TCB. No functional change intended.
2024-07-23 00:57:25 +02:00
var tls_ptr = linux.tls.prepareArea(mapped[tls_offset..]);
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
var user_desc: if (target.cpu.arch == .x86) linux.user_desc else void = undefined;
all: rename i386 to x86
2022-10-07 21:24:44 +03:30
if (target.cpu.arch == .x86) {
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
defer tls_ptr = @intFromPtr(&user_desc);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
user_desc = .{
std.os.linux.tls: Refactor and improve documentation. * Elaborate on the sub-variants of Variant I. * Clarify the use of the TCB term. * Rename a bunch of stuff to be more accurate/descriptive. * Follow Zig's style around namespacing more. * Use a structure for the ABI TCB. No functional change intended.
2024-07-23 00:57:25 +02:00
.entry_number = linux.tls.area_desc.gdt_entry_number,
std.Thread: fix tls 9386 linux typo
2021-06-28 14:17:16 -05:00
.base_addr = tls_ptr,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.limit = 0xfffff,
std: cleanup asm usage After fixing some issues with inline assembly in the C backend, the std cleanups have the side effect of making these functions compatible with the backend, allowing it to be used on linux without linking libc.
2023-07-30 03:18:10 -04:00
.flags = .{
.seg_32bit = 1,
.contents = 0, // Data
.read_exec_only = 0,
.limit_in_pages = 1,
.seg_not_present = 0,
.useable = 1,
},
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
};
}
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
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const instance: *Instance = @ptrCast(@alignCast(&mapped[instance_offset]));
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
instance.* = .{
.fn_args = args,
std.Thread: fix some typos
2021-06-20 09:56:30 -05:00
.thread = .{ .mapped = mapped },
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
};
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
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
const flags: u32 = linux.CLONE.THREAD | linux.CLONE.DETACHED |
linux.CLONE.VM | linux.CLONE.FS | linux.CLONE.FILES |
linux.CLONE.PARENT_SETTID | linux.CLONE.CHILD_CLEARTID |
linux.CLONE.SIGHAND | linux.CLONE.SYSVSEM | linux.CLONE.SETTLS;
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
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (linux.E.init(linux.clone(
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
Instance.entryFn,
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
@intFromPtr(&mapped[stack_offset]),
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
flags,
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
@intFromPtr(instance),
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
&instance.thread.parent_tid,
tls_ptr,
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
&instance.thread.child_tid.raw,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
))) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => return Impl{ .thread = &instance.thread },
.AGAIN => return error.ThreadQuotaExceeded,
.INVAL => unreachable,
.NOMEM => return error.SystemResources,
.NOSPC => unreachable,
.PERM => unreachable,
.USERS => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
else => |err| return posix.unexpectedErrno(err),
std.Thread: more typo fixes
2021-06-25 12:59:28 -05:00
}
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
}
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn getHandle(self: Impl) ThreadHandle {
return self.thread.parent_tid;
}
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn detach(self: Impl) void {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
switch (self.thread.completion.swap(.detached, .seq_cst)) {
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
.running => {},
.completed => self.join(),
.detached => unreachable,
}
initial support for haiku sync update * add cpu count * use haiku find_directory * add definitions and exports for building in haiku
2021-01-17 13:29:00 -06:00
}
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
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
fn join(self: Impl) void {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
defer posix.munmap(self.thread.mapped);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
var spin: u8 = 10;
while (true) {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
const tid = self.thread.child_tid.load(.seq_cst);
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
if (tid == 0) {
break;
}
if (spin > 0) {
spin -= 1;
std.atomic.spinLoopHint();
continue;
}
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (linux.E.init(linux.futex_wait(
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
&self.thread.child_tid.raw,
std.os: more reorganization efforts * std lib tests are passing on x86_64-linux with and without -lc * stage2 is building from source on x86_64-linux * down to 38 remaining uses of `usingnamespace`
2021-08-25 00:00:39 -07:00
linux.FUTEX.WAIT,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
tid,
null,
))) {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
.SUCCESS => continue,
.INTR => continue,
.AGAIN => continue,
std.Thread: rewrite + extensions
2021-06-19 17:08:56 -05:00
else => unreachable,
}
}
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
}
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
};
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
fn testThreadName(thread: *Thread) !void {
const testCases = &[_][]const u8{
"mythread",
"b" ** max_name_len,
};
inline for (testCases) |tc| {
try thread.setName(tc);
var name_buffer: [max_name_len:0]u8 = undefined;
const name = try thread.getName(&name_buffer);
if (name) |value| {
try std.testing.expectEqual(tc.len, value.len);
try std.testing.expectEqualStrings(tc, value);
}
}
}
test "setName, getName" {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
if (builtin.single_threaded) return error.SkipZigTest;
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
const Context = struct {
std.Thread: ResetEvent improvements (#11523) * std: start removing redundant ResetEvents * src: fix other uses of std.Thread.ResetEvent * src: add builtin.sanitize_thread for tsan detection * atomic: add Atomic.fence for proper fencing with tsan * Thread: remove the other ResetEvent's and rewrite the current one * Thread: ResetEvent docs * zig fmt + WaitGroup.reset() fix * src: fix build issues for ResetEvent + tsan * Thread: ResetEvent tests * Thread: ResetEvent module doc * Atomic: replace llvm *p memory constraint with *m * panicking: handle spurious wakeups in futex.wait() when waiting for abort() * zig fmt
2022-04-26 16:48:56 -05:00
start_wait_event: ResetEvent = .{},
test_done_event: ResetEvent = .{},
thread_done_event: ResetEvent = .{},
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
done: std.atomic.Value(bool) = std.atomic.Value(bool).init(false),
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
thread: Thread = undefined,
pub fn run(ctx: *@This()) !void {
// Wait for the main thread to have set the thread field in the context.
ctx.start_wait_event.wait();
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (native_os) {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
.windows => testThreadName(&ctx.thread) catch |err| switch (err) {
error.Unsupported => return error.SkipZigTest,
else => return err,
},
else => try testThreadName(&ctx.thread),
}
// Signal our test is done
ctx.test_done_event.set();
std.Thread: ResetEvent improvements (#11523) * std: start removing redundant ResetEvents * src: fix other uses of std.Thread.ResetEvent * src: add builtin.sanitize_thread for tsan detection * atomic: add Atomic.fence for proper fencing with tsan * Thread: remove the other ResetEvent's and rewrite the current one * Thread: ResetEvent docs * zig fmt + WaitGroup.reset() fix * src: fix build issues for ResetEvent + tsan * Thread: ResetEvent tests * Thread: ResetEvent module doc * Atomic: replace llvm *p memory constraint with *m * panicking: handle spurious wakeups in futex.wait() when waiting for abort() * zig fmt
2022-04-26 16:48:56 -05:00
// wait for the thread to property exit
ctx.thread_done_event.wait();
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
}
};
var context = Context{};
var thread = try spawn(.{}, Context.run, .{&context});
std.Thread: ResetEvent improvements (#11523) * std: start removing redundant ResetEvents * src: fix other uses of std.Thread.ResetEvent * src: add builtin.sanitize_thread for tsan detection * atomic: add Atomic.fence for proper fencing with tsan * Thread: remove the other ResetEvent's and rewrite the current one * Thread: ResetEvent docs * zig fmt + WaitGroup.reset() fix * src: fix build issues for ResetEvent + tsan * Thread: ResetEvent tests * Thread: ResetEvent module doc * Atomic: replace llvm *p memory constraint with *m * panicking: handle spurious wakeups in futex.wait() when waiting for abort() * zig fmt
2022-04-26 16:48:56 -05:00
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
context.thread = thread;
context.start_wait_event.set();
context.test_done_event.wait();
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
switch (native_os) {
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => {
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
const res = thread.setName("foobar");
try std.testing.expectError(error.Unsupported, res);
},
.windows => testThreadName(&thread) catch |err| switch (err) {
error.Unsupported => return error.SkipZigTest,
else => return err,
},
std.Thread: use pthread_getname_np on musl Starting with version 1.2.3, musl now supports pthread_getname_np: https://github.com/bminor/musl/blob/7a43f6fea9081bdd53d8a11cef9e9fab0348c53d/WHATSNEW#L2293-L2329
2023-02-24 20:58:36 +01:00
else => try testThreadName(&thread),
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
}
std.Thread: ResetEvent improvements (#11523) * std: start removing redundant ResetEvents * src: fix other uses of std.Thread.ResetEvent * src: add builtin.sanitize_thread for tsan detection * atomic: add Atomic.fence for proper fencing with tsan * Thread: remove the other ResetEvent's and rewrite the current one * Thread: ResetEvent docs * zig fmt + WaitGroup.reset() fix * src: fix build issues for ResetEvent + tsan * Thread: ResetEvent tests * Thread: ResetEvent module doc * Atomic: replace llvm *p memory constraint with *m * panicking: handle spurious wakeups in futex.wait() when waiting for abort() * zig fmt
2022-04-26 16:48:56 -05:00
context.thread_done_event.set();
thread: implement setName/getName
2021-04-21 10:59:36 +02:00
thread.join();
}
std: remove names from incorrectly named tests Tests that only reference decls for the purpose of analyzing more tests should be unnamed, otherwise trying to filter for just a referenced test can become impossible depending on the names.
2023-04-21 20:46:05 -04:00
test {
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
// Doesn't use testing.refAllDecls() since that would pull in the compileError spinLoopHint.
_ = Futex;
_ = ResetEvent;
_ = Mutex;
_ = Semaphore;
_ = Condition;
Fix counting in SingleThreadedRwLock's tryLockShared (#16560) Additionally we add RwLock to Thread.zig's list of tests
2023-07-26 06:19:52 -07:00
_ = RwLock;
test: Add `spawn` behavior test
2024-07-09 11:25:19 +09:00
_ = Pool;
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
}
fn testIncrementNotify(value: *usize, event: *ResetEvent) void {
value.* += 1;
event.set();
}
Change many test blocks to doctests/decltests
2024-02-26 15:14:43 -08:00
test join {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
if (builtin.single_threaded) return error.SkipZigTest;
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
var value: usize = 0;
std.Thread: ResetEvent improvements (#11523) * std: start removing redundant ResetEvents * src: fix other uses of std.Thread.ResetEvent * src: add builtin.sanitize_thread for tsan detection * atomic: add Atomic.fence for proper fencing with tsan * Thread: remove the other ResetEvent's and rewrite the current one * Thread: ResetEvent docs * zig fmt + WaitGroup.reset() fix * src: fix build issues for ResetEvent + tsan * Thread: ResetEvent tests * Thread: ResetEvent module doc * Atomic: replace llvm *p memory constraint with *m * panicking: handle spurious wakeups in futex.wait() when waiting for abort() * zig fmt
2022-04-26 16:48:56 -05:00
var event = ResetEvent{};
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
zig fmt
2021-06-30 21:49:38 -05:00
const thread = try Thread.spawn(.{}, testIncrementNotify, .{ &value, &event });
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
thread.join();
try std.testing.expectEqual(value, 1);
}
Change many test blocks to doctests/decltests
2024-02-26 15:14:43 -08:00
test detach {
std: [breaking] move errno to become an nonexhaustive enum The primary purpose of this change is to eliminate one usage of `usingnamespace` in the standard library - specifically the usage for errno values in `std.os.linux`. This is accomplished by truncating the `E` prefix from error values, and making errno a proper enum. A similar strategy can be used to eliminate some other `usingnamespace` sites in the std lib.
2021-08-23 17:06:56 -07:00
if (builtin.single_threaded) return error.SkipZigTest;
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
var value: usize = 0;
std.Thread: ResetEvent improvements (#11523) * std: start removing redundant ResetEvents * src: fix other uses of std.Thread.ResetEvent * src: add builtin.sanitize_thread for tsan detection * atomic: add Atomic.fence for proper fencing with tsan * Thread: remove the other ResetEvent's and rewrite the current one * Thread: ResetEvent docs * zig fmt + WaitGroup.reset() fix * src: fix build issues for ResetEvent + tsan * Thread: ResetEvent tests * Thread: ResetEvent module doc * Atomic: replace llvm *p memory constraint with *m * panicking: handle spurious wakeups in futex.wait() when waiting for abort() * zig fmt
2022-04-26 16:48:56 -05:00
var event = ResetEvent{};
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
zig fmt
2021-06-30 21:49:38 -05:00
const thread = try Thread.spawn(.{}, testIncrementNotify, .{ &value, &event });
std.Thread: more cleanup & testing
2021-06-28 11:27:23 -05:00
thread.detach();
event.wait();
try std.testing.expectEqual(value, 1);
zig fmt
2021-06-30 21:49:38 -05:00
}
Reference in New Issue Copy Permalink