blob: b2c5b6ce807ae64aa86aafe05dd1a6c4eee64832 [file] [log] [blame]
/*
* Copyright © 2018, VideoLAN and dav1d authors
* Copyright © 2018, Two Orioles, LLC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef DAV1D_SRC_THREAD_H
#define DAV1D_SRC_THREAD_H
#ifdef STARBOARD
#include <errno.h>
#include "starboard/common/log.h"
#include "starboard/condition_variable.h"
#include "starboard/mutex.h"
#include "starboard/once.h"
#include "starboard/thread.h"
#include "starboard/thread_types.h"
typedef SbThread dav1d_pthread_t;
typedef SbMutex dav1d_pthread_mutex_t;
typedef SbConditionVariable dav1d_pthread_cond_t;
typedef SbOnceControl dav1d_pthread_once_t;
typedef struct { int64_t stack_size; } dav1d_pthread_attr_t;
#define dav1d_set_thread_name SbThreadSetName
#define dav1d_init_thread() \
do { \
} while (0)
// pthread interface
static inline int dav1d_pthread_create(dav1d_pthread_t* thread,
const dav1d_pthread_attr_t* attr,
void* (*func)(void*),
void* arg);
static inline int dav1d_pthread_join(dav1d_pthread_t* thread, void** res);
static inline int dav1d_pthread_once(dav1d_pthread_once_t* once_control,
void (*init_routine)(void));
// pthread attributes
static inline int dav1d_pthread_attr_init(dav1d_pthread_attr_t* const attr);
static inline int dav1d_pthread_attr_destroy(dav1d_pthread_attr_t* const attr);
static inline int dav1d_pthread_attr_setstacksize(
dav1d_pthread_attr_t* const attr,
const int64_t stack_size);
// pthread mutex
static inline int dav1d_pthread_mutex_init(dav1d_pthread_mutex_t* const mutex,
const void* const attr);
static inline int dav1d_pthread_mutex_destroy(
dav1d_pthread_mutex_t* const mutex);
static inline int dav1d_pthread_mutex_lock(dav1d_pthread_mutex_t* const mutex);
static inline int dav1d_pthread_mutex_unlock(
dav1d_pthread_mutex_t* const mutex);
// pthread condition variable
static inline int dav1d_pthread_cond_init(dav1d_pthread_cond_t* const cond,
const void* const attr);
static inline int dav1d_pthread_cond_destroy(dav1d_pthread_cond_t* const cond);
static inline int dav1d_pthread_cond_wait(dav1d_pthread_cond_t* const cond,
dav1d_pthread_mutex_t* const mutex);
static inline int dav1d_pthread_cond_signal(dav1d_pthread_cond_t* const cond);
static inline int dav1d_pthread_cond_broadcast(
dav1d_pthread_cond_t* const cond);
// static
int dav1d_pthread_create(dav1d_pthread_t* thread,
const dav1d_pthread_attr_t* attr,
void* (*func)(void*),
void* arg) {
*thread = SbThreadCreate(attr->stack_size, kSbThreadNoPriority,
kSbThreadNoAffinity, true, NULL, func, arg);
// Options for errno are EAGAIN, EINVAL or EPERM.
// In the case of SbThreadCreate failure, EINVAL is the most appropriate.
// https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread_create.html
return SbThreadIsValid(*thread) ? 0 : EINVAL;
}
// static
int dav1d_pthread_join(dav1d_pthread_t* thread, void** res) {
if (SbThreadIsEqual(SbThreadGetCurrent(), *thread)) {
return EDEADLK;
}
// Note: all threads are joinable in this context.
// Thus the only failure case for SbThreadJoin is that no thread could be
// found corresponding to the given thread ID.
// https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread_join.html
return SbThreadJoin(*thread, res) ? 0 : ESRCH;
}
// static
int dav1d_pthread_once(dav1d_pthread_once_t* once_control,
void (*init_routine)(void)) {
// No errors are defined so we default to EINVAL.
// https://pubs.opengroup.org/onlinepubs/7908799/xsh/pthread_once.html
return SbOnce(once_control, init_routine) ? 0 : EINVAL;
}
// static
int dav1d_pthread_attr_init(dav1d_pthread_attr_t* const attr) {
attr->stack_size = 0;
return 0;
}
// static
int dav1d_pthread_attr_destroy(dav1d_pthread_attr_t* const attr) {
return 0;
}
// static
int dav1d_pthread_attr_setstacksize(dav1d_pthread_attr_t* const attr,
const int64_t stack_size) {
attr->stack_size = stack_size;
return 0;
}
// static
int dav1d_pthread_mutex_init(dav1d_pthread_mutex_t* const mutex,
const void* const attr) {
SbMutexCreate(mutex);
return 0;
}
// static
int dav1d_pthread_mutex_destroy(dav1d_pthread_mutex_t* const mutex) {
SbMutexDestroy(mutex);
return 0;
}
// static
int dav1d_pthread_mutex_lock(dav1d_pthread_mutex_t* const mutex) {
SbMutexAcquire(mutex);
return 0;
}
// static
int dav1d_pthread_mutex_unlock(dav1d_pthread_mutex_t* const mutex) {
SbMutexRelease(mutex);
return 0;
}
// static
int dav1d_pthread_cond_init(dav1d_pthread_cond_t* const cond,
const void* const attr) {
SbConditionVariableCreate(cond, NULL);
return 0;
}
// static
int dav1d_pthread_cond_destroy(dav1d_pthread_cond_t* const cond) {
SbConditionVariableDestroy(cond);
return 0;
}
// static
int dav1d_pthread_cond_wait(dav1d_pthread_cond_t* const cond,
dav1d_pthread_mutex_t* const mutex) {
switch (SbConditionVariableWait(cond, mutex)) {
case kSbConditionVariableSignaled: {
return 0;
}
case kSbConditionVariableTimedOut: {
return ETIMEDOUT;
}
case kSbConditionVariableFailed: {
return EINVAL;
}
}
SB_NOTREACHED();
return EINVAL;
}
// static
int dav1d_pthread_cond_signal(dav1d_pthread_cond_t* const cond) {
SbConditionVariableSignal(cond);
return 0;
}
// static
int dav1d_pthread_cond_broadcast(dav1d_pthread_cond_t* const cond) {
SbConditionVariableBroadcast(cond);
return 0;
}
#ifndef DAV1D_PTHREAD_ONCE_INIT
#define DAV1D_PTHREAD_ONCE_INIT SB_ONCE_INITIALIZER
#endif
#else // STARBOARD
#if defined(_WIN32)
#include <windows.h>
#define PTHREAD_ONCE_INIT INIT_ONCE_STATIC_INIT
typedef struct {
HANDLE h;
void *(*func)(void*);
void *arg;
} pthread_t;
typedef struct {
unsigned stack_size;
} pthread_attr_t;
typedef SRWLOCK pthread_mutex_t;
typedef CONDITION_VARIABLE pthread_cond_t;
typedef INIT_ONCE pthread_once_t;
void dav1d_init_thread(void);
void dav1d_set_thread_name(const wchar_t *name);
#define dav1d_set_thread_name(name) dav1d_set_thread_name(L##name)
int dav1d_pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*func)(void*), void *arg);
int dav1d_pthread_join(pthread_t *thread, void **res);
int dav1d_pthread_once(pthread_once_t *once_control,
void (*init_routine)(void));
#define pthread_create dav1d_pthread_create
#define pthread_join(thread, res) dav1d_pthread_join(&(thread), res)
#define pthread_once dav1d_pthread_once
static inline int pthread_attr_init(pthread_attr_t *const attr) {
attr->stack_size = 0;
return 0;
}
static inline int pthread_attr_destroy(pthread_attr_t *const attr) {
return 0;
}
static inline int pthread_attr_setstacksize(pthread_attr_t *const attr,
const unsigned stack_size)
{
attr->stack_size = stack_size;
return 0;
}
static inline int pthread_mutex_init(pthread_mutex_t *const mutex,
const void *const attr)
{
InitializeSRWLock(mutex);
return 0;
}
static inline int pthread_mutex_destroy(pthread_mutex_t *const mutex) {
return 0;
}
static inline int pthread_mutex_lock(pthread_mutex_t *const mutex) {
AcquireSRWLockExclusive(mutex);
return 0;
}
static inline int pthread_mutex_unlock(pthread_mutex_t *const mutex) {
ReleaseSRWLockExclusive(mutex);
return 0;
}
static inline int pthread_cond_init(pthread_cond_t *const cond,
const void *const attr)
{
InitializeConditionVariable(cond);
return 0;
}
static inline int pthread_cond_destroy(pthread_cond_t *const cond) {
return 0;
}
static inline int pthread_cond_wait(pthread_cond_t *const cond,
pthread_mutex_t *const mutex)
{
return !SleepConditionVariableSRW(cond, mutex, INFINITE, 0);
}
static inline int pthread_cond_signal(pthread_cond_t *const cond) {
WakeConditionVariable(cond);
return 0;
}
static inline int pthread_cond_broadcast(pthread_cond_t *const cond) {
WakeAllConditionVariable(cond);
return 0;
}
#else
#include <pthread.h>
#define dav1d_init_thread() do {} while (0)
/* Thread naming support */
#ifdef __linux__
#include <sys/prctl.h>
static inline void dav1d_set_thread_name(const char *const name) {
prctl(PR_SET_NAME, name);
}
#elif defined(__APPLE__)
static inline void dav1d_set_thread_name(const char *const name) {
pthread_setname_np(name);
}
#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
#if defined(__FreeBSD__)
/* ALIGN from <sys/param.h> conflicts with ALIGN from "common/attributes.h" */
#define _SYS_PARAM_H_
#include <sys/types.h>
#endif
#include <pthread_np.h>
static inline void dav1d_set_thread_name(const char *const name) {
pthread_set_name_np(pthread_self(), name);
}
#elif defined(__NetBSD__)
static inline void dav1d_set_thread_name(const char *const name) {
pthread_setname_np(pthread_self(), "%s", (void*)name);
}
#else
#define dav1d_set_thread_name(name) do {} while (0)
#endif
#endif
#endif // STARBOARD
#endif /* DAV1D_SRC_THREAD_H */