grpc 1.7.3 → 1.8.0

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

@@ -22,7 +22,7 @@
 
 #include "src/core/lib/debug/trace.h"
 
-grpc_tracer_flag grpc_polling_trace =
-    GRPC_TRACER_INITIALIZER(false, "polling"); /* Disabled by default */
+grpc_core::TraceFlag grpc_polling_trace(false,
+                                        "polling"); /* Disabled by default */
 
 #endif  // GRPC_WINSOCK_SOCKET

data/src/core/lib/iomgr/exec_ctx.cc

@@ -0,0 +1,177 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+
+#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/profiling/timers.h"
+
+bool grpc_exec_ctx_ready_to_finish(grpc_exec_ctx* exec_ctx) {
+  if ((exec_ctx->flags & GRPC_EXEC_CTX_FLAG_IS_FINISHED) == 0) {
+    if (exec_ctx->check_ready_to_finish(exec_ctx,
+                                        exec_ctx->check_ready_to_finish_arg)) {
+      exec_ctx->flags |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
+      return true;
+    }
+    return false;
+  } else {
+    return true;
+  }
+}
+
+bool grpc_never_ready_to_finish(grpc_exec_ctx* exec_ctx, void* arg_ignored) {
+  return false;
+}
+
+bool grpc_always_ready_to_finish(grpc_exec_ctx* exec_ctx, void* arg_ignored) {
+  return true;
+}
+
+bool grpc_exec_ctx_has_work(grpc_exec_ctx* exec_ctx) {
+  return exec_ctx->active_combiner != nullptr ||
+         !grpc_closure_list_empty(exec_ctx->closure_list);
+}
+
+void grpc_exec_ctx_finish(grpc_exec_ctx* exec_ctx) {
+  exec_ctx->flags |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
+  grpc_exec_ctx_flush(exec_ctx);
+}
+
+static void exec_ctx_run(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                         grpc_error* error) {
+#ifndef NDEBUG
+  closure->scheduled = false;
+  if (grpc_trace_closure.enabled()) {
+    gpr_log(GPR_DEBUG, "running closure %p: created [%s:%d]: %s [%s:%d]",
+            closure, closure->file_created, closure->line_created,
+            closure->run ? "run" : "scheduled", closure->file_initiated,
+            closure->line_initiated);
+  }
+#endif
+  closure->cb(exec_ctx, closure->cb_arg, error);
+#ifndef NDEBUG
+  if (grpc_trace_closure.enabled()) {
+    gpr_log(GPR_DEBUG, "closure %p finished", closure);
+  }
+#endif
+  GRPC_ERROR_UNREF(error);
+}
+
+bool grpc_exec_ctx_flush(grpc_exec_ctx* exec_ctx) {
+  bool did_something = 0;
+  GPR_TIMER_BEGIN("grpc_exec_ctx_flush", 0);
+  for (;;) {
+    if (!grpc_closure_list_empty(exec_ctx->closure_list)) {
+      grpc_closure* c = exec_ctx->closure_list.head;
+      exec_ctx->closure_list.head = exec_ctx->closure_list.tail = nullptr;
+      while (c != nullptr) {
+        grpc_closure* next = c->next_data.next;
+        grpc_error* error = c->error_data.error;
+        did_something = true;
+        exec_ctx_run(exec_ctx, c, error);
+        c = next;
+      }
+    } else if (!grpc_combiner_continue_exec_ctx(exec_ctx)) {
+      break;
+    }
+  }
+  GPR_ASSERT(exec_ctx->active_combiner == nullptr);
+  GPR_TIMER_END("grpc_exec_ctx_flush", 0);
+  return did_something;
+}
+
+static void exec_ctx_sched(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                           grpc_error* error) {
+  grpc_closure_list_append(&exec_ctx->closure_list, closure, error);
+}
+
+static gpr_timespec g_start_time;
+
+void grpc_exec_ctx_global_init(void) {
+  g_start_time = gpr_now(GPR_CLOCK_MONOTONIC);
+}
+
+void grpc_exec_ctx_global_shutdown(void) {}
+
+static gpr_atm timespec_to_atm_round_down(gpr_timespec ts) {
+  ts = gpr_time_sub(ts, g_start_time);
+  double x =
+      GPR_MS_PER_SEC * (double)ts.tv_sec + (double)ts.tv_nsec / GPR_NS_PER_MS;
+  if (x < 0) return 0;
+  if (x > GPR_ATM_MAX) return GPR_ATM_MAX;
+  return (gpr_atm)x;
+}
+
+static gpr_atm timespec_to_atm_round_up(gpr_timespec ts) {
+  ts = gpr_time_sub(ts, g_start_time);
+  double x = GPR_MS_PER_SEC * (double)ts.tv_sec +
+             (double)ts.tv_nsec / GPR_NS_PER_MS +
+             (double)(GPR_NS_PER_SEC - 1) / (double)GPR_NS_PER_SEC;
+  if (x < 0) return 0;
+  if (x > GPR_ATM_MAX) return GPR_ATM_MAX;
+  return (gpr_atm)x;
+}
+
+grpc_millis grpc_exec_ctx_now(grpc_exec_ctx* exec_ctx) {
+  if (!exec_ctx->now_is_valid) {
+    exec_ctx->now = timespec_to_atm_round_down(gpr_now(GPR_CLOCK_MONOTONIC));
+    exec_ctx->now_is_valid = true;
+  }
+  return exec_ctx->now;
+}
+
+void grpc_exec_ctx_invalidate_now(grpc_exec_ctx* exec_ctx) {
+  exec_ctx->now_is_valid = false;
+}
+
+gpr_timespec grpc_millis_to_timespec(grpc_millis millis,
+                                     gpr_clock_type clock_type) {
+  // special-case infinities as grpc_millis can be 32bit on some platforms
+  // while gpr_time_from_millis always takes an int64_t.
+  if (millis == GRPC_MILLIS_INF_FUTURE) {
+    return gpr_inf_future(clock_type);
+  }
+  if (millis == GRPC_MILLIS_INF_PAST) {
+    return gpr_inf_past(clock_type);
+  }
+
+  if (clock_type == GPR_TIMESPAN) {
+    return gpr_time_from_millis(millis, GPR_TIMESPAN);
+  }
+  return gpr_time_add(gpr_convert_clock_type(g_start_time, clock_type),
+                      gpr_time_from_millis(millis, GPR_TIMESPAN));
+}
+
+grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec ts) {
+  return timespec_to_atm_round_down(
+      gpr_convert_clock_type(ts, g_start_time.clock_type));
+}
+
+grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts) {
+  return timespec_to_atm_round_up(
+      gpr_convert_clock_type(ts, g_start_time.clock_type));
+}
+
+static const grpc_closure_scheduler_vtable exec_ctx_scheduler_vtable = {
+    exec_ctx_run, exec_ctx_sched, "exec_ctx"};
+static grpc_closure_scheduler exec_ctx_scheduler = {&exec_ctx_scheduler_vtable};
+grpc_closure_scheduler* grpc_schedule_on_exec_ctx = &exec_ctx_scheduler;

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

@@ -19,10 +19,19 @@
 #ifndef GRPC_CORE_LIB_IOMGR_EXEC_CTX_H
 #define GRPC_CORE_LIB_IOMGR_EXEC_CTX_H
 
+#include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
+
 #include "src/core/lib/iomgr/closure.h"
 
-/* #define GRPC_EXECUTION_CONTEXT_SANITIZER 1 */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef gpr_atm grpc_millis;
+
+#define GRPC_MILLIS_INF_FUTURE GPR_ATM_MAX
+#define GRPC_MILLIS_INF_PAST GPR_ATM_MIN
 
 /** A workqueue represents a list of work to be executed asynchronously.
     Forward declared here to avoid a circular dependency with workqueue.h. */
@@ -59,13 +68,16 @@ typedef struct grpc_combiner grpc_combiner;
 struct grpc_exec_ctx {
   grpc_closure_list closure_list;
   /** currently active combiner: updated only via combiner.c */
-  grpc_combiner *active_combiner;
+  grpc_combiner* active_combiner;
   /** last active combiner in the active combiner list */
-  grpc_combiner *last_combiner;
+  grpc_combiner* last_combiner;
   uintptr_t flags;
   unsigned starting_cpu;
-  void *check_ready_to_finish_arg;
-  bool (*check_ready_to_finish)(grpc_exec_ctx *exec_ctx, void *arg);
+  void* check_ready_to_finish_arg;
+  bool (*check_ready_to_finish)(grpc_exec_ctx* exec_ctx, void* arg);
+
+  bool now_is_valid;
+  grpc_millis now;
 };
 
 /* initializer for grpc_exec_ctx:
@@ -73,7 +85,7 @@ struct grpc_exec_ctx {
 #define GRPC_EXEC_CTX_INITIALIZER(flags, finish_check, finish_check_arg) \
   {                                                                      \
     GRPC_CLOSURE_LIST_INIT, NULL, NULL, flags, gpr_cpu_current_cpu(),    \
-        finish_check_arg, finish_check                                   \
+        finish_check_arg, finish_check, false, 0                         \
   }
 
 /* initialize an execution context at the top level of an API call into grpc
@@ -81,29 +93,39 @@ struct grpc_exec_ctx {
 #define GRPC_EXEC_CTX_INIT \
   GRPC_EXEC_CTX_INITIALIZER(GRPC_EXEC_CTX_FLAG_IS_FINISHED, NULL, NULL)
 
-extern grpc_closure_scheduler *grpc_schedule_on_exec_ctx;
+extern grpc_closure_scheduler* grpc_schedule_on_exec_ctx;
 
-bool grpc_exec_ctx_has_work(grpc_exec_ctx *exec_ctx);
+bool grpc_exec_ctx_has_work(grpc_exec_ctx* exec_ctx);
 
 /** Flush any work that has been enqueued onto this grpc_exec_ctx.
  *  Caller must guarantee that no interfering locks are held.
  *  Returns true if work was performed, false otherwise. */
-bool grpc_exec_ctx_flush(grpc_exec_ctx *exec_ctx);
+bool grpc_exec_ctx_flush(grpc_exec_ctx* exec_ctx);
 /** Finish any pending work for a grpc_exec_ctx. Must be called before
  *  the instance is destroyed, or work may be lost. */
-void grpc_exec_ctx_finish(grpc_exec_ctx *exec_ctx);
+void grpc_exec_ctx_finish(grpc_exec_ctx* exec_ctx);
 /** Returns true if we'd like to leave this execution context as soon as
     possible: useful for deciding whether to do something more or not depending
     on outside context */
-bool grpc_exec_ctx_ready_to_finish(grpc_exec_ctx *exec_ctx);
+bool grpc_exec_ctx_ready_to_finish(grpc_exec_ctx* exec_ctx);
 /** A finish check that is never ready to finish */
-bool grpc_never_ready_to_finish(grpc_exec_ctx *exec_ctx, void *arg_ignored);
+bool grpc_never_ready_to_finish(grpc_exec_ctx* exec_ctx, void* arg_ignored);
 /** A finish check that is always ready to finish */
-bool grpc_always_ready_to_finish(grpc_exec_ctx *exec_ctx, void *arg_ignored);
+bool grpc_always_ready_to_finish(grpc_exec_ctx* exec_ctx, void* arg_ignored);
 
 void grpc_exec_ctx_global_init(void);
 
 void grpc_exec_ctx_global_init(void);
 void grpc_exec_ctx_global_shutdown(void);
 
+grpc_millis grpc_exec_ctx_now(grpc_exec_ctx* exec_ctx);
+void grpc_exec_ctx_invalidate_now(grpc_exec_ctx* exec_ctx);
+gpr_timespec grpc_millis_to_timespec(grpc_millis millis, gpr_clock_type clock);
+grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec timespec);
+grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec timespec);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */

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

@@ -44,26 +44,25 @@ typedef struct {
   gpr_thd_id id;
 } thread_state;
 
-static thread_state *g_thread_state;
+static thread_state* g_thread_state;
 static size_t g_max_threads;
 static gpr_atm g_cur_threads;
 static gpr_spinlock g_adding_thread_lock = GPR_SPINLOCK_STATIC_INITIALIZER;
 
 GPR_TLS_DECL(g_this_thread_state);
 
-static grpc_tracer_flag executor_trace =
-    GRPC_TRACER_INITIALIZER(false, "executor");
+grpc_core::TraceFlag executor_trace(false, "executor");
 
-static void executor_thread(void *arg);
+static void executor_thread(void* arg);
 
-static size_t run_closures(grpc_exec_ctx *exec_ctx, grpc_closure_list list) {
+static size_t run_closures(grpc_exec_ctx* exec_ctx, grpc_closure_list list) {
   size_t n = 0;
 
-  grpc_closure *c = list.head;
-  while (c != NULL) {
-    grpc_closure *next = c->next_data.next;
-    grpc_error *error = c->error_data.error;
-    if (GRPC_TRACER_ON(executor_trace)) {
+  grpc_closure* c = list.head;
+  while (c != nullptr) {
+    grpc_closure* next = c->next_data.next;
+    grpc_error* error = c->error_data.error;
+    if (executor_trace.enabled()) {
 #ifndef NDEBUG
       gpr_log(GPR_DEBUG, "EXECUTOR: run %p [created by %s:%d]", c,
               c->file_created, c->line_created);
@@ -88,7 +87,7 @@ bool grpc_executor_is_threaded() {
   return gpr_atm_no_barrier_load(&g_cur_threads) > 0;
 }
 
-void grpc_executor_set_threading(grpc_exec_ctx *exec_ctx, bool threading) {
+void grpc_executor_set_threading(grpc_exec_ctx* exec_ctx, bool threading) {
   gpr_atm cur_threads = gpr_atm_no_barrier_load(&g_cur_threads);
   if (threading) {
     if (cur_threads > 0) return;
@@ -96,11 +95,11 @@ void grpc_executor_set_threading(grpc_exec_ctx *exec_ctx, bool threading) {
     gpr_atm_no_barrier_store(&g_cur_threads, 1);
     gpr_tls_init(&g_this_thread_state);
     g_thread_state =
-        (thread_state *)gpr_zalloc(sizeof(thread_state) * g_max_threads);
+        (thread_state*)gpr_zalloc(sizeof(thread_state) * g_max_threads);
     for (size_t i = 0; i < g_max_threads; i++) {
       gpr_mu_init(&g_thread_state[i].mu);
       gpr_cv_init(&g_thread_state[i].cv);
-      g_thread_state[i].elems = (grpc_closure_list)GRPC_CLOSURE_LIST_INIT;
+      g_thread_state[i].elems = GRPC_CLOSURE_LIST_INIT;
     }
 
     gpr_thd_options opt = gpr_thd_options_default();
@@ -133,26 +132,25 @@ void grpc_executor_set_threading(grpc_exec_ctx *exec_ctx, bool threading) {
   }
 }
 
-void grpc_executor_init(grpc_exec_ctx *exec_ctx) {
-  grpc_register_tracer(&executor_trace);
+void grpc_executor_init(grpc_exec_ctx* exec_ctx) {
   gpr_atm_no_barrier_store(&g_cur_threads, 0);
   grpc_executor_set_threading(exec_ctx, true);
 }
 
-void grpc_executor_shutdown(grpc_exec_ctx *exec_ctx) {
+void grpc_executor_shutdown(grpc_exec_ctx* exec_ctx) {
   grpc_executor_set_threading(exec_ctx, false);
 }
 
-static void executor_thread(void *arg) {
-  thread_state *ts = (thread_state *)arg;
+static void executor_thread(void* arg) {
+  thread_state* ts = (thread_state*)arg;
   gpr_tls_set(&g_this_thread_state, (intptr_t)ts);
 
   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);
 
   size_t subtract_depth = 0;
   for (;;) {
-    if (GRPC_TRACER_ON(executor_trace)) {
+    if (executor_trace.enabled()) {
       gpr_log(GPR_DEBUG, "EXECUTOR[%d]: step (sub_depth=%" PRIdPTR ")",
               (int)(ts - g_thread_state), subtract_depth);
     }
@@ -163,7 +161,7 @@ static void executor_thread(void *arg) {
       gpr_cv_wait(&ts->cv, &ts->mu, gpr_inf_future(GPR_CLOCK_REALTIME));
     }
     if (ts->shutdown) {
-      if (GRPC_TRACER_ON(executor_trace)) {
+      if (executor_trace.enabled()) {
         gpr_log(GPR_DEBUG, "EXECUTOR[%d]: shutdown",
                 (int)(ts - g_thread_state));
       }
@@ -172,19 +170,20 @@ static void executor_thread(void *arg) {
     }
     GRPC_STATS_INC_EXECUTOR_QUEUE_DRAINED(&exec_ctx);
     grpc_closure_list exec = ts->elems;
-    ts->elems = (grpc_closure_list)GRPC_CLOSURE_LIST_INIT;
+    ts->elems = GRPC_CLOSURE_LIST_INIT;
     gpr_mu_unlock(&ts->mu);
-    if (GRPC_TRACER_ON(executor_trace)) {
+    if (executor_trace.enabled()) {
       gpr_log(GPR_DEBUG, "EXECUTOR[%d]: execute", (int)(ts - g_thread_state));
     }
 
+    grpc_exec_ctx_invalidate_now(&exec_ctx);
     subtract_depth = run_closures(&exec_ctx, exec);
   }
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void executor_push(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                          grpc_error *error, bool is_short) {
+static void executor_push(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                          grpc_error* error, bool is_short) {
   bool retry_push;
   if (is_short) {
     GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS(exec_ctx);
@@ -195,7 +194,7 @@ static void executor_push(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
     retry_push = false;
     size_t cur_thread_count = (size_t)gpr_atm_no_barrier_load(&g_cur_threads);
     if (cur_thread_count == 0) {
-      if (GRPC_TRACER_ON(executor_trace)) {
+      if (executor_trace.enabled()) {
 #ifndef NDEBUG
         gpr_log(GPR_DEBUG, "EXECUTOR: schedule %p (created %s:%d) inline",
                 closure, closure->file_created, closure->line_created);
@@ -206,17 +205,17 @@ static void executor_push(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
       grpc_closure_list_append(&exec_ctx->closure_list, closure, error);
       return;
     }
-    thread_state *ts = (thread_state *)gpr_tls_get(&g_this_thread_state);
-    if (ts == NULL) {
+    thread_state* ts = (thread_state*)gpr_tls_get(&g_this_thread_state);
+    if (ts == nullptr) {
       ts = &g_thread_state[GPR_HASH_POINTER(exec_ctx, cur_thread_count)];
     } else {
       GRPC_STATS_INC_EXECUTOR_SCHEDULED_TO_SELF(exec_ctx);
     }
-    thread_state *orig_ts = ts;
+    thread_state* orig_ts = ts;
 
     bool try_new_thread;
     for (;;) {
-      if (GRPC_TRACER_ON(executor_trace)) {
+      if (executor_trace.enabled()) {
 #ifndef NDEBUG
         gpr_log(
             GPR_DEBUG,
@@ -275,13 +274,13 @@ static void executor_push(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
   } while (retry_push);
 }
 
-static void executor_push_short(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                                grpc_error *error) {
+static void executor_push_short(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                                grpc_error* error) {
   executor_push(exec_ctx, closure, error, true);
 }
 
-static void executor_push_long(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                               grpc_error *error) {
+static void executor_push_long(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
+                               grpc_error* error) {
   executor_push(exec_ctx, closure, error, false);
 }
 
@@ -294,7 +293,7 @@ static const grpc_closure_scheduler_vtable executor_vtable_long = {
     executor_push_long, executor_push_long, "executor"};
 static grpc_closure_scheduler executor_scheduler_long = {&executor_vtable_long};
 
-grpc_closure_scheduler *grpc_executor_scheduler(
+grpc_closure_scheduler* grpc_executor_scheduler(
     grpc_executor_job_length length) {
   return length == GRPC_EXECUTOR_SHORT ? &executor_scheduler_short
                                        : &executor_scheduler_long;