| Age | Commit message (Collapse) | Author |
|---|
|
`static const` variables can be computed and initialized at run-time
during initialization or the first time a function is called. Change
them to `static constexpr` to ensure they are computed at
compile-time.
This allows some removal of `strlen` because the length of the
`StringView` can be used which is pre-computed at compile-time.
|
|
This makes the _multiprocessing module from the Python port build. :^)
|
|
This reverts commit 5d51e26caff61516d6fcf612c2e9ba72a82b699f.
The threadlocal Vector was somehow misaligned, causing UBSAN to be sad
about calling a misaligned method (either the dtor or .is_empty()) on
it.
For now, let's revert this and avoid the CI flake.
Fixes #12957.
|
|
These are also supposed to run on cancellation, but we don't support
cancellation.
|
|
This is just the expected return value of pthread_join() when it fails.
|
|
NoAllocationGuard is an RAII stack guard that prevents allocations
while it exists. This is done through a thread-local global flag which
causes malloc to crash on a VERIFY if it is false. The guard allows for
recursion.
The intended use case for this class is in real-time audio code. In such
code, allocations are really bad, and this is an easy way of dynamically
enforcing the no-allocations rule while giving the user good feedback if
it is violated. Before real-time audio code is executed, e.g. in LibDSP,
a NoAllocationGuard is instantiated. This is not done with this commit,
as currently some code in LibDSP may still incorrectly allocate in real-
time situations.
Other use cases for the Kernel have also been added, so this commit
builds on the previous to add the support both in Userland and in the
Kernel.
|
|
|
|
I noticed this was missing while adding spec comments a bit ago.
It's small and easy enough to implement, might as well make us
more POSIX compliant.
|
|
I had somehow incorrectly added this link in a previous check-in.
Reported-by: Nico Weber <thakis@chromium.org>
|
|
|
|
|
|
|
|
|
|
|
|
All the way back in commit 1670ee5aba09, the default clock for
condition variables was set to `CLOCK_MONOTONIC`, because there was no
other clock available.
However, if a condition variable is initialized without any additional
attributes by an application, they sometimes assume that the absolute
time that is passed to e.g. `pthread_cond_timedwait` is actually based
on a realtime clock, as can be seen here in SDL2:
https://github.com/SerenityPorts/SDL/blob/6f419bdf5f56be236c070a9d364e0d238b868565/src/thread/pthread/SDL_syscond.c#L99
Additionally, the glibc implementation defaults to a realtime clock:
https://github.com/bminor/glibc/blob/aac54dcd378209bbdddbcec749561b1d8f167d11/nptl/pthread_cond_init.c#L42
...so we probably should do so as well :^)
|
|
The loop should terminate after the exchange happens, we shouldn't
repeat the operation until the count hits zero.
Fixes #10241.
|
|
The previous version was putting the old count in the control bits,
which is all kinds of wrong.
|
|
We only ever use private futexes, so it doesn't make sense to carry
around all the complexity required for global (cross-process) futexes.
|
|
|
|
Performance go brrrrr
|
|
|
|
It would be enough to use relaxed ordering here if it weren't for
the mutex, which we also need to store and retrieve. To ensure the
pthread_cond_broadcast() call sees the store, use release and acquire
as appropriate. Thankfully, both of these are on the slow paths.
|
|
This is a common but non-standard way of initializing a pthread_mutex_t
in recursive mode.
|
|
This implementation does not use locking or condition variables
internally; it's purely based on atomics and futexes.
Notably, concurrent sem_wait() and sem_post() calls can run *completely
in parallel* without slowing each other down, as long as there are empty
slots for them all to succeed without blocking.
Additionally, sem_wait() never executes an atomic operation with release
ordering, and sem_post() never executes an atomic operation with acquire
ordering (unless you count the syscall). This means the compiler and the
hardware are free to reorder code *into* the critical section.
|
|
This implementation features a fast path for pthread_cond_signal() and
pthread_cond_broadcast() for the case there's no thread waiting, and
does not exhibit the "thundering herd" issue in
pthread_cond_broadcast().
Fixes https://github.com/SerenityOS/serenity/issues/8432
|
|
These are convinient wrappers over the most used futex operations.
futex_wait() also does some smarts for timeout and clock handling.
Use the new futex_wait() instead of a similar private helper in
LibPthread.
|
|
This is not technically a toolchain change, but it does require
rebuilding the toolchain for x86_64 (and just that).
|
|
|
|
|
|
They're not yet properly supported.
|
|
The pthread_exit() function doesn't return and is marked as such.
|
|
This enables building more of the userspace applications for x86_64.
|
|
|
|
This adds two new arguments to the thread_exit system call which let
a thread unmap an arbitrary VM range on thread exit. LibPthread
uses this functionality to unmap the thread stack.
Fixes #7267.
|
|
|
|
This reverts commit 800ea8ea969835297dc7e7da345a45b9dc5e751a.
Booting the system no longer worked after these changes.
|
|
Problem:
- `static` variables consume memory and sometimes are less
optimizable.
- `static const` variables can be `constexpr`, usually.
- `static` function-local variables require an initialization check
every time the function is run.
Solution:
- If a global `static` variable is only used in a single function then
move it into the function and make it non-`static` and `constexpr`.
- Make all global `static` variables `constexpr` instead of `const`.
- Change function-local `static const[expr]` variables to be just
`constexpr`.
|
|
|
|
POSIX does not mandate this, therefore let's not do it.
|
|
With those partially implemented I can start to clone the SerenityOS
git repository via HTTPS.
The download still fails half-way through because SSL_read returns
an error for reasons I haven't investigated yet.
|
|
|
|
This change implements the pthread user space spinlock API. The
stress-ng Port requires a functioning version to work correctly.
To facilitate the requirements of the posix specification for the API
we implement the spinlock so that the owning tid is the value stored
in the spinlock. This gives us the proper ownership semantics needed
to implement the proper error handling.
|
|
If we get an absolute time passed to one of the pthread_*wait methods,
this is not an absolute monotonic time but rather an absolute wall
time. This means that we also need to pass FUTEX_CLOCK_REALTIME to the
futex syscall to ensure we're not using the monotonic clock.
|
|
Let's move this to LibC because the dynamic loader depends
on this function.
|
|
SPDX License Identifiers are a more compact / standardized
way of representing file license information.
See: https://spdx.dev/resources/use/#identifiers
This was done with the `ambr` search and replace tool.
ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
|
|
Standard: https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_attr_getscope.html
Needed for https://fio.readthedocs.io
|
|
The stress-ng port depends on these now that it detects we have
thread support.
|
|
GCC will insert various calls to pthread functions when compiling
C++ code with static initializers, even when the user doesn't link
their program against libpthread explicitly.
This is used to make static initializers thread-safe, e.g. when
building a library that does not itself use thread functionality
and thus does not link against libpthread - but is intended to
be used with other code that does use libpthread explicitly.
This makes these symbols available in libc.
|
|
The stubs are necessary to make the xz port properly detect pthread
support. The two functions are only used in the configure script and
nowhere else.
|
|
This ensures that __thread variables can be used when global destructors
are being invoked.
|
