grpc 1.8.7 → 1.9.0.pre1

data/include/grpc/impl/codegen/grpc_types.h

@@ -22,7 +22,6 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #include <grpc/impl/codegen/compression_types.h>
-#include <grpc/impl/codegen/exec_ctx_fwd.h>
 #include <grpc/impl/codegen/gpr_types.h>
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/impl/codegen/status.h>
@@ -85,7 +84,7 @@ typedef enum {
 
 typedef struct grpc_arg_pointer_vtable {
   void* (*copy)(void* p);
-  void (*destroy)(grpc_exec_ctx* exec_ctx, void* p);
+  void (*destroy)(void* p);
   int (*cmp)(void* p, void* q);
 } grpc_arg_pointer_vtable;
 

data/include/grpc/impl/codegen/port_platform.h

@@ -173,6 +173,7 @@
 #endif /* _LP64 */
 #ifdef __GLIBC__
 #define GPR_POSIX_CRASH_HANDLER 1
+#define GPR_LINUX_PTHREAD_NAME 1
 #else /* musl libc */
 #define GPR_MUSL_LIBC_COMPAT 1
 #endif
@@ -194,11 +195,25 @@
 #define GPR_PTHREAD_TLS 1
 #else /* __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_7 */
 #define GPR_CPU_POSIX 1
+/* TODO(vjpai): there is a reported issue in bazel build for Mac where __thread
+   in a header is currently not working (bazelbuild/bazel#4341). Remove
+   the following conditional and use GPR_GCC_TLS when that is fixed */
+#ifndef GRPC_BAZEL_BUILD
 #define GPR_GCC_TLS 1
+#else /* GRPC_BAZEL_BUILD */
+#define GPR_PTHREAD_TLS 1
+#endif /* GRPC_BAZEL_BUILD */
+#define GPR_APPLE_PTHREAD_NAME 1
 #endif
 #else /* __MAC_OS_X_VERSION_MIN_REQUIRED */
 #define GPR_CPU_POSIX 1
+/* TODO(vjpai): Remove the following conditional and use only GPR_GCC_TLS
+   when bazelbuild/bazel#4341 is fixed */
+#ifndef GRPC_BAZEL_BUILD
 #define GPR_GCC_TLS 1
+#else /* GRPC_BAZEL_BUILD */
+#define GPR_PTHREAD_TLS 1
+#endif /* GRPC_BAZEL_BUILD */
 #endif
 #define GPR_POSIX_CRASH_HANDLER 1
 #endif
@@ -303,20 +318,23 @@
  * This is primarily because of linker problems and toolchain misconfiguration:
  * TLS isn't supported until NDK r12b per
  * https://developer.android.com/ndk/downloads/revision_history.html
+ * TLS also does not work with Android NDK if GCC is being used as the compiler
+ * instead of Clang.
  * Since NDK r16, `__NDK_MAJOR__` and `__NDK_MINOR__` are defined in
  * <android/ndk-version.h>. For NDK < r16, users should define these macros,
  * e.g. `-D__NDK_MAJOR__=11 -D__NKD_MINOR__=0` for NDK r11. */
-#if defined(__ANDROID__) && defined(__clang__) && defined(GPR_GCC_TLS)
+#if defined(__ANDROID__) && defined(GPR_GCC_TLS)
 #if __has_include(<android/ndk-version.h>)
 #include <android/ndk-version.h>
 #endif /* __has_include(<android/ndk-version.h>) */
-#if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && \
-    defined(__NDK_MINOR__) &&                                               \
-    ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
+#if (defined(__clang__) && defined(__NDK_MAJOR__) && defined(__NDK_MINOR__) && \
+     ((__NDK_MAJOR__ < 12) ||                                                  \
+      ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))) ||                      \
+    (defined(__GNUC__) && !defined(__clang__))
 #undef GPR_GCC_TLS
 #define GPR_PTHREAD_TLS 1
 #endif
-#endif /*defined(__ANDROID__) && defined(__clang__) && defined(GPR_GCC_TLS) */
+#endif /*defined(__ANDROID__) && defined(GPR_GCC_TLS) */
 
 #if defined(__has_include)
 #if __has_include(<atomic>)
@@ -416,6 +434,14 @@ typedef unsigned __int64 uint64_t;
 #endif
 #endif
 
+#ifndef GRPC_UNUSED
+#if defined(__GNUC__) && !defined(__MINGW32__)
+#define GRPC_UNUSED __attribute__((unused))
+#else
+#define GRPC_UNUSED
+#endif
+#endif
+
 #ifndef GPR_PRINT_FORMAT_CHECK
 #ifdef __GNUC__
 #define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS) \
@@ -459,6 +485,21 @@ typedef unsigned __int64 uint64_t;
 #endif /* GPR_ATTRIBUTE_NO_TSAN (2) */
 #endif /* GPR_ATTRIBUTE_NO_TSAN (1) */
 
+/* GRPC_ALLOW_EXCEPTIONS should be 0 or 1 if exceptions are allowed or not */
+#ifndef GRPC_ALLOW_EXCEPTIONS
+/* If not already set, set to 1 on Windows (style guide standard) but to
+ * 0 on non-Windows platforms unless the compiler defines __EXCEPTIONS */
+#ifdef GPR_WINDOWS
+#define GRPC_ALLOW_EXCEPTIONS 1
+#else /* GPR_WINDOWS */
+#ifdef __EXCEPTIONS
+#define GRPC_ALLOW_EXCEPTIONS 1
+#else /* __EXCEPTIONS */
+#define GRPC_ALLOW_EXCEPTIONS 0
+#endif /* __EXCEPTIONS */
+#endif /* __GPR_WINDOWS */
+#endif /* GRPC_ALLOW_EXCEPTIONS */
+
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif

data/include/grpc/impl/codegen/slice.h

@@ -23,7 +23,6 @@
 
 #include <stddef.h>
 
-#include <grpc/impl/codegen/exec_ctx_fwd.h>
 #include <grpc/impl/codegen/gpr_slice.h>
 
 typedef struct grpc_slice grpc_slice;
@@ -43,7 +42,7 @@ typedef struct grpc_slice grpc_slice;
 
 typedef struct grpc_slice_refcount_vtable {
   void (*ref)(void*);
-  void (*unref)(grpc_exec_ctx* exec_ctx, void*);
+  void (*unref)(void*);
   int (*eq)(grpc_slice a, grpc_slice b);
   uint32_t (*hash)(grpc_slice slice);
 } grpc_slice_refcount_vtable;

data/include/grpc/module.modulemap

@@ -7,7 +7,6 @@ framework module grpc {
   header "support/avl.h"
   header "support/cmdline.h"
   header "support/cpu.h"
-  header "support/histogram.h"
   header "support/host_port.h"
   header "support/log.h"
   header "support/log_windows.h"
@@ -31,7 +30,6 @@ framework module grpc {
   header "impl/codegen/byte_buffer_reader.h"
   header "impl/codegen/compression_types.h"
   header "impl/codegen/connectivity_state.h"
-  header "impl/codegen/exec_ctx_fwd.h"
   header "impl/codegen/grpc_types.h"
   header "impl/codegen/propagation_bits.h"
   header "impl/codegen/slice.h"

data/include/grpc/slice_buffer.h

@@ -67,8 +67,7 @@ GPRAPI void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src,
                                                 size_t n,
                                                 grpc_slice_buffer* dst);
 /** move the first n bytes of src into dst (copying them) */
-GPRAPI void grpc_slice_buffer_move_first_into_buffer(grpc_exec_ctx* exec_ctx,
-                                                     grpc_slice_buffer* src,
+GPRAPI void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src,
                                                      size_t n, void* dst);
 /** take the first slice in the slice buffer */
 GPRAPI grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* src);

data/include/grpc/support/log.h

@@ -73,12 +73,14 @@ GPRAPI void gpr_log_verbosity_init(void);
 /** Log overrides: applications can use this API to intercept logging calls
    and use their own implementations */
 
-typedef struct {
+struct gpr_log_func_args {
   const char* file;
   int line;
   gpr_log_severity severity;
   const char* message;
-} gpr_log_func_args;
+};
+
+typedef struct gpr_log_func_args gpr_log_func_args;
 
 typedef void (*gpr_log_func)(gpr_log_func_args* args);
 GPRAPI void gpr_set_log_function(gpr_log_func func);

data/include/grpc/support/thd.h

@@ -42,9 +42,12 @@ typedef struct {
 
 /** Create a new thread running (*thd_body)(arg) and place its thread identifier
    in *t, and return true.  If there are insufficient resources, return false.
+   thd_name is the name of the thread for identification purposes on platforms
+   that support thread naming.
    If options==NULL, default options are used.
    The thread is immediately runnable, and exits when (*thd_body)() returns.  */
-GPRAPI int gpr_thd_new(gpr_thd_id* t, void (*thd_body)(void* arg), void* arg,
+GPRAPI int gpr_thd_new(gpr_thd_id* t, const char* thd_name,
+                       void (*thd_body)(void* arg), void* arg,
                        const gpr_thd_options* options);
 
 /** Return a gpr_thd_options struct with all fields set to defaults. */

data/include/grpc/support/tls.h

@@ -32,6 +32,12 @@
      GPR_TLS_DECL(foo);
    Thread locals always have static scope.
 
+   Declaring a thread local class variable 'foo':
+     GPR_TLS_CLASS_DECL(foo);
+
+   Defining the thread local class variable:
+     GPR_TLS_CLASS_DEF(foo);
+
    Initializing a thread local (must be done at library initialization
    time):
      gpr_tls_init(&foo);

data/include/grpc/support/tls_gcc.h

@@ -26,44 +26,6 @@
 /** Thread local storage based on gcc compiler primitives.
    #include tls.h to use this - and see that file for documentation */
 
-#ifndef NDEBUG
-
-struct gpr_gcc_thread_local {
-  intptr_t value;
-  bool* inited;
-};
-
-#define GPR_TLS_DECL(name)           \
-  static bool name##_inited = false; \
-  static __thread struct gpr_gcc_thread_local name = {0, &(name##_inited)}
-
-#define gpr_tls_init(tls)                  \
-  do {                                     \
-    GPR_ASSERT(*((tls)->inited) == false); \
-    *((tls)->inited) = true;               \
-  } while (0)
-
-/** It is allowed to call gpr_tls_init after gpr_tls_destroy is called. */
-#define gpr_tls_destroy(tls)      \
-  do {                            \
-    GPR_ASSERT(*((tls)->inited)); \
-    *((tls)->inited) = false;     \
-  } while (0)
-
-#define gpr_tls_set(tls, new_value) \
-  do {                              \
-    GPR_ASSERT(*((tls)->inited));   \
-    (tls)->value = (new_value);     \
-  } while (0)
-
-#define gpr_tls_get(tls)          \
-  ({                              \
-    GPR_ASSERT(*((tls)->inited)); \
-    (tls)->value;                 \
-  })
-
-#else /* NDEBUG */
-
 struct gpr_gcc_thread_local {
   intptr_t value;
 };
@@ -71,6 +33,11 @@ struct gpr_gcc_thread_local {
 #define GPR_TLS_DECL(name) \
   static __thread struct gpr_gcc_thread_local name = {0}
 
+#define GPR_TLS_CLASS_DECL(name) \
+  static __thread struct gpr_gcc_thread_local name
+
+#define GPR_TLS_CLASS_DEF(name) __thread struct gpr_gcc_thread_local name = {0}
+
 #define gpr_tls_init(tls) \
   do {                    \
   } while (0)
@@ -80,6 +47,4 @@ struct gpr_gcc_thread_local {
 #define gpr_tls_set(tls, new_value) (((tls)->value) = (new_value))
 #define gpr_tls_get(tls) ((tls)->value)
 
-#endif /* NDEBUG */
-
 #endif /* GRPC_SUPPORT_TLS_GCC_H */

data/include/grpc/support/tls_msvc.h

@@ -26,9 +26,18 @@ struct gpr_msvc_thread_local {
   intptr_t value;
 };
 
+/** Use GPR_TLS_DECL to declare tls static variables outside a class */
 #define GPR_TLS_DECL(name) \
   static __declspec(thread) struct gpr_msvc_thread_local name = {0}
 
+/** Use GPR_TLS_CLASS_DECL to declare tls static variable members of a class.
+ *  GPR_TLS_CLASS_DEF needs to be called to define this member. */
+#define GPR_TLS_CLASS_DECL(name) \
+  static __declspec(thread) struct gpr_msvc_thread_local name
+
+#define GPR_TLS_CLASS_DEF(name) \
+  __declspec(thread) struct gpr_msvc_thread_local name = {0}
+
 #define gpr_tls_init(tls) \
   do {                    \
   } while (0)

data/include/grpc/support/tls_pthread.h

@@ -29,8 +29,17 @@ struct gpr_pthread_thread_local {
   pthread_key_t key;
 };
 
+/** Use GPR_TLS_DECL to declare tls static variables outside a class */
 #define GPR_TLS_DECL(name) static struct gpr_pthread_thread_local name = {0}
 
+/** Use GPR_TLS_CLASS_DECL to declare tls static variable members of a class.
+ *  GPR_TLS_CLASS_DEF needs to be called to define this member. */
+#define GPR_TLS_CLASS_DECL(name) static struct gpr_pthread_thread_local name
+
+/** Use GPR_TLS_CLASS_DEF to declare tls static variable members of a class.
+ *  GPR_TLS_CLASS_DEF needs to be called to define this member. */
+#define GPR_TLS_CLASS_DEF(name) struct gpr_pthread_thread_local name = {0}
+
 #define gpr_tls_init(tls) GPR_ASSERT(0 == pthread_key_create(&(tls)->key, NULL))
 #define gpr_tls_destroy(tls) pthread_key_delete((tls)->key)
 #define gpr_tls_get(tls) ((intptr_t)pthread_getspecific((tls)->key))

data/src/core/ext/filters/client_channel/backup_poller.cc

@@ -23,17 +23,18 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/support/env.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 
 #define DEFAULT_POLL_INTERVAL_MS 5000
 
-typedef struct backup_poller {
+namespace {
+struct backup_poller {
   grpc_timer polling_timer;
   grpc_closure run_poller_closure;
   grpc_closure shutdown_closure;
@@ -42,7 +43,8 @@ typedef struct backup_poller {
   bool shutting_down;     // guarded by pollset_mu
   gpr_refcount refs;
   gpr_refcount shutdown_refs;
-} backup_poller;
+};
+}  // namespace
 
 static gpr_once g_once = GPR_ONCE_INIT;
 static gpr_mu g_poller_mu;
@@ -69,61 +71,62 @@ static void init_globals() {
   gpr_free(env);
 }
 
-static void backup_poller_shutdown_unref(grpc_exec_ctx* exec_ctx,
-                                         backup_poller* p) {
+static void backup_poller_shutdown_unref(backup_poller* p) {
   if (gpr_unref(&p->shutdown_refs)) {
-    grpc_pollset_destroy(exec_ctx, p->pollset);
+    grpc_pollset_destroy(p->pollset);
     gpr_free(p->pollset);
     gpr_free(p);
   }
 }
 
-static void done_poller(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
-  backup_poller_shutdown_unref(exec_ctx, (backup_poller*)arg);
+static void done_poller(void* arg, grpc_error* error) {
+  backup_poller_shutdown_unref((backup_poller*)arg);
 }
 
-static void g_poller_unref(grpc_exec_ctx* exec_ctx) {
+static void g_poller_unref() {
+  gpr_mu_lock(&g_poller_mu);
   if (gpr_unref(&g_poller->refs)) {
-    gpr_mu_lock(&g_poller_mu);
     backup_poller* p = g_poller;
     g_poller = nullptr;
     gpr_mu_unlock(&g_poller_mu);
     gpr_mu_lock(p->pollset_mu);
     p->shutting_down = true;
-    grpc_pollset_shutdown(exec_ctx, p->pollset,
-                          GRPC_CLOSURE_INIT(&p->shutdown_closure, done_poller,
-                                            p, grpc_schedule_on_exec_ctx));
+    grpc_pollset_shutdown(
+        p->pollset, GRPC_CLOSURE_INIT(&p->shutdown_closure, done_poller, p,
+                                      grpc_schedule_on_exec_ctx));
     gpr_mu_unlock(p->pollset_mu);
-    grpc_timer_cancel(exec_ctx, &p->polling_timer);
+    grpc_timer_cancel(&p->polling_timer);
+  } else {
+    gpr_mu_unlock(&g_poller_mu);
   }
 }
 
-static void run_poller(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+static void run_poller(void* arg, grpc_error* error) {
   backup_poller* p = (backup_poller*)arg;
   if (error != GRPC_ERROR_NONE) {
     if (error != GRPC_ERROR_CANCELLED) {
       GRPC_LOG_IF_ERROR("run_poller", GRPC_ERROR_REF(error));
     }
-    backup_poller_shutdown_unref(exec_ctx, p);
+    backup_poller_shutdown_unref(p);
     return;
   }
   gpr_mu_lock(p->pollset_mu);
   if (p->shutting_down) {
     gpr_mu_unlock(p->pollset_mu);
-    backup_poller_shutdown_unref(exec_ctx, p);
+    backup_poller_shutdown_unref(p);
     return;
   }
-  grpc_error* err = grpc_pollset_work(exec_ctx, p->pollset, nullptr,
-                                      grpc_exec_ctx_now(exec_ctx));
+  grpc_error* err =
+      grpc_pollset_work(p->pollset, nullptr, grpc_core::ExecCtx::Get()->Now());
   gpr_mu_unlock(p->pollset_mu);
   GRPC_LOG_IF_ERROR("Run client channel backup poller", err);
-  grpc_timer_init(exec_ctx, &p->polling_timer,
-                  grpc_exec_ctx_now(exec_ctx) + g_poll_interval_ms,
+  grpc_timer_init(&p->polling_timer,
+                  grpc_core::ExecCtx::Get()->Now() + g_poll_interval_ms,
                   &p->run_poller_closure);
 }
 
 void grpc_client_channel_start_backup_polling(
-    grpc_exec_ctx* exec_ctx, grpc_pollset_set* interested_parties) {
+    grpc_pollset_set* interested_parties) {
   gpr_once_init(&g_once, init_globals);
   if (g_poll_interval_ms == 0) {
     return;
@@ -139,8 +142,8 @@ void grpc_client_channel_start_backup_polling(
     gpr_ref_init(&g_poller->shutdown_refs, 2);
     GRPC_CLOSURE_INIT(&g_poller->run_poller_closure, run_poller, g_poller,
                       grpc_schedule_on_exec_ctx);
-    grpc_timer_init(exec_ctx, &g_poller->polling_timer,
-                    grpc_exec_ctx_now(exec_ctx) + g_poll_interval_ms,
+    grpc_timer_init(&g_poller->polling_timer,
+                    grpc_core::ExecCtx::Get()->Now() + g_poll_interval_ms,
                     &g_poller->run_poller_closure);
   }
 
@@ -152,14 +155,14 @@ void grpc_client_channel_start_backup_polling(
   grpc_pollset* pollset = g_poller->pollset;
   gpr_mu_unlock(&g_poller_mu);
 
-  grpc_pollset_set_add_pollset(exec_ctx, interested_parties, pollset);
+  grpc_pollset_set_add_pollset(interested_parties, pollset);
 }
 
 void grpc_client_channel_stop_backup_polling(
-    grpc_exec_ctx* exec_ctx, grpc_pollset_set* interested_parties) {
+    grpc_pollset_set* interested_parties) {
   if (g_poll_interval_ms == 0) {
     return;
   }
-  grpc_pollset_set_del_pollset(exec_ctx, interested_parties, g_poller->pollset);
-  g_poller_unref(exec_ctx);
+  grpc_pollset_set_del_pollset(interested_parties, g_poller->pollset);
+  g_poller_unref();
 }