zxc_threads.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause */
/*
 * ZXC - High-performance lossless compression
 *
 * Copyright (c) Bertrand Lebonnois and contributors.
 */
 
#ifndef ZXC_THREADS_H
#define ZXC_THREADS_H
 
#include "zxc_internal.h"
 
// LCOV_EXCL_START - Windows platform layer, not reachable on POSIX CI
#if defined(_WIN32)
 
#include <process.h> /* _beginthreadex */
#include <windows.h>
 
typedef CRITICAL_SECTION pthread_mutex_t;
typedef CONDITION_VARIABLE pthread_cond_t;
typedef HANDLE pthread_t;
 
#define pthread_mutex_init(m, a) InitializeCriticalSection(m)
#define pthread_mutex_destroy(m) DeleteCriticalSection(m)
#define pthread_mutex_lock(m) EnterCriticalSection(m)
#define pthread_mutex_unlock(m) LeaveCriticalSection(m)
 
#define pthread_cond_init(c, a) InitializeConditionVariable(c)
#define pthread_cond_destroy(c) (void)(0)
#define pthread_cond_wait(c, m) SleepConditionVariableCS(c, m, INFINITE)
#define pthread_cond_signal(c) WakeConditionVariable(c)
#define pthread_cond_broadcast(c) WakeAllConditionVariable(c)
 
typedef struct {
    void* (*func)(void*); /* worker to invoke */
    void* arg;            /* argument forwarded to @c func */
} zxc_win_thread_arg_t;
 
static inline unsigned __stdcall zxc_win_thread_entry(void* p) {
    zxc_win_thread_arg_t* a = (zxc_win_thread_arg_t*)p;
    void* (*f)(void*) = a->func;
    void* arg = a->arg;
    ZXC_FREE(a);
    f(arg);
    return 0;
}
 
static inline int pthread_create(pthread_t* thread, const void* attr, void* (*start_routine)(void*),
                                 void* arg) {
    (void)attr;
    zxc_win_thread_arg_t* wrapper = ZXC_MALLOC(sizeof(zxc_win_thread_arg_t));
    if (UNLIKELY(!wrapper)) return ZXC_ERROR_MEMORY;
    wrapper->func = start_routine;
    wrapper->arg = arg;
    uintptr_t handle = _beginthreadex(NULL, 0, zxc_win_thread_entry, wrapper, 0, NULL);
    if (UNLIKELY(handle == 0)) {
        ZXC_FREE(wrapper);
        return ZXC_ERROR_MEMORY;
    }
    *thread = (HANDLE)handle;
    return 0;
}
 
static inline int pthread_join(pthread_t thread, void** retval) {
    (void)retval;
    WaitForSingleObject(thread, INFINITE);
    CloseHandle(thread);
    return 0;
}
 
static ZXC_ALWAYS_INLINE int zxc_num_procs(void) {
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    return (int)si.dwNumberOfProcessors;
}
 
#else /* POSIX */
// LCOV_EXCL_STOP
 
#include <pthread.h>
#include <unistd.h>
 
static ZXC_ALWAYS_INLINE int zxc_num_procs(void) {
    const long n = sysconf(_SC_NPROCESSORS_ONLN);
    return (n > 0) ? (int)n : 1;
}
 
#endif /* _WIN32 */
 
#endif /* ZXC_THREADS_H */