mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
0a24b4fc3c
The *NSYNC linked list API is good enough that it deserves to be part of the C libray, so this change writes an improved version of it which uses that offsetof() trick from the Linux Kernel. We vendor all of the *NSYNC tests in third_party which helped confirm the needed refactoring is safe This change also deletes more old code that didn't pan out. My goal here is to work towards a vision where the Cosmopolitan core libraries become less experimental and more focused on curation. This better reflects the current level of quality we've managed to achieve.
125 lines
5.1 KiB
C
125 lines
5.1 KiB
C
/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set et ft=c ts=8 tw=8 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2016 Google Inc. │
|
|
│ │
|
|
│ Licensed under the Apache License, Version 2.0 (the "License"); │
|
|
│ you may not use this file except in compliance with the License. │
|
|
│ You may obtain a copy of the License at │
|
|
│ │
|
|
│ http://www.apache.org/licenses/LICENSE-2.0 │
|
|
│ │
|
|
│ Unless required by applicable law or agreed to in writing, software │
|
|
│ distributed under the License is distributed on an "AS IS" BASIS, │
|
|
│ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. │
|
|
│ See the License for the specific language governing permissions and │
|
|
│ limitations under the License. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "libc/assert.h"
|
|
#include "libc/errno.h"
|
|
#include "libc/str/str.h"
|
|
#include "libc/thread/thread.h"
|
|
#include "third_party/nsync/atomic.h"
|
|
#include "third_party/nsync/atomic.internal.h"
|
|
#include "third_party/nsync/futex.internal.h"
|
|
#include "third_party/nsync/mu_semaphore.internal.h"
|
|
// clang-format off
|
|
|
|
/**
|
|
* @fileoverview Semaphores w/ Linux Futexes API.
|
|
*/
|
|
|
|
#define ASSERT(x) _npassert(x)
|
|
|
|
/* Check that atomic operations on nsync_atomic_uint32_ can be applied to int. */
|
|
static const int assert_int_size = 1 /
|
|
(sizeof (assert_int_size) == sizeof (uint32_t) &&
|
|
sizeof (nsync_atomic_uint32_) == sizeof (uint32_t));
|
|
|
|
struct futex {
|
|
int i; /* lo half=count; hi half=waiter count */
|
|
};
|
|
|
|
static nsync_semaphore *sem_big_enough_for_futex = (nsync_semaphore *) (uintptr_t)(1 /
|
|
(sizeof (struct futex) <= sizeof (*sem_big_enough_for_futex)));
|
|
|
|
/* Initialize *s; the initial value is 0. */
|
|
void nsync_mu_semaphore_init_futex (nsync_semaphore *s) {
|
|
struct futex *f = (struct futex *) s;
|
|
f->i = 0;
|
|
}
|
|
|
|
/* Wait until the count of *s exceeds 0, and decrement it. */
|
|
errno_t nsync_mu_semaphore_p_futex (nsync_semaphore *s) {
|
|
struct futex *f = (struct futex *) s;
|
|
int e, i;
|
|
errno_t result = 0;
|
|
do {
|
|
i = ATM_LOAD ((nsync_atomic_uint32_ *) &f->i);
|
|
if (i == 0) {
|
|
int futex_result;
|
|
futex_result = -nsync_futex_wait_ (
|
|
(atomic_int *)&f->i, i,
|
|
PTHREAD_PROCESS_PRIVATE, 0);
|
|
ASSERT (futex_result == 0 ||
|
|
futex_result == EINTR ||
|
|
futex_result == EAGAIN ||
|
|
futex_result == ECANCELED ||
|
|
futex_result == EWOULDBLOCK);
|
|
if (futex_result == ECANCELED) {
|
|
result = ECANCELED;
|
|
}
|
|
}
|
|
} while (result == 0 && (i == 0 || !ATM_CAS_ACQ ((nsync_atomic_uint32_ *) &f->i, i, i-1)));
|
|
return result;
|
|
}
|
|
|
|
/* Wait until one of:
|
|
the count of *s is non-zero, in which case decrement *s and return 0;
|
|
or abs_deadline expires, in which case return ETIMEDOUT. */
|
|
errno_t nsync_mu_semaphore_p_with_deadline_futex (nsync_semaphore *s, nsync_time abs_deadline) {
|
|
struct futex *f = (struct futex *)s;
|
|
int e, i;
|
|
int result = 0;
|
|
do {
|
|
i = ATM_LOAD ((nsync_atomic_uint32_ *) &f->i);
|
|
if (i == 0) {
|
|
int futex_result;
|
|
struct timespec ts_buf;
|
|
const struct timespec *ts = NULL;
|
|
if (nsync_time_cmp (abs_deadline, nsync_time_no_deadline) != 0) {
|
|
bzero (&ts_buf, sizeof (ts_buf));
|
|
ts_buf.tv_sec = NSYNC_TIME_SEC (abs_deadline);
|
|
ts_buf.tv_nsec = NSYNC_TIME_NSEC (abs_deadline);
|
|
ts = &ts_buf;
|
|
}
|
|
futex_result = nsync_futex_wait_ ((atomic_int *)&f->i, i,
|
|
PTHREAD_PROCESS_PRIVATE, ts);
|
|
ASSERT (futex_result == 0 ||
|
|
futex_result == -EINTR ||
|
|
futex_result == -EAGAIN ||
|
|
futex_result == -ECANCELED ||
|
|
futex_result == -ETIMEDOUT ||
|
|
futex_result == -EWOULDBLOCK);
|
|
/* Some systems don't wait as long as they are told. */
|
|
if (futex_result == -ETIMEDOUT &&
|
|
nsync_time_cmp (abs_deadline, nsync_time_now ()) <= 0) {
|
|
result = ETIMEDOUT;
|
|
}
|
|
if (futex_result == -ECANCELED) {
|
|
result = ECANCELED;
|
|
}
|
|
}
|
|
} while (result == 0 && (i == 0 || !ATM_CAS_ACQ ((nsync_atomic_uint32_ *) &f->i, i, i - 1)));
|
|
return (result);
|
|
}
|
|
|
|
/* Ensure that the count of *s is at least 1. */
|
|
void nsync_mu_semaphore_v_futex (nsync_semaphore *s) {
|
|
struct futex *f = (struct futex *) s;
|
|
uint32_t old_value;
|
|
do {
|
|
old_value = ATM_LOAD ((nsync_atomic_uint32_ *) &f->i);
|
|
} while (!ATM_CAS_REL ((nsync_atomic_uint32_ *) &f->i, old_value, old_value+1));
|
|
ASSERT (nsync_futex_wake_ ((atomic_int *)&f->i, 1, PTHREAD_PROCESS_PRIVATE) >= 0);
|
|
}
|