grpc 1.18.0 → 1.22.0

data/src/core/lib/gpr/arena.cc

@@ -1,192 +0,0 @@
-/*
- *
- * Copyright 2017 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 <grpc/support/port_platform.h>
-
-#include "src/core/lib/gpr/arena.h"
-
-#include <string.h>
-#include <new>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-
-#include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gprpp/memory.h"
-
-namespace {
-enum init_strategy {
-  NO_INIT,        // Do not initialize the arena blocks.
-  ZERO_INIT,      // Initialize arena blocks with 0.
-  NON_ZERO_INIT,  // Initialize arena blocks with a non-zero value.
-};
-
-gpr_once g_init_strategy_once = GPR_ONCE_INIT;
-init_strategy g_init_strategy = NO_INIT;
-}  // namespace
-
-static void set_strategy_from_env() {
-  char* str = gpr_getenv("GRPC_ARENA_INIT_STRATEGY");
-  if (str == nullptr) {
-    g_init_strategy = NO_INIT;
-  } else if (strcmp(str, "zero_init") == 0) {
-    g_init_strategy = ZERO_INIT;
-  } else if (strcmp(str, "non_zero_init") == 0) {
-    g_init_strategy = NON_ZERO_INIT;
-  } else {
-    g_init_strategy = NO_INIT;
-  }
-  gpr_free(str);
-}
-
-static void* gpr_arena_alloc_maybe_init(size_t size) {
-  void* mem = gpr_malloc_aligned(size, GPR_MAX_ALIGNMENT);
-  gpr_once_init(&g_init_strategy_once, set_strategy_from_env);
-  if (GPR_UNLIKELY(g_init_strategy != NO_INIT)) {
-    if (g_init_strategy == ZERO_INIT) {
-      memset(mem, 0, size);
-    } else {  // NON_ZERO_INIT.
-      memset(mem, 0xFE, size);
-    }
-  }
-  return mem;
-}
-
-void gpr_arena_init() {
-  gpr_once_init(&g_init_strategy_once, set_strategy_from_env);
-}
-
-// Uncomment this to use a simple arena that simply allocates the
-// requested amount of memory for each call to gpr_arena_alloc().  This
-// effectively eliminates the efficiency gain of using an arena, but it
-// may be useful for debugging purposes.
-//#define SIMPLE_ARENA_FOR_DEBUGGING
-#ifdef SIMPLE_ARENA_FOR_DEBUGGING
-
-struct gpr_arena {
-  gpr_arena() { gpr_mu_init(&mu); }
-  ~gpr_arena() {
-    gpr_mu_destroy(&mu);
-    for (size_t i = 0; i < num_ptrs; ++i) {
-      gpr_free_aligned(ptrs[i]);
-    }
-    gpr_free(ptrs);
-  }
-
-  gpr_mu mu;
-  void** ptrs = nullptr;
-  size_t num_ptrs = 0;
-};
-
-gpr_arena* gpr_arena_create(size_t ignored_initial_size) {
-  return grpc_core::New<gpr_arena>();
-}
-
-size_t gpr_arena_destroy(gpr_arena* arena) {
-  grpc_core::Delete(arena);
-  return 1;  // Value doesn't matter, since it won't be used.
-}
-
-void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
-  gpr_mu_lock(&arena->mu);
-  arena->ptrs =
-      (void**)gpr_realloc(arena->ptrs, sizeof(void*) * (arena->num_ptrs + 1));
-  void* retval = arena->ptrs[arena->num_ptrs++] =
-      gpr_arena_alloc_maybe_init(size);
-  gpr_mu_unlock(&arena->mu);
-  return retval;
-}
-
-#else  // SIMPLE_ARENA_FOR_DEBUGGING
-
-// TODO(roth): We currently assume that all callers need alignment of 16
-// bytes, which may be wrong in some cases.  As part of converting the
-// arena API to C++, we should consider replacing gpr_arena_alloc() with a
-// template that takes the type of the value being allocated, which
-// would allow us to use the alignment actually needed by the caller.
-
-typedef struct zone {
-  zone* next = nullptr;
-} zone;
-
-struct gpr_arena {
-  gpr_arena(size_t initial_size)
-      : initial_zone_size(initial_size), last_zone(&initial_zone) {
-    gpr_mu_init(&arena_growth_mutex);
-  }
-  ~gpr_arena() {
-    gpr_mu_destroy(&arena_growth_mutex);
-    zone* z = initial_zone.next;
-    while (z) {
-      zone* next_z = z->next;
-      z->~zone();
-      gpr_free_aligned(z);
-      z = next_z;
-    }
-  }
-
-  // Keep track of the total used size. We use this in our call sizing
-  // historesis.
-  gpr_atm total_used = 0;
-  size_t initial_zone_size;
-  zone initial_zone;
-  zone* last_zone;
-  gpr_mu arena_growth_mutex;
-};
-
-gpr_arena* gpr_arena_create(size_t initial_size) {
-  initial_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size);
-  return new (gpr_arena_alloc_maybe_init(
-      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + initial_size))
-      gpr_arena(initial_size);
-}
-
-size_t gpr_arena_destroy(gpr_arena* arena) {
-  const gpr_atm size = gpr_atm_no_barrier_load(&arena->total_used);
-  arena->~gpr_arena();
-  gpr_free_aligned(arena);
-  return static_cast<size_t>(size);
-}
-
-void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
-  size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
-  size_t begin = gpr_atm_no_barrier_fetch_add(&arena->total_used, size);
-  if (begin + size <= arena->initial_zone_size) {
-    return reinterpret_cast<char*>(arena) +
-           GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + begin;
-  } else {
-    // If the allocation isn't able to end in the initial zone, create a new
-    // zone for this allocation, and any unused space in the initial zone is
-    // wasted. This overflowing and wasting is uncommon because of our arena
-    // sizing historesis (that is, most calls should have a large enough initial
-    // zone and will not need to grow the arena).
-    gpr_mu_lock(&arena->arena_growth_mutex);
-    zone* z = new (gpr_arena_alloc_maybe_init(
-        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + size)) zone();
-    arena->last_zone->next = z;
-    arena->last_zone = z;
-    gpr_mu_unlock(&arena->arena_growth_mutex);
-    return reinterpret_cast<char*>(z) +
-           GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone));
-  }
-}
-
-#endif  // SIMPLE_ARENA_FOR_DEBUGGING

data/src/core/lib/gprpp/atomic_with_atm.h

@@ -1,57 +0,0 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_ATM_H
-#define GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_ATM_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/support/atm.h>
-
-namespace grpc_core {
-
-enum MemoryOrderRelaxed { memory_order_relaxed };
-
-template <class T>
-class atomic;
-
-template <>
-class atomic<bool> {
- public:
-  atomic() { gpr_atm_no_barrier_store(&x_, static_cast<gpr_atm>(false)); }
-  explicit atomic(bool x) {
-    gpr_atm_no_barrier_store(&x_, static_cast<gpr_atm>(x));
-  }
-
-  bool compare_exchange_strong(bool& expected, bool update, MemoryOrderRelaxed,
-                               MemoryOrderRelaxed) {
-    if (!gpr_atm_no_barrier_cas(&x_, static_cast<gpr_atm>(expected),
-                                static_cast<gpr_atm>(update))) {
-      expected = gpr_atm_no_barrier_load(&x_) != 0;
-      return false;
-    }
-    return true;
-  }
-
- private:
-  gpr_atm x_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_WITH_ATM_H */

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

@@ -1,107 +0,0 @@
-/*
- *
- * 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 <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_POSIX_WAKEUP_FD
-
-#include "src/core/lib/iomgr/wakeup_fd_cv.h"
-
-#include <errno.h>
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/time.h>
-
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/thd.h"
-
-#define MAX_TABLE_RESIZE 256
-
-extern grpc_cv_fd_table g_cvfds;
-
-static grpc_error* cv_fd_init(grpc_wakeup_fd* fd_info) {
-  unsigned int i, newsize;
-  int idx;
-  gpr_mu_lock(&g_cvfds.mu);
-  if (!g_cvfds.free_fds) {
-    newsize = GPR_MIN(g_cvfds.size * 2, g_cvfds.size + MAX_TABLE_RESIZE);
-    g_cvfds.cvfds = static_cast<grpc_fd_node*>(
-        gpr_realloc(g_cvfds.cvfds, sizeof(grpc_fd_node) * newsize));
-    for (i = g_cvfds.size; i < newsize; i++) {
-      g_cvfds.cvfds[i].is_set = 0;
-      g_cvfds.cvfds[i].cvs = nullptr;
-      g_cvfds.cvfds[i].next_free = g_cvfds.free_fds;
-      g_cvfds.free_fds = &g_cvfds.cvfds[i];
-    }
-    g_cvfds.size = newsize;
-  }
-
-  idx = static_cast<int>(g_cvfds.free_fds - g_cvfds.cvfds);
-  g_cvfds.free_fds = g_cvfds.free_fds->next_free;
-  g_cvfds.cvfds[idx].cvs = nullptr;
-  g_cvfds.cvfds[idx].is_set = 0;
-  fd_info->read_fd = GRPC_IDX_TO_FD(idx);
-  fd_info->write_fd = -1;
-  gpr_mu_unlock(&g_cvfds.mu);
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error* cv_fd_wakeup(grpc_wakeup_fd* fd_info) {
-  grpc_cv_node* cvn;
-  gpr_mu_lock(&g_cvfds.mu);
-  g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].is_set = 1;
-  cvn = g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].cvs;
-  while (cvn) {
-    gpr_cv_signal(cvn->cv);
-    cvn = cvn->next;
-  }
-  gpr_mu_unlock(&g_cvfds.mu);
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error* cv_fd_consume(grpc_wakeup_fd* fd_info) {
-  gpr_mu_lock(&g_cvfds.mu);
-  g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].is_set = 0;
-  gpr_mu_unlock(&g_cvfds.mu);
-  return GRPC_ERROR_NONE;
-}
-
-static void cv_fd_destroy(grpc_wakeup_fd* fd_info) {
-  if (fd_info->read_fd == 0) {
-    return;
-  }
-  gpr_mu_lock(&g_cvfds.mu);
-  // Assert that there are no active pollers
-  GPR_ASSERT(!g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].cvs);
-  g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)].next_free = g_cvfds.free_fds;
-  g_cvfds.free_fds = &g_cvfds.cvfds[GRPC_FD_TO_IDX(fd_info->read_fd)];
-  gpr_mu_unlock(&g_cvfds.mu);
-}
-
-static int cv_check_availability(void) { return 1; }
-
-const grpc_wakeup_fd_vtable grpc_cv_wakeup_fd_vtable = {
-    cv_fd_init, cv_fd_consume, cv_fd_wakeup, cv_fd_destroy,
-    cv_check_availability};
-
-#endif /* GRPC_POSIX_WAKUP_FD */

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

@@ -1,69 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-/*
- * wakeup_fd_cv uses condition variables to implement wakeup fds.
- *
- * It is intended for use only in cases when eventfd() and pipe() are not
- * available.  It can only be used with the "poll" engine.
- *
- * Implementation:
- * A global table of cv wakeup fds is mantained.  A cv wakeup fd is a negative
- * file descriptor.  poll() is then run in a background thread with only the
- * real socket fds while we wait on a condition variable trigged by either the
- * poll() completion or a wakeup_fd() call.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_WAKEUP_FD_CV_H
-#define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_CV_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/support/sync.h>
-
-#include "src/core/lib/iomgr/ev_posix.h"
-
-#define GRPC_FD_TO_IDX(fd) (-(fd)-1)
-#define GRPC_IDX_TO_FD(idx) (-(idx)-1)
-
-typedef struct grpc_cv_node {
-  gpr_cv* cv;
-  struct grpc_cv_node* next;
-  struct grpc_cv_node* prev;
-} grpc_cv_node;
-
-typedef struct grpc_fd_node {
-  int is_set;
-  grpc_cv_node* cvs;
-  struct grpc_fd_node* next_free;
-} grpc_fd_node;
-
-typedef struct grpc_cv_fd_table {
-  gpr_mu mu;
-  gpr_refcount pollcount;
-  gpr_cv shutdown_cv;
-  grpc_fd_node* cvfds;
-  grpc_fd_node* free_fds;
-  unsigned int size;
-  grpc_poll_function_type poll;
-} grpc_cv_fd_table;
-
-extern const grpc_wakeup_fd_vtable grpc_cv_wakeup_fd_vtable;
-
-#endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_CV_H */

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

@@ -1,106 +0,0 @@
-//
-// 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 <grpc/support/port_platform.h>
-
-#include "src/core/lib/transport/service_config.h"
-
-#include <string.h>
-
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/slice/slice_hash_table.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-
-namespace grpc_core {
-
-UniquePtr<ServiceConfig> ServiceConfig::Create(const char* json) {
-  UniquePtr<char> json_string(gpr_strdup(json));
-  grpc_json* json_tree = grpc_json_parse_string(json_string.get());
-  if (json_tree == nullptr) {
-    gpr_log(GPR_INFO, "failed to parse JSON for service config");
-    return nullptr;
-  }
-  return MakeUnique<ServiceConfig>(std::move(json_string), json_tree);
-}
-
-ServiceConfig::ServiceConfig(UniquePtr<char> json_string, grpc_json* json_tree)
-    : json_string_(std::move(json_string)), json_tree_(json_tree) {}
-
-ServiceConfig::~ServiceConfig() { grpc_json_destroy(json_tree_); }
-
-const char* ServiceConfig::GetLoadBalancingPolicyName() const {
-  if (json_tree_->type != GRPC_JSON_OBJECT || json_tree_->key != nullptr) {
-    return nullptr;
-  }
-  const char* lb_policy_name = nullptr;
-  for (grpc_json* field = json_tree_->child; field != nullptr;
-       field = field->next) {
-    if (field->key == nullptr) return nullptr;
-    if (strcmp(field->key, "loadBalancingPolicy") == 0) {
-      if (lb_policy_name != nullptr) return nullptr;  // Duplicate.
-      if (field->type != GRPC_JSON_STRING) return nullptr;
-      lb_policy_name = field->value;
-    }
-  }
-  return lb_policy_name;
-}
-
-int ServiceConfig::CountNamesInMethodConfig(grpc_json* json) {
-  int num_names = 0;
-  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;
-}
-
-UniquePtr<char> ServiceConfig::ParseJsonMethodName(grpc_json* json) {
-  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 != nullptr) return nullptr;  // Duplicate.
-      if (child->value == nullptr) return nullptr;
-      service_name = child->value;
-    } else if (strcmp(child->key, "method") == 0) {
-      if (method_name != nullptr) return nullptr;  // Duplicate.
-      if (child->value == nullptr) return nullptr;
-      method_name = child->value;
-    }
-  }
-  if (service_name == nullptr) return nullptr;  // Required field.
-  char* path;
-  gpr_asprintf(&path, "/%s/%s", service_name,
-               method_name == nullptr ? "*" : method_name);
-  return UniquePtr<char>(path);
-}
-
-}  // namespace grpc_core