thread.c File Reference

#include <assert.h>
#include <limits.h>
#include <stdlib.h>
#include "uv.h"
#include "internal.h"

Go to the source code of this file.

Classes
struct	thread_ctx

Functions
static void	uv__once_inner (uv_once_t *guard, void(*callback)(void))
void	uv_once (uv_once_t *guard, void(*callback)(void))
	STATIC_ASSERT (sizeof(uv_thread_t)<=sizeof(void *))
static void	uv__init_current_thread_key (void)
static UINT __stdcall	uv__thread_start (void *arg)
int	uv_thread_create (uv_thread_t *tid, void(*entry)(void *arg), void *arg)
int	uv_thread_create_ex (uv_thread_t *tid, const uv_thread_options_t *params, void(*entry)(void *arg), void *arg)
uv_thread_t	uv_thread_self (void)
int	uv_thread_join (uv_thread_t *tid)
int	uv_thread_equal (const uv_thread_t *t1, const uv_thread_t *t2)
int	uv_mutex_init (uv_mutex_t *mutex)
int	uv_mutex_init_recursive (uv_mutex_t *mutex)
void	uv_mutex_destroy (uv_mutex_t *mutex)
void	uv_mutex_lock (uv_mutex_t *mutex)
int	uv_mutex_trylock (uv_mutex_t *mutex)
void	uv_mutex_unlock (uv_mutex_t *mutex)
int	uv_rwlock_init (uv_rwlock_t *rwlock)
void	uv_rwlock_destroy (uv_rwlock_t *rwlock)
void	uv_rwlock_rdlock (uv_rwlock_t *rwlock)
int	uv_rwlock_tryrdlock (uv_rwlock_t *rwlock)
void	uv_rwlock_rdunlock (uv_rwlock_t *rwlock)
void	uv_rwlock_wrlock (uv_rwlock_t *rwlock)
int	uv_rwlock_trywrlock (uv_rwlock_t *rwlock)
void	uv_rwlock_wrunlock (uv_rwlock_t *rwlock)
int	uv_sem_init (uv_sem_t *sem, unsigned int value)
void	uv_sem_destroy (uv_sem_t *sem)
void	uv_sem_post (uv_sem_t *sem)
void	uv_sem_wait (uv_sem_t *sem)
int	uv_sem_trywait (uv_sem_t *sem)
int	uv_cond_init (uv_cond_t *cond)
void	uv_cond_destroy (uv_cond_t *cond)
void	uv_cond_signal (uv_cond_t *cond)
void	uv_cond_broadcast (uv_cond_t *cond)
void	uv_cond_wait (uv_cond_t *cond, uv_mutex_t *mutex)
int	uv_cond_timedwait (uv_cond_t *cond, uv_mutex_t *mutex, uint64_t timeout)
int	uv_barrier_init (uv_barrier_t *barrier, unsigned int count)
void	uv_barrier_destroy (uv_barrier_t *barrier)
int	uv_barrier_wait (uv_barrier_t *barrier)
int	uv_key_create (uv_key_t *key)
void	uv_key_delete (uv_key_t *key)
void *	uv_key_get (uv_key_t *key)
void	uv_key_set (uv_key_t *key, void *value)

Variables
static uv_key_t	uv__current_thread_key
static uv_once_t	uv__current_thread_init_guard = UV_ONCE_INIT

Function Documentation

STATIC_ASSERT()

STATIC_ASSERT

(

sizeof(uv_thread_t)<=sizeof(void *)

)

uv__init_current_thread_key()

static void uv__init_current_thread_key ( void  )

static

Definition at line 84 of file thread.c.

                                              {
  if (uv_key_create(&uv__current_thread_key))
    abort();
}

References uv__current_thread_key, and uv_key_create().

Referenced by uv__thread_start(), and uv_thread_self().

uv__once_inner()

static void uv__once_inner ( uv_once_t *  guard, void(*)(void)  callback  )

static

Definition at line 35 of file thread.c.

                                                                     {
  DWORD result;
  HANDLE existing_event, created_event;
 
  created_event = CreateEvent(NULL, 1, 0, NULL);
  if (created_event == 0) {
    /* Could fail in a low-memory situation? */
    uv_fatal_error(GetLastError(), "CreateEvent");
  }
 
  existing_event = InterlockedCompareExchangePointer(&guard->event,
                                                     created_event,
                                                     NULL);
 
  if (existing_event == NULL) {
    /* We won the race */
    callback();
 
    result = SetEvent(created_event);
    assert(result);
    guard->ran = 1;
 
  } else {
    /* We lost the race. Destroy the event we created and wait for the existing
     * one to become signaled. */
    CloseHandle(created_event);
    result = WaitForSingleObject(existing_event, INFINITE);
    assert(result == WAIT_OBJECT_0);
  }
}

References assert(), DWORD, HANDLE, NULL, and uv_fatal_error().

Referenced by uv_once().

uv__thread_start()

static UINT __stdcall uv__thread_start ( void *  arg )

static

Definition at line 97 of file thread.c.

                                                  {
  struct thread_ctx *ctx_p;
  struct thread_ctx ctx;
 
  ctx_p = arg;
  ctx = *ctx_p;
  uv__free(ctx_p);
 
  uv_once(&uv__current_thread_init_guard, uv__init_current_thread_key);
  uv_key_set(&uv__current_thread_key, (void*) ctx.self);
 
  ctx.entry(ctx.arg);
 
  return 0;
}

References arg(), uv__current_thread_init_guard, uv__current_thread_key, uv__free(), uv__init_current_thread_key(), uv_key_set(), and uv_once().

Referenced by uv_thread_create_ex().

uv_barrier_destroy()

void uv_barrier_destroy

(

uv_barrier_t *

barrier

)

Definition at line 456 of file thread.c.

                                               {
  uv_sem_destroy(&barrier->turnstile2);
  uv_sem_destroy(&barrier->turnstile1);
  uv_mutex_destroy(&barrier->mutex);
}

References assert(), uv_barrier_t::b, b, uv_barrier_t::mutex, NULL, uv_barrier_t::turnstile1, uv_barrier_t::turnstile2, uv__free(), uv_cond_destroy(), uv_mutex_destroy(), uv_mutex_lock(), uv_mutex_unlock(), and uv_sem_destroy().

Referenced by main().

uv_barrier_init()

int uv_barrier_init	(	uv_barrier_t *	barrier,
		unsigned int	count
	)

Definition at line 427 of file thread.c.

                                                               {
  int err;
 
  barrier->n = count;
  barrier->count = 0;
 
  err = uv_mutex_init(&barrier->mutex);
  if (err)
    return err;
 
  err = uv_sem_init(&barrier->turnstile1, 0);
  if (err)
    goto error2;
 
  err = uv_sem_init(&barrier->turnstile2, 1);
  if (err)
    goto error;
 
  return 0;
 
error:
  uv_sem_destroy(&barrier->turnstile1);
error2:
  uv_mutex_destroy(&barrier->mutex);
  return err;
 
}

References uv_barrier_t::b, b, count, uv_barrier_t::count, err, error(), uv_barrier_t::mutex, uv_barrier_t::n, NULL, uv_barrier_t::turnstile1, uv_barrier_t::turnstile2, uv__free(), uv__malloc(), uv_cond_init(), uv_mutex_destroy(), uv_mutex_init(), uv_sem_destroy(), and uv_sem_init().

Referenced by main().

uv_barrier_wait()

int uv_barrier_wait

(

uv_barrier_t *

barrier

)

Definition at line 463 of file thread.c.

                                           {
  int serial_thread;
 
  uv_mutex_lock(&barrier->mutex);
  if (++barrier->count == barrier->n) {
    uv_sem_wait(&barrier->turnstile2);
    uv_sem_post(&barrier->turnstile1);
  }
  uv_mutex_unlock(&barrier->mutex);
 
  uv_sem_wait(&barrier->turnstile1);
  uv_sem_post(&barrier->turnstile1);
 
  uv_mutex_lock(&barrier->mutex);
  serial_thread = (--barrier->count == 0);
  if (serial_thread) {
    uv_sem_wait(&barrier->turnstile1);
    uv_sem_post(&barrier->turnstile2);
  }
  uv_mutex_unlock(&barrier->mutex);
 
  uv_sem_wait(&barrier->turnstile2);
  uv_sem_post(&barrier->turnstile2);
  return serial_thread;
}

References uv_barrier_t::b, b, uv_barrier_t::count, uv_barrier_t::mutex, uv_barrier_t::n, NULL, uv_barrier_t::turnstile1, uv_barrier_t::turnstile2, uv_cond_signal(), uv_cond_wait(), uv_mutex_lock(), uv_mutex_unlock(), uv_sem_post(), and uv_sem_wait().

Referenced by main(), reader(), and writer().

uv_cond_broadcast()

void uv_cond_broadcast

(

uv_cond_t *

cond

)

Definition at line 408 of file thread.c.

                                        {
  WakeAllConditionVariable(&cond->cond_var);
}

References cond.

uv_cond_destroy()

void uv_cond_destroy

(

uv_cond_t *

cond

)

Definition at line 397 of file thread.c.

                                      {
  /* nothing to do */
  (void) &cond;
}

References cond, err, ETIMEDOUT, mutex, NULL, timespec::tv_nsec, and timespec::tv_sec.

Referenced by uv__threadpool_cleanup().

uv_cond_init()

int uv_cond_init

(

uv_cond_t *

cond

)

Definition at line 391 of file thread.c.

                                  {
  InitializeConditionVariable(&cond->cond_var);
  return 0;
}

References cond, err, error(), and UV__ERR.

Referenced by init_threads().

uv_cond_signal()

void uv_cond_signal

(

uv_cond_t *

cond

)

Definition at line 403 of file thread.c.

                                     {
  WakeConditionVariable(&cond->cond_var);
}

References cond.

Referenced by post(), and worker().

uv_cond_timedwait()

int uv_cond_timedwait	(	uv_cond_t *	cond,
		uv_mutex_t *	mutex,
		uint64_t	timeout
	)

Definition at line 418 of file thread.c.

                                                                            {
  if (SleepConditionVariableCS(&cond->cond_var, mutex, (DWORD)(timeout / 1e6)))
    return 0;
  if (GetLastError() != ERROR_TIMEOUT)
    abort();
  return UV_ETIMEDOUT;
}

References cond, DWORD, ETIMEDOUT, gettimeofday, mutex, NANOSEC, NULL, r, timeout, tv, timespec::tv_nsec, timespec::tv_sec, uv__hrtime(), and UV_CLOCK_PRECISE.

uv_cond_wait()

void uv_cond_wait	(	uv_cond_t *	cond,
		uv_mutex_t *	mutex
	)

Definition at line 413 of file thread.c.

                                                      {
  if (!SleepConditionVariableCS(&cond->cond_var, mutex, INFINITE))
    abort();
}

References cond, and mutex.

Referenced by worker().

uv_key_create()

int uv_key_create

(

uv_key_t *

key

)

Definition at line 490 of file thread.c.

                                 {
  key->tls_index = TlsAlloc();
  if (key->tls_index == TLS_OUT_OF_INDEXES)
    return UV_ENOMEM;
  return 0;
}

References key, NULL, and UV__ERR.

uv_key_delete()

void uv_key_delete

(

uv_key_t *

key

)

Definition at line 498 of file thread.c.

                                  {
  if (TlsFree(key->tls_index) == FALSE)
    abort();
  key->tls_index = TLS_OUT_OF_INDEXES;
}

References FALSE, and key.

uv_key_get()

void* uv_key_get

(

uv_key_t *

key

)

Definition at line 505 of file thread.c.

                                {
  void* value;
 
  value = TlsGetValue(key->tls_index);
  if (value == NULL)
    if (GetLastError() != ERROR_SUCCESS)
      abort();
 
  return value;
}

References key, NULL, and value.

uv_key_set()

void uv_key_set	(	uv_key_t *	key,
		void *	value
	)

Definition at line 517 of file thread.c.

                                            {
  if (TlsSetValue(key->tls_index, value) == FALSE)
    abort();
}

References FALSE, key, and value.

uv_mutex_destroy()

void uv_mutex_destroy

(

uv_mutex_t *

mutex

)

Definition at line 218 of file thread.c.

                                         {
  DeleteCriticalSection(mutex);
}

References mutex.

Referenced by child_fork(), uv__loop_close(), uv__threadpool_cleanup(), and uv_loop_init().

uv_mutex_init()

int uv_mutex_init

(

uv_mutex_t *

mutex

)

Definition at line 207 of file thread.c.

                                     {
  InitializeCriticalSection(mutex);
  return 0;
}

References err, mutex, NULL, and UV__ERR.

Referenced by epoll_init(), init_process_title_mutex_once(), init_threads(), uv__fd_hash_init(), uv__loops_init(), uv_console_init(), and uv_loop_init().

uv_mutex_init_recursive()

int uv_mutex_init_recursive

(

uv_mutex_t *

mutex

)

Definition at line 213 of file thread.c.

                                               {
  return uv_mutex_init(mutex);
}

References err, mutex, UV__ERR, and uv_mutex_init().

uv_mutex_lock()

void uv_mutex_lock

(

uv_mutex_t *

mutex

)

Definition at line 223 of file thread.c.

                                      {
  EnterCriticalSection(mutex);
}

References mutex.

Referenced by before_fork(), epoll_create1(), epoll_ctl(), epoll_file_close(), epoll_queue_close(), post(), uv__fd_hash_add(), uv__fd_hash_get(), uv__fd_hash_remove(), uv__loop_close(), uv__loops_add(), uv__loops_remove(), uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), uv__tty_console_signal_resize(), uv__wake_all_loops(), uv__work_cancel(), uv__work_done(), uv_exepath(), uv_get_process_title(), uv_metrics_idle_time(), uv_set_process_title(), uv_setup_args(), and worker().

uv_mutex_trylock()

int uv_mutex_trylock

(

uv_mutex_t *

mutex

)

Definition at line 228 of file thread.c.

                                        {
  if (TryEnterCriticalSection(mutex))
    return 0;
  else
    return UV_EBUSY;
}

References EAGAIN, EBUSY, err, and mutex.

uv_mutex_unlock()

void uv_mutex_unlock

(

uv_mutex_t *

mutex

)

Definition at line 236 of file thread.c.

                                        {
  LeaveCriticalSection(mutex);
}

References mutex.

Referenced by after_fork(), child_fork(), epoll_create1(), epoll_ctl(), epoll_file_close(), epoll_queue_close(), post(), uv__fd_hash_add(), uv__fd_hash_get(), uv__fd_hash_remove(), uv__loop_close(), uv__loops_add(), uv__loops_remove(), uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), uv__tty_console_signal_resize(), uv__wake_all_loops(), uv__work_cancel(), uv__work_done(), uv_exepath(), uv_get_process_title(), uv_metrics_idle_time(), uv_set_process_title(), uv_setup_args(), and worker().

uv_once()

void uv_once	(	uv_once_t *	guard,
		void(*)(void)	callback
	)

Definition at line 67 of file thread.c.

                                                       {
  /* Fast case - avoid WaitForSingleObject. */
  if (guard->ran) {
    return;
  }
 
  uv__once_inner(guard, callback);
}

References uv__once_inner().

Referenced by epoll_create1(), epoll_file_close(), uv__fs_mkstemp(), uv__get_overlapped_dummy(), uv__hrtime(), uv__once_init(), uv__random_devurandom(), uv__random_getentropy(), uv__random_getrandom_init(), uv__signal_global_once_init(), uv__udp_sendmsg(), uv__work_submit(), uv_exepath(), uv_get_process_title(), uv_set_process_title(), uv_setup_args(), uv_spawn(), and uv_udp_using_recvmmsg().

uv_rwlock_destroy()

void uv_rwlock_destroy

(

uv_rwlock_t *

rwlock

)

Definition at line 258 of file thread.c.

                                            {
  DeleteCriticalSection(&rwlock->state_.num_readers_lock_);
  CloseHandle(rwlock->state_.write_semaphore_);
}

References uv_rwlock_t::num_readers_lock_, uv_rwlock_t::state_, and uv_rwlock_t::write_semaphore_.

Referenced by main(), uv__loop_close(), and uv_loop_init().

uv_rwlock_init()

int uv_rwlock_init

(

uv_rwlock_t *

rwlock

)

Definition at line 241 of file thread.c.

                                        {
  /* Initialize the semaphore that acts as the write lock. */
  HANDLE handle = CreateSemaphoreW(NULL, 1, 1, NULL);
  if (handle == NULL)
    return uv_translate_sys_error(GetLastError());
  rwlock->state_.write_semaphore_ = handle;
 
  /* Initialize the critical section protecting the reader count. */
  InitializeCriticalSection(&rwlock->state_.num_readers_lock_);
 
  /* Initialize the reader count. */
  rwlock->state_.num_readers_ = 0;
 
  return 0;
}

References handle, HANDLE, NULL, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, uv_rwlock_t::state_, UV__ERR, uv_translate_sys_error(), and uv_rwlock_t::write_semaphore_.

Referenced by main(), and uv_loop_init().

uv_rwlock_rdlock()

void uv_rwlock_rdlock

(

uv_rwlock_t *

rwlock

)

Definition at line 264 of file thread.c.

                                           {
  /* Acquire the lock that protects the reader count. */
  EnterCriticalSection(&rwlock->state_.num_readers_lock_);
 
  /* Increase the reader count, and lock for write if this is the first
   * reader.
   */
  if (++rwlock->state_.num_readers_ == 1) {
    DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, INFINITE);
    if (r != WAIT_OBJECT_0)
      uv_fatal_error(GetLastError(), "WaitForSingleObject");
  }
 
  /* Release the lock that protects the reader count. */
  LeaveCriticalSection(&rwlock->state_.num_readers_lock_);
}

References DWORD, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by reader(), uv__fs_mkstemp(), and uv__fs_open().

uv_rwlock_rdunlock()

void uv_rwlock_rdunlock

(

uv_rwlock_t *

rwlock

)

Definition at line 314 of file thread.c.

                                             {
  EnterCriticalSection(&rwlock->state_.num_readers_lock_);
 
  if (--rwlock->state_.num_readers_ == 0) {
    if (!ReleaseSemaphore(rwlock->state_.write_semaphore_, 1, NULL))
      uv_fatal_error(GetLastError(), "ReleaseSemaphore");
  }
 
  LeaveCriticalSection(&rwlock->state_.num_readers_lock_);
}

References NULL, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by reader(), uv__fs_mkstemp(), and uv__fs_open().

uv_rwlock_tryrdlock()

int uv_rwlock_tryrdlock

(

uv_rwlock_t *

rwlock

)

Definition at line 282 of file thread.c.

                                             {
  int err;
 
  if (!TryEnterCriticalSection(&rwlock->state_.num_readers_lock_))
    return UV_EBUSY;
 
  err = 0;
 
  if (rwlock->state_.num_readers_ == 0) {
    /* Currently there are no other readers, which means that the write lock
     * needs to be acquired.
     */
    DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, 0);
    if (r == WAIT_OBJECT_0)
      rwlock->state_.num_readers_++;
    else if (r == WAIT_TIMEOUT)
      err = UV_EBUSY;
    else if (r == WAIT_FAILED)
      uv_fatal_error(GetLastError(), "WaitForSingleObject");
 
  } else {
    /* The write lock has already been acquired because there are other
     * active readers.
     */
    rwlock->state_.num_readers_++;
  }
 
  LeaveCriticalSection(&rwlock->state_.num_readers_lock_);
  return err;
}

References DWORD, EAGAIN, EBUSY, err, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

uv_rwlock_trywrlock()

int uv_rwlock_trywrlock

(

uv_rwlock_t *

rwlock

)

Definition at line 333 of file thread.c.

                                             {
  DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, 0);
  if (r == WAIT_OBJECT_0)
    return 0;
  else if (r == WAIT_TIMEOUT)
    return UV_EBUSY;
  else
    uv_fatal_error(GetLastError(), "WaitForSingleObject");
}

References DWORD, EAGAIN, EBUSY, err, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

uv_rwlock_wrlock()

void uv_rwlock_wrlock

(

uv_rwlock_t *

rwlock

)

Definition at line 326 of file thread.c.

                                           {
  DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, INFINITE);
  if (r != WAIT_OBJECT_0)
    uv_fatal_error(GetLastError(), "WaitForSingleObject");
}

References DWORD, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by uv_spawn(), and writer().

uv_rwlock_wrunlock()

void uv_rwlock_wrunlock

(

uv_rwlock_t *

rwlock

)

Definition at line 344 of file thread.c.

                                             {
  if (!ReleaseSemaphore(rwlock->state_.write_semaphore_, 1, NULL))
    uv_fatal_error(GetLastError(), "ReleaseSemaphore");
}

References NULL, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by uv_spawn(), and writer().

uv_sem_destroy()

void uv_sem_destroy

(

uv_sem_t *

sem

)

Definition at line 359 of file thread.c.

                                   {
  if (!CloseHandle(*sem))
    abort();
}

References platform_needs_custom_semaphore, uv__custom_sem_destroy(), and uv__sem_destroy().

Referenced by init_threads(), and uv__stream_close().

uv_sem_init()

int uv_sem_init	(	uv_sem_t *	sem,
		unsigned int	value
	)

Definition at line 350 of file thread.c.

                                                   {
  *sem = CreateSemaphore(NULL, value, INT_MAX, NULL);
  if (*sem == NULL)
    return uv_translate_sys_error(GetLastError());
  else
    return 0;
}

References INT_MAX, NULL, platform_needs_custom_semaphore, uv__custom_sem_init(), uv__sem_init(), uv_once(), uv_translate_sys_error(), and value.

Referenced by init_threads(), and uv_console_init().

uv_sem_post()

void uv_sem_post

(

uv_sem_t *

sem

)

Definition at line 365 of file thread.c.

                                {
  if (!ReleaseSemaphore(*sem, 1, NULL))
    abort();
}

References NULL, platform_needs_custom_semaphore, uv__custom_sem_post(), and uv__sem_post().

Referenced by uv__cancel_read_console(), uv__stream_close(), uv_tty_get_vterm_state(), uv_tty_get_winsize(), uv_tty_init(), uv_tty_line_read_thread(), uv_tty_set_mode(), uv_tty_set_vterm_state(), uv_tty_write_bufs(), and worker().

uv_sem_trywait()

int uv_sem_trywait

(

uv_sem_t *

sem

)

Definition at line 377 of file thread.c.

                                  {
  DWORD r = WaitForSingleObject(*sem, 0);
 
  if (r == WAIT_OBJECT_0)
    return 0;
 
  if (r == WAIT_TIMEOUT)
    return UV_EAGAIN;
 
  abort();
  return -1; /* Satisfy the compiler. */
}

References DWORD, platform_needs_custom_semaphore, r, uv__custom_sem_trywait(), and uv__sem_trywait().

uv_sem_wait()

void uv_sem_wait

(

uv_sem_t *

sem

)

Definition at line 371 of file thread.c.

                                {
  if (WaitForSingleObject(*sem, INFINITE) != WAIT_OBJECT_0)
    abort();
}

References platform_needs_custom_semaphore, uv__custom_sem_wait(), and uv__sem_wait().

Referenced by init_threads(), uv__cancel_read_console(), uv_tty_get_vterm_state(), uv_tty_get_winsize(), uv_tty_init(), uv_tty_set_mode(), uv_tty_set_vterm_state(), and uv_tty_write_bufs().

uv_thread_create()

int uv_thread_create	(	uv_thread_t *	tid,
		void(*)(void *arg)	entry,
		void *	arg
	)

Definition at line 114 of file thread.c.

                                                                            {
  uv_thread_options_t params;
  params.flags = UV_THREAD_NO_FLAGS;
  return uv_thread_create_ex(tid, &params, entry, arg);
}

References uv_thread_options_s::flags, uv_thread_create_ex(), and UV_THREAD_NO_FLAGS.

Referenced by init_threads(), and main().

uv_thread_create_ex()

int uv_thread_create_ex	(	uv_thread_t *	tid,
		const uv_thread_options_t *	params,
		void(*)(void *arg)	entry,
		void *	arg
	)

Definition at line 120 of file thread.c.

                                   {
  struct thread_ctx* ctx;
  int err;
  HANDLE thread;
  SYSTEM_INFO sysinfo;
  size_t stack_size;
  size_t pagesize;
 
  stack_size =
      params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
 
  if (stack_size != 0) {
    GetNativeSystemInfo(&sysinfo);
    pagesize = (size_t)sysinfo.dwPageSize;
    /* Round up to the nearest page boundary. */
    stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
 
    if ((unsigned)stack_size != stack_size)
      return UV_EINVAL;
  }
 
  ctx = uv__malloc(sizeof(*ctx));
  if (ctx == NULL)
    return UV_ENOMEM;
 
  ctx->entry = entry;
  ctx->arg = arg;
 
  /* Create the thread in suspended state so we have a chance to pass
   * its own creation handle to it */
  thread = (HANDLE) _beginthreadex(NULL,
                                   (unsigned)stack_size,
                                   uv__thread_start,
                                   ctx,
                                   CREATE_SUSPENDED,
                                   NULL);
  if (thread == NULL) {
    err = errno;
    uv__free(ctx);
  } else {
    err = 0;
    *tid = thread;
    ctx->self = thread;
    ResumeThread(thread);
  }
 
  switch (err) {
    case 0:
      return 0;
    case EACCES:
      return UV_EACCES;
    case EAGAIN:
      return UV_EAGAIN;
    case EINVAL:
      return UV_EINVAL;
  }
 
  return UV_EIO;
}

References arg(), EACCES, EAGAIN, EINVAL, thread_ctx::entry, err, f, uv_thread_options_s::flags, HANDLE, in, NULL, uv_thread_options_s::stack_size, sysinfo, thread_stack_size(), UV__ERR, uv__free(), uv__malloc(), uv__thread_start(), and UV_THREAD_HAS_STACK_SIZE.

uv_thread_equal()

int uv_thread_equal	(	const uv_thread_t *	t1,
		const uv_thread_t *	t2
	)

Definition at line 202 of file thread.c.

                                                                  {
  return *t1 == *t2;
}

References benchmark::t1.

uv_thread_join()

int uv_thread_join

(

uv_thread_t *

tid

)

Definition at line 190 of file thread.c.

                                     {
  if (WaitForSingleObject(*tid, INFINITE))
    return uv_translate_sys_error(GetLastError());
  else {
    CloseHandle(*tid);
    *tid = 0;
    MemoryBarrier();  /* For feature parity with pthread_join(). */
    return 0;
  }
}

References NULL, UV__ERR, and uv_translate_sys_error().

Referenced by main(), uv__stream_close(), and uv__threadpool_cleanup().

uv_thread_self()

uv_thread_t uv_thread_self

(

void

)

Definition at line 184 of file thread.c.

                                 {
  uv_once(&uv__current_thread_init_guard, uv__init_current_thread_key);
  return (uv_thread_t) uv_key_get(&uv__current_thread_key);
}

References uv__current_thread_init_guard, uv__current_thread_key, uv__init_current_thread_key(), uv_key_get(), and uv_once().

Variable Documentation

uv__current_thread_init_guard

uv_once_t uv__current_thread_init_guard = UV_ONCE_INIT

static

Definition at line 81 of file thread.c.

Referenced by uv__thread_start(), and uv_thread_self().

uv__current_thread_key

uv_key_t uv__current_thread_key

static

Definition at line 80 of file thread.c.

Referenced by uv__init_current_thread_key(), uv__thread_start(), and uv_thread_self().