anulax
/
glfw
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Updated TinyCThread.

Browse Source
master
Camilla Berglund ago%!(EXTRA string=13 years)
parent b4d0223faa
commit a49c61f1a7
2 changed files with 106 additions and 73 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 90
      support/tinycthread.c
  2. 89
      support/tinycthread.h

90
support/tinycthread.c
Unescape View File

@ -21,13 +21,6 @@ freely, subject to the following restrictions:
distribution.
*/
/* Activate some POSIX functionality (e.g. recursive mutexes) */
#define _GNU_SOURCE
#if !defined(_XOPEN_SOURCE) || (_XOPEN_SOURCE < 500)
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 500
#endif
#include "tinycthread.h"
#include <stdlib.h>
@ -99,9 +92,11 @@ int mtx_lock(mtx_t *mtx)
#endif
}
int mtx_timedlock(mtx_t *mtx, const xtime *xt)
int mtx_timedlock(mtx_t *mtx, const struct timespec *ts)
{
/* FIXME! */
(void)mtx;
(void)ts;
return thrd_error;
}
@ -290,21 +285,21 @@ int cnd_wait(cnd_t *cond, mtx_t *mtx)
#endif
}
int cnd_timedwait(cnd_t *cond, mtx_t *mtx, const xtime *xt)
int cnd_timedwait(cnd_t *cond, mtx_t *mtx, const struct timespec *ts)
{
#if defined(_TTHREAD_WIN32_)
xtime now;
DWORD delta;
xtime_get(&now, TIME_UTC);
delta = (xt->sec - now.sec) * 1000 +
(xt->nsec - now.nsec + 500000) / 1000000;
return _cnd_timedwait_win32(cond, mtx, delta);
struct timespec now;
if (clock_gettime(TIME_UTC, &now) == 0)
{
DWORD delta = (ts->tv_sec - now.tv_sec) * 1000 +
(ts->tv_nsec - now.tv_nsec + 500000) / 1000000;
return _cnd_timedwait_win32(cond, mtx, delta);
}
else
return thrd_error;
#else
struct timespec ts;
int ret;
ts.tv_sec = xt->sec;
ts.tv_nsec = xt->nsec;
ret = pthread_cond_timedwait(cond, mtx, &ts);
ret = pthread_cond_timedwait(cond, mtx, ts);
if (ret == ETIMEDOUT)
{
return thrd_timeout;
@ -322,9 +317,9 @@ typedef struct {
/* Thread wrapper function. */
#if defined(_TTHREAD_WIN32_)
unsigned WINAPI _thrd_wrapper_function(void * aArg)
static unsigned WINAPI _thrd_wrapper_function(void * aArg)
#elif defined(_TTHREAD_POSIX_)
void * _thrd_wrapper_function(void * aArg)
static void * _thrd_wrapper_function(void * aArg)
#endif
{
thrd_start_t fun;
@ -401,6 +396,7 @@ thrd_t thrd_current(void)
int thrd_detach(thrd_t thr)
{
/* FIXME! */
(void)thr;
return thrd_error;
}
@ -460,9 +456,9 @@ int thrd_join(thrd_t thr, int *res)
return thrd_success;
}
void thrd_sleep(const xtime *xt)
int thrd_sleep(const struct timespec *time_point, struct timespec *remaining)
{
xtime now;
struct timespec now;
#if defined(_TTHREAD_WIN32_)
DWORD delta;
#else
@ -470,20 +466,21 @@ void thrd_sleep(const xtime *xt)
#endif
/* Get the current time */
xtime_get(&now, TIME_UTC);
if (clock_gettime(TIME_UTC, &now) != 0)
return -2; // FIXME: Some specific error code?
#if defined(_TTHREAD_WIN32_)
/* Delta in milliseconds */
delta = (xt->sec - now.sec) * 1000 +
(xt->nsec - now.nsec + 500000) / 1000000;
delta = (time_point->tv_sec - now.tv_sec) * 1000 +
(time_point->tv_nsec - now.tv_nsec + 500000) / 1000000;
if (delta > 0)
{
Sleep(delta);
}
#else
/* Delta in microseconds */
delta = (xt->sec - now.sec) * 1000000L +
(xt->nsec - now.nsec + 500L) / 1000L;
delta = (time_point->tv_sec - now.tv_sec) * 1000000L +
(time_point->tv_nsec - now.tv_nsec + 500L) / 1000L;
/* On some systems, the usleep argument must be < 1000000 */
while (delta > 999999L)
@ -496,6 +493,14 @@ void thrd_sleep(const xtime *xt)
usleep((useconds_t)delta);
}
#endif
/* We don't support waking up prematurely (yet) */
if (remaining)
{
remaining->tv_sec = 0;
remaining->tv_nsec = 0;
}
return 0;
}
void thrd_yield(void)
@ -563,26 +568,21 @@ int tss_set(tss_t key, void *val)
return thrd_success;
}
int xtime_get(xtime *xt, int base)
#if defined(_TTHREAD_EMULATE_CLOCK_GETTIME_)
int _tthread_clock_gettime(clockid_t clk_id, struct timespec *ts)
{
if (base == TIME_UTC)
{
#if defined(_TTHREAD_WIN32_)
struct _timeb tb;
_ftime(&tb);
xt->sec = (time_t)tb.time;
xt->nsec = 1000000 * (long)tb.millitm;
struct _timeb tb;
_ftime(&tb);
ts->tv_sec = (time_t)tb.time;
ts->tv_nsec = 1000000L * (long)tb.millitm;
#else
struct timeval tv;
gettimeofday(&tv, NULL);
xt->sec = (time_t)tv.tv_sec;
xt->nsec = 1000 * (long)tv.tv_usec;
struct timeval tv;
gettimeofday(&tv, NULL);
ts->tv_sec = (time_t)tv.tv_sec;
ts->tv_nsec = 1000L * (long)tv.tv_usec;
#endif
return base;
}
else
{
return 0;
}
return 0;
}
#endif // _TTHREAD_EMULATE_CLOCK_GETTIME_

89
support/tinycthread.h
Unescape View File

@ -57,6 +57,22 @@ freely, subject to the following restrictions:
#define _TTHREAD_PLATFORM_DEFINED_
#endif
/* Activate some POSIX functionality (e.g. clock_gettime and recursive mutexes) */
#if defined(_TTHREAD_POSIX_)
#undef _FEATURES_H
#if !defined(_GNU_SOURCE)
#define _GNU_SOURCE
#endif
#if !defined(_POSIX_C_SOURCE) || ((_POSIX_C_SOURCE - 0) < 199309L)
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 199309L
#endif
#if !defined(_XOPEN_SOURCE) || ((_XOPEN_SOURCE - 0) < 500)
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 500
#endif
#endif
/* Generic includes */
#include <time.h>
@ -75,10 +91,42 @@ freely, subject to the following restrictions:
#endif
#endif
/* Workaround for missing TIME_UTC: If time.h doesn't provide TIME_UTC,
it's quite likely that libc does not support it either. Hence, fall back to
the only other supported time specifier: CLOCK_REALTIME (and if that fails,
we're probably emulating clock_gettime anyway, so anything goes). */
#ifndef TIME_UTC
#ifdef CLOCK_REALTIME
#define TIME_UTC CLOCK_REALTIME
#else
#define TIME_UTC 0
#endif
#endif
/* Workaround for missing clock_gettime (most Windows compilers, afaik) */
#if defined(_TTHREAD_WIN32_)
#define _TTHREAD_EMULATE_CLOCK_GETTIME_
/* Emulate struct timespec */
struct _ttherad_timespec {
time_t tv_sec;
long tv_nsec;
};
#define timespec _ttherad_timespec
/* Emulate clockid_t */
typedef int _tthread_clockid_t;
#define clockid_t _tthread_clockid_t
/* Emulate clock_gettime */
int _tthread_clock_gettime(clockid_t clk_id, struct timespec *ts);
#define clock_gettime _tthread_clock_gettime
#endif
/** TinyCThread version (major number). */
#define TINYCTHREAD_VERSION_MAJOR 1
/** TinyCThread version (minor number). */
#define TINYCTHREAD_VERSION_MINOR 0
#define TINYCTHREAD_VERSION_MINOR 1
/** TinyCThread version (full version). */
#define TINYCTHREAD_VERSION (TINYCTHREAD_VERSION_MAJOR * 100 + TINYCTHREAD_VERSION_MINOR)
@ -101,7 +149,7 @@ freely, subject to the following restrictions:
* @hideinitializer
*/
/* FIXME: Check for a PROPER value of __STDC_VERSION__ to know if we have C11 or */
/* FIXME: Check for a PROPER value of __STDC_VERSION__ to know if we have C11 */
#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201102L)) && !defined(_Thread_local)
#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
#define _Thread_local __thread
@ -126,12 +174,6 @@ freely, subject to the following restrictions:
#define mtx_try 4
#define mtx_recursive 8
/** Time specification */
typedef struct {
time_t sec; /**< Seconds */
long nsec; /**< Nanoseconds */
} xtime;
/* Mutex */
#if defined(_TTHREAD_WIN32_)
typedef struct {
@ -174,7 +216,7 @@ int mtx_lock(mtx_t *mtx);
/** NOT YET IMPLEMENTED.
*/
int mtx_timedlock(mtx_t *mtx, const xtime *xt);
int mtx_timedlock(mtx_t *mtx, const struct timespec *ts);
/** Try to lock the given mutex.
* The specified mutex shall support either test and return or timeout. If the
@ -260,7 +302,7 @@ int cnd_wait(cnd_t *cond, mtx_t *mtx);
* specified in the call was reached without acquiring the requested resource, or
* @ref thrd_error if the request could not be honored.
*/
int cnd_timedwait(cnd_t *cond, mtx_t *mtx, const xtime *xt);
int cnd_timedwait(cnd_t *cond, mtx_t *mtx, const struct timespec *ts);
/* Thread */
#if defined(_TTHREAD_WIN32_)
@ -326,11 +368,16 @@ void thrd_exit(int res);
int thrd_join(thrd_t thr, int *res);
/** Put the calling thread to sleep.
* Suspend execution of the calling thread until after the time specified by the
* xtime object.
* @param xt A point in time at which the thread will resume (absolute time).
* Suspend execution of the calling thread.
* @param time_point A point in time at which the thread will resume (absolute time).
* @param remaining If non-NULL, this parameter will hold the remaining time until
* time_point upon return. This will typically be zero, but if
* the thread was woken up by a signal that is not ignored before
* time_point was reached @c remaining will hold a positive
* time.
* @return 0 (zero) on successful sleep, or -1 if an interrupt occurred.
*/
void thrd_sleep(const xtime *xt);
int thrd_sleep(const struct timespec *time_point, struct timespec *remaining);
/** Yield execution to another thread.
* Permit other threads to run, even if the current thread would ordinarily
@ -385,20 +432,6 @@ void *tss_get(tss_t key);
*/
int tss_set(tss_t key, void *val);
/* Timing */
enum
{
TIME_UTC = 1
};
/** Get the current time.
* Set the xtime object to hold the current time based on the given time base.
* @param xt Will be filled out with the current time.
* @param base Time base (must be @c TIME_UTC).
* @return The non-zero value @c base if the function is successful, otherwise
* it returns zero.
*/
int xtime_get(xtime *xt, int base);
#endif /* _TINYTHREAD_H_ */

Write Preview
Loading…
Cancel
Save