grpc-flamingo 1.11.0 → 1.15.0

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

@@ -44,10 +44,16 @@ const char* gpr_log_severity_string(gpr_log_severity severity) {
   GPR_UNREACHABLE_CODE(return "UNKNOWN");
 }
 
+int gpr_should_log(gpr_log_severity severity) {
+  return static_cast<gpr_atm>(severity) >=
+                 gpr_atm_no_barrier_load(&g_min_severity_to_print)
+             ? 1
+             : 0;
+}
+
 void gpr_log_message(const char* file, int line, gpr_log_severity severity,
                      const char* message) {
-  if (static_cast<gpr_atm>(severity) <
-      gpr_atm_no_barrier_load(&g_min_severity_to_print)) {
+  if (gpr_should_log(severity) == 0) {
     return;
   }
 

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

@@ -41,6 +41,10 @@ static android_LogPriority severity_to_log_priority(gpr_log_severity severity) {
 
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
+  /* Avoid message construction if gpr_log_message won't log */
+  if (gpr_should_log(severity) == 0) {
+    return;
+  }
   char* message = NULL;
   va_list args;
   va_start(args, format);

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

@@ -44,6 +44,10 @@ static long gettid(void) { return syscall(__NR_gettid); }
 
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
+  /* Avoid message construction if gpr_log_message won't log */
+  if (gpr_should_log(severity) == 0) {
+    return;
+  }
   char* message = nullptr;
   va_list args;
   va_start(args, format);

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

@@ -34,6 +34,10 @@ static intptr_t gettid(void) { return (intptr_t)pthread_self(); }
 
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
+  /* Avoid message construction if gpr_log_message won't log */
+  if (gpr_should_log(severity) == 0) {
+    return;
+  }
   char buf[64];
   char* allocated = nullptr;
   char* message = nullptr;

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

@@ -34,6 +34,11 @@
 
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
+  /* Avoid message construction if gpr_log_message won't log */
+  if (gpr_should_log(severity) == 0) {
+    return;
+  }
+
   char* message = NULL;
   va_list args;
   int ret;

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

@@ -23,8 +23,10 @@
 #include <ctype.h>
 #include <limits.h>
 #include <stddef.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -54,6 +56,32 @@ typedef struct {
   char* data;
 } dump_out;
 
+char* gpr_format_timespec(gpr_timespec tm) {
+  char time_buffer[35];
+  char ns_buffer[11];  // '.' + 9 digits of precision
+  struct tm* tm_info = localtime((const time_t*)&tm.tv_sec);
+  strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S", tm_info);
+  snprintf(ns_buffer, 11, ".%09d", tm.tv_nsec);
+  // This loop trims off trailing zeros by inserting a null character that the
+  // right point. We iterate in chunks of three because we want 0, 3, 6, or 9
+  // fractional digits.
+  for (int i = 7; i >= 1; i -= 3) {
+    if (ns_buffer[i] == '0' && ns_buffer[i + 1] == '0' &&
+        ns_buffer[i + 2] == '0') {
+      ns_buffer[i] = '\0';
+      // Edge case in which all fractional digits were 0.
+      if (i == 1) {
+        ns_buffer[0] = '\0';
+      }
+    } else {
+      break;
+    }
+  }
+  char* full_time_str;
+  gpr_asprintf(&full_time_str, "%s%sZ", time_buffer, ns_buffer);
+  return full_time_str;
+}
+
 static dump_out dump_out_create(void) {
   dump_out r = {0, 0, nullptr};
   return r;

data/src/core/lib/gpr/string.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/impl/codegen/gpr_types.h>
+
 #include <stdbool.h>
 #include <stddef.h>
 
@@ -81,6 +83,14 @@ char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
 void gpr_string_split(const char* input, const char* sep, char*** strs,
                       size_t* nstrs);
 
+/* Returns an allocated string that represents tm according to RFC-3339, and,
+   more specifically, follows:
+   https://developers.google.com/protocol-buffers/docs/proto3#json
+
+   Uses RFC 3339, where generated output will always be Z-normalized and uses
+   0, 3, 6 or 9 fractional digits. */
+char* gpr_format_timespec(gpr_timespec);
+
 /* A vector of strings... for building up a final string one piece at a time */
 typedef struct {
   char** strs;

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

@@ -28,7 +28,10 @@
 
 // gRPC currently can't depend on libstdc++, so we can't use "= 0" for
 // pure virtual methods.  Instead, we use this macro.
-#define GRPC_ABSTRACT \
-  { GPR_ASSERT(false); }
+#define GRPC_ABSTRACT                                                        \
+  {                                                                          \
+    gpr_log(GPR_ERROR, "Function marked GRPC_ABSTRACT was not implemented"); \
+    GPR_ASSERT(false);                                                       \
+  }
 
 #endif /* GRPC_CORE_LIB_GPRPP_ABSTRACT_H */

data/src/core/lib/gprpp/fork.cc

@@ -0,0 +1,268 @@
+/*
+ *
+ * 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/gprpp/fork.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/memory.h"
+
+/*
+ * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
+ *       AROUND VERY SPECIFIC USE CASES.
+ */
+
+namespace grpc_core {
+namespace internal {
+// The exec_ctx_count has 2 modes, blocked and unblocked.
+// When unblocked, the count is 2-indexed; exec_ctx_count=2 indicates
+// 0 active ExecCtxs, exex_ctx_count=3 indicates 1 active ExecCtxs...
+
+// When blocked, the exec_ctx_count is 0-indexed.  Note that ExecCtx
+// creation can only be blocked if there is exactly 1 outstanding ExecCtx,
+// meaning that BLOCKED and UNBLOCKED counts partition the integers
+#define UNBLOCKED(n) (n + 2)
+#define BLOCKED(n) (n)
+
+class ExecCtxState {
+ public:
+  ExecCtxState() : fork_complete_(true) {
+    gpr_mu_init(&mu_);
+    gpr_cv_init(&cv_);
+    gpr_atm_no_barrier_store(&count_, UNBLOCKED(0));
+  }
+
+  void IncExecCtxCount() {
+    gpr_atm count = gpr_atm_no_barrier_load(&count_);
+    while (true) {
+      if (count <= BLOCKED(1)) {
+        // This only occurs if we are trying to fork.  Wait until the fork()
+        // operation completes before allowing new ExecCtxs.
+        gpr_mu_lock(&mu_);
+        if (gpr_atm_no_barrier_load(&count_) <= BLOCKED(1)) {
+          while (!fork_complete_) {
+            gpr_cv_wait(&cv_, &mu_, gpr_inf_future(GPR_CLOCK_REALTIME));
+          }
+        }
+        gpr_mu_unlock(&mu_);
+      } else if (gpr_atm_no_barrier_cas(&count_, count, count + 1)) {
+        break;
+      }
+      count = gpr_atm_no_barrier_load(&count_);
+    }
+  }
+
+  void DecExecCtxCount() { gpr_atm_no_barrier_fetch_add(&count_, -1); }
+
+  bool BlockExecCtx() {
+    // Assumes there is an active ExecCtx when this function is called
+    if (gpr_atm_no_barrier_cas(&count_, UNBLOCKED(1), BLOCKED(1))) {
+      gpr_mu_lock(&mu_);
+      fork_complete_ = false;
+      gpr_mu_unlock(&mu_);
+      return true;
+    }
+    return false;
+  }
+
+  void AllowExecCtx() {
+    gpr_mu_lock(&mu_);
+    gpr_atm_no_barrier_store(&count_, UNBLOCKED(0));
+    fork_complete_ = true;
+    gpr_cv_broadcast(&cv_);
+    gpr_mu_unlock(&mu_);
+  }
+
+  ~ExecCtxState() {
+    gpr_mu_destroy(&mu_);
+    gpr_cv_destroy(&cv_);
+  }
+
+ private:
+  bool fork_complete_;
+  gpr_mu mu_;
+  gpr_cv cv_;
+  gpr_atm count_;
+};
+
+class ThreadState {
+ public:
+  ThreadState() : awaiting_threads_(false), threads_done_(false), count_(0) {
+    gpr_mu_init(&mu_);
+    gpr_cv_init(&cv_);
+  }
+
+  void IncThreadCount() {
+    gpr_mu_lock(&mu_);
+    count_++;
+    gpr_mu_unlock(&mu_);
+  }
+
+  void DecThreadCount() {
+    gpr_mu_lock(&mu_);
+    count_--;
+    if (awaiting_threads_ && count_ == 0) {
+      threads_done_ = true;
+      gpr_cv_signal(&cv_);
+    }
+    gpr_mu_unlock(&mu_);
+  }
+  void AwaitThreads() {
+    gpr_mu_lock(&mu_);
+    awaiting_threads_ = true;
+    threads_done_ = (count_ == 0);
+    while (!threads_done_) {
+      gpr_cv_wait(&cv_, &mu_, gpr_inf_future(GPR_CLOCK_REALTIME));
+    }
+    awaiting_threads_ = true;
+    gpr_mu_unlock(&mu_);
+  }
+
+  ~ThreadState() {
+    gpr_mu_destroy(&mu_);
+    gpr_cv_destroy(&cv_);
+  }
+
+ private:
+  bool awaiting_threads_;
+  bool threads_done_;
+  gpr_mu mu_;
+  gpr_cv cv_;
+  int count_;
+};
+
+}  // namespace
+
+void Fork::GlobalInit() {
+  if (!override_enabled_) {
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+    support_enabled_ = true;
+#else
+    support_enabled_ = false;
+#endif
+    bool env_var_set = false;
+    char* env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
+    if (env != nullptr) {
+      static const char* truthy[] = {"yes",  "Yes",  "YES", "true",
+                                     "True", "TRUE", "1"};
+      static const char* falsey[] = {"no",    "No",    "NO", "false",
+                                     "False", "FALSE", "0"};
+      for (size_t i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
+        if (0 == strcmp(env, truthy[i])) {
+          support_enabled_ = true;
+          env_var_set = true;
+          break;
+        }
+      }
+      if (!env_var_set) {
+        for (size_t i = 0; i < GPR_ARRAY_SIZE(falsey); i++) {
+          if (0 == strcmp(env, falsey[i])) {
+            support_enabled_ = false;
+            env_var_set = true;
+            break;
+          }
+        }
+      }
+      gpr_free(env);
+    }
+  }
+  if (support_enabled_) {
+    exec_ctx_state_ = grpc_core::New<internal::ExecCtxState>();
+    thread_state_ = grpc_core::New<internal::ThreadState>();
+  }
+}
+
+void Fork::GlobalShutdown() {
+  if (support_enabled_) {
+    grpc_core::Delete(exec_ctx_state_);
+    grpc_core::Delete(thread_state_);
+  }
+}
+
+bool Fork::Enabled() { return support_enabled_; }
+
+// Testing Only
+void Fork::Enable(bool enable) {
+  override_enabled_ = true;
+  support_enabled_ = enable;
+}
+
+void Fork::IncExecCtxCount() {
+  if (support_enabled_) {
+    exec_ctx_state_->IncExecCtxCount();
+  }
+}
+
+void Fork::DecExecCtxCount() {
+  if (support_enabled_) {
+    exec_ctx_state_->DecExecCtxCount();
+  }
+}
+
+void Fork::SetResetChildPollingEngineFunc(
+    Fork::child_postfork_func reset_child_polling_engine) {
+  reset_child_polling_engine_ = reset_child_polling_engine;
+}
+Fork::child_postfork_func Fork::GetResetChildPollingEngineFunc() {
+  return reset_child_polling_engine_;
+}
+
+bool Fork::BlockExecCtx() {
+  if (support_enabled_) {
+    return exec_ctx_state_->BlockExecCtx();
+  }
+  return false;
+}
+
+void Fork::AllowExecCtx() {
+  if (support_enabled_) {
+    exec_ctx_state_->AllowExecCtx();
+  }
+}
+
+void Fork::IncThreadCount() {
+  if (support_enabled_) {
+    thread_state_->IncThreadCount();
+  }
+}
+
+void Fork::DecThreadCount() {
+  if (support_enabled_) {
+    thread_state_->DecThreadCount();
+  }
+}
+void Fork::AwaitThreads() {
+  if (support_enabled_) {
+    thread_state_->AwaitThreads();
+  }
+}
+
+internal::ExecCtxState* Fork::exec_ctx_state_ = nullptr;
+internal::ThreadState* Fork::thread_state_ = nullptr;
+bool Fork::support_enabled_ = false;
+bool Fork::override_enabled_ = false;
+Fork::child_postfork_func Fork::reset_child_polling_engine_ = nullptr;
+}  // namespace grpc_core

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

@@ -0,0 +1,88 @@
+/*
+ *
+ * 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_FORK_H
+#define GRPC_CORE_LIB_GPRPP_FORK_H
+
+/*
+ * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
+ *       AROUND VERY SPECIFIC USE CASES.
+ */
+
+namespace grpc_core {
+
+namespace internal {
+class ExecCtxState;
+class ThreadState;
+}  // namespace internal
+
+class Fork {
+ public:
+  typedef void (*child_postfork_func)(void);
+
+  static void GlobalInit();
+  static void GlobalShutdown();
+
+  // Returns true if fork suppport is enabled, false otherwise
+  static bool Enabled();
+
+  // Increment the count of active ExecCtxs.
+  // Will block until a pending fork is complete if one is in progress.
+  static void IncExecCtxCount();
+
+  // Decrement the count of active ExecCtxs
+  static void DecExecCtxCount();
+
+  // Provide a function that will be invoked in the child's postfork handler to
+  // reset the polling engine's internal state.
+  static void SetResetChildPollingEngineFunc(
+      child_postfork_func reset_child_polling_engine);
+  static child_postfork_func GetResetChildPollingEngineFunc();
+
+  // Check if there is a single active ExecCtx
+  // (the one used to invoke this function).  If there are more,
+  // return false.  Otherwise, return true and block creation of
+  // more ExecCtx s until AlloWExecCtx() is called
+  //
+  static bool BlockExecCtx();
+  static void AllowExecCtx();
+
+  // Increment the count of active threads.
+  static void IncThreadCount();
+
+  // Decrement the count of active threads.
+  static void DecThreadCount();
+
+  // Await all core threads to be joined.
+  static void AwaitThreads();
+
+  // Test only: overrides environment variables/compile flags
+  // Must be called before grpc_init()
+  static void Enable(bool enable);
+
+ private:
+  static internal::ExecCtxState* exec_ctx_state_;
+  static internal::ThreadState* thread_state_;
+  static bool support_enabled_;
+  static bool override_enabled_;
+  static child_postfork_func reset_child_polling_engine_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_FORK_H */