grpc 1.7.3 → 1.8.0

data/src/core/lib/support/{thd_posix.c → thd_posix.cc}

@@ -39,31 +39,31 @@ static int g_thread_count;
 static int g_awaiting_threads;
 
 struct thd_arg {
-  void (*body)(void *arg); /* body of a thread */
-  void *arg;               /* argument to a thread */
+  void (*body)(void* arg); /* body of a thread */
+  void* arg;               /* argument to a thread */
 };
 
 static void inc_thd_count();
 static void dec_thd_count();
 
 /* Body of every thread started via gpr_thd_new. */
-static void *thread_body(void *v) {
-  struct thd_arg a = *(struct thd_arg *)v;
+static void* thread_body(void* v) {
+  struct thd_arg a = *(struct thd_arg*)v;
   free(v);
   (*a.body)(a.arg);
   dec_thd_count();
-  return NULL;
+  return nullptr;
 }
 
-int gpr_thd_new(gpr_thd_id *t, void (*thd_body)(void *arg), void *arg,
-                const gpr_thd_options *options) {
+int gpr_thd_new(gpr_thd_id* t, void (*thd_body)(void* arg), void* arg,
+                const gpr_thd_options* options) {
   int thread_started;
   pthread_attr_t attr;
   pthread_t p;
   /* don't use gpr_malloc as we may cause an infinite recursion with
    * the profiling code */
-  struct thd_arg *a = (struct thd_arg *)malloc(sizeof(*a));
-  GPR_ASSERT(a != NULL);
+  struct thd_arg* a = (struct thd_arg*)malloc(sizeof(*a));
+  GPR_ASSERT(a != nullptr);
   a->body = thd_body;
   a->arg = arg;
   inc_thd_count();
@@ -89,7 +89,7 @@ int gpr_thd_new(gpr_thd_id *t, void (*thd_body)(void *arg), void *arg,
 
 gpr_thd_id gpr_thd_currentid(void) { return (gpr_thd_id)pthread_self(); }
 
-void gpr_thd_join(gpr_thd_id t) { pthread_join((pthread_t)t, NULL); }
+void gpr_thd_join(gpr_thd_id t) { pthread_join((pthread_t)t, nullptr); }
 
 /*****************************************
  * Only used when fork support is enabled

data/src/core/lib/support/{thd_windows.c → thd_windows.cc}

@@ -36,16 +36,16 @@
 #endif
 
 struct thd_info {
-  void (*body)(void *arg); /* body of a thread */
-  void *arg;               /* argument to a thread */
+  void (*body)(void* arg); /* body of a thread */
+  void* arg;               /* argument to a thread */
   HANDLE join_event;       /* if joinable, the join event */
   int joinable;            /* true if not detached */
 };
 
-static thread_local struct thd_info *g_thd_info;
+static thread_local struct thd_info* g_thd_info;
 
 /* Destroys a thread info */
-static void destroy_thread(struct thd_info *t) {
+static void destroy_thread(struct thd_info* t) {
   if (t->joinable) CloseHandle(t->join_event);
   gpr_free(t);
 }
@@ -53,8 +53,8 @@ static void destroy_thread(struct thd_info *t) {
 void gpr_thd_init(void) {}
 
 /* Body of every thread started via gpr_thd_new. */
-static DWORD WINAPI thread_body(void *v) {
-  g_thd_info = (struct thd_info *)v;
+static DWORD WINAPI thread_body(void* v) {
+  g_thd_info = (struct thd_info*)v;
   g_thd_info->body(g_thd_info->arg);
   if (g_thd_info->joinable) {
     BOOL ret = SetEvent(g_thd_info->join_event);
@@ -65,10 +65,10 @@ static DWORD WINAPI thread_body(void *v) {
   return 0;
 }
 
-int gpr_thd_new(gpr_thd_id *t, void (*thd_body)(void *arg), void *arg,
-                const gpr_thd_options *options) {
+int gpr_thd_new(gpr_thd_id* t, void (*thd_body)(void* arg), void* arg,
+                const gpr_thd_options* options) {
   HANDLE handle;
-  struct thd_info *info = gpr_malloc(sizeof(*info));
+  struct thd_info* info = (struct thd_info*)gpr_malloc(sizeof(*info));
   info->body = thd_body;
   info->arg = arg;
   *t = 0;
@@ -95,7 +95,7 @@ int gpr_thd_new(gpr_thd_id *t, void (*thd_body)(void *arg), void *arg,
 gpr_thd_id gpr_thd_currentid(void) { return (gpr_thd_id)g_thd_info; }
 
 void gpr_thd_join(gpr_thd_id t) {
-  struct thd_info *info = (struct thd_info *)t;
+  struct thd_info* info = (struct thd_info*)t;
   DWORD ret = WaitForSingleObject(info->join_event, INFINITE);
   GPR_ASSERT(ret == WAIT_OBJECT_0);
   destroy_thread(info);

data/src/core/lib/support/{time_posix.c → time_posix.cc}

@@ -30,7 +30,6 @@
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
-#include "src/core/lib/support/block_annotate.h"
 
 static struct timespec timespec_from_gpr(gpr_timespec gts) {
   struct timespec rv;
@@ -43,7 +42,7 @@ static struct timespec timespec_from_gpr(gpr_timespec gts) {
   return rv;
 }
 
-#if _POSIX_TIMERS > 0
+#if _POSIX_TIMERS > 0 || defined(__OpenBSD__)
 static gpr_timespec gpr_from_timespec(struct timespec ts,
                                       gpr_clock_type clock_type) {
   /*
@@ -82,7 +81,7 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
   }
 }
 #else
-/* For some reason Apple's OSes haven't implemented clock_gettime. */
+  /* For some reason Apple's OSes haven't implemented clock_gettime. */
 
 #include <mach/mach.h>
 #include <mach/mach_time.h>
@@ -128,7 +127,9 @@ static gpr_timespec now_impl(gpr_clock_type clock) {
 }
 #endif
 
+extern "C" {
 gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type) = now_impl;
+}
 
 #ifdef GPR_LOW_LEVEL_COUNTERS
 gpr_atm gpr_now_call_count;
@@ -157,9 +158,7 @@ void gpr_sleep_until(gpr_timespec until) {
 
     delta = gpr_time_sub(until, now);
     delta_ts = timespec_from_gpr(delta);
-    GRPC_SCHEDULING_START_BLOCKING_REGION;
-    ns_result = nanosleep(&delta_ts, NULL);
-    GRPC_SCHEDULING_END_BLOCKING_REGION;
+    ns_result = nanosleep(&delta_ts, nullptr);
     if (ns_result == 0) {
       break;
     }

data/src/core/lib/support/{time_precise.c → time_precise.cc}

@@ -20,9 +20,11 @@
 #include <grpc/support/time.h>
 #include <stdio.h>
 
+#include "src/core/lib/support/time_precise.h"
+
 #ifdef GRPC_TIMERS_RDTSC
 #if defined(__i386__)
-static void gpr_get_cycle_counter(int64_t int *clk) {
+static void gpr_get_cycle_counter(int64_t int* clk) {
   int64_t int ret;
   __asm__ volatile("rdtsc" : "=A"(ret));
   *clk = ret;
@@ -30,7 +32,7 @@ static void gpr_get_cycle_counter(int64_t int *clk) {
 
 // ----------------------------------------------------------------
 #elif defined(__x86_64__) || defined(__amd64__)
-static void gpr_get_cycle_counter(int64_t *clk) {
+static void gpr_get_cycle_counter(int64_t* clk) {
   uint64_t low, high;
   __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
   *clk = (int64_t)(high << 32) | (int64_t)low;
@@ -54,7 +56,7 @@ void gpr_precise_clock_init(void) {
   gpr_log(GPR_DEBUG, "... cycles_per_second = %f\n", cycles_per_second);
 }
 
-void gpr_precise_clock_now(gpr_timespec *clk) {
+void gpr_precise_clock_now(gpr_timespec* clk) {
   int64_t counter;
   double secs;
   gpr_get_cycle_counter(&counter);
@@ -67,7 +69,7 @@ void gpr_precise_clock_now(gpr_timespec *clk) {
 #else  /* GRPC_TIMERS_RDTSC */
 void gpr_precise_clock_init(void) {}
 
-void gpr_precise_clock_now(gpr_timespec *clk) {
+void gpr_precise_clock_now(gpr_timespec* clk) {
   *clk = gpr_now(GPR_CLOCK_REALTIME);
   clk->clock_type = GPR_CLOCK_PRECISE;
 }

data/src/core/lib/support/time_precise.h

@@ -21,7 +21,15 @@
 
 #include <grpc/support/time.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void gpr_precise_clock_init(void);
-void gpr_precise_clock_now(gpr_timespec *clk);
+void gpr_precise_clock_now(gpr_timespec* clk);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SUPPORT_TIME_PRECISE_H */

data/src/core/lib/support/{time_windows.c → time_windows.cc}

@@ -28,7 +28,6 @@
 #include <process.h>
 #include <sys/timeb.h>
 
-#include "src/core/lib/support/block_annotate.h"
 #include "src/core/lib/support/time_precise.h"
 
 static LARGE_INTEGER g_start_time;
@@ -69,7 +68,9 @@ static gpr_timespec now_impl(gpr_clock_type clock) {
   return now_tv;
 }
 
+extern "C" {
 gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type) = now_impl;
+}
 
 gpr_timespec gpr_now(gpr_clock_type clock_type) {
   return gpr_now_impl(clock_type);
@@ -92,9 +93,7 @@ void gpr_sleep_until(gpr_timespec until) {
     sleep_millis =
         delta.tv_sec * GPR_MS_PER_SEC + delta.tv_nsec / GPR_NS_PER_MS;
     GPR_ASSERT((sleep_millis >= 0) && (sleep_millis <= INT_MAX));
-    GRPC_SCHEDULING_START_BLOCKING_REGION;
     Sleep((DWORD)sleep_millis);
-    GRPC_SCHEDULING_END_BLOCKING_REGION;
   }
 }
 

data/src/core/lib/support/{tls_pthread.c → tls_pthread.cc}

@@ -22,8 +22,8 @@
 
 #include <grpc/support/tls.h>
 
-intptr_t gpr_tls_set(struct gpr_pthread_thread_local *tls, intptr_t value) {
-  GPR_ASSERT(0 == pthread_setspecific(tls->key, (void *)value));
+intptr_t gpr_tls_set(struct gpr_pthread_thread_local* tls, intptr_t value) {
+  GPR_ASSERT(0 == pthread_setspecific(tls->key, (void*)value));
   return value;
 }
 

data/src/core/lib/support/tmpfile.h

@@ -29,7 +29,7 @@ extern "C" {
    If tmp_filename is not NULL, *tmp_filename is assigned the name of the
    created file and it is the responsibility of the caller to gpr_free it
    unless an error occurs in which case it will be set to NULL. */
-FILE *gpr_tmpfile(const char *prefix, char **tmp_filename);
+FILE* gpr_tmpfile(const char* prefix, char** tmp_filename);
 
 #ifdef __cplusplus
 }

data/src/core/lib/support/{tmpfile_msys.c → tmpfile_msys.cc}

@@ -32,8 +32,8 @@
 #include "src/core/lib/support/string_windows.h"
 #include "src/core/lib/support/tmpfile.h"
 
-FILE *gpr_tmpfile(const char *prefix, char **tmp_filename_out) {
-  FILE *result = NULL;
+FILE* gpr_tmpfile(const char* prefix, char** tmp_filename_out) {
+  FILE* result = NULL;
   char tmp_filename[MAX_PATH];
   UINT success;
 

data/src/core/lib/support/{tmpfile_posix.c → tmpfile_posix.cc}

@@ -33,15 +33,15 @@
 
 #include "src/core/lib/support/string.h"
 
-FILE *gpr_tmpfile(const char *prefix, char **tmp_filename) {
-  FILE *result = NULL;
-  char *filename_template;
+FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
+  FILE* result = nullptr;
+  char* filename_template;
   int fd;
 
-  if (tmp_filename != NULL) *tmp_filename = NULL;
+  if (tmp_filename != nullptr) *tmp_filename = nullptr;
 
   gpr_asprintf(&filename_template, "/tmp/%s_XXXXXX", prefix);
-  GPR_ASSERT(filename_template != NULL);
+  GPR_ASSERT(filename_template != nullptr);
 
   fd = mkstemp(filename_template);
   if (fd == -1) {
@@ -50,7 +50,7 @@ FILE *gpr_tmpfile(const char *prefix, char **tmp_filename) {
     goto end;
   }
   result = fdopen(fd, "w+");
-  if (result == NULL) {
+  if (result == nullptr) {
     gpr_log(GPR_ERROR, "Could not open file %s from fd %d (error = %s).",
             filename_template, fd, strerror(errno));
     unlink(filename_template);
@@ -59,7 +59,7 @@ FILE *gpr_tmpfile(const char *prefix, char **tmp_filename) {
   }
 
 end:
-  if (result != NULL && tmp_filename != NULL) {
+  if (result != nullptr && tmp_filename != nullptr) {
     *tmp_filename = filename_template;
   } else {
     gpr_free(filename_template);

data/src/core/lib/support/{tmpfile_windows.c → tmpfile_windows.cc}

@@ -32,8 +32,8 @@
 #include "src/core/lib/support/string_windows.h"
 #include "src/core/lib/support/tmpfile.h"
 
-FILE *gpr_tmpfile(const char *prefix, char **tmp_filename_out) {
-  FILE *result = NULL;
+FILE* gpr_tmpfile(const char* prefix, char** tmp_filename_out) {
+  FILE* result = NULL;
   LPTSTR template_string = NULL;
   TCHAR tmp_path[MAX_PATH];
   TCHAR tmp_filename[MAX_PATH];

data/src/core/lib/support/{wrap_memcpy.c → wrap_memcpy.cc}

@@ -26,15 +26,17 @@
  * Enable by setting LDFLAGS=-Wl,-wrap,memcpy when linking.
  */
 
+extern "C" {
 #ifdef __linux__
 #if defined(__x86_64__) && !defined(GPR_MUSL_LIBC_COMPAT)
 __asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
-void *__wrap_memcpy(void *destination, const void *source, size_t num) {
+void* __wrap_memcpy(void* destination, const void* source, size_t num) {
   return memcpy(destination, source, num);
 }
 #else /* !__x86_64__ */
-void *__wrap_memcpy(void *destination, const void *source, size_t num) {
+void* __wrap_memcpy(void* destination, const void* source, size_t num) {
   return memmove(destination, source, num);
 }
 #endif
 #endif
+}

data/src/core/lib/surface/{alarm.c → alarm.cc}

@@ -15,6 +15,10 @@
  * limitations under the License.
  *
  */
+#include <grpc/support/port_platform.h>
+
+#include <inttypes.h>
+
 #include "src/core/lib/surface/alarm_internal.h"
 
 #include <grpc/grpc.h>
@@ -23,10 +27,8 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/surface/completion_queue.h"
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_alarm_refcount =
-    GRPC_TRACER_INITIALIZER(false, "alarm_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_alarm_refcount(false,
+                                                        "alarm_refcount");
 
 struct grpc_alarm {
   gpr_refcount refs;
@@ -34,17 +36,17 @@ struct grpc_alarm {
   grpc_closure on_alarm;
   grpc_cq_completion completion;
   /** completion queue where events about this alarm will be posted */
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   /** user supplied tag */
-  void *tag;
+  void* tag;
 };
 
-static void alarm_ref(grpc_alarm *alarm) { gpr_ref(&alarm->refs); }
+static void alarm_ref(grpc_alarm* alarm) { gpr_ref(&alarm->refs); }
 
-static void alarm_unref(grpc_alarm *alarm) {
+static void alarm_unref(grpc_alarm* alarm) {
   if (gpr_unref(&alarm->refs)) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    if (alarm->cq != NULL) {
+    if (alarm->cq != nullptr) {
       GRPC_CQ_INTERNAL_UNREF(&exec_ctx, alarm->cq, "alarm");
     }
     grpc_exec_ctx_finish(&exec_ctx);
@@ -53,9 +55,9 @@ static void alarm_unref(grpc_alarm *alarm) {
 }
 
 #ifndef NDEBUG
-static void alarm_ref_dbg(grpc_alarm *alarm, const char *reason,
-                          const char *file, int line) {
-  if (GRPC_TRACER_ON(grpc_trace_alarm_refcount)) {
+static void alarm_ref_dbg(grpc_alarm* alarm, const char* reason,
+                          const char* file, int line) {
+  if (grpc_trace_alarm_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&alarm->refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "Alarm:%p  ref %" PRIdPTR " -> %" PRIdPTR " %s", alarm, val,
@@ -65,9 +67,9 @@ static void alarm_ref_dbg(grpc_alarm *alarm, const char *reason,
   alarm_ref(alarm);
 }
 
-static void alarm_unref_dbg(grpc_alarm *alarm, const char *reason,
-                            const char *file, int line) {
-  if (GRPC_TRACER_ON(grpc_trace_alarm_refcount)) {
+static void alarm_unref_dbg(grpc_alarm* alarm, const char* reason,
+                            const char* file, int line) {
+  if (grpc_trace_alarm_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&alarm->refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "Alarm:%p  Unref %" PRIdPTR " -> %" PRIdPTR " %s", alarm, val,
@@ -78,42 +80,42 @@ static void alarm_unref_dbg(grpc_alarm *alarm, const char *reason,
 }
 #endif
 
-static void alarm_end_completion(grpc_exec_ctx *exec_ctx, void *arg,
-                                 grpc_cq_completion *c) {
-  grpc_alarm *alarm = (grpc_alarm *)arg;
+static void alarm_end_completion(grpc_exec_ctx* exec_ctx, void* arg,
+                                 grpc_cq_completion* c) {
+  grpc_alarm* alarm = (grpc_alarm*)arg;
   GRPC_ALARM_UNREF(alarm, "dequeue-end-op");
 }
 
-static void alarm_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_alarm *alarm = (grpc_alarm *)arg;
+static void alarm_cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  grpc_alarm* alarm = (grpc_alarm*)arg;
 
   /* We are queuing an op on completion queue. This means, the alarm's structure
      cannot be destroyed until the op is dequeued. Adding an extra ref
      here and unref'ing when the op is dequeued will achieve this */
   GRPC_ALARM_REF(alarm, "queue-end-op");
   grpc_cq_end_op(exec_ctx, alarm->cq, alarm->tag, error, alarm_end_completion,
-                 (void *)alarm, &alarm->completion);
+                 (void*)alarm, &alarm->completion);
 }
 
-grpc_alarm *grpc_alarm_create(void *reserved) {
-  grpc_alarm *alarm = (grpc_alarm *)gpr_malloc(sizeof(grpc_alarm));
+grpc_alarm* grpc_alarm_create(void* reserved) {
+  grpc_alarm* alarm = (grpc_alarm*)gpr_malloc(sizeof(grpc_alarm));
 
 #ifndef NDEBUG
-  if (GRPC_TRACER_ON(grpc_trace_alarm_refcount)) {
+  if (grpc_trace_alarm_refcount.enabled()) {
     gpr_log(GPR_DEBUG, "Alarm:%p created (ref: 1)", alarm);
   }
 #endif
 
   gpr_ref_init(&alarm->refs, 1);
   grpc_timer_init_unset(&alarm->alarm);
-  alarm->cq = NULL;
+  alarm->cq = nullptr;
   GRPC_CLOSURE_INIT(&alarm->on_alarm, alarm_cb, alarm,
                     grpc_schedule_on_exec_ctx);
   return alarm;
 }
 
-void grpc_alarm_set(grpc_alarm *alarm, grpc_completion_queue *cq,
-                    gpr_timespec deadline, void *tag, void *reserved) {
+void grpc_alarm_set(grpc_alarm* alarm, grpc_completion_queue* cq,
+                    gpr_timespec deadline, void* tag, void* reserved) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   GRPC_CQ_INTERNAL_REF(cq, "alarm");
@@ -122,18 +124,17 @@ void grpc_alarm_set(grpc_alarm *alarm, grpc_completion_queue *cq,
 
   GPR_ASSERT(grpc_cq_begin_op(cq, tag));
   grpc_timer_init(&exec_ctx, &alarm->alarm,
-                  gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC),
-                  &alarm->on_alarm, gpr_now(GPR_CLOCK_MONOTONIC));
+                  grpc_timespec_to_millis_round_up(deadline), &alarm->on_alarm);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void grpc_alarm_cancel(grpc_alarm *alarm, void *reserved) {
+void grpc_alarm_cancel(grpc_alarm* alarm, void* reserved) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_timer_cancel(&exec_ctx, &alarm->alarm);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void grpc_alarm_destroy(grpc_alarm *alarm, void *reserved) {
+void grpc_alarm_destroy(grpc_alarm* alarm, void* reserved) {
   grpc_alarm_cancel(alarm, reserved);
   GRPC_ALARM_UNREF(alarm, "alarm_destroy");
 }