Initial version.
This commit is contained in:
Igor Sysoev
468
src/nxt_thread_time.c
Normal file
468
src/nxt_thread_time.c
Normal file
@@ -0,0 +1,468 @@
|
||||
|
||||
/*
|
||||
* Copyright (C) Igor Sysoev
|
||||
* Copyright (C) NGINX, Inc.
|
||||
*/
|
||||
|
||||
#include <nxt_main.h>
|
||||
|
||||
|
||||
/*
|
||||
* Each thread keeps several time representations in its thread local
|
||||
* storage:
|
||||
* the monotonic time in nanoseconds since unspecified point in the past,
|
||||
* the real time in seconds and nanoseconds since the Epoch,
|
||||
* the local time and GMT time structs,
|
||||
* and various user-defined text representations of local and GMT times.
|
||||
*
|
||||
* The monotonic time is used mainly by engine timers and is updated after
|
||||
* a kernel operation which can block for unpredictable duration like event
|
||||
* polling. Besides getting the monotonic time is generally faster than
|
||||
* getting the real time, so the monotonic time is also used for milestones
|
||||
* to update cached real time seconds and, if debug log enabled, milliseconds.
|
||||
* As a result, the cached real time is updated at most one time per second
|
||||
* or millisecond respectively. If there is a signal event support or in
|
||||
* multi-threaded mode, then the cached real time and local time structs
|
||||
* are updated only on demand. In single-threaded mode without the signal
|
||||
* event support the cached real and local time are updated synchronously
|
||||
* with the monotonic time update. GMT time structs and text representations
|
||||
* are always updated only on demand.
|
||||
*/
|
||||
|
||||
|
||||
#if (NXT_THREADS)
|
||||
static void nxt_time_thread(void *data);
|
||||
static void nxt_thread_time_shared(nxt_monotonic_time_t *now);
|
||||
|
||||
static nxt_bool_t nxt_use_shared_time = 0;
|
||||
static volatile nxt_monotonic_time_t nxt_shared_time;
|
||||
#endif
|
||||
|
||||
static void nxt_thread_realtime_update(nxt_thread_t *thr,
|
||||
nxt_monotonic_time_t *now);
|
||||
static u_char *nxt_thread_time_string_no_cache(nxt_thread_t *thr,
|
||||
nxt_time_string_t *ts, u_char *buf);
|
||||
static nxt_atomic_uint_t nxt_thread_time_string_slot(nxt_time_string_t *ts);
|
||||
static nxt_time_string_cache_t *nxt_thread_time_string_cache(nxt_thread_t *thr,
|
||||
nxt_atomic_uint_t slot);
|
||||
|
||||
|
||||
static nxt_atomic_int_t nxt_gmtoff;
|
||||
|
||||
|
||||
void
|
||||
nxt_thread_time_update(nxt_thread_t *thr)
|
||||
{
|
||||
#if (NXT_THREADS)
|
||||
|
||||
if (nxt_use_shared_time) {
|
||||
nxt_thread_time_shared(&thr->time.now);
|
||||
|
||||
} else {
|
||||
nxt_monotonic_time(&thr->time.now);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
nxt_monotonic_time(&thr->time.now);
|
||||
|
||||
if (thr->time.signal >= 0) {
|
||||
nxt_time_t s;
|
||||
|
||||
/*
|
||||
* Synchronous real time update:
|
||||
* single-threaded mode without signal event support.
|
||||
*/
|
||||
|
||||
s = nxt_thread_time(thr);
|
||||
|
||||
if (thr->time.signal == 0 && thr->time.last_localtime != s) {
|
||||
/* Synchronous local time update in non-signal context. */
|
||||
|
||||
nxt_localtime(s, &thr->time.localtime);
|
||||
thr->time.last_localtime = s;
|
||||
|
||||
nxt_gmtoff = nxt_timezone(&thr->time.localtime);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
nxt_thread_time_free(nxt_thread_t *thr)
|
||||
{
|
||||
nxt_uint_t i;
|
||||
nxt_time_string_cache_t *tsc;
|
||||
|
||||
tsc = thr->time.strings;
|
||||
|
||||
if (tsc) {
|
||||
thr->time.no_cache = 1;
|
||||
|
||||
for (i = 0; i < thr->time.nstrings; i++) {
|
||||
nxt_free(tsc[i].string.data);
|
||||
}
|
||||
|
||||
nxt_free(tsc);
|
||||
thr->time.strings = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#if (NXT_THREADS)
|
||||
|
||||
void
|
||||
nxt_time_thread_start(nxt_msec_t interval)
|
||||
{
|
||||
nxt_thread_link_t *link;
|
||||
nxt_thread_handle_t handle;
|
||||
|
||||
link = nxt_zalloc(sizeof(nxt_thread_link_t));
|
||||
|
||||
if (nxt_fast_path(link != NULL)) {
|
||||
link->start = nxt_time_thread;
|
||||
link->data = (void *) (uintptr_t) interval;
|
||||
|
||||
(void) nxt_thread_create(&handle, link);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
nxt_time_thread(void *data)
|
||||
{
|
||||
nxt_nsec_t interval, rest;
|
||||
nxt_thread_t *thr;
|
||||
nxt_monotonic_time_t now;
|
||||
|
||||
interval = (uintptr_t) data;
|
||||
interval *= 1000000;
|
||||
|
||||
thr = nxt_thread();
|
||||
/*
|
||||
* The time thread is never preempted by asynchronous signals, since
|
||||
* the signals are processed synchronously by dedicated thread.
|
||||
*/
|
||||
thr->time.signal = -1;
|
||||
|
||||
nxt_log_debug(thr->log, "time thread");
|
||||
|
||||
nxt_memzero(&now, sizeof(nxt_monotonic_time_t));
|
||||
|
||||
nxt_monotonic_time(&now);
|
||||
nxt_thread_realtime_update(thr, &now);
|
||||
|
||||
nxt_shared_time = now;
|
||||
nxt_use_shared_time = 1;
|
||||
|
||||
for ( ;; ) {
|
||||
rest = 1000000000 - now.realtime.nsec;
|
||||
|
||||
nxt_nanosleep(nxt_min(interval, rest));
|
||||
|
||||
nxt_monotonic_time(&now);
|
||||
nxt_thread_realtime_update(thr, &now);
|
||||
|
||||
nxt_shared_time = now;
|
||||
|
||||
#if 0
|
||||
thr->time.now = now;
|
||||
nxt_log_debug(thr->log, "time thread");
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
if (nxt_exiting) {
|
||||
nxt_use_shared_time = 0;
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
nxt_thread_time_shared(nxt_monotonic_time_t *now)
|
||||
{
|
||||
nxt_uint_t n;
|
||||
nxt_time_t t;
|
||||
nxt_nsec_t m, u;
|
||||
|
||||
/* Lock-free thread time update. */
|
||||
|
||||
for ( ;; ) {
|
||||
*now = nxt_shared_time;
|
||||
|
||||
t = nxt_shared_time.realtime.sec;
|
||||
n = nxt_shared_time.realtime.nsec;
|
||||
m = nxt_shared_time.monotonic;
|
||||
u = nxt_shared_time.update;
|
||||
|
||||
if (now->realtime.sec == t && now->realtime.nsec == n
|
||||
&& now->monotonic == m && now->update == u)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
nxt_time_t
|
||||
nxt_thread_time(nxt_thread_t *thr)
|
||||
{
|
||||
nxt_thread_realtime_update(thr, &thr->time.now);
|
||||
|
||||
return thr->time.now.realtime.sec;
|
||||
}
|
||||
|
||||
|
||||
nxt_realtime_t *
|
||||
nxt_thread_realtime(nxt_thread_t *thr)
|
||||
{
|
||||
nxt_thread_realtime_update(thr, &thr->time.now);
|
||||
|
||||
return &thr->time.now.realtime;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
nxt_thread_realtime_update(nxt_thread_t *thr, nxt_monotonic_time_t *now)
|
||||
{
|
||||
nxt_nsec_t delta;
|
||||
|
||||
#if (NXT_DEBUG)
|
||||
|
||||
if (nxt_slow_path(thr->log->level == NXT_LOG_DEBUG || nxt_debug)) {
|
||||
|
||||
if (now->monotonic >= now->update) {
|
||||
nxt_realtime(&now->realtime);
|
||||
|
||||
delta = 1000000 - now->realtime.nsec % 1000000;
|
||||
now->update = now->monotonic + delta;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
if (now->monotonic >= now->update) {
|
||||
nxt_realtime(&now->realtime);
|
||||
|
||||
delta = 1000000000 - now->realtime.nsec;
|
||||
now->update = now->monotonic + delta;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
u_char *
|
||||
nxt_thread_time_string(nxt_thread_t *thr, nxt_time_string_t *ts, u_char *buf)
|
||||
{
|
||||
u_char *p;
|
||||
struct tm *tm;
|
||||
nxt_time_t s;
|
||||
nxt_bool_t update;
|
||||
nxt_atomic_uint_t slot;
|
||||
nxt_time_string_cache_t *tsc;
|
||||
|
||||
if (nxt_slow_path(thr == NULL || thr->time.no_cache)) {
|
||||
return nxt_thread_time_string_no_cache(thr, ts, buf);
|
||||
}
|
||||
|
||||
slot = nxt_thread_time_string_slot(ts);
|
||||
|
||||
tsc = nxt_thread_time_string_cache(thr, slot);
|
||||
if (tsc == NULL) {
|
||||
return buf;
|
||||
}
|
||||
|
||||
if (thr->time.signal < 0) {
|
||||
/*
|
||||
* Lazy real time update:
|
||||
* signal event support or multi-threaded mode.
|
||||
*/
|
||||
nxt_thread_realtime_update(thr, &thr->time.now);
|
||||
}
|
||||
|
||||
s = thr->time.now.realtime.sec;
|
||||
|
||||
update = (s != tsc->last);
|
||||
|
||||
#if (NXT_DEBUG)
|
||||
|
||||
if (ts->msec == NXT_THREAD_TIME_MSEC
|
||||
&& (nxt_slow_path(thr->log->level == NXT_LOG_DEBUG || nxt_debug)))
|
||||
{
|
||||
nxt_msec_t ms;
|
||||
|
||||
ms = thr->time.now.realtime.nsec / 1000000;
|
||||
update |= (ms != tsc->last_msec);
|
||||
tsc->last_msec = ms;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
if (nxt_slow_path(update)) {
|
||||
|
||||
if (ts->timezone == NXT_THREAD_TIME_LOCAL) {
|
||||
|
||||
tm = &thr->time.localtime;
|
||||
|
||||
if (nxt_slow_path(s != thr->time.last_localtime)) {
|
||||
|
||||
if (thr->time.signal < 0) {
|
||||
/*
|
||||
* Lazy local time update:
|
||||
* signal event support or multi-threaded mode.
|
||||
*/
|
||||
nxt_localtime(s, &thr->time.localtime);
|
||||
thr->time.last_localtime = s;
|
||||
|
||||
} else {
|
||||
/*
|
||||
* "thr->time.signal >= 0" means that a thread may be
|
||||
* interrupted by a signal handler. Since localtime()
|
||||
* cannot be safely called in a signal context, the
|
||||
* thread's thr->time.localtime must be updated regularly
|
||||
* by nxt_thread_time_update() in non-signal context.
|
||||
* Stale timestamp means that nxt_thread_time_string()
|
||||
* is being called in a signal context, so here is
|
||||
* Async-Signal-Safe localtime() emulation using the
|
||||
* latest cached GMT offset.
|
||||
*
|
||||
* The timestamp is not set here intentionally to update
|
||||
* thr->time.localtime later in non-signal context. The
|
||||
* real previously cached thr->localtime is used because
|
||||
* Linux and Solaris strftime() depend on tm.tm_isdst
|
||||
* and tm.tm_gmtoff fields.
|
||||
*/
|
||||
nxt_gmtime(s + nxt_timezone(tm), tm);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
tm = &thr->time.gmtime;
|
||||
|
||||
if (nxt_slow_path(s != thr->time.last_gmtime)) {
|
||||
nxt_gmtime(s, tm);
|
||||
thr->time.last_gmtime = s;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
p = tsc->string.data;
|
||||
|
||||
if (nxt_slow_path(p == NULL)) {
|
||||
|
||||
thr->time.no_cache = 1;
|
||||
p = nxt_zalloc(ts->size);
|
||||
thr->time.no_cache = 0;
|
||||
|
||||
if (p == NULL) {
|
||||
return buf;
|
||||
}
|
||||
|
||||
tsc->string.data = p;
|
||||
}
|
||||
|
||||
p = ts->handler(p, &thr->time.now.realtime, tm, ts->size, ts->format);
|
||||
|
||||
tsc->string.len = p - tsc->string.data;
|
||||
|
||||
if (nxt_slow_path(tsc->string.len == 0)) {
|
||||
return buf;
|
||||
}
|
||||
|
||||
tsc->last = s;
|
||||
}
|
||||
|
||||
return nxt_cpymem(buf, tsc->string.data, tsc->string.len);
|
||||
}
|
||||
|
||||
|
||||
static u_char *
|
||||
nxt_thread_time_string_no_cache(nxt_thread_t *thr, nxt_time_string_t *ts,
|
||||
u_char *buf)
|
||||
{
|
||||
struct tm tm;
|
||||
nxt_realtime_t now;
|
||||
|
||||
nxt_realtime(&now);
|
||||
|
||||
if (ts->timezone == NXT_THREAD_TIME_LOCAL) {
|
||||
|
||||
if (thr == NULL || thr->time.signal <= 0) {
|
||||
/* Non-signal context */
|
||||
nxt_localtime(now.sec, &tm);
|
||||
|
||||
} else {
|
||||
nxt_gmtime(now.sec + nxt_gmtoff, &tm);
|
||||
}
|
||||
|
||||
} else {
|
||||
nxt_gmtime(now.sec, &tm);
|
||||
}
|
||||
|
||||
return ts->handler(buf, &now, &tm, ts->size, ts->format);
|
||||
}
|
||||
|
||||
|
||||
static nxt_atomic_uint_t
|
||||
nxt_thread_time_string_slot(nxt_time_string_t *ts)
|
||||
{
|
||||
static nxt_atomic_t slot;
|
||||
|
||||
while (nxt_slow_path((nxt_atomic_int_t) ts->slot < 0)) {
|
||||
/*
|
||||
* Atomic allocation of a slot number.
|
||||
* -1 means an uninitialized slot,
|
||||
* -2 is the initializing lock to assure the single value for the slot.
|
||||
*/
|
||||
if (nxt_atomic_cmp_set(&ts->slot, -1, -2)) {
|
||||
ts->slot = nxt_atomic_fetch_add(&slot, 1);
|
||||
|
||||
/* No "break" here since it adds only dispensable "jmp". */
|
||||
}
|
||||
}
|
||||
|
||||
return (nxt_atomic_uint_t) ts->slot;
|
||||
}
|
||||
|
||||
|
||||
static nxt_time_string_cache_t *
|
||||
nxt_thread_time_string_cache(nxt_thread_t *thr, nxt_atomic_uint_t slot)
|
||||
{
|
||||
size_t size;
|
||||
nxt_atomic_uint_t i, nstrings;
|
||||
nxt_time_string_cache_t *tsc;
|
||||
|
||||
if (nxt_fast_path(slot < thr->time.nstrings)) {
|
||||
tsc = &thr->time.strings[slot];
|
||||
nxt_prefetch(tsc->string.data);
|
||||
return tsc;
|
||||
}
|
||||
|
||||
nstrings = slot + 1;
|
||||
size = nstrings * sizeof(nxt_time_string_cache_t);
|
||||
|
||||
thr->time.no_cache = 1;
|
||||
tsc = nxt_realloc(thr->time.strings, size);
|
||||
thr->time.no_cache = 0;
|
||||
|
||||
if (tsc == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = thr->time.nstrings; i < nstrings; i++) {
|
||||
tsc[i].last = -1;
|
||||
tsc[i].string.data = NULL;
|
||||
}
|
||||
|
||||
thr->time.strings = tsc;
|
||||
thr->time.nstrings = nstrings;
|
||||
|
||||
return &tsc[slot];
|
||||
}
|
||||
Reference in New Issue
Block a user