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 29 static 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 38 static 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 58 int 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 66 int 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 97 int 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 110 int 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 123 void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) { 124 handle->repeat = repeat; 125 } 126 127 128 uint64_t uv_timer_get_repeat(const uv_timer_t* handle) { 129 return handle->repeat; 130 } 131 132 133 int 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 154 void 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 174 void uv__timer_close(uv_timer_t* handle) { 175 uv_timer_stop(handle); 176 } 177