timer.c revision 1.1.1.1 
1/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2 * Permission is hereby granted, free of charge, to any person obtaining a copy
3 * of this software and associated documentation files (the "Software"), to
4 * deal in the Software without restriction, including without limitation the
5 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
6 * sell copies of the Software, and to permit persons to whom the Software is
7 * furnished to do so, subject to the following conditions:
8 *
9 * The above copyright notice and this permission notice shall be included in
10 * all copies or substantial portions of the Software.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
15 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
17 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
18 * IN THE SOFTWARE.
19 */
20
21#include "uv.h"
22#include "uv-common.h"
23#include "heap-inl.h"
24
25#include <assert.h>
26#include <limits.h>
27
28
29static struct heap *timer_heap(const uv_loop_t* loop) {
30#ifdef _WIN32
31  return (struct heap*) loop->timer_heap;
32#else
33  return (struct heap*) &loop->timer_heap;
34#endif
35}
36
37
38static int timer_less_than(const struct heap_node* ha,
39                           const struct heap_node* hb) {
40  const uv_timer_t* a;
41  const uv_timer_t* b;
42
43  a = container_of(ha, uv_timer_t, heap_node);
44  b = container_of(hb, uv_timer_t, heap_node);
45
46  if (a->timeout < b->timeout)
47    return 1;
48  if (b->timeout < a->timeout)
49    return 0;
50
51  /* Compare start_id when both have the same timeout. start_id is
52   * allocated with loop->timer_counter in uv_timer_start().
53   */
54  return a->start_id < b->start_id;
55}
56
57
58int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) {
59  uv__handle_init(loop, (uv_handle_t*)handle, UV_TIMER);
60  handle->timer_cb = NULL;
61  handle->repeat = 0;
62  return 0;
63}
64
65
66int uv_timer_start(uv_timer_t* handle,
67                   uv_timer_cb cb,
68                   uint64_t timeout,
69                   uint64_t repeat) {
70  uint64_t clamped_timeout;
71
72  if (uv__is_closing(handle) || cb == NULL)
73    return UV_EINVAL;
74
75  if (uv__is_active(handle))
76    uv_timer_stop(handle);
77
78  clamped_timeout = handle->loop->time + timeout;
79  if (clamped_timeout < timeout)
80    clamped_timeout = (uint64_t) -1;
81
82  handle->timer_cb = cb;
83  handle->timeout = clamped_timeout;
84  handle->repeat = repeat;
85  /* start_id is the second index to be compared in timer_less_than() */
86  handle->start_id = handle->loop->timer_counter++;
87
88  heap_insert(timer_heap(handle->loop),
89              (struct heap_node*) &handle->heap_node,
90              timer_less_than);
91  uv__handle_start(handle);
92
93  return 0;
94}
95
96
97int uv_timer_stop(uv_timer_t* handle) {
98  if (!uv__is_active(handle))
99    return 0;
100
101  heap_remove(timer_heap(handle->loop),
102              (struct heap_node*) &handle->heap_node,
103              timer_less_than);
104  uv__handle_stop(handle);
105
106  return 0;
107}
108
109
110int uv_timer_again(uv_timer_t* handle) {
111  if (handle->timer_cb == NULL)
112    return UV_EINVAL;
113
114  if (handle->repeat) {
115    uv_timer_stop(handle);
116    uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
117  }
118
119  return 0;
120}
121
122
123void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) {
124  handle->repeat = repeat;
125}
126
127
128uint64_t uv_timer_get_repeat(const uv_timer_t* handle) {
129  return handle->repeat;
130}
131
132
133int uv__next_timeout(const uv_loop_t* loop) {
134  const struct heap_node* heap_node;
135  const uv_timer_t* handle;
136  uint64_t diff;
137
138  heap_node = heap_min(timer_heap(loop));
139  if (heap_node == NULL)
140    return -1; /* block indefinitely */
141
142  handle = container_of(heap_node, uv_timer_t, heap_node);
143  if (handle->timeout <= loop->time)
144    return 0;
145
146  diff = handle->timeout - loop->time;
147  if (diff > INT_MAX)
148    diff = INT_MAX;
149
150  return (int) diff;
151}
152
153
154void uv__run_timers(uv_loop_t* loop) {
155  struct heap_node* heap_node;
156  uv_timer_t* handle;
157
158  for (;;) {
159    heap_node = heap_min(timer_heap(loop));
160    if (heap_node == NULL)
161      break;
162
163    handle = container_of(heap_node, uv_timer_t, heap_node);
164    if (handle->timeout > loop->time)
165      break;
166
167    uv_timer_stop(handle);
168    uv_timer_again(handle);
169    handle->timer_cb(handle);
170  }
171}
172
173
174void uv__timer_close(uv_timer_t* handle) {
175  uv_timer_stop(handle);
176}
177