mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-02-25 07:19:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
cosmopolitan/libc/testlib/manystack.c

70 lines
3 KiB
C
Raw Normal View History

Make mutex calling code 10x tinier Calls to lock/unlock functions are now NOPs by default. The first time clone() is called, they get turned into CALL instructions. Doing this caused funcctions like fputc() to shrink from 85 bytes to 45+4 bytes. Since the ANSI solution of `(__threaded && lock())` inlines os much superfluous binary content into functions all over the place.
2022-06-12 19:33:42 -07:00
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
flip et / noet in modelines `et` means `expandtab`. ```sh rg 'vi: .* :vi' -l -0 | \ xargs -0 sed -i '' 's/vi: \(.*\) et\(.*\) :vi/vi: \1 xoet\2:vi/' rg 'vi: .* :vi' -l -0 | \ xargs -0 sed -i '' 's/vi: \(.*\)noet\(.*\):vi/vi: \1et\2 :vi/' rg 'vi: .* :vi' -l -0 | \ xargs -0 sed -i '' 's/vi: \(.*\)xoet\(.*\):vi/vi: \1noet\2:vi/' ```
2023-12-07 22:11:56 -05:00
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
Reduce makefile dependencies by 10% The includes in libc/calls/calls.h have now been refactored so that functions with struct parameters are declared in libc/calls/struct/
2022-06-08 20:01:28 -07:00
╞══════════════════════════════════════════════════════════════════════════════╡
Make threads faster and more reliable This change doubles the performance of thread spawning. That's thanks to our new stack manager, which allows us to avoid zeroing stacks. It gives us 15µs spawns rather than 30µs spawns on Linux. Also, pthread_exit() is faster now, since it doesn't need to acquire the pthread GIL. On NetBSD, that helps us avoid allocating too many semaphores. Even if that happens we're now able to survive semaphores running out and even memory running out, when allocating *NSYNC waiter objects. I found a lot more rare bugs in the POSIX threads runtime that could cause things to crash, if you've got dozens of threads all spawning and joining dozens of threads. I want cosmo to be world class production worthy for 2025 so happy holidays all
2024-12-18 04:59:02 -08:00
│ Copyright 2024 Justine Alexandra Roberts Tunney │
Reduce makefile dependencies by 10% The includes in libc/calls/calls.h have now been refactored so that functions with struct parameters are declared in libc/calls/struct/
2022-06-08 20:01:28 -07:00
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
Make threads faster and more reliable This change doubles the performance of thread spawning. That's thanks to our new stack manager, which allows us to avoid zeroing stacks. It gives us 15µs spawns rather than 30µs spawns on Linux. Also, pthread_exit() is faster now, since it doesn't need to acquire the pthread GIL. On NetBSD, that helps us avoid allocating too many semaphores. Even if that happens we're now able to survive semaphores running out and even memory running out, when allocating *NSYNC waiter objects. I found a lot more rare bugs in the POSIX threads runtime that could cause things to crash, if you've got dozens of threads all spawning and joining dozens of threads. I want cosmo to be world class production worthy for 2025 so happy holidays all
2024-12-18 04:59:02 -08:00
#include "libc/testlib/manystack.h"
#include "libc/atomic.h"
#include "libc/calls/struct/sigaction.h"
#include "libc/calls/struct/sigset.h"
#include "libc/intrin/dll.h"
#include "libc/sysv/consts/sig.h"
#include "libc/thread/posixthread.internal.h"
Reduce makefile dependencies by 10% The includes in libc/calls/calls.h have now been refactored so that functions with struct parameters are declared in libc/calls/struct/
2022-06-08 20:01:28 -07:00
Make threads faster and more reliable This change doubles the performance of thread spawning. That's thanks to our new stack manager, which allows us to avoid zeroing stacks. It gives us 15µs spawns rather than 30µs spawns on Linux. Also, pthread_exit() is faster now, since it doesn't need to acquire the pthread GIL. On NetBSD, that helps us avoid allocating too many semaphores. Even if that happens we're now able to survive semaphores running out and even memory running out, when allocating *NSYNC waiter objects. I found a lot more rare bugs in the POSIX threads runtime that could cause things to crash, if you've got dozens of threads all spawning and joining dozens of threads. I want cosmo to be world class production worthy for 2025 so happy holidays all
2024-12-18 04:59:02 -08:00
static atomic_int manystack_gotsig;
static atomic_bool manystack_shutdown;
static void manystack_signal(int sig) {
manystack_gotsig = sig;
}
static void *manystack_thread(void *arg) {
sigset_t ss;
sigfillset(&ss);
sigdelset(&ss, SIGUSR2);
while (!manystack_shutdown) {
sigsuspend(&ss);
if (!manystack_shutdown) {
_pthread_lock();
for (struct Dll *e = dll_first(_pthread_list); e;
e = dll_next(_pthread_list, e)) {
pthread_t th = (pthread_t)POSIXTHREAD_CONTAINER(e);
if (!pthread_equal(th, pthread_self()))
pthread_kill(th, SIGQUIT);
}
_pthread_unlock();
}
Introduce pthread_condattr_setclock() This is one of the few POSIX APIs that was missing. It lets you choose a monotonic clock for your condition variables. This might improve perf on some platforms. It might also grant more flexibility with NTP configs. I know Qt is one project that believes it needs this. To introduce this, I needed to change some the *NSYNC APIs, to support passing a clock param. There's also new benchmarks, demonstrating Cosmopolitan's supremacy over many libc implementations when it comes to mutex performance. Cygwin has an alarmingly bad pthread_mutex_t implementation. It is so bad that they would have been significantly better off if they'd used naive spinlocks.
2024-09-02 23:37:50 -07:00
}
Add pthread attributes and other libc functions
2022-09-07 05:23:44 -07:00
return 0;
Make mutex calling code 10x tinier Calls to lock/unlock functions are now NOPs by default. The first time clone() is called, they get turned into CALL instructions. Doing this caused funcctions like fputc() to shrink from 85 bytes to 45+4 bytes. Since the ANSI solution of `(__threaded && lock())` inlines os much superfluous binary content into functions all over the place.
2022-06-12 19:33:42 -07:00
}
Make threads faster and more reliable This change doubles the performance of thread spawning. That's thanks to our new stack manager, which allows us to avoid zeroing stacks. It gives us 15µs spawns rather than 30µs spawns on Linux. Also, pthread_exit() is faster now, since it doesn't need to acquire the pthread GIL. On NetBSD, that helps us avoid allocating too many semaphores. Even if that happens we're now able to survive semaphores running out and even memory running out, when allocating *NSYNC waiter objects. I found a lot more rare bugs in the POSIX threads runtime that could cause things to crash, if you've got dozens of threads all spawning and joining dozens of threads. I want cosmo to be world class production worthy for 2025 so happy holidays all
2024-12-18 04:59:02 -08:00
pthread_t manystack_start(void) {
sigset_t ss;
pthread_t msh;
sigemptyset(&ss);
sigaddset(&ss, SIGUSR2);
sigprocmask(SIG_BLOCK, &ss, 0);
signal(SIGUSR2, manystack_signal);
pthread_create(&msh, 0, manystack_thread, 0);
return msh;
}
void manystack_stop(pthread_t msh) {
manystack_shutdown = true;
pthread_kill(msh, SIGUSR2);
pthread_join(msh, 0);
}
Reference in a new issue Copy permalink