timer.c File Reference

#include "uv.h"
#include "uv-common.h"
#include "heap-inl.h"
#include <assert.h>
#include <limits.h>

Go to the source code of this file.

Functions
static struct heap *	timer_heap (const uv_loop_t *loop)
static int	timer_less_than (const struct heap_node *ha, const struct heap_node *hb)
int	uv_timer_init (uv_loop_t *loop, uv_timer_t *handle)
int	uv_timer_start (uv_timer_t *handle, uv_timer_cb cb, uint64_t timeout, uint64_t repeat)
int	uv_timer_stop (uv_timer_t *handle)
int	uv_timer_again (uv_timer_t *handle)
void	uv_timer_set_repeat (uv_timer_t *handle, uint64_t repeat)
uint64_t	uv_timer_get_repeat (const uv_timer_t *handle)
uint64_t	uv_timer_get_due_in (const uv_timer_t *handle)
int	uv__next_timeout (const uv_loop_t *loop)
void	uv__run_timers (uv_loop_t *loop)
void	uv__timer_close (uv_timer_t *handle)

Function Documentation

timer_heap()

static struct heap* timer_heap ( const uv_loop_t *  loop )

static

Definition at line 29 of file timer.c.

                                                      {
#ifdef _WIN32
  return (struct heap*) loop->timer_heap;
#else
  return (struct heap*) &loop->timer_heap;
#endif
}

References loop.

Referenced by uv__next_timeout(), uv__run_timers(), uv_loop_init(), uv_timer_start(), and uv_timer_stop().

timer_less_than()

static int timer_less_than ( const struct heap_node *  ha, const struct heap_node *  hb  )

static

Definition at line 38 of file timer.c.

                                                       {
  const uv_timer_t* a;
  const uv_timer_t* b;
 
  a = container_of(ha, uv_timer_t, heap_node);
  b = container_of(hb, uv_timer_t, heap_node);
 
  if (a->timeout < b->timeout)
    return 1;
  if (b->timeout < a->timeout)
    return 0;
 
  /* Compare start_id when both have the same timeout. start_id is
   * allocated with loop->timer_counter in uv_timer_start().
   */
  return a->start_id < b->start_id;
}

References a, b, and container_of.

Referenced by uv_timer_start(), and uv_timer_stop().

uv__next_timeout()

int uv__next_timeout

(

const uv_loop_t *

loop

)

Definition at line 141 of file timer.c.

                                            {
  const struct heap_node* heap_node;
  const uv_timer_t* handle;
  uint64_t diff;
 
  heap_node = heap_min(timer_heap(loop));
  if (heap_node == NULL)
    return -1; /* block indefinitely */
 
  handle = container_of(heap_node, uv_timer_t, heap_node);
  if (handle->timeout <= loop->time)
    return 0;
 
  diff = handle->timeout - loop->time;
  if (diff > INT_MAX)
    diff = INT_MAX;
 
  return (int) diff;
}

References container_of, handle, INT_MAX, loop, NULL, and timer_heap().

Referenced by uv_backend_timeout().

uv__run_timers()

void uv__run_timers

(

uv_loop_t *

loop

)

Definition at line 162 of file timer.c.

                                     {
  struct heap_node* heap_node;
  uv_timer_t* handle;
 
  for (;;) {
    heap_node = heap_min(timer_heap(loop));
    if (heap_node == NULL)
      break;
 
    handle = container_of(heap_node, uv_timer_t, heap_node);
    if (handle->timeout > loop->time)
      break;
 
    uv_timer_stop(handle);
    uv_timer_again(handle);
    handle->timer_cb(handle);
  }
}

References container_of, handle, loop, NULL, timer_heap(), uv_timer_again(), and uv_timer_stop().

Referenced by uv_run().

uv__timer_close()

void uv__timer_close

(

uv_timer_t *

handle

)

Definition at line 182 of file timer.c.

                                         {
  uv_timer_stop(handle);
}

References handle, and uv_timer_stop().

Referenced by uv_close(), and uv_process_endgames().

uv_timer_again()

int uv_timer_again

(

uv_timer_t *

handle

)

Definition at line 110 of file timer.c.

                                       {
  if (handle->timer_cb == NULL)
    return UV_EINVAL;
 
  if (handle->repeat) {
    uv_timer_stop(handle);
    uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
  }
 
  return 0;
}

References handle, NULL, uv_timer_start(), and uv_timer_stop().

Referenced by uv__run_timers().

uv_timer_get_due_in()

uint64_t uv_timer_get_due_in

(

const uv_timer_t *

handle

)

Definition at line 133 of file timer.c.

                                                       {
  if (handle->loop->time >= handle->timeout)
    return 0;
 
  return handle->timeout - handle->loop->time;
}

References handle.

uv_timer_get_repeat()

uint64_t uv_timer_get_repeat

(

const uv_timer_t *

handle

)

Definition at line 128 of file timer.c.

                                                       {
  return handle->repeat;
}

References handle.

uv_timer_init()

int uv_timer_init	(	uv_loop_t *	loop,
		uv_timer_t *	handle
	)

Definition at line 58 of file timer.c.

                                                       {
  uv__handle_init(loop, (uv_handle_t*)handle, UV_TIMER);
  handle->timer_cb = NULL;
  handle->repeat = 0;
  return 0;
}

References handle, loop, NULL, and uv__handle_init.

Referenced by eof_timer_init(), main(), and uv_fs_poll_start().

uv_timer_set_repeat()

void uv_timer_set_repeat	(	uv_timer_t *	handle,
		uint64_t	repeat
	)

Definition at line 123 of file timer.c.

                                                              {
  handle->repeat = repeat;
}

References handle, and repeat().

uv_timer_start()

int uv_timer_start	(	uv_timer_t *	handle,
		uv_timer_cb	cb,
		uint64_t	timeout,
		uint64_t	repeat
	)

Definition at line 66 of file timer.c.

                                    {
  uint64_t clamped_timeout;
 
  if (uv__is_closing(handle) || cb == NULL)
    return UV_EINVAL;
 
  if (uv__is_active(handle))
    uv_timer_stop(handle);
 
  clamped_timeout = handle->loop->time + timeout;
  if (clamped_timeout < timeout)
    clamped_timeout = (uint64_t) -1;
 
  handle->timer_cb = cb;
  handle->timeout = clamped_timeout;
  handle->repeat = repeat;
  /* start_id is the second index to be compared in timer_less_than() */
  handle->start_id = handle->loop->timer_counter++;
 
  heap_insert(timer_heap(handle->loop),
              (struct heap_node*) &handle->heap_node,
              timer_less_than);
  uv__handle_start(handle);
 
  return 0;
}

References cb, handle, NULL, repeat(), timeout, timer_heap(), timer_less_than(), uv__handle_start, uv__is_active, uv__is_closing, and uv_timer_stop().

Referenced by eof_timer_start(), main(), poll_cb(), start_timeout(), and uv_timer_again().

uv_timer_stop()

int uv_timer_stop

(

uv_timer_t *

handle

)

Definition at line 97 of file timer.c.

                                      {
  if (!uv__is_active(handle))
    return 0;
 
  heap_remove(timer_heap(handle->loop),
              (struct heap_node*) &handle->heap_node,
              timer_less_than);
  uv__handle_stop(handle);
 
  return 0;
}

References handle, timer_heap(), timer_less_than(), uv__handle_stop, and uv__is_active.

Referenced by curl_perform(), eof_timer_stop(), update(), uv__run_timers(), uv__timer_close(), uv_close(), uv_timer_again(), and uv_timer_start().