grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/timer_generic.h

@@ -26,11 +26,11 @@ struct grpc_timer {
   gpr_atm deadline;
   uint32_t heap_index; /* INVALID_HEAP_INDEX if not in heap */
   bool pending;
-  struct grpc_timer *next;
-  struct grpc_timer *prev;
-  grpc_closure *closure;
+  struct grpc_timer* next;
+  struct grpc_timer* prev;
+  grpc_closure* closure;
 #ifndef NDEBUG
-  struct grpc_timer *hash_table_next;
+  struct grpc_timer* hash_table_next;
 #endif
 };
 

data/src/core/lib/iomgr/{timer_heap.c → timer_heap.cc}

@@ -32,7 +32,7 @@
    position. This functor is called each time immediately after modifying a
    value in the underlying container, with the offset of the modified element as
    its argument. */
-static void adjust_upwards(grpc_timer **first, uint32_t i, grpc_timer *t) {
+static void adjust_upwards(grpc_timer** first, uint32_t i, grpc_timer* t) {
   while (i > 0) {
     uint32_t parent = (uint32_t)(((int)i - 1) / 2);
     if (first[parent]->deadline <= t->deadline) break;
@@ -47,17 +47,16 @@ static void adjust_upwards(grpc_timer **first, uint32_t i, grpc_timer *t) {
 /* Adjusts a heap so as to move a hole at position i farther away from the root,
    until a suitable position is found for element t.  Then, copies t into that
    position. */
-static void adjust_downwards(grpc_timer **first, uint32_t i, uint32_t length,
-                             grpc_timer *t) {
+static void adjust_downwards(grpc_timer** first, uint32_t i, uint32_t length,
+                             grpc_timer* t) {
   for (;;) {
     uint32_t left_child = 1u + 2u * i;
     if (left_child >= length) break;
     uint32_t right_child = left_child + 1;
-    uint32_t next_i =
-        right_child < length &&
-                first[left_child]->deadline > first[right_child]->deadline
-            ? right_child
-            : left_child;
+    uint32_t next_i = right_child < length && first[left_child]->deadline >
+                                                  first[right_child]->deadline
+                          ? right_child
+                          : left_child;
     if (t->deadline <= first[next_i]->deadline) break;
     first[i] = first[next_i];
     first[i]->heap_index = i;
@@ -70,16 +69,16 @@ static void adjust_downwards(grpc_timer **first, uint32_t i, uint32_t length,
 #define SHRINK_MIN_ELEMS 8
 #define SHRINK_FULLNESS_FACTOR 2
 
-static void maybe_shrink(grpc_timer_heap *heap) {
+static void maybe_shrink(grpc_timer_heap* heap) {
   if (heap->timer_count >= 8 &&
       heap->timer_count <= heap->timer_capacity / SHRINK_FULLNESS_FACTOR / 2) {
     heap->timer_capacity = heap->timer_count * SHRINK_FULLNESS_FACTOR;
-    heap->timers = (grpc_timer **)gpr_realloc(
-        heap->timers, heap->timer_capacity * sizeof(grpc_timer *));
+    heap->timers = (grpc_timer**)gpr_realloc(
+        heap->timers, heap->timer_capacity * sizeof(grpc_timer*));
   }
 }
 
-static void note_changed_priority(grpc_timer_heap *heap, grpc_timer *timer) {
+static void note_changed_priority(grpc_timer_heap* heap, grpc_timer* timer) {
   uint32_t i = timer->heap_index;
   uint32_t parent = (uint32_t)(((int)i - 1) / 2);
   if (heap->timers[parent]->deadline > timer->deadline) {
@@ -89,18 +88,18 @@ static void note_changed_priority(grpc_timer_heap *heap, grpc_timer *timer) {
   }
 }
 
-void grpc_timer_heap_init(grpc_timer_heap *heap) {
+void grpc_timer_heap_init(grpc_timer_heap* heap) {
   memset(heap, 0, sizeof(*heap));
 }
 
-void grpc_timer_heap_destroy(grpc_timer_heap *heap) { gpr_free(heap->timers); }
+void grpc_timer_heap_destroy(grpc_timer_heap* heap) { gpr_free(heap->timers); }
 
-int grpc_timer_heap_add(grpc_timer_heap *heap, grpc_timer *timer) {
+int grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer) {
   if (heap->timer_count == heap->timer_capacity) {
     heap->timer_capacity =
         GPR_MAX(heap->timer_capacity + 1, heap->timer_capacity * 3 / 2);
-    heap->timers = (grpc_timer **)gpr_realloc(
-        heap->timers, heap->timer_capacity * sizeof(grpc_timer *));
+    heap->timers = (grpc_timer**)gpr_realloc(
+        heap->timers, heap->timer_capacity * sizeof(grpc_timer*));
   }
   timer->heap_index = heap->timer_count;
   adjust_upwards(heap->timers, heap->timer_count, timer);
@@ -108,7 +107,7 @@ int grpc_timer_heap_add(grpc_timer_heap *heap, grpc_timer *timer) {
   return timer->heap_index == 0;
 }
 
-void grpc_timer_heap_remove(grpc_timer_heap *heap, grpc_timer *timer) {
+void grpc_timer_heap_remove(grpc_timer_heap* heap, grpc_timer* timer) {
   uint32_t i = timer->heap_index;
   if (i == heap->timer_count - 1) {
     heap->timer_count--;
@@ -122,15 +121,15 @@ void grpc_timer_heap_remove(grpc_timer_heap *heap, grpc_timer *timer) {
   note_changed_priority(heap, heap->timers[i]);
 }
 
-int grpc_timer_heap_is_empty(grpc_timer_heap *heap) {
+int grpc_timer_heap_is_empty(grpc_timer_heap* heap) {
   return heap->timer_count == 0;
 }
 
-grpc_timer *grpc_timer_heap_top(grpc_timer_heap *heap) {
+grpc_timer* grpc_timer_heap_top(grpc_timer_heap* heap) {
   return heap->timers[0];
 }
 
-void grpc_timer_heap_pop(grpc_timer_heap *heap) {
+void grpc_timer_heap_pop(grpc_timer_heap* heap) {
   grpc_timer_heap_remove(heap, grpc_timer_heap_top(heap));
 }
 

data/src/core/lib/iomgr/timer_heap.h

@@ -21,22 +21,30 @@
 
 #include "src/core/lib/iomgr/timer.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
-  grpc_timer **timers;
+  grpc_timer** timers;
   uint32_t timer_count;
   uint32_t timer_capacity;
 } grpc_timer_heap;
 
 /* return 1 if the new timer is the first timer in the heap */
-int grpc_timer_heap_add(grpc_timer_heap *heap, grpc_timer *timer);
+int grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer);
+
+void grpc_timer_heap_init(grpc_timer_heap* heap);
+void grpc_timer_heap_destroy(grpc_timer_heap* heap);
 
-void grpc_timer_heap_init(grpc_timer_heap *heap);
-void grpc_timer_heap_destroy(grpc_timer_heap *heap);
+void grpc_timer_heap_remove(grpc_timer_heap* heap, grpc_timer* timer);
+grpc_timer* grpc_timer_heap_top(grpc_timer_heap* heap);
+void grpc_timer_heap_pop(grpc_timer_heap* heap);
 
-void grpc_timer_heap_remove(grpc_timer_heap *heap, grpc_timer *timer);
-grpc_timer *grpc_timer_heap_top(grpc_timer_heap *heap);
-void grpc_timer_heap_pop(grpc_timer_heap *heap);
+int grpc_timer_heap_is_empty(grpc_timer_heap* heap);
 
-int grpc_timer_heap_is_empty(grpc_timer_heap *heap);
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_TIMER_HEAP_H */

data/src/core/lib/iomgr/{timer_manager.c → timer_manager.cc}

@@ -20,17 +20,20 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/thd.h>
 
+#include <inttypes.h>
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/timer.h"
 
 typedef struct completed_thread {
   gpr_thd_id t;
-  struct completed_thread *next;
+  struct completed_thread* next;
 } completed_thread;
 
-extern grpc_tracer_flag grpc_timer_check_trace;
+extern grpc_core::TraceFlag grpc_timer_check_trace;
 
 // global mutex
 static gpr_mu g_mu;
@@ -45,27 +48,27 @@ static int g_thread_count;
 // number of threads sitting around waiting
 static int g_waiter_count;
 // linked list of threads that have completed (and need joining)
-static completed_thread *g_completed_threads;
+static completed_thread* g_completed_threads;
 // was the manager kicked by the timer system
 static bool g_kicked;
 // is there a thread waiting until the next timer should fire?
 static bool g_has_timed_waiter;
 // the deadline of the current timed waiter thread (only relevant if
 // g_has_timed_waiter is true)
-static gpr_timespec g_timed_waiter_deadline;
+static grpc_millis g_timed_waiter_deadline;
 // generation counter to track which thread is waiting for the next timer
 static uint64_t g_timed_waiter_generation;
 
-static void timer_thread(void *completed_thread_ptr);
+static void timer_thread(void* completed_thread_ptr);
 
 static void gc_completed_threads(void) {
-  if (g_completed_threads != NULL) {
-    completed_thread *to_gc = g_completed_threads;
-    g_completed_threads = NULL;
+  if (g_completed_threads != nullptr) {
+    completed_thread* to_gc = g_completed_threads;
+    g_completed_threads = nullptr;
     gpr_mu_unlock(&g_mu);
-    while (to_gc != NULL) {
+    while (to_gc != nullptr) {
       gpr_thd_join(to_gc->t);
-      completed_thread *next = to_gc->next;
+      completed_thread* next = to_gc->next;
       gpr_free(to_gc);
       to_gc = next;
     }
@@ -78,12 +81,12 @@ static void start_timer_thread_and_unlock(void) {
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);
-  if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+  if (grpc_timer_check_trace.enabled()) {
     gpr_log(GPR_DEBUG, "Spawn timer thread");
   }
   gpr_thd_options opt = gpr_thd_options_default();
   gpr_thd_options_set_joinable(&opt);
-  completed_thread *ct = (completed_thread *)gpr_malloc(sizeof(*ct));
+  completed_thread* ct = (completed_thread*)gpr_malloc(sizeof(*ct));
   // The call to gpr_thd_new() has to be under the same lock used by
   // gc_completed_threads(), particularly due to ct->t, which is written here
   // (internally by gpr_thd_new) and read there. Otherwise it's possible for ct
@@ -96,13 +99,12 @@ static void start_timer_thread_and_unlock(void) {
 
 void grpc_timer_manager_tick() {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  gpr_timespec next = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-  gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
-  grpc_timer_check(&exec_ctx, now, &next);
+  grpc_millis next = GRPC_MILLIS_INF_FUTURE;
+  grpc_timer_check(&exec_ctx, &next);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void run_some_timers(grpc_exec_ctx *exec_ctx) {
+static void run_some_timers(grpc_exec_ctx* exec_ctx) {
   // if there's something to execute...
   gpr_mu_lock(&g_mu);
   // remove a waiter from the pool, and start another thread if necessary
@@ -113,7 +115,7 @@ static void run_some_timers(grpc_exec_ctx *exec_ctx) {
     // if there's no thread waiting with a timeout, kick an existing
     // waiter so that the next deadline is not missed
     if (!g_has_timed_waiter) {
-      if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+      if (grpc_timer_check_trace.enabled()) {
         gpr_log(GPR_DEBUG, "kick untimed waiter");
       }
       gpr_cv_signal(&g_cv_wait);
@@ -121,6 +123,9 @@ static void run_some_timers(grpc_exec_ctx *exec_ctx) {
     gpr_mu_unlock(&g_mu);
   }
   // without our lock, flush the exec_ctx
+  if (grpc_timer_check_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "flush exec_ctx");
+  }
   grpc_exec_ctx_flush(exec_ctx);
   gpr_mu_lock(&g_mu);
   // garbage collect any threads hanging out that are dead
@@ -133,8 +138,7 @@ static void run_some_timers(grpc_exec_ctx *exec_ctx) {
 // wait until 'next' (or forever if there is already a timed waiter in the pool)
 // returns true if the thread should continue executing (false if it should
 // shutdown)
-static bool wait_until(gpr_timespec next) {
-  const gpr_timespec inf_future = gpr_inf_future(GPR_CLOCK_MONOTONIC);
+static bool wait_until(grpc_exec_ctx* exec_ctx, grpc_millis next) {
   gpr_mu_lock(&g_mu);
   // if we're not threaded anymore, leave
   if (!g_threaded) {
@@ -168,32 +172,30 @@ static bool wait_until(gpr_timespec next) {
        unless their 'next' is earlier than the current timed-waiter's deadline
        (in which case the thread with earlier 'next' takes over as the new timed
        waiter) */
-    if (gpr_time_cmp(next, inf_future) != 0) {
-      if (!g_has_timed_waiter ||
-          (gpr_time_cmp(next, g_timed_waiter_deadline) < 0)) {
+    if (next != GRPC_MILLIS_INF_FUTURE) {
+      if (!g_has_timed_waiter || (next < g_timed_waiter_deadline)) {
         my_timed_waiter_generation = ++g_timed_waiter_generation;
         g_has_timed_waiter = true;
         g_timed_waiter_deadline = next;
 
-        if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
-          gpr_timespec wait_time =
-              gpr_time_sub(next, gpr_now(GPR_CLOCK_MONOTONIC));
-          gpr_log(GPR_DEBUG, "sleep for a %" PRId64 ".%09d seconds",
-                  wait_time.tv_sec, wait_time.tv_nsec);
+        if (grpc_timer_check_trace.enabled()) {
+          grpc_millis wait_time = next - grpc_exec_ctx_now(exec_ctx);
+          gpr_log(GPR_DEBUG, "sleep for a %" PRIdPTR " milliseconds",
+                  wait_time);
         }
       } else {  // g_timed_waiter == true && next >= g_timed_waiter_deadline
-        next = inf_future;
+        next = GRPC_MILLIS_INF_FUTURE;
       }
     }
 
-    if (GRPC_TRACER_ON(grpc_timer_check_trace) &&
-        gpr_time_cmp(next, inf_future) == 0) {
+    if (grpc_timer_check_trace.enabled() && next == GRPC_MILLIS_INF_FUTURE) {
       gpr_log(GPR_DEBUG, "sleep until kicked");
     }
 
-    gpr_cv_wait(&g_cv_wait, &g_mu, next);
+    gpr_cv_wait(&g_cv_wait, &g_mu,
+                grpc_millis_to_timespec(next, GPR_CLOCK_REALTIME));
 
-    if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+    if (grpc_timer_check_trace.enabled()) {
       gpr_log(GPR_DEBUG, "wait ended: was_timed:%d kicked:%d",
               my_timed_waiter_generation == g_timed_waiter_generation,
               g_kicked);
@@ -203,7 +205,7 @@ static bool wait_until(gpr_timespec next) {
     // there's work to do after checking timers (code above)
     if (my_timed_waiter_generation == g_timed_waiter_generation) {
       g_has_timed_waiter = false;
-      g_timed_waiter_deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
+      g_timed_waiter_deadline = GRPC_MILLIS_INF_FUTURE;
     }
   }
 
@@ -218,13 +220,13 @@ static bool wait_until(gpr_timespec next) {
   return true;
 }
 
-static void timer_main_loop(grpc_exec_ctx *exec_ctx) {
-  const gpr_timespec inf_future = gpr_inf_future(GPR_CLOCK_MONOTONIC);
+static void timer_main_loop(grpc_exec_ctx* exec_ctx) {
   for (;;) {
-    gpr_timespec next = inf_future;
-    gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
+    grpc_millis next = GRPC_MILLIS_INF_FUTURE;
+    grpc_exec_ctx_invalidate_now(exec_ctx);
+
     // check timer state, updates next to the next time to run a check
-    switch (grpc_timer_check(exec_ctx, now, &next)) {
+    switch (grpc_timer_check(exec_ctx, &next)) {
       case GRPC_TIMERS_FIRED:
         run_some_timers(exec_ctx);
         break;
@@ -238,13 +240,13 @@ static void timer_main_loop(grpc_exec_ctx *exec_ctx) {
 
            Consequently, we can just sleep forever here and be happy at some
            saved wakeup cycles. */
-        if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+        if (grpc_timer_check_trace.enabled()) {
           gpr_log(GPR_DEBUG, "timers not checked: expect another thread to");
         }
-        next = inf_future;
+        next = GRPC_MILLIS_INF_FUTURE;
       /* fall through */
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
-        if (!wait_until(next)) {
+        if (!wait_until(exec_ctx, next)) {
           return;
         }
         break;
@@ -252,7 +254,7 @@ static void timer_main_loop(grpc_exec_ctx *exec_ctx) {
   }
 }
 
-static void timer_thread_cleanup(completed_thread *ct) {
+static void timer_thread_cleanup(completed_thread* ct) {
   gpr_mu_lock(&g_mu);
   // terminate the thread: drop the waiter count, thread count, and let whomever
   // stopped the threading stuff know that we're done
@@ -264,19 +266,19 @@ static void timer_thread_cleanup(completed_thread *ct) {
   ct->next = g_completed_threads;
   g_completed_threads = ct;
   gpr_mu_unlock(&g_mu);
-  if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+  if (grpc_timer_check_trace.enabled()) {
     gpr_log(GPR_DEBUG, "End timer thread");
   }
 }
 
-static void timer_thread(void *completed_thread_ptr) {
+static void timer_thread(void* completed_thread_ptr) {
   // this threads exec_ctx: we try to run things through to completion here
   // since it's easy to spin up new threads
   grpc_exec_ctx exec_ctx =
-      GRPC_EXEC_CTX_INITIALIZER(0, grpc_never_ready_to_finish, NULL);
+      GRPC_EXEC_CTX_INITIALIZER(0, grpc_never_ready_to_finish, nullptr);
   timer_main_loop(&exec_ctx);
   grpc_exec_ctx_finish(&exec_ctx);
-  timer_thread_cleanup((completed_thread *)completed_thread_ptr);
+  timer_thread_cleanup((completed_thread*)completed_thread_ptr);
 }
 
 static void start_threads(void) {
@@ -297,28 +299,28 @@ void grpc_timer_manager_init(void) {
   g_threaded = false;
   g_thread_count = 0;
   g_waiter_count = 0;
-  g_completed_threads = NULL;
+  g_completed_threads = nullptr;
 
   g_has_timed_waiter = false;
-  g_timed_waiter_deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
+  g_timed_waiter_deadline = GRPC_MILLIS_INF_FUTURE;
 
   start_threads();
 }
 
 static void stop_threads(void) {
   gpr_mu_lock(&g_mu);
-  if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+  if (grpc_timer_check_trace.enabled()) {
     gpr_log(GPR_DEBUG, "stop timer threads: threaded=%d", g_threaded);
   }
   if (g_threaded) {
     g_threaded = false;
     gpr_cv_broadcast(&g_cv_wait);
-    if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+    if (grpc_timer_check_trace.enabled()) {
       gpr_log(GPR_DEBUG, "num timer threads: %d", g_thread_count);
     }
     while (g_thread_count > 0) {
       gpr_cv_wait(&g_cv_shutdown, &g_mu, gpr_inf_future(GPR_CLOCK_REALTIME));
-      if (GRPC_TRACER_ON(grpc_timer_check_trace)) {
+      if (grpc_timer_check_trace.enabled()) {
         gpr_log(GPR_DEBUG, "num timer threads: %d", g_thread_count);
       }
       gc_completed_threads();
@@ -347,7 +349,7 @@ void grpc_kick_poller(void) {
   gpr_mu_lock(&g_mu);
   g_kicked = true;
   g_has_timed_waiter = false;
-  g_timed_waiter_deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
+  g_timed_waiter_deadline = GRPC_MILLIS_INF_FUTURE;
   ++g_timed_waiter_generation;
   gpr_cv_signal(&g_cv_wait);
   gpr_mu_unlock(&g_mu);

data/src/core/lib/iomgr/timer_manager.h

@@ -21,6 +21,10 @@
 
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Timer Manager tries to keep one thread waiting for the next timeout at all
    times */
 
@@ -34,4 +38,8 @@ void grpc_timer_manager_set_threading(bool enabled);
  * disabled */
 void grpc_timer_manager_tick(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_TIMER_MANAGER_H */