grpc 1.9.1 → 1.10.0.pre1

data/src/core/lib/compression/stream_compression_gzip.cc

@@ -48,11 +48,11 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
     size_t slice_size = max_output_size < OUTPUT_BLOCK_SIZE ? max_output_size
                                                             : OUTPUT_BLOCK_SIZE;
     grpc_slice slice_out = GRPC_SLICE_MALLOC(slice_size);
-    ctx->zs.avail_out = (uInt)slice_size;
+    ctx->zs.avail_out = static_cast<uInt>(slice_size);
     ctx->zs.next_out = GRPC_SLICE_START_PTR(slice_out);
     while (ctx->zs.avail_out > 0 && in->length > 0 && !eoc) {
       grpc_slice slice = grpc_slice_buffer_take_first(in);
-      ctx->zs.avail_in = (uInt)GRPC_SLICE_LENGTH(slice);
+      ctx->zs.avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(slice);
       ctx->zs.next_in = GRPC_SLICE_START_PTR(slice);
       r = ctx->flate(&ctx->zs, Z_NO_FLUSH);
       if (r < 0 && r != Z_BUF_ERROR) {
@@ -142,7 +142,7 @@ static bool grpc_stream_compress_gzip(grpc_stream_compression_context* ctx,
     return false;
   }
   grpc_stream_compression_context_gzip* gzip_ctx =
-      (grpc_stream_compression_context_gzip*)ctx;
+      reinterpret_cast<grpc_stream_compression_context_gzip*>(ctx);
   GPR_ASSERT(gzip_ctx->flate == deflate);
   int gzip_flush;
   switch (flush) {
@@ -172,7 +172,7 @@ static bool grpc_stream_decompress_gzip(grpc_stream_compression_context* ctx,
     return false;
   }
   grpc_stream_compression_context_gzip* gzip_ctx =
-      (grpc_stream_compression_context_gzip*)ctx;
+      reinterpret_cast<grpc_stream_compression_context_gzip*>(ctx);
   GPR_ASSERT(gzip_ctx->flate == inflate);
   return gzip_flate(gzip_ctx, in, out, output_size, max_output_size,
                     Z_SYNC_FLUSH, end_of_context);
@@ -184,8 +184,8 @@ grpc_stream_compression_context_create_gzip(
   GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_GZIP_COMPRESS ||
              method == GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_stream_compression_context_gzip* gzip_ctx =
-      (grpc_stream_compression_context_gzip*)gpr_zalloc(
-          sizeof(grpc_stream_compression_context_gzip));
+      static_cast<grpc_stream_compression_context_gzip*>(
+          gpr_zalloc(sizeof(grpc_stream_compression_context_gzip)));
   int r;
   if (gzip_ctx == nullptr) {
     return nullptr;
@@ -204,7 +204,7 @@ grpc_stream_compression_context_create_gzip(
   }
 
   gzip_ctx->base.vtable = &grpc_stream_compression_gzip_vtable;
-  return (grpc_stream_compression_context*)gzip_ctx;
+  return reinterpret_cast<grpc_stream_compression_context*>(gzip_ctx);
 }
 
 static void grpc_stream_compression_context_destroy_gzip(
@@ -213,7 +213,7 @@ static void grpc_stream_compression_context_destroy_gzip(
     return;
   }
   grpc_stream_compression_context_gzip* gzip_ctx =
-      (grpc_stream_compression_context_gzip*)ctx;
+      reinterpret_cast<grpc_stream_compression_context_gzip*>(ctx);
   if (gzip_ctx->flate == inflate) {
     inflateEnd(&gzip_ctx->zs);
   } else {

data/src/core/lib/compression/stream_compression_identity.cc

@@ -79,7 +79,7 @@ grpc_stream_compression_context_create_identity(
   GPR_ASSERT(method == GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS ||
              method == GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS);
   /* No context needed in this case. Use fake context instead. */
-  return (grpc_stream_compression_context*)&identity_ctx;
+  return &identity_ctx;
 }
 
 static void grpc_stream_compression_context_destroy_identity(

data/src/core/lib/debug/stats.cc

@@ -23,17 +23,17 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
 
 grpc_stats_data* grpc_stats_per_cpu_storage = nullptr;
 static size_t g_num_cores;
 
 void grpc_stats_init(void) {
   g_num_cores = GPR_MAX(1, gpr_cpu_num_cores());
-  grpc_stats_per_cpu_storage =
-      (grpc_stats_data*)gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores);
+  grpc_stats_per_cpu_storage = static_cast<grpc_stats_data*>(
+      gpr_zalloc(sizeof(grpc_stats_data) * g_num_cores));
 }
 
 void grpc_stats_shutdown(void) { gpr_free(grpc_stats_per_cpu_storage); }
@@ -76,14 +76,15 @@ int grpc_stats_histo_find_bucket_slow(int value, const int* table,
       table_size = step;
     }
   }
-  return (int)(table - start) - 1;
+  return static_cast<int>(table - start) - 1;
 }
 
 size_t grpc_stats_histo_count(const grpc_stats_data* stats,
                               grpc_stats_histograms histogram) {
   size_t sum = 0;
   for (int i = 0; i < grpc_stats_histo_buckets[histogram]; i++) {
-    sum += (size_t)stats->histograms[grpc_stats_histo_start[histogram] + i];
+    sum += static_cast<size_t>(
+        stats->histograms[grpc_stats_histo_start[histogram] + i]);
   }
   return sum;
 }
@@ -100,7 +101,7 @@ static double threshold_for_count_below(const gpr_atm* bucket_counts,
   /* find the lowest bucket that gets us above count_below */
   count_so_far = 0.0;
   for (lower_idx = 0; lower_idx < num_buckets; lower_idx++) {
-    count_so_far += (double)bucket_counts[lower_idx];
+    count_so_far += static_cast<double>(bucket_counts[lower_idx]);
     if (count_so_far >= count_below) {
       break;
     }
@@ -121,7 +122,7 @@ static double threshold_for_count_below(const gpr_atm* bucket_counts,
     upper_bound = bucket_boundaries[lower_idx + 1];
     return upper_bound - (upper_bound - lower_bound) *
                              (count_so_far - count_below) /
-                             (double)bucket_counts[lower_idx];
+                             static_cast<double>(bucket_counts[lower_idx]);
   }
 }
 
@@ -133,7 +134,8 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats,
   return threshold_for_count_below(
       stats->histograms + grpc_stats_histo_start[histogram],
       grpc_stats_histo_bucket_boundaries[histogram],
-      grpc_stats_histo_buckets[histogram], (double)count * percentile / 100.0);
+      grpc_stats_histo_buckets[histogram],
+      static_cast<double>(count) * percentile / 100.0);
 }
 
 char* grpc_stats_data_as_json(const grpc_stats_data* data) {

data/src/core/lib/debug/stats_data.cc

@@ -19,9 +19,10 @@
  */
 
 #include "src/core/lib/debug/stats_data.h"
-#include <grpc/support/useful.h>
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+
 const char* grpc_stats_counter_name[GRPC_STATS_COUNTER_COUNT] = {
     "client_calls_created",
     "server_calls_created",

data/src/core/lib/debug/trace.cc

@@ -88,11 +88,11 @@ static void add(const char* beg, const char* end, char*** ss, size_t* ns) {
   char* s;
   size_t len;
   GPR_ASSERT(end >= beg);
-  len = (size_t)(end - beg);
-  s = (char*)gpr_malloc(len + 1);
+  len = static_cast<size_t>(end - beg);
+  s = static_cast<char*>(gpr_malloc(len + 1));
   memcpy(s, beg, len);
   s[len] = 0;
-  *ss = (char**)gpr_realloc(*ss, sizeof(char**) * np);
+  *ss = static_cast<char**>(gpr_realloc(*ss, sizeof(char**) * np));
   (*ss)[n] = s;
   *ns = np;
 }

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

@@ -50,48 +50,44 @@ void gpr_set_allocation_functions(gpr_allocation_functions functions) {
 }
 
 void* gpr_malloc(size_t size) {
+  GPR_TIMER_SCOPE("gpr_malloc", 0);
   void* p;
   if (size == 0) return nullptr;
-  GPR_TIMER_BEGIN("gpr_malloc", 0);
   p = g_alloc_functions.malloc_fn(size);
   if (!p) {
     abort();
   }
-  GPR_TIMER_END("gpr_malloc", 0);
   return p;
 }
 
 void* gpr_zalloc(size_t size) {
+  GPR_TIMER_SCOPE("gpr_zalloc", 0);
   void* p;
   if (size == 0) return nullptr;
-  GPR_TIMER_BEGIN("gpr_zalloc", 0);
   p = g_alloc_functions.zalloc_fn(size);
   if (!p) {
     abort();
   }
-  GPR_TIMER_END("gpr_zalloc", 0);
   return p;
 }
 
 void gpr_free(void* p) {
-  GPR_TIMER_BEGIN("gpr_free", 0);
+  GPR_TIMER_SCOPE("gpr_free", 0);
   g_alloc_functions.free_fn(p);
-  GPR_TIMER_END("gpr_free", 0);
 }
 
 void* gpr_realloc(void* p, size_t size) {
+  GPR_TIMER_SCOPE("gpr_realloc", 0);
   if ((size == 0) && (p == nullptr)) return nullptr;
-  GPR_TIMER_BEGIN("gpr_realloc", 0);
   p = g_alloc_functions.realloc_fn(p, size);
   if (!p) {
     abort();
   }
-  GPR_TIMER_END("gpr_realloc", 0);
   return p;
 }
 
-void* gpr_malloc_aligned(size_t size, size_t alignment_log) {
-  size_t alignment = ((size_t)1) << alignment_log;
+void* gpr_malloc_aligned(size_t size, size_t alignment) {
+  GPR_ASSERT(((alignment - 1) & alignment) == 0);  // Must be power of 2.
   size_t extra = alignment - 1 + sizeof(void*);
   void* p = gpr_malloc(size + extra);
   void** ret = (void**)(((uintptr_t)p + extra) & ~(alignment - 1));
@@ -99,4 +95,4 @@ void* gpr_malloc_aligned(size_t size, size_t alignment_log) {
   return (void*)ret;
 }
 
-void gpr_free_aligned(void* ptr) { gpr_free(((void**)ptr)[-1]); }
+void gpr_free_aligned(void* ptr) { gpr_free((static_cast<void**>(ptr))[-1]); }

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

@@ -17,11 +17,18 @@
  */
 
 #include "src/core/lib/gpr/arena.h"
+
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
-#include <grpc/support/useful.h>
 
+// 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.
 #define ROUND_UP_TO_ALIGNMENT_SIZE(x) \
   (((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))
 
@@ -36,9 +43,16 @@ struct gpr_arena {
   zone initial_zone;
 };
 
+static void* zalloc_aligned(size_t size) {
+  void* ptr = gpr_malloc_aligned(size, GPR_MAX_ALIGNMENT);
+  memset(ptr, 0, size);
+  return ptr;
+}
+
 gpr_arena* gpr_arena_create(size_t initial_size) {
   initial_size = ROUND_UP_TO_ALIGNMENT_SIZE(initial_size);
-  gpr_arena* a = (gpr_arena*)gpr_zalloc(sizeof(gpr_arena) + initial_size);
+  gpr_arena* a = static_cast<gpr_arena*>(zalloc_aligned(
+      ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + initial_size));
   a->initial_zone.size_end = initial_size;
   return a;
 }
@@ -46,29 +60,32 @@ gpr_arena* gpr_arena_create(size_t initial_size) {
 size_t gpr_arena_destroy(gpr_arena* arena) {
   gpr_atm size = gpr_atm_no_barrier_load(&arena->size_so_far);
   zone* z = (zone*)gpr_atm_no_barrier_load(&arena->initial_zone.next_atm);
-  gpr_free(arena);
+  gpr_free_aligned(arena);
   while (z) {
     zone* next_z = (zone*)gpr_atm_no_barrier_load(&z->next_atm);
-    gpr_free(z);
+    gpr_free_aligned(z);
     z = next_z;
   }
-  return (size_t)size;
+  return static_cast<size_t>(size);
 }
 
 void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
   size = ROUND_UP_TO_ALIGNMENT_SIZE(size);
-  size_t start =
-      (size_t)gpr_atm_no_barrier_fetch_add(&arena->size_so_far, size);
+  size_t start = static_cast<size_t>(
+      gpr_atm_no_barrier_fetch_add(&arena->size_so_far, size));
   zone* z = &arena->initial_zone;
   while (start > z->size_end) {
     zone* next_z = (zone*)gpr_atm_acq_load(&z->next_atm);
     if (next_z == nullptr) {
-      size_t next_z_size = (size_t)gpr_atm_no_barrier_load(&arena->size_so_far);
-      next_z = (zone*)gpr_zalloc(sizeof(zone) + next_z_size);
+      size_t next_z_size =
+          static_cast<size_t>(gpr_atm_no_barrier_load(&arena->size_so_far));
+      next_z = static_cast<zone*>(zalloc_aligned(
+          ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + next_z_size));
       next_z->size_begin = z->size_end;
       next_z->size_end = z->size_end + next_z_size;
-      if (!gpr_atm_rel_cas(&z->next_atm, (gpr_atm)NULL, (gpr_atm)next_z)) {
-        gpr_free(next_z);
+      if (!gpr_atm_rel_cas(&z->next_atm, static_cast<gpr_atm>(NULL),
+                           (gpr_atm)next_z)) {
+        gpr_free_aligned(next_z);
         next_z = (zone*)gpr_atm_acq_load(&z->next_atm);
       }
     }
@@ -79,5 +96,10 @@ void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
   }
   GPR_ASSERT(start >= z->size_begin);
   GPR_ASSERT(start + size <= z->size_end);
-  return ((char*)(z + 1)) + start - z->size_begin;
+  char* ptr = (z == &arena->initial_zone)
+                  ? reinterpret_cast<char*>(arena) +
+                        ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena))
+                  : reinterpret_cast<char*>(z) +
+                        ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone));
+  return ptr + start - z->size_begin;
 }

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

@@ -17,7 +17,8 @@
  */
 
 #include <grpc/support/atm.h>
-#include <grpc/support/useful.h>
+
+#include "src/core/lib/gpr/useful.h"
 
 gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
                                        gpr_atm min, gpr_atm max) {

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

@@ -45,7 +45,7 @@ static void init_num_cpus() {
 #endif
   /* This must be signed. sysconf returns -1 when the number cannot be
      determined */
-  ncpus = (int)sysconf(_SC_NPROCESSORS_ONLN);
+  ncpus = static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN));
   if (ncpus < 1) {
     gpr_log(GPR_ERROR, "Cannot determine number of CPUs: assuming 1");
     ncpus = 1;
@@ -55,7 +55,7 @@ static void init_num_cpus() {
 unsigned gpr_cpu_num_cores(void) {
   static gpr_once once = GPR_ONCE_INIT;
   gpr_once_init(&once, init_num_cpus);
-  return (unsigned)ncpus;
+  return static_cast<unsigned>(ncpus);
 }
 
 unsigned gpr_cpu_current_cpu(void) {
@@ -71,7 +71,7 @@ unsigned gpr_cpu_current_cpu(void) {
     gpr_log(GPR_ERROR, "Error determining current CPU: %s\n", strerror(errno));
     return 0;
   }
-  return (unsigned)cpu;
+  return static_cast<unsigned>(cpu);
 #endif
 }
 

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

@@ -29,7 +29,8 @@
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
-#include <grpc/support/useful.h>
+
+#include "src/core/lib/gpr/useful.h"
 
 static long ncpus = 0;
 

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

@@ -29,7 +29,7 @@
    variable exists). */
 char* gpr_getenv(const char* name);
 
-/* Sets the the environment with the specified name to the specified value. */
+/* Sets the environment with the specified name to the specified value. */
 void gpr_setenv(const char* name, const char* value);
 
 /* This is a version of gpr_getenv that does not produce any output if it has to

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

@@ -34,9 +34,9 @@
 
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
 
 const char* gpr_getenv_silent(const char* name, char** dst) {
   const char* insecure_func_used = nullptr;

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

@@ -22,14 +22,14 @@
 
 #include <windows.h>
 
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/string_windows.h"
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/string_windows.h"
+
 const char* gpr_getenv_silent(const char* name, char** dst) {
   *dst = gpr_getenv(name);
   return NULL;

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

@@ -21,9 +21,9 @@
 #include <string.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/useful.h>
 
 #include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/useful.h"
 
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
@@ -38,18 +38,32 @@ void grpc_fork_support_init() {
   fork_support_enabled = 1;
 #else
   fork_support_enabled = 0;
+#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])) {
         fork_support_enabled = 1;
+        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])) {
+          fork_support_enabled = 0;
+          env_var_set = true;
+          break;
+        }
       }
     }
     gpr_free(env);
   }
-#endif
   if (override_fork_support_enabled != -1) {
     fork_support_enabled = override_fork_support_enabled;
   }