grpc 1.8.7 → 1.9.0.pre1

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -21,10 +21,6 @@
 
 #include "src/core/lib/transport/transport_impl.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          grpc_channel_args* args,
                                          void* reserved);
@@ -34,8 +30,4 @@ extern grpc_core::TraceFlag grpc_inproc_trace;
 void grpc_inproc_transport_init(void);
 void grpc_inproc_transport_shutdown(void);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H */

data/src/core/lib/backoff/backoff.cc

@@ -18,63 +18,58 @@
 
 #include "src/core/lib/backoff/backoff.h"
 
+#include <algorithm>
+
 #include <grpc/support/useful.h>
 
-void grpc_backoff_init(grpc_backoff* backoff, grpc_millis initial_backoff,
-                       double multiplier, double jitter,
-                       grpc_millis min_connect_timeout,
-                       grpc_millis max_backoff) {
-  backoff->initial_backoff = initial_backoff;
-  backoff->multiplier = multiplier;
-  backoff->jitter = jitter;
-  backoff->min_connect_timeout = min_connect_timeout;
-  backoff->max_backoff = max_backoff;
-  backoff->rng_state = (uint32_t)gpr_now(GPR_CLOCK_REALTIME).tv_nsec;
-}
+namespace grpc_core {
 
-grpc_backoff_result grpc_backoff_begin(grpc_exec_ctx* exec_ctx,
-                                       grpc_backoff* backoff) {
-  backoff->current_backoff = backoff->initial_backoff;
-  const grpc_millis initial_timeout =
-      GPR_MAX(backoff->initial_backoff, backoff->min_connect_timeout);
-  const grpc_millis now = grpc_exec_ctx_now(exec_ctx);
-  const grpc_backoff_result result = {now + initial_timeout,
-                                      now + backoff->current_backoff};
-  return result;
-}
+namespace {
 
-/* Generate a random number between 0 and 1. */
-static double generate_uniform_random_number(uint32_t* rng_state) {
-  *rng_state = (1103515245 * *rng_state + 12345) % ((uint32_t)1 << 31);
-  return *rng_state / (double)((uint32_t)1 << 31);
+/* Generate a random number between 0 and 1. We roll our own RNG because seeding
+ * rand() modifies a global variable we have no control over. */
+double generate_uniform_random_number(uint32_t* rng_state) {
+  constexpr uint32_t two_raise_31 = uint32_t(1) << 31;
+  *rng_state = (1103515245 * *rng_state + 12345) % two_raise_31;
+  return *rng_state / static_cast<double>(two_raise_31);
 }
 
-static double generate_uniform_random_number_between(uint32_t* rng_state,
-                                                     double a, double b) {
+double generate_uniform_random_number_between(uint32_t* rng_state, double a,
+                                              double b) {
   if (a == b) return a;
   if (a > b) GPR_SWAP(double, a, b);  // make sure a < b
   const double range = b - a;
   return a + generate_uniform_random_number(rng_state) * range;
 }
 
-grpc_backoff_result grpc_backoff_step(grpc_exec_ctx* exec_ctx,
-                                      grpc_backoff* backoff) {
-  backoff->current_backoff = (grpc_millis)(GPR_MIN(
-      backoff->current_backoff * backoff->multiplier, backoff->max_backoff));
+}  // namespace
+
+BackOff::BackOff(const Options& options)
+    : options_(options),
+      rng_state_(static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec)) {
+  Reset();
+}
+
+grpc_millis BackOff::NextAttemptTime() {
+  if (initial_) {
+    initial_ = false;
+    return current_backoff_ + grpc_core::ExecCtx::Get()->Now();
+  }
+  current_backoff_ =
+      (grpc_millis)(std::min(current_backoff_ * options_.multiplier(),
+                             (double)options_.max_backoff()));
   const double jitter = generate_uniform_random_number_between(
-      &backoff->rng_state, -backoff->jitter * backoff->current_backoff,
-      backoff->jitter * backoff->current_backoff);
-  const grpc_millis current_timeout =
-      GPR_MAX((grpc_millis)(backoff->current_backoff + jitter),
-              backoff->min_connect_timeout);
-  const grpc_millis next_timeout = GPR_MIN(
-      (grpc_millis)(backoff->current_backoff + jitter), backoff->max_backoff);
-  const grpc_millis now = grpc_exec_ctx_now(exec_ctx);
-  const grpc_backoff_result result = {now + current_timeout,
-                                      now + next_timeout};
-  return result;
+      &rng_state_, -options_.jitter() * current_backoff_,
+      options_.jitter() * current_backoff_);
+  const grpc_millis next_timeout = (grpc_millis)(current_backoff_ + jitter);
+  return next_timeout + grpc_core::ExecCtx::Get()->Now();
 }
 
-void grpc_backoff_reset(grpc_backoff* backoff) {
-  backoff->current_backoff = backoff->initial_backoff;
+void BackOff::Reset() {
+  current_backoff_ = options_.initial_backoff();
+  initial_ = true;
 }
+
+void BackOff::SetRandomSeed(uint32_t seed) { rng_state_ = seed; }
+
+}  // namespace grpc_core

data/src/core/lib/backoff/backoff.h

@@ -21,63 +21,67 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-  /// const:  how long to wait after the first failure before retrying
-  grpc_millis initial_backoff;
-
-  /// const: factor with which to multiply backoff after a failed retry
-  double multiplier;
-
-  /// const: amount to randomize backoffs
-  double jitter;
-
-  /// const: minimum time between retries
-  grpc_millis min_connect_timeout;
-
-  /// const: maximum time between retries
-  grpc_millis max_backoff;
-
+namespace grpc_core {
+
+/// Implementation of the backoff mechanism described in
+/// doc/connection-backoff.md
+class BackOff {
+ public:
+  class Options;
+
+  /// Initialize backoff machinery - does not need to be destroyed
+  explicit BackOff(const Options& options);
+
+  /// Returns the time at which the next attempt should start.
+  grpc_millis NextAttemptTime();
+
+  /// Reset the backoff, so the next value returned by NextAttemptTime()
+  /// will be the time of the second attempt (rather than the Nth).
+  void Reset();
+
+  void SetRandomSeed(unsigned int seed);
+
+  class Options {
+   public:
+    Options& set_initial_backoff(grpc_millis initial_backoff) {
+      initial_backoff_ = initial_backoff;
+      return *this;
+    }
+    Options& set_multiplier(double multiplier) {
+      multiplier_ = multiplier;
+      return *this;
+    }
+    Options& set_jitter(double jitter) {
+      jitter_ = jitter;
+      return *this;
+    }
+    Options& set_max_backoff(grpc_millis max_backoff) {
+      max_backoff_ = max_backoff;
+      return *this;
+    }
+    /// how long to wait after the first failure before retrying
+    grpc_millis initial_backoff() const { return initial_backoff_; }
+    /// factor with which to multiply backoff after a failed retry
+    double multiplier() const { return multiplier_; }
+    /// amount to randomize backoffs
+    double jitter() const { return jitter_; }
+    /// maximum time between retries
+    grpc_millis max_backoff() const { return max_backoff_; }
+
+   private:
+    grpc_millis initial_backoff_;
+    double multiplier_;
+    double jitter_;
+    grpc_millis max_backoff_;
+  };  // class Options
+
+ private:
+  const Options options_;
+  uint32_t rng_state_;
+  bool initial_;
   /// current delay before retries
-  grpc_millis current_backoff;
-
-  /// random number generator
-  uint32_t rng_state;
-} grpc_backoff;
-
-typedef struct {
-  /// Deadline to be used for the current attempt.
-  grpc_millis current_deadline;
-
-  /// Deadline to be used for the next attempt, following the backoff strategy.
-  grpc_millis next_attempt_start_time;
-} grpc_backoff_result;
-
-/// Initialize backoff machinery - does not need to be destroyed
-void grpc_backoff_init(grpc_backoff* backoff, grpc_millis initial_backoff,
-                       double multiplier, double jitter,
-                       grpc_millis min_connect_timeout,
-                       grpc_millis max_backoff);
-
-/// Begin retry loop: returns the deadlines to be used for the current attempt
-/// and the subsequent retry, if any.
-grpc_backoff_result grpc_backoff_begin(grpc_exec_ctx* exec_ctx,
-                                       grpc_backoff* backoff);
-
-/// Step a retry loop: returns the deadlines to be used for the current attempt
-/// and the subsequent retry, if any.
-grpc_backoff_result grpc_backoff_step(grpc_exec_ctx* exec_ctx,
-                                      grpc_backoff* backoff);
-
-/// Reset the backoff, so the next grpc_backoff_step will be a
-/// grpc_backoff_begin.
-void grpc_backoff_reset(grpc_backoff* backoff);
-
-#ifdef __cplusplus
-}
-#endif
+  grpc_millis current_backoff_;
+};
 
+}  // namespace grpc_core
 #endif /* GRPC_CORE_LIB_BACKOFF_BACKOFF_H */

data/src/core/lib/channel/channel_args.cc

@@ -29,7 +29,7 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/support/string.h"
+#include "src/core/lib/gpr/string.h"
 
 static grpc_arg copy_arg(const grpc_arg* src) {
   grpc_arg dst;
@@ -188,7 +188,7 @@ grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
   return b;
 }
 
-void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a) {
+void grpc_channel_args_destroy(grpc_channel_args* a) {
   size_t i;
   if (!a) return;
   for (i = 0; i < a->num_args; i++) {
@@ -199,8 +199,7 @@ void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a) {
       case GRPC_ARG_INTEGER:
         break;
       case GRPC_ARG_POINTER:
-        a->args[i].value.pointer.vtable->destroy(exec_ctx,
-                                                 a->args[i].value.pointer.p);
+        a->args[i].value.pointer.vtable->destroy(a->args[i].value.pointer.p);
         break;
     }
     gpr_free(a->args[i].key);
@@ -299,8 +298,7 @@ static int find_stream_compression_algorithm_states_bitset(
 }
 
 grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
-    grpc_compression_algorithm algorithm, int state) {
+    grpc_channel_args** a, grpc_compression_algorithm algorithm, int state) {
   int* states_arg = nullptr;
   grpc_channel_args* result = *a;
   const int states_arg_found =
@@ -333,15 +331,15 @@ grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
       GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
     }
     result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
-    grpc_channel_args_destroy(exec_ctx, *a);
+    grpc_channel_args_destroy(*a);
     *a = result;
   }
   return result;
 }
 
 grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
-    grpc_stream_compression_algorithm algorithm, int state) {
+    grpc_channel_args** a, grpc_stream_compression_algorithm algorithm,
+    int state) {
   int* states_arg = nullptr;
   grpc_channel_args* result = *a;
   const int states_arg_found =
@@ -375,7 +373,7 @@ grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
       GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
     }
     result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
-    grpc_channel_args_destroy(exec_ctx, *a);
+    grpc_channel_args_destroy(*a);
     *a = result;
   }
   return result;

data/src/core/lib/channel/channel_args.h

@@ -23,10 +23,6 @@
 #include <grpc/grpc.h>
 #include "src/core/lib/iomgr/socket_mutator.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 // Channel args are intentionally immutable, to avoid the need for locking.
 
 /** Copy the arguments in \a src into a new instance */
@@ -57,7 +53,7 @@ grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
                                            const grpc_channel_args* b);
 
 /** Destroy arguments created by \a grpc_channel_args_copy */
-void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a);
+void grpc_channel_args_destroy(grpc_channel_args* a);
 
 /** Returns the compression algorithm set in \a a. */
 grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
@@ -89,8 +85,7 @@ grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
  * modified to point to the returned instance (which may be different from the
  * input value of \a a). */
 grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
-    grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
-    grpc_compression_algorithm algorithm, int enabled);
+    grpc_channel_args** a, grpc_compression_algorithm algorithm, int enabled);
 
 /** Sets the support for the given stream compression algorithm. By default, all
  * stream compression algorithms are enabled. It's an error to disable an
@@ -100,8 +95,8 @@ grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
  * modified to point to the returned instance (which may be different from the
  * input value of \a a). */
 grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
-    grpc_stream_compression_algorithm algorithm, int enabled);
+    grpc_channel_args** a, grpc_stream_compression_algorithm algorithm,
+    int enabled);
 
 /** Returns the bitset representing the support state (true for enabled, false
  * for disabled) for compression algorithms.
@@ -153,8 +148,4 @@ grpc_arg grpc_channel_arg_integer_create(char* name, int value);
 grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
                                          const grpc_arg_pointer_vtable* vtable);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_H */

data/src/core/lib/channel/channel_stack.cc

@@ -88,8 +88,8 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
 }
 
 grpc_error* grpc_channel_stack_init(
-    grpc_exec_ctx* exec_ctx, int initial_refs, grpc_iomgr_cb_func destroy,
-    void* destroy_arg, const grpc_channel_filter** filters, size_t filter_count,
+    int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
+    const grpc_channel_filter** filters, size_t filter_count,
     const grpc_channel_args* channel_args, grpc_transport* optional_transport,
     const char* name, grpc_channel_stack* stack) {
   size_t call_size =
@@ -117,8 +117,7 @@ grpc_error* grpc_channel_stack_init(
     args.is_last = i == (filter_count - 1);
     elems[i].filter = filters[i];
     elems[i].channel_data = user_data;
-    grpc_error* error =
-        elems[i].filter->init_channel_elem(exec_ctx, &elems[i], &args);
+    grpc_error* error = elems[i].filter->init_channel_elem(&elems[i], &args);
     if (error != GRPC_ERROR_NONE) {
       if (first_error == GRPC_ERROR_NONE) {
         first_error = error;
@@ -138,20 +137,18 @@ grpc_error* grpc_channel_stack_init(
   return first_error;
 }
 
-void grpc_channel_stack_destroy(grpc_exec_ctx* exec_ctx,
-                                grpc_channel_stack* stack) {
+void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(stack);
   size_t count = stack->count;
   size_t i;
 
   /* destroy per-filter data */
   for (i = 0; i < count; i++) {
-    channel_elems[i].filter->destroy_channel_elem(exec_ctx, &channel_elems[i]);
+    channel_elems[i].filter->destroy_channel_elem(&channel_elems[i]);
   }
 }
 
-grpc_error* grpc_call_stack_init(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel_stack* channel_stack,
+grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
                                  int initial_refs, grpc_iomgr_cb_func destroy,
                                  void* destroy_arg,
                                  const grpc_call_element_args* elem_args) {
@@ -174,8 +171,8 @@ grpc_error* grpc_call_stack_init(grpc_exec_ctx* exec_ctx,
     call_elems[i].filter = channel_elems[i].filter;
     call_elems[i].channel_data = channel_elems[i].channel_data;
     call_elems[i].call_data = user_data;
-    grpc_error* error = call_elems[i].filter->init_call_elem(
-        exec_ctx, &call_elems[i], elem_args);
+    grpc_error* error =
+        call_elems[i].filter->init_call_elem(&call_elems[i], elem_args);
     if (error != GRPC_ERROR_NONE) {
       if (first_error == GRPC_ERROR_NONE) {
         first_error = error;
@@ -189,8 +186,7 @@ grpc_error* grpc_call_stack_init(grpc_exec_ctx* exec_ctx,
   return first_error;
 }
 
-void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
-                                                grpc_call_stack* call_stack,
+void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
                                                 grpc_polling_entity* pollent) {
   size_t count = call_stack->count;
   grpc_call_element* call_elems;
@@ -203,18 +199,16 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
 
   /* init per-filter data */
   for (i = 0; i < count; i++) {
-    call_elems[i].filter->set_pollset_or_pollset_set(exec_ctx, &call_elems[i],
-                                                     pollent);
+    call_elems[i].filter->set_pollset_or_pollset_set(&call_elems[i], pollent);
     user_data +=
         ROUND_UP_TO_ALIGNMENT_SIZE(call_elems[i].filter->sizeof_call_data);
   }
 }
 
 void grpc_call_stack_ignore_set_pollset_or_pollset_set(
-    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
-    grpc_polling_entity* pollent) {}
+    grpc_call_element* elem, grpc_polling_entity* pollent) {}
 
-void grpc_call_stack_destroy(grpc_exec_ctx* exec_ctx, grpc_call_stack* stack,
+void grpc_call_stack_destroy(grpc_call_stack* stack,
                              const grpc_call_final_info* final_info,
                              grpc_closure* then_schedule_closure) {
   grpc_call_element* elems = CALL_ELEMS_FROM_STACK(stack);
@@ -224,29 +218,27 @@ void grpc_call_stack_destroy(grpc_exec_ctx* exec_ctx, grpc_call_stack* stack,
   /* destroy per-filter data */
   for (i = 0; i < count; i++) {
     elems[i].filter->destroy_call_elem(
-        exec_ctx, &elems[i], final_info,
+        &elems[i], final_info,
         i == count - 1 ? then_schedule_closure : nullptr);
   }
 }
 
-void grpc_call_next_op(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+void grpc_call_next_op(grpc_call_element* elem,
                        grpc_transport_stream_op_batch* op) {
   grpc_call_element* next_elem = elem + 1;
   GRPC_CALL_LOG_OP(GPR_INFO, next_elem, op);
-  next_elem->filter->start_transport_stream_op_batch(exec_ctx, next_elem, op);
+  next_elem->filter->start_transport_stream_op_batch(next_elem, op);
 }
 
-void grpc_channel_next_get_info(grpc_exec_ctx* exec_ctx,
-                                grpc_channel_element* elem,
+void grpc_channel_next_get_info(grpc_channel_element* elem,
                                 const grpc_channel_info* channel_info) {
   grpc_channel_element* next_elem = elem + 1;
-  next_elem->filter->get_channel_info(exec_ctx, next_elem, channel_info);
+  next_elem->filter->get_channel_info(next_elem, channel_info);
 }
 
-void grpc_channel_next_op(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
-                          grpc_transport_op* op) {
+void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op) {
   grpc_channel_element* next_elem = elem + 1;
-  next_elem->filter->start_transport_op(exec_ctx, next_elem, op);
+  next_elem->filter->start_transport_op(next_elem, op);
 }
 
 grpc_channel_stack* grpc_channel_stack_from_top_element(