From 62fc55fc7485783ee7af6f62567065f38af1972c Mon Sep 17 00:00:00 2001 From: Calvin Rose Date: Fri, 17 Jun 2022 17:13:58 -0500 Subject: [PATCH] Remove pthread.h from janet.h Should make janet a bit easier to use. Also changes the header to not expose the size of native mutexes and rwlocks, except with janet_os_mutex_size and janet_os_rwlock_size. --- src/boot/boot.janet | 1 + src/core/abstract.c | 37 ++++++++++++++++++++-------- src/core/ev.c | 60 ++++++++++++++++++++------------------------- src/core/pp.c | 5 ++-- src/core/util.h | 4 +++ src/include/janet.h | 47 ++++++++--------------------------- 6 files changed, 72 insertions(+), 82 deletions(-) diff --git a/src/boot/boot.janet b/src/boot/boot.janet index e3a5d2b5..cef6b613 100644 --- a/src/boot/boot.janet +++ b/src/boot/boot.janet @@ -45,6 +45,7 @@ (defn defmacro :macro "Define a macro." [name & more] + (setdyn name @{}) # override old macro definitions in the case of a recursive macro (apply defn name :macro more)) (defmacro as-macro diff --git a/src/core/abstract.c b/src/core/abstract.c index ba2e0cf5..1e218efb 100644 --- a/src/core/abstract.c +++ b/src/core/abstract.c @@ -23,6 +23,7 @@ #ifndef JANET_AMALG #include "features.h" #include +#include "util.h" #include "gc.h" #include "state.h" #ifdef JANET_EV @@ -85,6 +86,14 @@ void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) { #ifdef JANET_WINDOWS +void janet_os_mutex_size(void) { + return sizeof(CRITICAL_SECTION); +} + +void janet_os_rwlock_size(void) { + return sizeof(SRWLock); +} + static int32_t janet_incref(JanetAbstractHead *ab) { return InterlockedIncrement(&ab->gc.data.refcount); } @@ -137,6 +146,14 @@ void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) { #else +size_t janet_os_mutex_size(void) { + return sizeof(pthread_mutex_t); +} + +size_t janet_os_rwlock_size(void) { + return sizeof(pthread_rwlock_t); +} + static int32_t janet_incref(JanetAbstractHead *ab) { return __atomic_add_fetch(&ab->gc.data.refcount, 1, __ATOMIC_RELAXED); } @@ -149,44 +166,44 @@ void janet_os_mutex_init(JanetOSMutex *mutex) { pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); - pthread_mutex_init(mutex, &attr); + pthread_mutex_init((pthread_mutex_t *) mutex, &attr); } void janet_os_mutex_deinit(JanetOSMutex *mutex) { - pthread_mutex_destroy(mutex); + pthread_mutex_destroy((pthread_mutex_t *) mutex); } void janet_os_mutex_lock(JanetOSMutex *mutex) { - pthread_mutex_lock(mutex); + pthread_mutex_lock((pthread_mutex_t *) mutex); } void janet_os_mutex_unlock(JanetOSMutex *mutex) { - int ret = pthread_mutex_unlock(mutex); + int ret = pthread_mutex_unlock((pthread_mutex_t *) mutex); if (ret) janet_panic("cannot release lock"); } void janet_os_rwlock_init(JanetOSRWLock *rwlock) { - pthread_rwlock_init(rwlock, NULL); + pthread_rwlock_init((pthread_rwlock_t *) rwlock, NULL); } void janet_os_rwlock_deinit(JanetOSRWLock *rwlock) { - pthread_rwlock_destroy(rwlock); + pthread_rwlock_destroy((pthread_rwlock_t *) rwlock); } void janet_os_rwlock_rlock(JanetOSRWLock *rwlock) { - pthread_rwlock_rdlock(rwlock); + pthread_rwlock_rdlock((pthread_rwlock_t *) rwlock); } void janet_os_rwlock_wlock(JanetOSRWLock *rwlock) { - pthread_rwlock_wrlock(rwlock); + pthread_rwlock_wrlock((pthread_rwlock_t *) rwlock); } void janet_os_rwlock_runlock(JanetOSRWLock *rwlock) { - pthread_rwlock_unlock(rwlock); + pthread_rwlock_unlock((pthread_rwlock_t *) rwlock); } void janet_os_rwlock_wunlock(JanetOSRWLock *rwlock) { - pthread_rwlock_unlock(rwlock); + pthread_rwlock_unlock((pthread_rwlock_t *) rwlock); } #endif diff --git a/src/core/ev.c b/src/core/ev.c index 00a1eb29..6e41131e 100644 --- a/src/core/ev.c +++ b/src/core/ev.c @@ -79,7 +79,11 @@ typedef struct { int32_t limit; int closed; int is_threaded; - JanetOSMutex lock; +#ifdef JANET_WINDOWS + CRITICAL_SECTION lock; +#else + pthread_mutex_t lock; +#endif } JanetChannel; typedef struct { @@ -643,7 +647,7 @@ static void janet_chan_init(JanetChannel *chan, int32_t limit, int threaded) { janet_q_init(&chan->items); janet_q_init(&chan->read_pending); janet_q_init(&chan->write_pending); - janet_os_mutex_init(&chan->lock); + janet_os_mutex_init((JanetOSMutex *) &chan->lock); } static void janet_chan_deinit(JanetChannel *chan) { @@ -656,17 +660,17 @@ static void janet_chan_deinit(JanetChannel *chan) { } } janet_q_deinit(&chan->items); - janet_os_mutex_deinit(&chan->lock); + janet_os_mutex_deinit((JanetOSMutex *) &chan->lock); } static void janet_chan_lock(JanetChannel *chan) { if (!janet_chan_is_threaded(chan)) return; - janet_os_mutex_lock(&chan->lock); + janet_os_mutex_lock((JanetOSMutex *) &chan->lock); } static void janet_chan_unlock(JanetChannel *chan) { if (!janet_chan_is_threaded(chan)) return; - janet_os_mutex_unlock(&chan->lock); + janet_os_mutex_unlock((JanetOSMutex *) &chan->lock); } /* @@ -3013,14 +3017,9 @@ JANET_CORE_FN(janet_cfun_stream_write, janet_await(); } -typedef struct { - JanetOSMutex mutex; -} JanetAbstractMutex; - static int mutexgc(void *p, size_t size) { - JanetAbstractMutex *mutex = (JanetAbstractMutex *) p; (void) size; - janet_os_mutex_deinit(&mutex->mutex); + janet_os_mutex_deinit(p); return 0; } @@ -3035,8 +3034,8 @@ JANET_CORE_FN(janet_cfun_mutex, "Create a new lock to coordinate threads.") { janet_fixarity(argc, 0); (void) argv; - JanetAbstractMutex *mutex = janet_abstract_threaded(&janet_mutex_type, sizeof(JanetAbstractMutex)); - janet_os_mutex_init(&mutex->mutex); + void *mutex = janet_abstract_threaded(&janet_mutex_type, janet_os_mutex_size()); + janet_os_mutex_init(mutex); return janet_wrap_abstract(mutex); } @@ -3046,8 +3045,8 @@ JANET_CORE_FN(janet_cfun_mutex_acquire, " This will block this entire thread until the lock becomes available, and will not yield to other fibers " "on this system thread.") { janet_fixarity(argc, 1); - JanetAbstractMutex *mutex = janet_getabstract(argv, 0, &janet_mutex_type); - janet_os_mutex_lock(&mutex->mutex); + void *mutex = janet_getabstract(argv, 0, &janet_mutex_type); + janet_os_mutex_lock(mutex); return argv[0]; } @@ -3055,19 +3054,14 @@ JANET_CORE_FN(janet_cfun_mutex_release, "(ev/release-lock lock)", "Release a lock such that other threads may acquire it.") { janet_fixarity(argc, 1); - JanetAbstractMutex *mutex = janet_getabstract(argv, 0, &janet_mutex_type); - janet_os_mutex_unlock(&mutex->mutex); + void *mutex = janet_getabstract(argv, 0, &janet_mutex_type); + janet_os_mutex_unlock(mutex); return argv[0]; } -typedef struct { - JanetOSRWLock rwlock; -} JanetAbstractRWLock; - static int rwlockgc(void *p, size_t size) { - JanetAbstractRWLock *rwlock = (JanetAbstractRWLock *) p; (void) size; - janet_os_rwlock_deinit(&rwlock->rwlock); + janet_os_rwlock_deinit(p); return 0; } @@ -3082,8 +3076,8 @@ JANET_CORE_FN(janet_cfun_rwlock, "Create a new read-write lock to coordinate threads.") { janet_fixarity(argc, 0); (void) argv; - JanetAbstractRWLock *rwlock = janet_abstract_threaded(&janet_rwlock_type, sizeof(JanetAbstractRWLock)); - janet_os_rwlock_init(&rwlock->rwlock); + void *rwlock = janet_abstract_threaded(&janet_rwlock_type, janet_os_rwlock_size()); + janet_os_rwlock_init(rwlock); return janet_wrap_abstract(rwlock); } @@ -3091,8 +3085,8 @@ JANET_CORE_FN(janet_cfun_rwlock_read_lock, "(ev/acquire-rlock rwlock)", "Acquire a read lock an a read-write lock.") { janet_fixarity(argc, 1); - JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); - janet_os_rwlock_rlock(&rwlock->rwlock); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_rlock(rwlock); return argv[0]; } @@ -3100,8 +3094,8 @@ JANET_CORE_FN(janet_cfun_rwlock_write_lock, "(ev/acquire-wlock rwlock)", "Acquire a write lock on a read-write lock.") { janet_fixarity(argc, 1); - JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); - janet_os_rwlock_wlock(&rwlock->rwlock); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_wlock(rwlock); return argv[0]; } @@ -3109,8 +3103,8 @@ JANET_CORE_FN(janet_cfun_rwlock_read_release, "(ev/release-rlock rwlock)", "Release a read lock on a read-write lock") { janet_fixarity(argc, 1); - JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); - janet_os_rwlock_runlock(&rwlock->rwlock); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_runlock(rwlock); return argv[0]; } @@ -3118,8 +3112,8 @@ JANET_CORE_FN(janet_cfun_rwlock_write_release, "(ev/release-wlock rwlock)", "Release a write lock on a read-write lock") { janet_fixarity(argc, 1); - JanetAbstractRWLock *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); - janet_os_rwlock_wunlock(&rwlock->rwlock); + void *rwlock = janet_getabstract(argv, 0, &janet_rwlock_type); + janet_os_rwlock_wunlock(rwlock); return argv[0]; } diff --git a/src/core/pp.c b/src/core/pp.c index ff3f0c85..1a7ad6a1 100644 --- a/src/core/pp.c +++ b/src/core/pp.c @@ -983,8 +983,9 @@ void janet_buffer_format( break; } case 's': { - const uint8_t *s = janet_getstring(argv, arg); - int32_t l = janet_string_length(s); + JanetByteView bytes = janet_getbytes(argv, arg); + const uint8_t *s = bytes.bytes; + int32_t l = bytes.len; if (form[2] == '\0') janet_buffer_push_bytes(b, s, l); else { diff --git a/src/core/util.h b/src/core/util.h index 3ac3e449..f42a3c84 100644 --- a/src/core/util.h +++ b/src/core/util.h @@ -34,6 +34,10 @@ #include #include +#ifdef JANET_EV +#include +#endif + #ifndef _MSC_VER #include #endif diff --git a/src/include/janet.h b/src/include/janet.h index 9f93ddb5..28d9c360 100644 --- a/src/include/janet.h +++ b/src/include/janet.h @@ -307,22 +307,10 @@ typedef struct { JANET_CURRENT_CONFIG_BITS }) #endif -/* Feature include for pthreads. Most feature detection code should go in - * features.h instead. */ -#ifndef JANET_WINDOWS -#ifndef _XOPEN_SOURCE -#define _XOPEN_SOURCE 600 -#endif -#if _XOPEN_SOURCE < 600 -#undef _XOPEN_SOURCE -#define _XOPEN_SOURCE 600 -#endif -#endif - -/* What to do when out of memory */ -#ifndef JANET_OUT_OF_MEMORY -#include -#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "janet out of memory\n"); exit(1); } while (0) +/* Some extra includes if EV is enabled */ +#ifdef JANET_EV +typedef struct JanetOSMutex JanetOSMutex; +typedef struct JanetOSRWLock JanetOSRWLock; #endif /***** END SECTION CONFIG *****/ @@ -342,27 +330,10 @@ typedef struct { #include #include -/* Some extra includes if EV is enabled */ -#ifdef JANET_EV -#ifdef JANET_WINDOWS -typedef struct JanetDudCriticalSection { - /* Avoid including windows.h here - instead, create a structure of the same size */ - /* Needs to be same size as crtical section see WinNT.h for CRITCIAL_SECTION definition */ - void *debug_info; - long lock_count; - long recursion_count; - void *owning_thread; - void *lock_semaphore; - unsigned long spin_count; -} JanetOSMutex; -typedef struct JanetDudRWLock { - void *ptr; -} JanetOSRWLock; -#else -#include -typedef pthread_mutex_t JanetOSMutex; -typedef pthread_rwlock_t JanetOSRWLock; -#endif + +/* What to do when out of memory */ +#ifndef JANET_OUT_OF_MEMORY +#define JANET_OUT_OF_MEMORY do { fprintf(stderr, "janet out of memory\n"); exit(1); } while (0) #endif #ifdef JANET_BSD @@ -1394,6 +1365,8 @@ JANET_API int32_t janet_abstract_incref(void *abst); JANET_API int32_t janet_abstract_decref(void *abst); /* Expose some OS sync primitives */ +JANET_API size_t janet_os_mutex_size(void); +JANET_API size_t janet_os_rwlock_size(void); JANET_API void janet_os_mutex_init(JanetOSMutex *mutex); JANET_API void janet_os_mutex_deinit(JanetOSMutex *mutex); JANET_API void janet_os_mutex_lock(JanetOSMutex *mutex);