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->timeout = 0;
62 handle->repeat = 0;
63 return 0;
64}
65
66
67int uv_timer_start(uv_timer_t* handle,
68 uv_timer_cb cb,
69 uint64_t timeout,
70 uint64_t repeat) {
71 uint64_t clamped_timeout;
72
73 if (uv__is_closing(handle) || cb == NULL)
74 return UV_EINVAL;
75
76 if (uv__is_active(handle))
77 uv_timer_stop(handle);
78
79 clamped_timeout = handle->loop->time + timeout;
80 if (clamped_timeout < timeout)
81 clamped_timeout = (uint64_t) -1;
82
83 handle->timer_cb = cb;
84 handle->timeout = clamped_timeout;
85 handle->repeat = repeat;
86 /* start_id is the second index to be compared in timer_less_than() */
87 handle->start_id = handle->loop->timer_counter++;
88
89 heap_insert(timer_heap(handle->loop),
90 (struct heap_node*) &handle->heap_node,
91 timer_less_than);
92 uv__handle_start(handle);
93
94 return 0;
95}
96
97
98int uv_timer_stop(uv_timer_t* handle) {
99 if (!uv__is_active(handle))
100 return 0;
101
102 heap_remove(timer_heap(handle->loop),
103 (struct heap_node*) &handle->heap_node,
104 timer_less_than);
105 uv__handle_stop(handle);
106
107 return 0;
108}
109
110
111int uv_timer_again(uv_timer_t* handle) {
112 if (handle->timer_cb == NULL)
113 return UV_EINVAL;
114
115 if (handle->repeat) {
116 uv_timer_stop(handle);
117 uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
118 }
119
120 return 0;
121}
122
123
124void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) {
125 handle->repeat = repeat;
126}
127
128
129uint64_t uv_timer_get_repeat(const uv_timer_t* handle) {
130 return handle->repeat;
131}
132
133
134uint64_t uv_timer_get_due_in(const uv_timer_t* handle) {
135 if (handle->loop->time >= handle->timeout)
136 return 0;
137
138 return handle->timeout - handle->loop->time;
139}
140
141
142int uv__next_timeout(const uv_loop_t* loop) {
143 const struct heap_node* heap_node;
144 const uv_timer_t* handle;
145 uint64_t diff;
146
147 heap_node = heap_min(timer_heap(loop));
148 if (heap_node == NULL)
149 return -1; /* block indefinitely */
150
151 handle = container_of(heap_node, uv_timer_t, heap_node);
152 if (handle->timeout <= loop->time)
153 return 0;
154
155 diff = handle->timeout - loop->time;
156 if (diff > INT_MAX)
157 diff = INT_MAX;
158
159 return (int) diff;
160}
161
162
163void uv__run_timers(uv_loop_t* loop) {
164 struct heap_node* heap_node;
165 uv_timer_t* handle;
166
167 for (;;) {
168 heap_node = heap_min(timer_heap(loop));
169 if (heap_node == NULL)
170 break;
171
172 handle = container_of(heap_node, uv_timer_t, heap_node);
173 if (handle->timeout > loop->time)
174 break;
175
176 uv_timer_stop(handle);
177 uv_timer_again(handle);
178 handle->timer_cb(handle);
179 }
180}
181
182
183void uv__timer_close(uv_timer_t* handle) {
184 uv_timer_stop(handle);
185}
186