grpc 1.7.3 → 1.8.0

data/src/core/lib/transport/pid_controller.cc

@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright 2016 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/transport/pid_controller.h"
+#include <grpc/support/useful.h>
+
+namespace grpc_core {
+
+PidController::PidController(const Args& args)
+    : last_control_value_(args.initial_control_value()), args_(args) {}
+
+double PidController::Update(double error, double dt) {
+  if (dt <= 0) return last_control_value_;
+  /* integrate error using the trapezoid rule */
+  error_integral_ += dt * (last_error_ + error) * 0.5;
+  error_integral_ = GPR_CLAMP(error_integral_, -args_.integral_range(),
+                              args_.integral_range());
+  double diff_error = (error - last_error_) / dt;
+  /* calculate derivative of control value vs time */
+  double dc_dt = args_.gain_p() * error + args_.gain_i() * error_integral_ +
+                 args_.gain_d() * diff_error;
+  /* and perform trapezoidal integration */
+  double new_control_value =
+      last_control_value_ + dt * (last_dc_dt_ + dc_dt) * 0.5;
+  new_control_value = GPR_CLAMP(new_control_value, args_.min_control_value(),
+                                args_.max_control_value());
+  last_error_ = error;
+  last_dc_dt_ = dc_dt;
+  last_control_value_ = new_control_value;
+  return new_control_value;
+}
+
+}  // namespace grpc_core

data/src/core/lib/transport/pid_controller.h

@@ -19,6 +19,8 @@
 #ifndef GRPC_CORE_LIB_TRANSPORT_PID_CONTROLLER_H
 #define GRPC_CORE_LIB_TRANSPORT_PID_CONTROLLER_H
 
+#include <limits>
+
 /* \file Simple PID controller.
    Implements a proportional-integral-derivative controller.
    Used when we want to iteratively control a variable to converge some other
@@ -26,37 +28,87 @@
    Gains can be set to adjust sensitivity to current error (p), the integral
    of error (i), and the derivative of error (d). */
 
-typedef struct {
-  double gain_p;
-  double gain_i;
-  double gain_d;
-  double initial_control_value;
-  double min_control_value;
-  double max_control_value;
-  double integral_range;
-} grpc_pid_controller_args;
-
-typedef struct {
-  double last_error;
-  double error_integral;
-  double last_control_value;
-  double last_dc_dt;
-  grpc_pid_controller_args args;
-} grpc_pid_controller;
-
-/** Initialize the controller */
-void grpc_pid_controller_init(grpc_pid_controller *pid_controller,
-                              grpc_pid_controller_args args);
-
-/** Reset the controller: useful when things have changed significantly */
-void grpc_pid_controller_reset(grpc_pid_controller *pid_controller);
-
-/** Update the controller: given a current error estimate, and the time since
-    the last update, returns a new control value */
-double grpc_pid_controller_update(grpc_pid_controller *pid_controller,
-                                  double error, double dt);
-
-/** Returns the last control value calculated */
-double grpc_pid_controller_last(grpc_pid_controller *pid_controller);
+namespace grpc_core {
+
+class PidController {
+ public:
+  class Args {
+   public:
+    double gain_p() const { return gain_p_; }
+    double gain_i() const { return gain_i_; }
+    double gain_d() const { return gain_d_; }
+    double initial_control_value() const { return initial_control_value_; }
+    double min_control_value() const { return min_control_value_; }
+    double max_control_value() const { return max_control_value_; }
+    double integral_range() const { return integral_range_; }
+
+    Args& set_gain_p(double gain_p) {
+      gain_p_ = gain_p;
+      return *this;
+    }
+    Args& set_gain_i(double gain_i) {
+      gain_i_ = gain_i;
+      return *this;
+    }
+    Args& set_gain_d(double gain_d) {
+      gain_d_ = gain_d;
+      return *this;
+    }
+    Args& set_initial_control_value(double initial_control_value) {
+      initial_control_value_ = initial_control_value;
+      return *this;
+    }
+    Args& set_min_control_value(double min_control_value) {
+      min_control_value_ = min_control_value;
+      return *this;
+    }
+    Args& set_max_control_value(double max_control_value) {
+      max_control_value_ = max_control_value;
+      return *this;
+    }
+    Args& set_integral_range(double integral_range) {
+      integral_range_ = integral_range;
+      return *this;
+    }
+
+   private:
+    double gain_p_ = 0.0;
+    double gain_i_ = 0.0;
+    double gain_d_ = 0.0;
+    double initial_control_value_ = 0.0;
+    double min_control_value_ = std::numeric_limits<double>::min();
+    double max_control_value_ = std::numeric_limits<double>::max();
+    double integral_range_ = std::numeric_limits<double>::max();
+  };
+
+  explicit PidController(const Args& args);
+
+  /// Reset the controller internal state: useful when the environment has
+  /// changed significantly
+  void Reset() {
+    last_error_ = 0.0;
+    last_dc_dt_ = 0.0;
+    error_integral_ = 0.0;
+  }
+
+  /// Update the controller: given a current error estimate, and the time since
+  /// the last update, returns a new control value
+  double Update(double error, double dt);
+
+  /// Returns the last control value calculated
+  double last_control_value() const { return last_control_value_; }
+
+  /// Returns the current error integral (mostly for testing)
+  double error_integral() const { return error_integral_; }
+
+ private:
+  double last_error_ = 0.0;
+  double error_integral_ = 0.0;
+  double last_control_value_;
+  double last_dc_dt_ = 0.0;
+  const Args args_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_PID_CONTROLLER_H */

data/src/core/lib/transport/{service_config.c → service_config.cc}

@@ -64,11 +64,11 @@ grpc_service_config* grpc_service_config_create(const char* json_string) {
   service_config->json_string = gpr_strdup(json_string);
   service_config->json_tree =
       grpc_json_parse_string(service_config->json_string);
-  if (service_config->json_tree == NULL) {
+  if (service_config->json_tree == nullptr) {
     gpr_log(GPR_INFO, "failed to parse JSON for service config");
     gpr_free(service_config->json_string);
     gpr_free(service_config);
-    return NULL;
+    return nullptr;
   }
   return service_config;
 }
@@ -83,9 +83,9 @@ void grpc_service_config_parse_global_params(
     const grpc_service_config* service_config,
     void (*process_json)(const grpc_json* json, void* arg), void* arg) {
   const grpc_json* json = service_config->json_tree;
-  if (json->type != GRPC_JSON_OBJECT || json->key != NULL) return;
-  for (grpc_json* field = json->child; field != NULL; field = field->next) {
-    if (field->key == NULL) return;
+  if (json->type != GRPC_JSON_OBJECT || json->key != nullptr) return;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key == nullptr) return;
     if (strcmp(field->key, "methodConfig") == 0) continue;
     process_json(field, arg);
   }
@@ -94,13 +94,13 @@ void grpc_service_config_parse_global_params(
 const char* grpc_service_config_get_lb_policy_name(
     const grpc_service_config* service_config) {
   const grpc_json* json = service_config->json_tree;
-  if (json->type != GRPC_JSON_OBJECT || json->key != NULL) return NULL;
-  const char* lb_policy_name = NULL;
-  for (grpc_json* field = json->child; field != NULL; field = field->next) {
-    if (field->key == NULL) return NULL;
+  if (json->type != GRPC_JSON_OBJECT || json->key != nullptr) return nullptr;
+  const char* lb_policy_name = nullptr;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key == nullptr) return nullptr;
     if (strcmp(field->key, "loadBalancingPolicy") == 0) {
-      if (lb_policy_name != NULL) return NULL;  // Duplicate.
-      if (field->type != GRPC_JSON_STRING) return NULL;
+      if (lb_policy_name != nullptr) return nullptr;  // Duplicate.
+      if (field->type != GRPC_JSON_STRING) return nullptr;
       lb_policy_name = field->value;
     }
   }
@@ -110,8 +110,14 @@ const char* grpc_service_config_get_lb_policy_name(
 // Returns the number of names specified in the method config \a json.
 static size_t count_names_in_method_config_json(grpc_json* json) {
   size_t num_names = 0;
-  for (grpc_json* field = json->child; field != NULL; field = field->next) {
-    if (field->key != NULL && strcmp(field->key, "name") == 0) ++num_names;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key != nullptr && strcmp(field->key, "name") == 0) {
+      if (field->type != GRPC_JSON_ARRAY) return -1;
+      for (grpc_json* name = field->child; name != nullptr; name = name->next) {
+        if (name->type != GRPC_JSON_OBJECT) return -1;
+        ++num_names;
+      }
+    }
   }
   return num_names;
 }
@@ -119,26 +125,26 @@ static size_t count_names_in_method_config_json(grpc_json* json) {
 // Returns a path string for the JSON name object specified by \a json.
 // Returns NULL on error.  Caller takes ownership of result.
 static char* parse_json_method_name(grpc_json* json) {
-  if (json->type != GRPC_JSON_OBJECT) return NULL;
-  const char* service_name = NULL;
-  const char* method_name = NULL;
-  for (grpc_json* child = json->child; child != NULL; child = child->next) {
-    if (child->key == NULL) return NULL;
-    if (child->type != GRPC_JSON_STRING) return NULL;
+  if (json->type != GRPC_JSON_OBJECT) return nullptr;
+  const char* service_name = nullptr;
+  const char* method_name = nullptr;
+  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
+    if (child->key == nullptr) return nullptr;
+    if (child->type != GRPC_JSON_STRING) return nullptr;
     if (strcmp(child->key, "service") == 0) {
-      if (service_name != NULL) return NULL;  // Duplicate.
-      if (child->value == NULL) return NULL;
+      if (service_name != nullptr) return nullptr;  // Duplicate.
+      if (child->value == nullptr) return nullptr;
       service_name = child->value;
     } else if (strcmp(child->key, "method") == 0) {
-      if (method_name != NULL) return NULL;  // Duplicate.
-      if (child->value == NULL) return NULL;
+      if (method_name != nullptr) return nullptr;  // Duplicate.
+      if (child->value == nullptr) return nullptr;
       method_name = child->value;
     }
   }
-  if (service_name == NULL) return NULL;  // Required field.
+  if (service_name == nullptr) return nullptr;  // Required field.
   char* path;
   gpr_asprintf(&path, "/%s/%s", service_name,
-               method_name == NULL ? "*" : method_name);
+               method_name == nullptr ? "*" : method_name);
   return path;
 }
 
@@ -148,20 +154,23 @@ static char* parse_json_method_name(grpc_json* json) {
 static bool parse_json_method_config(
     grpc_exec_ctx* exec_ctx, grpc_json* json,
     void* (*create_value)(const grpc_json* method_config_json),
+    void* (*ref_value)(void* value),
+    void (*unref_value)(grpc_exec_ctx* exec_ctx, void* value),
     grpc_slice_hash_table_entry* entries, size_t* idx) {
   // Construct value.
   void* method_config = create_value(json);
-  if (method_config == NULL) return false;
+  if (method_config == nullptr) return false;
   // Construct list of paths.
   bool success = false;
   gpr_strvec paths;
   gpr_strvec_init(&paths);
-  for (grpc_json* child = json->child; child != NULL; child = child->next) {
-    if (child->key == NULL) continue;
+  for (grpc_json* child = json->child; child != nullptr; child = child->next) {
+    if (child->key == nullptr) continue;
     if (strcmp(child->key, "name") == 0) {
       if (child->type != GRPC_JSON_ARRAY) goto done;
-      for (grpc_json* name = child->child; name != NULL; name = name->next) {
+      for (grpc_json* name = child->child; name != nullptr; name = name->next) {
         char* path = parse_json_method_name(name);
+        if (path == nullptr) goto done;
         gpr_strvec_add(&paths, path);
       }
     }
@@ -170,11 +179,12 @@ static bool parse_json_method_config(
   // Add entry for each path.
   for (size_t i = 0; i < paths.count; ++i) {
     entries[*idx].key = grpc_slice_from_copied_string(paths.strs[i]);
-    entries[*idx].value = method_config;
+    entries[*idx].value = ref_value(method_config);
     ++*idx;
   }
   success = true;
 done:
+  unref_value(exec_ctx, method_config);
   gpr_strvec_destroy(&paths);
   return success;
 }
@@ -182,41 +192,49 @@ done:
 grpc_slice_hash_table* grpc_service_config_create_method_config_table(
     grpc_exec_ctx* exec_ctx, const grpc_service_config* service_config,
     void* (*create_value)(const grpc_json* method_config_json),
-    void (*destroy_value)(grpc_exec_ctx* exec_ctx, void* value)) {
+    void* (*ref_value)(void* value),
+    void (*unref_value)(grpc_exec_ctx* exec_ctx, void* value)) {
   const grpc_json* json = service_config->json_tree;
   // Traverse parsed JSON tree.
-  if (json->type != GRPC_JSON_OBJECT || json->key != NULL) return NULL;
+  if (json->type != GRPC_JSON_OBJECT || json->key != nullptr) return nullptr;
   size_t num_entries = 0;
-  grpc_slice_hash_table_entry* entries = NULL;
-  for (grpc_json* field = json->child; field != NULL; field = field->next) {
-    if (field->key == NULL) return NULL;
+  grpc_slice_hash_table_entry* entries = nullptr;
+  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
+    if (field->key == nullptr) return nullptr;
     if (strcmp(field->key, "methodConfig") == 0) {
-      if (entries != NULL) return NULL;  // Duplicate.
-      if (field->type != GRPC_JSON_ARRAY) return NULL;
+      if (entries != nullptr) return nullptr;  // Duplicate.
+      if (field->type != GRPC_JSON_ARRAY) return nullptr;
       // Find number of entries.
-      for (grpc_json* method = field->child; method != NULL;
+      for (grpc_json* method = field->child; method != nullptr;
            method = method->next) {
-        num_entries += count_names_in_method_config_json(method);
+        size_t count = count_names_in_method_config_json(method);
+        if (count <= 0) return nullptr;
+        num_entries += count;
       }
       // Populate method config table entries.
       entries = (grpc_slice_hash_table_entry*)gpr_malloc(
           num_entries * sizeof(grpc_slice_hash_table_entry));
       size_t idx = 0;
-      for (grpc_json* method = field->child; method != NULL;
+      for (grpc_json* method = field->child; method != nullptr;
            method = method->next) {
-        if (!parse_json_method_config(exec_ctx, method, create_value, entries,
-                                      &idx)) {
-          return NULL;
+        if (!parse_json_method_config(exec_ctx, method, create_value, ref_value,
+                                      unref_value, entries, &idx)) {
+          for (size_t i = 0; i < idx; ++i) {
+            grpc_slice_unref_internal(exec_ctx, entries[i].key);
+            unref_value(exec_ctx, entries[i].value);
+          }
+          gpr_free(entries);
+          return nullptr;
         }
       }
       GPR_ASSERT(idx == num_entries);
     }
   }
   // Instantiate method config table.
-  grpc_slice_hash_table* method_config_table = NULL;
-  if (entries != NULL) {
-    method_config_table =
-        grpc_slice_hash_table_create(num_entries, entries, destroy_value, NULL);
+  grpc_slice_hash_table* method_config_table = nullptr;
+  if (entries != nullptr) {
+    method_config_table = grpc_slice_hash_table_create(num_entries, entries,
+                                                       unref_value, nullptr);
     gpr_free(entries);
   }
   return method_config_table;
@@ -228,7 +246,7 @@ void* grpc_method_config_table_get(grpc_exec_ctx* exec_ctx,
   void* value = grpc_slice_hash_table_get(table, path);
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/*").
-  if (value == NULL) {
+  if (value == nullptr) {
     char* path_str = grpc_slice_to_c_string(path);
     const char* sep = strrchr(path_str, '/') + 1;
     const size_t len = (size_t)(sep - path_str);

data/src/core/lib/transport/service_config.h

@@ -22,6 +22,10 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/slice/slice_hash_table.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_service_config grpc_service_config;
 
 grpc_service_config* grpc_service_config_create(const char* json_string);
@@ -42,12 +46,13 @@ const char* grpc_service_config_get_lb_policy_name(
 /// Creates a method config table based on the data in \a json.
 /// The table's keys are request paths.  The table's value type is
 /// returned by \a create_value(), based on data parsed from the JSON tree.
-/// \a destroy_value is used to clean up values.
+/// \a ref_value() and \a unref_value() are used to ref and unref values.
 /// Returns NULL on error.
 grpc_slice_hash_table* grpc_service_config_create_method_config_table(
     grpc_exec_ctx* exec_ctx, const grpc_service_config* service_config,
     void* (*create_value)(const grpc_json* method_config_json),
-    void (*destroy_value)(grpc_exec_ctx* exec_ctx, void* value));
+    void* (*ref_value)(void* value),
+    void (*unref_value)(grpc_exec_ctx* exec_ctx, void* value));
 
 /// A helper function for looking up values in the table returned by
 /// \a grpc_service_config_create_method_config_table().
@@ -59,4 +64,8 @@ void* grpc_method_config_table_get(grpc_exec_ctx* exec_ctx,
                                    const grpc_slice_hash_table* table,
                                    grpc_slice path);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_TRANSPORT_SERVICE_CONFIG_H */

data/src/core/lib/transport/{static_metadata.c → static_metadata.cc}

@@ -103,8 +103,8 @@ static uint8_t g_bytes[] = {
     105, 100, 101, 110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116,
     101, 44,  103, 122, 105, 112};
 
-static void static_ref(void *unused) {}
-static void static_unref(grpc_exec_ctx *exec_ctx, void *unused) {}
+static void static_ref(void* unused) {}
+static void static_unref(grpc_exec_ctx* exec_ctx, void* unused) {}
 static const grpc_slice_refcount_vtable static_sub_vtable = {
     static_ref, static_unref, grpc_slice_default_eq_impl,
     grpc_slice_default_hash_impl};

data/src/core/lib/transport/static_metadata.h

@@ -27,6 +27,10 @@
 #ifndef GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H
 #define GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "src/core/lib/transport/metadata.h"
 
 #define GRPC_STATIC_MDSTR_COUNT 100
@@ -537,30 +541,30 @@ typedef enum {
 } grpc_metadata_batch_callouts_index;
 
 typedef union {
-  struct grpc_linked_mdelem *array[GRPC_BATCH_CALLOUTS_COUNT];
+  struct grpc_linked_mdelem* array[GRPC_BATCH_CALLOUTS_COUNT];
   struct {
-    struct grpc_linked_mdelem *path;
-    struct grpc_linked_mdelem *method;
-    struct grpc_linked_mdelem *status;
-    struct grpc_linked_mdelem *authority;
-    struct grpc_linked_mdelem *scheme;
-    struct grpc_linked_mdelem *te;
-    struct grpc_linked_mdelem *grpc_message;
-    struct grpc_linked_mdelem *grpc_status;
-    struct grpc_linked_mdelem *grpc_payload_bin;
-    struct grpc_linked_mdelem *grpc_encoding;
-    struct grpc_linked_mdelem *grpc_accept_encoding;
-    struct grpc_linked_mdelem *grpc_server_stats_bin;
-    struct grpc_linked_mdelem *grpc_tags_bin;
-    struct grpc_linked_mdelem *grpc_trace_bin;
-    struct grpc_linked_mdelem *content_type;
-    struct grpc_linked_mdelem *content_encoding;
-    struct grpc_linked_mdelem *accept_encoding;
-    struct grpc_linked_mdelem *grpc_internal_encoding_request;
-    struct grpc_linked_mdelem *grpc_internal_stream_encoding_request;
-    struct grpc_linked_mdelem *user_agent;
-    struct grpc_linked_mdelem *host;
-    struct grpc_linked_mdelem *lb_token;
+    struct grpc_linked_mdelem* path;
+    struct grpc_linked_mdelem* method;
+    struct grpc_linked_mdelem* status;
+    struct grpc_linked_mdelem* authority;
+    struct grpc_linked_mdelem* scheme;
+    struct grpc_linked_mdelem* te;
+    struct grpc_linked_mdelem* grpc_message;
+    struct grpc_linked_mdelem* grpc_status;
+    struct grpc_linked_mdelem* grpc_payload_bin;
+    struct grpc_linked_mdelem* grpc_encoding;
+    struct grpc_linked_mdelem* grpc_accept_encoding;
+    struct grpc_linked_mdelem* grpc_server_stats_bin;
+    struct grpc_linked_mdelem* grpc_tags_bin;
+    struct grpc_linked_mdelem* grpc_trace_bin;
+    struct grpc_linked_mdelem* content_type;
+    struct grpc_linked_mdelem* content_encoding;
+    struct grpc_linked_mdelem* accept_encoding;
+    struct grpc_linked_mdelem* grpc_internal_encoding_request;
+    struct grpc_linked_mdelem* grpc_internal_stream_encoding_request;
+    struct grpc_linked_mdelem* user_agent;
+    struct grpc_linked_mdelem* host;
+    struct grpc_linked_mdelem* lb_token;
   } named;
 } grpc_metadata_batch_callouts;
 
@@ -584,4 +588,7 @@ extern const uint8_t grpc_static_accept_stream_encoding_metadata[4];
   (GRPC_MAKE_MDELEM(&grpc_static_mdelem_table                                  \
                         [grpc_static_accept_stream_encoding_metadata[(algs)]], \
                     GRPC_MDELEM_STORAGE_STATIC))
+#ifdef __cplusplus
+}
+#endif
 #endif /* GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H */