ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 6169d5f | 2016-03-31 07:46:18 -0700 | [diff] [blame] | 3 | * Copyright 2015, Google Inc. |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
murgatroid99 | 9030c81 | 2016-09-16 13:25:08 -0700 | [diff] [blame] | 34 | #include "src/core/lib/iomgr/port.h" |
| 35 | |
| 36 | #ifdef GRPC_TIMER_USE_GENERIC |
| 37 | |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 38 | #include "src/core/lib/iomgr/timer.h" |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 39 | |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 40 | #include <grpc/support/alloc.h> |
Craig Tiller | 6a7626c | 2015-07-19 22:21:41 -0700 | [diff] [blame] | 41 | #include <grpc/support/log.h> |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 42 | #include <grpc/support/string_util.h> |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 43 | #include <grpc/support/sync.h> |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 44 | #include <grpc/support/tls.h> |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 45 | #include <grpc/support/useful.h> |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 46 | #include "src/core/lib/debug/trace.h" |
Craig Tiller | 9533d04 | 2016-03-25 17:11:06 -0700 | [diff] [blame] | 47 | #include "src/core/lib/iomgr/time_averaged_stats.h" |
| 48 | #include "src/core/lib/iomgr/timer_heap.h" |
Craig Tiller | edbf2b9 | 2017-02-27 07:24:00 -0800 | [diff] [blame] | 49 | #include "src/core/lib/support/spinlock.h" |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 50 | |
| 51 | #define INVALID_HEAP_INDEX 0xffffffffu |
| 52 | |
| 53 | #define LOG2_NUM_SHARDS 5 |
| 54 | #define NUM_SHARDS (1 << LOG2_NUM_SHARDS) |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 55 | #define ADD_DEADLINE_SCALE 0.33 |
| 56 | #define MIN_QUEUE_WINDOW_DURATION 0.01 |
| 57 | #define MAX_QUEUE_WINDOW_DURATION 1 |
| 58 | |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 59 | int grpc_timer_trace = 0; |
| 60 | int grpc_timer_check_trace = 0; |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 61 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 62 | typedef struct { |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 63 | gpr_mu mu; |
| 64 | grpc_time_averaged_stats stats; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 65 | /* All and only timers with deadlines <= this will be in the heap. */ |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 66 | gpr_atm queue_deadline_cap; |
| 67 | gpr_atm min_deadline; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 68 | /* Index in the g_shard_queue */ |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 69 | uint32_t shard_queue_index; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 70 | /* This holds all timers with deadlines < queue_deadline_cap. Timers in this |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 71 | list have the top bit of their deadline set to 0. */ |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 72 | grpc_timer_heap heap; |
| 73 | /* This holds timers whose deadline is >= queue_deadline_cap. */ |
| 74 | grpc_timer list; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 75 | } shard_type; |
| 76 | |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 77 | struct shared_mutables { |
| 78 | gpr_atm min_timer; |
| 79 | /* Allow only one run_some_expired_timers at once */ |
| 80 | gpr_spinlock checker_mu; |
| 81 | bool initialized; |
| 82 | /* Protects g_shard_queue */ |
| 83 | gpr_mu mu; |
| 84 | } GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE); |
| 85 | |
| 86 | static struct shared_mutables g_shared_mutables = { |
| 87 | .checker_mu = GPR_SPINLOCK_STATIC_INITIALIZER, .initialized = false, |
| 88 | }; |
Craig Tiller | 6a7626c | 2015-07-19 22:21:41 -0700 | [diff] [blame] | 89 | static gpr_clock_type g_clock_type; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 90 | static shard_type g_shards[NUM_SHARDS]; |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 91 | /* Protected by g_shared_mutables.mu */ |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 92 | static shard_type *g_shard_queue[NUM_SHARDS]; |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 93 | static gpr_timespec g_start_time; |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 94 | |
| 95 | GPR_TLS_DECL(g_last_seen_min_timer); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 96 | |
Craig Tiller | bd0af4f | 2017-03-20 08:33:02 -0700 | [diff] [blame] | 97 | static gpr_atm saturating_add(gpr_atm a, gpr_atm b) { |
| 98 | if (a > GPR_ATM_MAX - b) { |
| 99 | return GPR_ATM_MAX; |
| 100 | } |
| 101 | return a + b; |
| 102 | } |
| 103 | |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 104 | static int run_some_expired_timers(grpc_exec_ctx *exec_ctx, gpr_atm now, |
| 105 | gpr_atm *next, grpc_error *error); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 106 | |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 107 | static gpr_timespec dbl_to_ts(double d) { |
| 108 | gpr_timespec ts; |
| 109 | ts.tv_sec = (int64_t)d; |
| 110 | ts.tv_nsec = (int32_t)(1e9 * (d - (double)ts.tv_sec)); |
| 111 | ts.clock_type = GPR_TIMESPAN; |
| 112 | return ts; |
| 113 | } |
| 114 | |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 115 | static gpr_atm timespec_to_atm_round_up(gpr_timespec ts) { |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 116 | ts = gpr_time_sub(ts, g_start_time); |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 117 | double x = GPR_MS_PER_SEC * (double)ts.tv_sec + |
Craig Tiller | 883243a | 2017-03-24 16:08:08 -0700 | [diff] [blame] | 118 | (double)ts.tv_nsec / GPR_NS_PER_MS + |
| 119 | (double)(GPR_NS_PER_SEC - 1) / (double)GPR_NS_PER_SEC; |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 120 | if (x < 0) return 0; |
| 121 | if (x > GPR_ATM_MAX) return GPR_ATM_MAX; |
| 122 | return (gpr_atm)x; |
| 123 | } |
| 124 | |
| 125 | static gpr_atm timespec_to_atm_round_down(gpr_timespec ts) { |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 126 | ts = gpr_time_sub(ts, g_start_time); |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 127 | double x = |
| 128 | GPR_MS_PER_SEC * (double)ts.tv_sec + (double)ts.tv_nsec / GPR_NS_PER_MS; |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 129 | if (x < 0) return 0; |
| 130 | if (x > GPR_ATM_MAX) return GPR_ATM_MAX; |
| 131 | return (gpr_atm)x; |
| 132 | } |
| 133 | |
| 134 | static gpr_timespec atm_to_timespec(gpr_atm x) { |
| 135 | return gpr_time_add(g_start_time, dbl_to_ts((double)x / 1000.0)); |
| 136 | } |
| 137 | |
| 138 | static gpr_atm compute_min_deadline(shard_type *shard) { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 139 | return grpc_timer_heap_is_empty(&shard->heap) |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 140 | ? saturating_add(shard->queue_deadline_cap, 1) |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 141 | : grpc_timer_heap_top(&shard->heap)->deadline; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 142 | } |
| 143 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 144 | void grpc_timer_list_init(gpr_timespec now) { |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 145 | uint32_t i; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 146 | |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 147 | g_shared_mutables.initialized = true; |
| 148 | gpr_mu_init(&g_shared_mutables.mu); |
Craig Tiller | 6a7626c | 2015-07-19 22:21:41 -0700 | [diff] [blame] | 149 | g_clock_type = now.clock_type; |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 150 | g_start_time = now; |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 151 | g_shared_mutables.min_timer = timespec_to_atm_round_down(now); |
| 152 | gpr_tls_init(&g_last_seen_min_timer); |
Craig Tiller | 4e4647a | 2017-03-21 08:44:43 -0700 | [diff] [blame] | 153 | gpr_tls_set(&g_last_seen_min_timer, 0); |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 154 | grpc_register_tracer("timer", &grpc_timer_trace); |
| 155 | grpc_register_tracer("timer_check", &grpc_timer_check_trace); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 156 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 157 | for (i = 0; i < NUM_SHARDS; i++) { |
| 158 | shard_type *shard = &g_shards[i]; |
| 159 | gpr_mu_init(&shard->mu); |
| 160 | grpc_time_averaged_stats_init(&shard->stats, 1.0 / ADD_DEADLINE_SCALE, 0.1, |
| 161 | 0.5); |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 162 | shard->queue_deadline_cap = g_shared_mutables.min_timer; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 163 | shard->shard_queue_index = i; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 164 | grpc_timer_heap_init(&shard->heap); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 165 | shard->list.next = shard->list.prev = &shard->list; |
| 166 | shard->min_deadline = compute_min_deadline(shard); |
| 167 | g_shard_queue[i] = shard; |
| 168 | } |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 169 | } |
| 170 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 171 | void grpc_timer_list_shutdown(grpc_exec_ctx *exec_ctx) { |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 172 | int i; |
ncteisen | 4b36a3d | 2017-03-13 19:08:06 -0700 | [diff] [blame] | 173 | run_some_expired_timers( |
Craig Tiller | c900063 | 2017-03-24 14:28:48 -0700 | [diff] [blame] | 174 | exec_ctx, GPR_ATM_MAX, NULL, |
ncteisen | 4b36a3d | 2017-03-13 19:08:06 -0700 | [diff] [blame] | 175 | GRPC_ERROR_CREATE_FROM_STATIC_STRING("Timer list shutdown")); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 176 | for (i = 0; i < NUM_SHARDS; i++) { |
| 177 | shard_type *shard = &g_shards[i]; |
| 178 | gpr_mu_destroy(&shard->mu); |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 179 | grpc_timer_heap_destroy(&shard->heap); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 180 | } |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 181 | gpr_mu_destroy(&g_shared_mutables.mu); |
| 182 | gpr_tls_destroy(&g_last_seen_min_timer); |
| 183 | g_shared_mutables.initialized = false; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 184 | } |
| 185 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 186 | static double ts_to_dbl(gpr_timespec ts) { |
| 187 | return (double)ts.tv_sec + 1e-9 * ts.tv_nsec; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 188 | } |
| 189 | |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 190 | /* returns true if the first element in the list */ |
Craig Tiller | 1a76926 | 2017-03-27 12:52:59 -0700 | [diff] [blame] | 191 | static void list_join(grpc_timer *head, grpc_timer *timer) { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 192 | timer->next = head; |
| 193 | timer->prev = head->prev; |
| 194 | timer->next->prev = timer->prev->next = timer; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 195 | } |
| 196 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 197 | static void list_remove(grpc_timer *timer) { |
| 198 | timer->next->prev = timer->prev; |
| 199 | timer->prev->next = timer->next; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 200 | } |
| 201 | |
Craig Tiller | 7536af0 | 2015-12-22 13:49:30 -0800 | [diff] [blame] | 202 | static void swap_adjacent_shards_in_queue(uint32_t first_shard_queue_index) { |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 203 | shard_type *temp; |
| 204 | temp = g_shard_queue[first_shard_queue_index]; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 205 | g_shard_queue[first_shard_queue_index] = |
| 206 | g_shard_queue[first_shard_queue_index + 1]; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 207 | g_shard_queue[first_shard_queue_index + 1] = temp; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 208 | g_shard_queue[first_shard_queue_index]->shard_queue_index = |
| 209 | first_shard_queue_index; |
| 210 | g_shard_queue[first_shard_queue_index + 1]->shard_queue_index = |
| 211 | first_shard_queue_index + 1; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 212 | } |
| 213 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 214 | static void note_deadline_change(shard_type *shard) { |
| 215 | while (shard->shard_queue_index > 0 && |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 216 | shard->min_deadline < |
| 217 | g_shard_queue[shard->shard_queue_index - 1]->min_deadline) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 218 | swap_adjacent_shards_in_queue(shard->shard_queue_index - 1); |
| 219 | } |
| 220 | while (shard->shard_queue_index < NUM_SHARDS - 1 && |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 221 | shard->min_deadline > |
| 222 | g_shard_queue[shard->shard_queue_index + 1]->min_deadline) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 223 | swap_adjacent_shards_in_queue(shard->shard_queue_index); |
| 224 | } |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 225 | } |
| 226 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 227 | void grpc_timer_init(grpc_exec_ctx *exec_ctx, grpc_timer *timer, |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 228 | gpr_timespec deadline, grpc_closure *closure, |
| 229 | gpr_timespec now) { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 230 | int is_first_timer = 0; |
yang-g | 6955c5e | 2017-02-13 15:49:27 -0800 | [diff] [blame] | 231 | shard_type *shard = &g_shards[GPR_HASH_POINTER(timer, NUM_SHARDS)]; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 232 | GPR_ASSERT(deadline.clock_type == g_clock_type); |
| 233 | GPR_ASSERT(now.clock_type == g_clock_type); |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 234 | timer->closure = closure; |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 235 | timer->deadline = timespec_to_atm_round_up(deadline); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 236 | |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 237 | if (grpc_timer_trace) { |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 238 | gpr_log(GPR_DEBUG, "TIMER %p: SET %" PRId64 ".%09d [%" PRIdPTR |
| 239 | "] now %" PRId64 ".%09d [%" PRIdPTR "] call %p[%p]", |
Craig Tiller | afb168b | 2017-03-21 12:48:57 -0700 | [diff] [blame] | 240 | timer, deadline.tv_sec, deadline.tv_nsec, timer->deadline, |
| 241 | now.tv_sec, now.tv_nsec, timespec_to_atm_round_down(now), closure, |
| 242 | closure->cb); |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 243 | } |
| 244 | |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 245 | if (!g_shared_mutables.initialized) { |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 246 | timer->pending = false; |
ncteisen | 4b36a3d | 2017-03-13 19:08:06 -0700 | [diff] [blame] | 247 | grpc_closure_sched(exec_ctx, timer->closure, |
| 248 | GRPC_ERROR_CREATE_FROM_STATIC_STRING( |
| 249 | "Attempt to create timer before initialization")); |
Craig Tiller | 3f72df9 | 2016-04-13 20:26:07 -0700 | [diff] [blame] | 250 | return; |
| 251 | } |
| 252 | |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 253 | gpr_mu_lock(&shard->mu); |
| 254 | timer->pending = true; |
Craig Tiller | 3f72df9 | 2016-04-13 20:26:07 -0700 | [diff] [blame] | 255 | if (gpr_time_cmp(deadline, now) <= 0) { |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 256 | timer->pending = false; |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 257 | grpc_closure_sched(exec_ctx, timer->closure, GRPC_ERROR_NONE); |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 258 | gpr_mu_unlock(&shard->mu); |
| 259 | /* early out */ |
Craig Tiller | 3f72df9 | 2016-04-13 20:26:07 -0700 | [diff] [blame] | 260 | return; |
| 261 | } |
| 262 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 263 | grpc_time_averaged_stats_add_sample(&shard->stats, |
| 264 | ts_to_dbl(gpr_time_sub(deadline, now))); |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 265 | if (timer->deadline < shard->queue_deadline_cap) { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 266 | is_first_timer = grpc_timer_heap_add(&shard->heap, timer); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 267 | } else { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 268 | timer->heap_index = INVALID_HEAP_INDEX; |
Craig Tiller | 1a76926 | 2017-03-27 12:52:59 -0700 | [diff] [blame] | 269 | list_join(&shard->list, timer); |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 270 | } |
| 271 | if (grpc_timer_trace) { |
| 272 | gpr_log(GPR_DEBUG, " .. add to shard %d with queue_deadline_cap=%" PRIdPTR |
| 273 | " => is_first_timer=%s", |
| 274 | (int)(shard - g_shards), shard->queue_deadline_cap, |
| 275 | is_first_timer ? "true" : "false"); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 276 | } |
| 277 | gpr_mu_unlock(&shard->mu); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 278 | |
| 279 | /* Deadline may have decreased, we need to adjust the master queue. Note |
| 280 | that there is a potential racy unlocked region here. There could be a |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 281 | reordering of multiple grpc_timer_init calls, at this point, but the < test |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 282 | below should ensure that we err on the side of caution. There could |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 283 | also be a race with grpc_timer_check, which might beat us to the lock. In |
| 284 | that case, it is possible that the timer that we added will have already |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 285 | run by the time we hold the lock, but that too is a safe error. |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 286 | Finally, it's possible that the grpc_timer_check that intervened failed to |
| 287 | trigger the new timer because the min_deadline hadn't yet been reduced. |
| 288 | In that case, the timer will simply have to wait for the next |
| 289 | grpc_timer_check. */ |
| 290 | if (is_first_timer) { |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 291 | gpr_mu_lock(&g_shared_mutables.mu); |
Craig Tiller | 18e7465 | 2017-03-24 15:44:27 -0700 | [diff] [blame] | 292 | if (grpc_timer_trace) { |
| 293 | gpr_log(GPR_DEBUG, " .. old shard min_deadline=%" PRIdPTR, |
| 294 | shard->min_deadline); |
| 295 | } |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 296 | if (timer->deadline < shard->min_deadline) { |
| 297 | gpr_atm old_min_deadline = g_shard_queue[0]->min_deadline; |
| 298 | shard->min_deadline = timer->deadline; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 299 | note_deadline_change(shard); |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 300 | if (shard->shard_queue_index == 0 && timer->deadline < old_min_deadline) { |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 301 | gpr_atm_no_barrier_store(&g_shared_mutables.min_timer, timer->deadline); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 302 | grpc_kick_poller(); |
| 303 | } |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 304 | } |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 305 | gpr_mu_unlock(&g_shared_mutables.mu); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 306 | } |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 307 | } |
| 308 | |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 309 | void grpc_timer_consume_kick(void) { |
| 310 | /* force re-evaluation of last seeen min */ |
| 311 | gpr_tls_set(&g_last_seen_min_timer, 0); |
| 312 | } |
| 313 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 314 | void grpc_timer_cancel(grpc_exec_ctx *exec_ctx, grpc_timer *timer) { |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 315 | if (!g_shared_mutables.initialized) { |
Craig Tiller | 82c63eb | 2016-05-10 15:28:01 -0700 | [diff] [blame] | 316 | /* must have already been cancelled, also the shard mutex is invalid */ |
| 317 | return; |
| 318 | } |
| 319 | |
yang-g | 6955c5e | 2017-02-13 15:49:27 -0800 | [diff] [blame] | 320 | shard_type *shard = &g_shards[GPR_HASH_POINTER(timer, NUM_SHARDS)]; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 321 | gpr_mu_lock(&shard->mu); |
Craig Tiller | a0bfee9 | 2017-03-27 09:21:11 -0700 | [diff] [blame] | 322 | if (grpc_timer_trace) { |
| 323 | gpr_log(GPR_DEBUG, "TIMER %p: CANCEL pending=%s", timer, |
| 324 | timer->pending ? "true" : "false"); |
| 325 | } |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 326 | if (timer->pending) { |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 327 | grpc_closure_sched(exec_ctx, timer->closure, GRPC_ERROR_CANCELLED); |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 328 | timer->pending = false; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 329 | if (timer->heap_index == INVALID_HEAP_INDEX) { |
| 330 | list_remove(timer); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 331 | } else { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 332 | grpc_timer_heap_remove(&shard->heap, timer); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 333 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 334 | } |
| 335 | gpr_mu_unlock(&shard->mu); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | /* This is called when the queue is empty and "now" has reached the |
| 339 | queue_deadline_cap. We compute a new queue deadline and then scan the map |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 340 | for timers that fall at or under it. Returns true if the queue is no |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 341 | longer empty. |
| 342 | REQUIRES: shard->mu locked */ |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 343 | static int refill_queue(shard_type *shard, gpr_atm now) { |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 344 | /* Compute the new queue window width and bound by the limits: */ |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 345 | double computed_deadline_delta = |
| 346 | grpc_time_averaged_stats_update_average(&shard->stats) * |
| 347 | ADD_DEADLINE_SCALE; |
| 348 | double deadline_delta = |
| 349 | GPR_CLAMP(computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION, |
| 350 | MAX_QUEUE_WINDOW_DURATION); |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 351 | grpc_timer *timer, *next; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 352 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 353 | /* Compute the new cap and put all timers under it into the queue: */ |
Craig Tiller | bd0af4f | 2017-03-20 08:33:02 -0700 | [diff] [blame] | 354 | shard->queue_deadline_cap = |
| 355 | saturating_add(GPR_MAX(now, shard->queue_deadline_cap), |
| 356 | (gpr_atm)(deadline_delta * 1000.0)); |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 357 | |
| 358 | if (grpc_timer_check_trace) { |
| 359 | gpr_log(GPR_DEBUG, " .. shard[%d]->queue_deadline_cap --> %" PRIdPTR, |
| 360 | (int)(shard - g_shards), shard->queue_deadline_cap); |
| 361 | } |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 362 | for (timer = shard->list.next; timer != &shard->list; timer = next) { |
| 363 | next = timer->next; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 364 | |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 365 | if (timer->deadline < shard->queue_deadline_cap) { |
Craig Tiller | 18e7465 | 2017-03-24 15:44:27 -0700 | [diff] [blame] | 366 | if (grpc_timer_check_trace) { |
| 367 | gpr_log(GPR_DEBUG, " .. add timer with deadline %" PRIdPTR " to heap", |
| 368 | timer->deadline); |
| 369 | } |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 370 | list_remove(timer); |
| 371 | grpc_timer_heap_add(&shard->heap, timer); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 372 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 373 | } |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 374 | return !grpc_timer_heap_is_empty(&shard->heap); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 375 | } |
| 376 | |
David G. Quintas | dfff4de | 2016-06-07 19:57:33 -0700 | [diff] [blame] | 377 | /* This pops the next non-cancelled timer with deadline <= now from the |
| 378 | queue, or returns NULL if there isn't one. |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 379 | REQUIRES: shard->mu locked */ |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 380 | static grpc_timer *pop_one(shard_type *shard, gpr_atm now) { |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 381 | grpc_timer *timer; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 382 | for (;;) { |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 383 | if (grpc_timer_check_trace) { |
| 384 | gpr_log(GPR_DEBUG, " .. shard[%d]: heap_empty=%s", |
| 385 | (int)(shard - g_shards), |
| 386 | grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false"); |
| 387 | } |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 388 | if (grpc_timer_heap_is_empty(&shard->heap)) { |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 389 | if (now < shard->queue_deadline_cap) return NULL; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 390 | if (!refill_queue(shard, now)) return NULL; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 391 | } |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 392 | timer = grpc_timer_heap_top(&shard->heap); |
Craig Tiller | 18e7465 | 2017-03-24 15:44:27 -0700 | [diff] [blame] | 393 | if (grpc_timer_check_trace) { |
| 394 | gpr_log(GPR_DEBUG, |
| 395 | " .. check top timer deadline=%" PRIdPTR " now=%" PRIdPTR, |
| 396 | timer->deadline, now); |
| 397 | } |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 398 | if (timer->deadline > now) return NULL; |
Craig Tiller | a0bfee9 | 2017-03-27 09:21:11 -0700 | [diff] [blame] | 399 | if (grpc_timer_trace) { |
| 400 | gpr_log(GPR_DEBUG, "TIMER %p: FIRE %" PRIdPTR "ms late", timer, |
| 401 | now - timer->deadline); |
| 402 | } |
Craig Tiller | c84886b | 2017-02-16 13:10:38 -0800 | [diff] [blame] | 403 | timer->pending = false; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 404 | grpc_timer_heap_pop(&shard->heap); |
| 405 | return timer; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 406 | } |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 407 | } |
| 408 | |
| 409 | /* REQUIRES: shard->mu unlocked */ |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 410 | static size_t pop_timers(grpc_exec_ctx *exec_ctx, shard_type *shard, |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 411 | gpr_atm now, gpr_atm *new_min_deadline, |
Craig Tiller | c027e77 | 2016-05-03 16:27:00 -0700 | [diff] [blame] | 412 | grpc_error *error) { |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 413 | size_t n = 0; |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 414 | grpc_timer *timer; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 415 | gpr_mu_lock(&shard->mu); |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 416 | while ((timer = pop_one(shard, now))) { |
Masood Malekghassemi | b5b4372 | 2017-01-05 15:07:26 -0800 | [diff] [blame] | 417 | grpc_closure_sched(exec_ctx, timer->closure, GRPC_ERROR_REF(error)); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 418 | n++; |
| 419 | } |
| 420 | *new_min_deadline = compute_min_deadline(shard); |
| 421 | gpr_mu_unlock(&shard->mu); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 422 | return n; |
| 423 | } |
| 424 | |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 425 | static int run_some_expired_timers(grpc_exec_ctx *exec_ctx, gpr_atm now, |
| 426 | gpr_atm *next, grpc_error *error) { |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 427 | size_t n = 0; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 428 | |
Craig Tiller | 1a76926 | 2017-03-27 12:52:59 -0700 | [diff] [blame] | 429 | gpr_atm min_timer = gpr_atm_no_barrier_load(&g_shared_mutables.min_timer); |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 430 | gpr_tls_set(&g_last_seen_min_timer, min_timer); |
| 431 | if (now < min_timer) { |
| 432 | if (next != NULL) *next = GPR_MIN(*next, min_timer); |
| 433 | return 0; |
| 434 | } |
| 435 | |
| 436 | if (gpr_spinlock_trylock(&g_shared_mutables.checker_mu)) { |
| 437 | gpr_mu_lock(&g_shared_mutables.mu); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 438 | |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 439 | if (grpc_timer_check_trace) { |
| 440 | gpr_log(GPR_DEBUG, " .. shard[%d]->min_deadline = %" PRIdPTR, |
| 441 | (int)(g_shard_queue[0] - g_shards), |
| 442 | g_shard_queue[0]->min_deadline); |
| 443 | } |
| 444 | |
Craig Tiller | 041bf64 | 2017-03-27 09:26:07 -0700 | [diff] [blame] | 445 | while (g_shard_queue[0]->min_deadline < now || |
| 446 | (now != GPR_ATM_MAX && g_shard_queue[0]->min_deadline == now)) { |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 447 | gpr_atm new_min_deadline; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 448 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 449 | /* For efficiency, we pop as many available timers as we can from the |
| 450 | shard. This may violate perfect timer deadline ordering, but that |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 451 | shouldn't be a big deal because we don't make ordering guarantees. */ |
Craig Tiller | c027e77 | 2016-05-03 16:27:00 -0700 | [diff] [blame] | 452 | n += |
| 453 | pop_timers(exec_ctx, g_shard_queue[0], now, &new_min_deadline, error); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 454 | |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 455 | if (grpc_timer_check_trace) { |
Craig Tiller | a0bfee9 | 2017-03-27 09:21:11 -0700 | [diff] [blame] | 456 | gpr_log(GPR_DEBUG, " .. popped --> %" PRIdPTR |
| 457 | ", shard[%d]->min_deadline %" PRIdPTR |
| 458 | " --> %" PRIdPTR ", now=%" PRIdPTR, |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 459 | n, (int)(g_shard_queue[0] - g_shards), |
Craig Tiller | a0bfee9 | 2017-03-27 09:21:11 -0700 | [diff] [blame] | 460 | g_shard_queue[0]->min_deadline, new_min_deadline, now); |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 461 | } |
| 462 | |
David Garcia Quintas | f747bbc | 2015-10-04 23:09:47 -0700 | [diff] [blame] | 463 | /* An grpc_timer_init() on the shard could intervene here, adding a new |
| 464 | timer that is earlier than new_min_deadline. However, |
| 465 | grpc_timer_init() will block on the master_lock before it can call |
| 466 | set_min_deadline, so this one will complete first and then the Addtimer |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 467 | will reduce the min_deadline (perhaps unnecessarily). */ |
| 468 | g_shard_queue[0]->min_deadline = new_min_deadline; |
| 469 | note_deadline_change(g_shard_queue[0]); |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 470 | } |
| 471 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 472 | if (next) { |
Craig Tiller | 7b2dd93 | 2017-03-16 16:25:12 -0700 | [diff] [blame] | 473 | *next = GPR_MIN(*next, g_shard_queue[0]->min_deadline); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 474 | } |
| 475 | |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 476 | gpr_atm_no_barrier_store(&g_shared_mutables.min_timer, |
| 477 | g_shard_queue[0]->min_deadline); |
| 478 | gpr_mu_unlock(&g_shared_mutables.mu); |
| 479 | gpr_spinlock_unlock(&g_shared_mutables.checker_mu); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 480 | } |
| 481 | |
Craig Tiller | f707d62 | 2016-05-06 14:26:12 -0700 | [diff] [blame] | 482 | GRPC_ERROR_UNREF(error); |
Craig Tiller | c027e77 | 2016-05-03 16:27:00 -0700 | [diff] [blame] | 483 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 484 | return (int)n; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 485 | } |
| 486 | |
Craig Tiller | 311445f | 2016-02-18 07:31:39 -0800 | [diff] [blame] | 487 | bool grpc_timer_check(grpc_exec_ctx *exec_ctx, gpr_timespec now, |
| 488 | gpr_timespec *next) { |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 489 | // prelude |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 490 | GPR_ASSERT(now.clock_type == g_clock_type); |
Craig Tiller | 185f6c9 | 2017-03-17 08:33:19 -0700 | [diff] [blame] | 491 | gpr_atm now_atm = timespec_to_atm_round_down(now); |
Craig Tiller | 1a76926 | 2017-03-27 12:52:59 -0700 | [diff] [blame] | 492 | |
| 493 | /* fetch from a thread-local first: this avoids contention on a globally |
| 494 | mutable cacheline in the common case */ |
| 495 | gpr_atm min_timer = gpr_tls_get(&g_last_seen_min_timer); |
| 496 | if (now_atm < min_timer) { |
| 497 | if (next != NULL) { |
| 498 | *next = |
| 499 | atm_to_timespec(GPR_MIN(timespec_to_atm_round_up(*next), min_timer)); |
| 500 | } |
| 501 | if (grpc_timer_check_trace) { |
| 502 | gpr_log(GPR_DEBUG, |
Craig Tiller | 97d4011 | 2017-03-29 16:46:13 -0700 | [diff] [blame^] | 503 | "TIMER CHECK SKIP: now_atm=%" PRIdPTR " min_timer=%" PRIdPTR, |
Craig Tiller | 1a76926 | 2017-03-27 12:52:59 -0700 | [diff] [blame] | 504 | now_atm, min_timer); |
| 505 | } |
| 506 | return 0; |
| 507 | } |
| 508 | |
Craig Tiller | 18e1506 | 2017-03-20 09:35:39 -0700 | [diff] [blame] | 509 | grpc_error *shutdown_error = |
Craig Tiller | c027e77 | 2016-05-03 16:27:00 -0700 | [diff] [blame] | 510 | gpr_time_cmp(now, gpr_inf_future(now.clock_type)) != 0 |
| 511 | ? GRPC_ERROR_NONE |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 512 | : GRPC_ERROR_CREATE_FROM_STATIC_STRING("Shutting down timer system"); |
Craig Tiller | 1a76926 | 2017-03-27 12:52:59 -0700 | [diff] [blame] | 513 | |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 514 | // tracing |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 515 | if (grpc_timer_check_trace) { |
| 516 | char *next_str; |
| 517 | if (next == NULL) { |
| 518 | next_str = gpr_strdup("NULL"); |
| 519 | } else { |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 520 | gpr_asprintf(&next_str, "%" PRId64 ".%09d [%" PRIdPTR "]", next->tv_sec, |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 521 | next->tv_nsec, timespec_to_atm_round_down(*next)); |
| 522 | } |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 523 | gpr_log(GPR_DEBUG, "TIMER CHECK BEGIN: now=%" PRId64 ".%09d [%" PRIdPTR |
Craig Tiller | afb168b | 2017-03-21 12:48:57 -0700 | [diff] [blame] | 524 | "] next=%s tls_min=%" PRIdPTR " glob_min=%" PRIdPTR, |
| 525 | now.tv_sec, now.tv_nsec, now_atm, next_str, |
| 526 | gpr_tls_get(&g_last_seen_min_timer), |
| 527 | gpr_atm_no_barrier_load(&g_shared_mutables.min_timer)); |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 528 | gpr_free(next_str); |
| 529 | } |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 530 | // actual code |
Craig Tiller | 99c718b | 2017-03-20 20:03:52 -0700 | [diff] [blame] | 531 | bool r; |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 532 | gpr_atm next_atm; |
Craig Tiller | 18e1506 | 2017-03-20 09:35:39 -0700 | [diff] [blame] | 533 | if (next == NULL) { |
| 534 | r = run_some_expired_timers(exec_ctx, now_atm, NULL, shutdown_error); |
| 535 | } else { |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 536 | next_atm = timespec_to_atm_round_down(*next); |
Craig Tiller | 18e1506 | 2017-03-20 09:35:39 -0700 | [diff] [blame] | 537 | r = run_some_expired_timers(exec_ctx, now_atm, &next_atm, shutdown_error); |
| 538 | *next = atm_to_timespec(next_atm); |
| 539 | } |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 540 | // tracing |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 541 | if (grpc_timer_check_trace) { |
| 542 | char *next_str; |
| 543 | if (next == NULL) { |
| 544 | next_str = gpr_strdup("NULL"); |
| 545 | } else { |
Craig Tiller | 0b4c531 | 2017-03-24 15:23:57 -0700 | [diff] [blame] | 546 | gpr_asprintf(&next_str, "%" PRId64 ".%09d [%" PRIdPTR "]", next->tv_sec, |
Craig Tiller | 2a1949e | 2017-03-21 09:29:12 -0700 | [diff] [blame] | 547 | next->tv_nsec, next_atm); |
| 548 | } |
| 549 | gpr_log(GPR_DEBUG, "TIMER CHECK END: %d timers triggered; next=%s", r, |
| 550 | next_str); |
| 551 | gpr_free(next_str); |
| 552 | } |
| 553 | return r > 0; |
ctiller | 3bf466f | 2014-12-19 16:21:57 -0800 | [diff] [blame] | 554 | } |
murgatroid99 | 9030c81 | 2016-09-16 13:25:08 -0700 | [diff] [blame] | 555 | |
| 556 | #endif /* GRPC_TIMER_USE_GENERIC */ |