grpc 1.8.7 → 1.9.0.pre1

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

@@ -21,13 +21,11 @@
 
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
+#include <grpc/support/log.h>
+#include <grpc/support/tls.h>
 
 #include "src/core/lib/iomgr/closure.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef gpr_atm grpc_millis;
 
 #define GRPC_MILLIS_INF_FUTURE GPR_ATM_MAX
@@ -45,6 +43,13 @@ typedef struct grpc_combiner grpc_combiner;
    should be given to not delete said call/channel from this exec_ctx */
 #define GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP 2
 
+extern grpc_closure_scheduler* grpc_schedule_on_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);
+
+namespace grpc_core {
 /** Execution context.
  *  A bag of data that collects information along a callstack.
  *  Generally created at public API entry points, and passed down as
@@ -65,67 +70,129 @@ typedef struct grpc_combiner grpc_combiner;
  *  - Instances are always passed as the first argument to a function that
  *    takes it, and always as a pointer (grpc_exec_ctx is never copied).
  */
-struct grpc_exec_ctx {
-  grpc_closure_list closure_list;
-  /** currently active combiner: updated only via combiner.c */
-  grpc_combiner* active_combiner;
-  /** last active combiner in the active combiner list */
-  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);
-
-  bool now_is_valid;
-  grpc_millis now;
-};
+class ExecCtx {
+ public:
+  /** Default Constructor */
+
+  ExecCtx() : flags_(GRPC_EXEC_CTX_FLAG_IS_FINISHED) { Set(this); }
+
+  /** Parameterised Constructor */
+  ExecCtx(uintptr_t fl) : flags_(fl) { Set(this); }
 
-/* initializer for grpc_exec_ctx:
-   prefer to use GRPC_EXEC_CTX_INIT whenever possible */
-#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, false, 0                         \
+  /** Destructor */
+  virtual ~ExecCtx() {
+    flags_ |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
+    Flush();
+    Set(last_exec_ctx_);
   }
 
-/* initialize an execution context at the top level of an API call into grpc
-   (this is safe to use elsewhere, though possibly not as efficient) */
-#define GRPC_EXEC_CTX_INIT \
-  GRPC_EXEC_CTX_INITIALIZER(GRPC_EXEC_CTX_FLAG_IS_FINISHED, NULL, NULL)
+  /** Disallow copy and assignment operators */
+  ExecCtx(const ExecCtx&) = delete;
+  ExecCtx& operator=(const ExecCtx&) = delete;
 
-extern grpc_closure_scheduler* grpc_schedule_on_exec_ctx;
+  /** Return starting_cpu */
+  unsigned starting_cpu() const { return starting_cpu_; }
 
-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);
-/** 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);
-/** 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);
-/** A finish check that is never ready to finish */
-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);
-
-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);
+  struct CombinerData {
+    /* currently active combiner: updated only via combiner.c */
+    grpc_combiner* active_combiner;
+    /* last active combiner in the active combiner list */
+    grpc_combiner* last_combiner;
+  };
+
+  /** Only to be used by grpc-combiner code */
+  CombinerData* combiner_data() { return &combiner_data_; }
+
+  /** Return pointer to grpc_closure_list */
+  grpc_closure_list* closure_list() { return &closure_list_; }
+
+  /** Return flags */
+  uintptr_t flags() { return flags_; }
+
+  /** Checks if there is work to be done */
+  bool HasWork() {
+    return combiner_data_.active_combiner != nullptr ||
+           !grpc_closure_list_empty(closure_list_);
+  }
 
-#ifdef __cplusplus
-}
-#endif
+  /** 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 Flush();
+
+  /** 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 IsReadyToFinish() {
+    if ((flags_ & GRPC_EXEC_CTX_FLAG_IS_FINISHED) == 0) {
+      if (CheckReadyToFinish()) {
+        flags_ |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
+        return true;
+      }
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  /** Returns the stored current time relative to start if valid,
+   * otherwise refreshes the stored time, sets it valid and returns the new
+   * value */
+  grpc_millis Now();
+
+  /** Invalidates the stored time value. A new time value will be set on calling
+   * Now() */
+  void InvalidateNow() { now_is_valid_ = false; }
+
+  /** To be used only by shutdown code in iomgr */
+  void SetNowIomgrShutdown() {
+    now_ = GRPC_MILLIS_INF_FUTURE;
+    now_is_valid_ = true;
+  }
+
+  /** To be used only for testing.
+   * Sets the now value
+   */
+  void TestOnlySetNow(grpc_millis new_val) {
+    now_ = new_val;
+    now_is_valid_ = true;
+  }
+
+  /** Global initialization for ExecCtx. Called by iomgr */
+  static void GlobalInit(void);
+
+  /** Global shutdown for ExecCtx. Called by iomgr */
+  static void GlobalShutdown(void) { gpr_tls_destroy(&exec_ctx_); }
+
+  /** Gets pointer to current exec_ctx */
+  static ExecCtx* Get() {
+    return reinterpret_cast<ExecCtx*>(gpr_tls_get(&exec_ctx_));
+  }
+
+ protected:
+  /** Check if ready to finish */
+  virtual bool CheckReadyToFinish() { return false; }
+
+  /** Disallow delete on ExecCtx */
+  static void operator delete(void* p) { abort(); }
+
+ private:
+  /** Set exec_ctx_ to exec_ctx */
+  void Set(ExecCtx* exec_ctx) {
+    gpr_tls_set(&exec_ctx_, reinterpret_cast<intptr_t>(exec_ctx));
+  }
+
+  grpc_closure_list closure_list_ = GRPC_CLOSURE_LIST_INIT;
+  CombinerData combiner_data_ = {nullptr, nullptr};
+  uintptr_t flags_;
+  unsigned starting_cpu_ = gpr_cpu_current_cpu();
+
+  bool now_is_valid_ = false;
+  grpc_millis now_ = 0;
+
+  GPR_TLS_CLASS_DECL(exec_ctx_);
+  ExecCtx* last_exec_ctx_ = Get();
+};
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXEC_CTX_H */

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

@@ -29,8 +29,8 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/support/spinlock.h"
 
 #define MAX_DEPTH 2
 
@@ -55,7 +55,7 @@ grpc_core::TraceFlag executor_trace(false, "executor");
 
 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_closure_list list) {
   size_t n = 0;
 
   grpc_closure* c = list.head;
@@ -73,11 +73,11 @@ static size_t run_closures(grpc_exec_ctx* exec_ctx, grpc_closure_list list) {
 #ifndef NDEBUG
     c->scheduled = false;
 #endif
-    c->cb(exec_ctx, c->cb_arg, error);
+    c->cb(c->cb_arg, error);
     GRPC_ERROR_UNREF(error);
     c = next;
     n++;
-    grpc_exec_ctx_flush(exec_ctx);
+    grpc_core::ExecCtx::Get()->Flush();
   }
 
   return n;
@@ -87,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(bool threading) {
   gpr_atm cur_threads = gpr_atm_no_barrier_load(&g_cur_threads);
   if (threading) {
     if (cur_threads > 0) return;
@@ -104,8 +104,8 @@ void grpc_executor_set_threading(grpc_exec_ctx* exec_ctx, bool threading) {
 
     gpr_thd_options opt = gpr_thd_options_default();
     gpr_thd_options_set_joinable(&opt);
-    gpr_thd_new(&g_thread_state[0].id, executor_thread, &g_thread_state[0],
-                &opt);
+    gpr_thd_new(&g_thread_state[0].id, "grpc_executor", executor_thread,
+                &g_thread_state[0], &opt);
   } else {
     if (cur_threads == 0) return;
     for (size_t i = 0; i < g_max_threads; i++) {
@@ -125,28 +125,25 @@ void grpc_executor_set_threading(grpc_exec_ctx* exec_ctx, bool threading) {
     for (size_t i = 0; i < g_max_threads; i++) {
       gpr_mu_destroy(&g_thread_state[i].mu);
       gpr_cv_destroy(&g_thread_state[i].cv);
-      run_closures(exec_ctx, g_thread_state[i].elems);
+      run_closures(g_thread_state[i].elems);
     }
     gpr_free(g_thread_state);
     gpr_tls_destroy(&g_this_thread_state);
   }
 }
 
-void grpc_executor_init(grpc_exec_ctx* exec_ctx) {
+void grpc_executor_init() {
   gpr_atm_no_barrier_store(&g_cur_threads, 0);
-  grpc_executor_set_threading(exec_ctx, true);
+  grpc_executor_set_threading(true);
 }
 
-void grpc_executor_shutdown(grpc_exec_ctx* exec_ctx) {
-  grpc_executor_set_threading(exec_ctx, false);
-}
+void grpc_executor_shutdown() { grpc_executor_set_threading(false); }
 
 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, nullptr);
+  grpc_core::ExecCtx exec_ctx(0);
 
   size_t subtract_depth = 0;
   for (;;) {
@@ -158,7 +155,7 @@ static void executor_thread(void* arg) {
     ts->depth -= subtract_depth;
     while (grpc_closure_list_empty(ts->elems) && !ts->shutdown) {
       ts->queued_long_job = false;
-      gpr_cv_wait(&ts->cv, &ts->mu, gpr_inf_future(GPR_CLOCK_REALTIME));
+      gpr_cv_wait(&ts->cv, &ts->mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
     }
     if (ts->shutdown) {
       if (executor_trace.enabled()) {
@@ -168,7 +165,7 @@ static void executor_thread(void* arg) {
       gpr_mu_unlock(&ts->mu);
       break;
     }
-    GRPC_STATS_INC_EXECUTOR_QUEUE_DRAINED(&exec_ctx);
+    GRPC_STATS_INC_EXECUTOR_QUEUE_DRAINED();
     grpc_closure_list exec = ts->elems;
     ts->elems = GRPC_CLOSURE_LIST_INIT;
     gpr_mu_unlock(&ts->mu);
@@ -176,19 +173,18 @@ static void executor_thread(void* arg) {
       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_core::ExecCtx::Get()->InvalidateNow();
+    subtract_depth = run_closures(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_closure* closure, grpc_error* error,
+                          bool is_short) {
   bool retry_push;
   if (is_short) {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS(exec_ctx);
+    GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS();
   } else {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_LONG_ITEMS(exec_ctx);
+    GRPC_STATS_INC_EXECUTOR_SCHEDULED_LONG_ITEMS();
   }
   do {
     retry_push = false;
@@ -202,14 +198,16 @@ static void executor_push(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
         gpr_log(GPR_DEBUG, "EXECUTOR: schedule %p inline", closure);
 #endif
       }
-      grpc_closure_list_append(&exec_ctx->closure_list, closure, error);
+      grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(),
+                               closure, error);
       return;
     }
     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)];
+      ts = &g_thread_state[GPR_HASH_POINTER(grpc_core::ExecCtx::Get(),
+                                            cur_thread_count)];
     } else {
-      GRPC_STATS_INC_EXECUTOR_SCHEDULED_TO_SELF(exec_ctx);
+      GRPC_STATS_INC_EXECUTOR_SCHEDULED_TO_SELF();
     }
     thread_state* orig_ts = ts;
 
@@ -244,8 +242,8 @@ static void executor_push(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
         }
         continue;
       }
-      if (grpc_closure_list_empty(ts->elems)) {
-        GRPC_STATS_INC_EXECUTOR_WAKEUP_INITIATED(exec_ctx);
+      if (grpc_closure_list_empty(ts->elems) && !ts->shutdown) {
+        GRPC_STATS_INC_EXECUTOR_WAKEUP_INITIATED();
         gpr_cv_signal(&ts->cv);
       }
       grpc_closure_list_append(&ts->elems, closure, error);
@@ -263,25 +261,23 @@ static void executor_push(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
 
         gpr_thd_options opt = gpr_thd_options_default();
         gpr_thd_options_set_joinable(&opt);
-        gpr_thd_new(&g_thread_state[cur_thread_count].id, executor_thread,
-                    &g_thread_state[cur_thread_count], &opt);
+        gpr_thd_new(&g_thread_state[cur_thread_count].id, "gpr_executor",
+                    executor_thread, &g_thread_state[cur_thread_count], &opt);
       }
       gpr_spinlock_unlock(&g_adding_thread_lock);
     }
     if (retry_push) {
-      GRPC_STATS_INC_EXECUTOR_PUSH_RETRIES(exec_ctx);
+      GRPC_STATS_INC_EXECUTOR_PUSH_RETRIES();
     }
   } while (retry_push);
 }
 
-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_short(grpc_closure* closure, grpc_error* error) {
+  executor_push(closure, error, true);
 }
 
-static void executor_push_long(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
-                               grpc_error* error) {
-  executor_push(exec_ctx, closure, error, false);
+static void executor_push_long(grpc_closure* closure, grpc_error* error) {
+  executor_push(closure, error, false);
 }
 
 static const grpc_closure_scheduler_vtable executor_vtable_short = {

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

@@ -21,10 +21,6 @@
 
 #include "src/core/lib/iomgr/closure.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef enum {
   GRPC_EXECUTOR_SHORT,
   GRPC_EXECUTOR_LONG
@@ -35,22 +31,18 @@ typedef enum {
  * This mechanism is meant to outsource work (grpc_closure instances) to a
  * thread, for those cases where blocking isn't an option but there isn't a
  * non-blocking solution available. */
-void grpc_executor_init(grpc_exec_ctx* exec_ctx);
+void grpc_executor_init();
 
 grpc_closure_scheduler* grpc_executor_scheduler(grpc_executor_job_length);
 
 /** Shutdown the executor, running all pending work as part of the call */
-void grpc_executor_shutdown(grpc_exec_ctx* exec_ctx);
+void grpc_executor_shutdown();
 
 /** Is the executor multi-threaded? */
 bool grpc_executor_is_threaded();
 
 /* enable/disable threading - must be called after grpc_executor_init and before
    grpc_executor_shutdown */
-void grpc_executor_set_threading(grpc_exec_ctx* exec_ctx, bool enable);
-
-#ifdef __cplusplus
-}
-#endif
+void grpc_executor_set_threading(bool enable);
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */

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

@@ -27,13 +27,13 @@
 #include <grpc/support/thd.h>
 #include <grpc/support/useful.h>
 
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/fork.h"
+#include "src/core/lib/gpr/thd_internal.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-#include "src/core/lib/support/env.h"
-#include "src/core/lib/support/fork.h"
-#include "src/core/lib/support/thd_internal.h"
 #include "src/core/lib/surface/init.h"
 
 /*
@@ -49,10 +49,10 @@ void grpc_prefork() {
     return;
   }
   if (grpc_is_initialized()) {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_core::ExecCtx exec_ctx;
     grpc_timer_manager_set_threading(false);
-    grpc_executor_set_threading(&exec_ctx, false);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_executor_set_threading(false);
+    grpc_core::ExecCtx::Get()->Flush();
     if (!gpr_await_threads(
             gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                          gpr_time_from_seconds(3, GPR_TIMESPAN)))) {
@@ -64,24 +64,25 @@ void grpc_prefork() {
 void grpc_postfork_parent() {
   if (grpc_is_initialized()) {
     grpc_timer_manager_set_threading(true);
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_executor_set_threading(&exec_ctx, true);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_core::ExecCtx exec_ctx;
+    grpc_executor_set_threading(true);
   }
 }
 
 void grpc_postfork_child() {
   if (grpc_is_initialized()) {
     grpc_timer_manager_set_threading(true);
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_executor_set_threading(&exec_ctx, true);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_core::ExecCtx exec_ctx;
+    grpc_executor_set_threading(true);
+    grpc_core::ExecCtx::Get()->Flush();
   }
 }
 
 void grpc_fork_handlers_auto_register() {
   if (grpc_fork_support_enabled()) {
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
     pthread_atfork(grpc_prefork, grpc_postfork_parent, grpc_postfork_child);
+#endif  // GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
   }
 }