grpc 1.7.3 → 1.8.0

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

@@ -30,33 +30,33 @@
 typedef enum { ARGTYPE_INT, ARGTYPE_BOOL, ARGTYPE_STRING } argtype;
 
 typedef struct arg {
-  const char *name;
-  const char *help;
+  const char* name;
+  const char* help;
   argtype type;
-  void *value;
-  struct arg *next;
+  void* value;
+  struct arg* next;
 } arg;
 
 struct gpr_cmdline {
-  const char *description;
-  arg *args;
-  const char *argv0;
+  const char* description;
+  arg* args;
+  const char* argv0;
 
-  const char *extra_arg_name;
-  const char *extra_arg_help;
-  void (*extra_arg)(void *user_data, const char *arg);
-  void *extra_arg_user_data;
+  const char* extra_arg_name;
+  const char* extra_arg_help;
+  void (*extra_arg)(void* user_data, const char* arg);
+  void* extra_arg_user_data;
 
-  int (*state)(gpr_cmdline *cl, char *arg);
-  arg *cur_arg;
+  int (*state)(gpr_cmdline* cl, char* arg);
+  arg* cur_arg;
 
   int survive_failure;
 };
 
-static int normal_state(gpr_cmdline *cl, char *arg);
+static int normal_state(gpr_cmdline* cl, char* arg);
 
-gpr_cmdline *gpr_cmdline_create(const char *description) {
-  gpr_cmdline *cl = (gpr_cmdline *)gpr_zalloc(sizeof(gpr_cmdline));
+gpr_cmdline* gpr_cmdline_create(const char* description) {
+  gpr_cmdline* cl = (gpr_cmdline*)gpr_zalloc(sizeof(gpr_cmdline));
 
   cl->description = description;
   cl->state = normal_state;
@@ -64,28 +64,28 @@ gpr_cmdline *gpr_cmdline_create(const char *description) {
   return cl;
 }
 
-void gpr_cmdline_set_survive_failure(gpr_cmdline *cl) {
+void gpr_cmdline_set_survive_failure(gpr_cmdline* cl) {
   cl->survive_failure = 1;
 }
 
-void gpr_cmdline_destroy(gpr_cmdline *cl) {
+void gpr_cmdline_destroy(gpr_cmdline* cl) {
   while (cl->args) {
-    arg *a = cl->args;
+    arg* a = cl->args;
     cl->args = a->next;
     gpr_free(a);
   }
   gpr_free(cl);
 }
 
-static void add_arg(gpr_cmdline *cl, const char *name, const char *help,
-                    argtype type, void *value) {
-  arg *a;
+static void add_arg(gpr_cmdline* cl, const char* name, const char* help,
+                    argtype type, void* value) {
+  arg* a;
 
   for (a = cl->args; a; a = a->next) {
     GPR_ASSERT(0 != strcmp(a->name, name));
   }
 
-  a = (arg *)gpr_zalloc(sizeof(arg));
+  a = (arg*)gpr_zalloc(sizeof(arg));
   a->name = name;
   a->help = help;
   a->type = type;
@@ -94,24 +94,24 @@ static void add_arg(gpr_cmdline *cl, const char *name, const char *help,
   cl->args = a;
 }
 
-void gpr_cmdline_add_int(gpr_cmdline *cl, const char *name, const char *help,
-                         int *value) {
+void gpr_cmdline_add_int(gpr_cmdline* cl, const char* name, const char* help,
+                         int* value) {
   add_arg(cl, name, help, ARGTYPE_INT, value);
 }
 
-void gpr_cmdline_add_flag(gpr_cmdline *cl, const char *name, const char *help,
-                          int *value) {
+void gpr_cmdline_add_flag(gpr_cmdline* cl, const char* name, const char* help,
+                          int* value) {
   add_arg(cl, name, help, ARGTYPE_BOOL, value);
 }
 
-void gpr_cmdline_add_string(gpr_cmdline *cl, const char *name, const char *help,
-                            char **value) {
+void gpr_cmdline_add_string(gpr_cmdline* cl, const char* name, const char* help,
+                            const char** value) {
   add_arg(cl, name, help, ARGTYPE_STRING, value);
 }
 
 void gpr_cmdline_on_extra_arg(
-    gpr_cmdline *cl, const char *name, const char *help,
-    void (*on_extra_arg)(void *user_data, const char *arg), void *user_data) {
+    gpr_cmdline* cl, const char* name, const char* help,
+    void (*on_extra_arg)(void* user_data, const char* arg), void* user_data) {
   GPR_ASSERT(!cl->extra_arg);
   GPR_ASSERT(on_extra_arg);
 
@@ -124,8 +124,8 @@ void gpr_cmdline_on_extra_arg(
 /* recursively descend argument list, adding the last element
    to s first - so that arguments are added in the order they were
    added to the list by api calls */
-static void add_args_to_usage(gpr_strvec *s, arg *a) {
-  char *tmp;
+static void add_args_to_usage(gpr_strvec* s, arg* a) {
+  char* tmp;
 
   if (!a) return;
   add_args_to_usage(s, a->next);
@@ -146,11 +146,11 @@ static void add_args_to_usage(gpr_strvec *s, arg *a) {
   }
 }
 
-char *gpr_cmdline_usage_string(gpr_cmdline *cl, const char *argv0) {
+char* gpr_cmdline_usage_string(gpr_cmdline* cl, const char* argv0) {
   /* TODO(ctiller): make this prettier */
   gpr_strvec s;
-  char *tmp;
-  const char *name = strrchr(argv0, '/');
+  char* tmp;
+  const char* name = strrchr(argv0, '/');
 
   if (name) {
     name++;
@@ -169,13 +169,13 @@ char *gpr_cmdline_usage_string(gpr_cmdline *cl, const char *argv0) {
   }
   gpr_strvec_add(&s, gpr_strdup("\n"));
 
-  tmp = gpr_strvec_flatten(&s, NULL);
+  tmp = gpr_strvec_flatten(&s, nullptr);
   gpr_strvec_destroy(&s);
   return tmp;
 }
 
-static int print_usage_and_die(gpr_cmdline *cl) {
-  char *usage = gpr_cmdline_usage_string(cl, cl->argv0);
+static int print_usage_and_die(gpr_cmdline* cl) {
+  char* usage = gpr_cmdline_usage_string(cl, cl->argv0);
   fprintf(stderr, "%s", usage);
   gpr_free(usage);
   if (!cl->survive_failure) {
@@ -184,7 +184,7 @@ static int print_usage_and_die(gpr_cmdline *cl) {
   return 0;
 }
 
-static int extra_state(gpr_cmdline *cl, char *str) {
+static int extra_state(gpr_cmdline* cl, char* str) {
   if (!cl->extra_arg) {
     return print_usage_and_die(cl);
   }
@@ -192,8 +192,8 @@ static int extra_state(gpr_cmdline *cl, char *str) {
   return 1;
 }
 
-static arg *find_arg(gpr_cmdline *cl, char *name) {
-  arg *a;
+static arg* find_arg(gpr_cmdline* cl, char* name) {
+  arg* a;
 
   for (a = cl->args; a; a = a->next) {
     if (0 == strcmp(a->name, name)) {
@@ -203,15 +203,15 @@ static arg *find_arg(gpr_cmdline *cl, char *name) {
 
   if (!a) {
     fprintf(stderr, "Unknown argument: %s\n", name);
-    return NULL;
+    return nullptr;
   }
 
   return a;
 }
 
-static int value_state(gpr_cmdline *cl, char *str) {
+static int value_state(gpr_cmdline* cl, char* str) {
   long intval;
-  char *end;
+  char* end;
 
   GPR_ASSERT(cl->cur_arg);
 
@@ -223,13 +223,13 @@ static int value_state(gpr_cmdline *cl, char *str) {
                 cl->cur_arg->name);
         return print_usage_and_die(cl);
       }
-      *(int *)cl->cur_arg->value = (int)intval;
+      *(int*)cl->cur_arg->value = (int)intval;
       break;
     case ARGTYPE_BOOL:
       if (0 == strcmp(str, "1") || 0 == strcmp(str, "true")) {
-        *(int *)cl->cur_arg->value = 1;
+        *(int*)cl->cur_arg->value = 1;
       } else if (0 == strcmp(str, "0") || 0 == strcmp(str, "false")) {
-        *(int *)cl->cur_arg->value = 0;
+        *(int*)cl->cur_arg->value = 0;
       } else {
         fprintf(stderr, "expected boolean, got '%s' for %s\n", str,
                 cl->cur_arg->name);
@@ -237,7 +237,7 @@ static int value_state(gpr_cmdline *cl, char *str) {
       }
       break;
     case ARGTYPE_STRING:
-      *(char **)cl->cur_arg->value = str;
+      *(char**)cl->cur_arg->value = str;
       break;
   }
 
@@ -245,10 +245,10 @@ static int value_state(gpr_cmdline *cl, char *str) {
   return 1;
 }
 
-static int normal_state(gpr_cmdline *cl, char *str) {
-  char *eq = NULL;
-  char *tmp = NULL;
-  char *arg_name = NULL;
+static int normal_state(gpr_cmdline* cl, char* str) {
+  char* eq = nullptr;
+  char* tmp = nullptr;
+  char* arg_name = nullptr;
   int r = 1;
 
   if (0 == strcmp(str, "-help") || 0 == strcmp(str, "--help") ||
@@ -256,7 +256,7 @@ static int normal_state(gpr_cmdline *cl, char *str) {
     return print_usage_and_die(cl);
   }
 
-  cl->cur_arg = NULL;
+  cl->cur_arg = nullptr;
 
   if (str[0] == '-') {
     if (str[1] == '-') {
@@ -274,30 +274,30 @@ static int normal_state(gpr_cmdline *cl, char *str) {
       /* str is of the form '--no-foo' - it's a flag disable */
       str += 3;
       cl->cur_arg = find_arg(cl, str);
-      if (cl->cur_arg == NULL) {
+      if (cl->cur_arg == nullptr) {
         return print_usage_and_die(cl);
       }
       if (cl->cur_arg->type != ARGTYPE_BOOL) {
         fprintf(stderr, "%s is not a flag argument\n", str);
         return print_usage_and_die(cl);
       }
-      *(int *)cl->cur_arg->value = 0;
+      *(int*)cl->cur_arg->value = 0;
       return 1; /* early out */
     }
     eq = strchr(str, '=');
-    if (eq != NULL) {
+    if (eq != nullptr) {
       /* copy the string into a temp buffer and extract the name */
-      tmp = arg_name = (char *)gpr_malloc((size_t)(eq - str + 1));
+      tmp = arg_name = (char*)gpr_malloc((size_t)(eq - str + 1));
       memcpy(arg_name, str, (size_t)(eq - str));
       arg_name[eq - str] = 0;
     } else {
       arg_name = str;
     }
     cl->cur_arg = find_arg(cl, arg_name);
-    if (cl->cur_arg == NULL) {
+    if (cl->cur_arg == nullptr) {
       return print_usage_and_die(cl);
     }
-    if (eq != NULL) {
+    if (eq != nullptr) {
       /* str was of the type --foo=value, parse the value */
       r = value_state(cl, eq + 1);
     } else if (cl->cur_arg->type != ARGTYPE_BOOL) {
@@ -305,7 +305,7 @@ static int normal_state(gpr_cmdline *cl, char *str) {
       cl->state = value_state;
     } else {
       /* flag parameter: just set the value */
-      *(int *)cl->cur_arg->value = 1;
+      *(int*)cl->cur_arg->value = 1;
     }
   } else {
     r = extra_state(cl, str);
@@ -315,7 +315,7 @@ static int normal_state(gpr_cmdline *cl, char *str) {
   return r;
 }
 
-int gpr_cmdline_parse(gpr_cmdline *cl, int argc, char **argv) {
+int gpr_cmdline_parse(gpr_cmdline* cl, int argc, char** argv) {
   int i;
 
   GPR_ASSERT(argc >= 1);

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/cpu.h>
+
 #ifdef GPR_CPU_IPHONE
 
 /* Probably 2 instead of 1, but see comment on gpr_cpu_current_cpu. */

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

@@ -36,6 +36,13 @@
 static int ncpus = 0;
 
 static void init_num_cpus() {
+#ifndef GPR_MUSL_LIBC_COMPAT
+  if (sched_getcpu() < 0) {
+    gpr_log(GPR_ERROR, "Error determining current CPU: %s\n", strerror(errno));
+    ncpus = 1;
+    return;
+  }
+#endif
   /* This must be signed. sysconf returns -1 when the number cannot be
      determined */
   ncpus = (int)sysconf(_SC_NPROCESSORS_ONLN);
@@ -56,6 +63,9 @@ unsigned gpr_cpu_current_cpu(void) {
   // sched_getcpu() is undefined on musl
   return 0;
 #else
+  if (gpr_cpu_num_cores() == 1) {
+    return 0;
+  }
   int cpu = sched_getcpu();
   if (cpu < 0) {
     gpr_log(GPR_ERROR, "Error determining current CPU: %s\n", strerror(errno));

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

@@ -18,20 +18,23 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef GPR_CPU_POSIX
+#if defined(GPR_CPU_POSIX)
 
 #include <errno.h>
+#include <pthread.h>
 #include <string.h>
 #include <unistd.h>
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/useful.h>
 
-static __thread char magic_thread_local;
-
 static long ncpus = 0;
 
+static pthread_key_t thread_id_key;
+
 static void init_ncpus() {
   ncpus = sysconf(_SC_NPROCESSORS_ONLN);
   if (ncpus < 1 || ncpus > INT32_MAX) {
@@ -46,12 +49,32 @@ unsigned gpr_cpu_num_cores(void) {
   return (unsigned)ncpus;
 }
 
+static void delete_thread_id(void* value) {
+  if (value) {
+    gpr_free(value);
+  }
+}
+
+static void init_thread_id_key(void) {
+  pthread_key_create(&thread_id_key, delete_thread_id);
+}
+
 unsigned gpr_cpu_current_cpu(void) {
   /* NOTE: there's no way I know to return the actual cpu index portably...
      most code that's using this is using it to shard across work queues though,
      so here we use thread identity instead to achieve a similar though not
      identical effect */
-  return (unsigned)GPR_HASH_POINTER(&magic_thread_local, gpr_cpu_num_cores());
+  static gpr_once once = GPR_ONCE_INIT;
+  gpr_once_init(&once, init_thread_id_key);
+
+  unsigned int* thread_id =
+      static_cast<unsigned int*>(pthread_getspecific(thread_id_key));
+  if (thread_id == nullptr) {
+    thread_id = static_cast<unsigned int*>(gpr_malloc(sizeof(unsigned int)));
+    pthread_setspecific(thread_id_key, thread_id);
+  }
+
+  return (unsigned)GPR_HASH_POINTER(thread_id, gpr_cpu_num_cores());
 }
 
 #endif /* GPR_CPU_POSIX */

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

@@ -19,6 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GPR_WINDOWS
+#include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 
 unsigned gpr_cpu_num_cores(void) {

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

@@ -31,16 +31,16 @@ extern "C" {
    Returns a newly allocated string. It is the responsability of the caller to
    gpr_free the return value if not NULL (which means that the environment
    variable exists). */
-char *gpr_getenv(const char *name);
+char* gpr_getenv(const char* name);
 
 /* Sets the the environment with the specified name to the specified value. */
-void gpr_setenv(const char *name, const char *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
    use an insecure version of the function. It is ONLY to be used to solve the
    problem in which we need to check an env variable to configure the verbosity
    level of logging. So DO NOT USE THIS. */
-const char *gpr_getenv_silent(const char *name, char **dst);
+const char* gpr_getenv_silent(const char* name, char** dst);
 
 #ifdef __cplusplus
 }

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

@@ -38,15 +38,15 @@
 
 #include "src/core/lib/support/string.h"
 
-const char *gpr_getenv_silent(const char *name, char **dst) {
-  const char *insecure_func_used = NULL;
-  char *result = NULL;
+const char* gpr_getenv_silent(const char* name, char** dst) {
+  const char* insecure_func_used = nullptr;
+  char* result = nullptr;
 #if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
-  typedef char *(*getenv_type)(const char *);
+  typedef char* (*getenv_type)(const char*);
   static getenv_type getenv_func = NULL;
   /* Check to see which getenv variant is supported (go from most
    * to least secure) */
-  const char *names[] = {"secure_getenv", "__secure_getenv", "getenv"};
+  const char* names[] = {"secure_getenv", "__secure_getenv", "getenv"};
   for (size_t i = 0; getenv_func == NULL && i < GPR_ARRAY_SIZE(names); i++) {
     getenv_func = (getenv_type)dlsym(RTLD_DEFAULT, names[i]);
     if (getenv_func != NULL && strstr(names[i], "secure") == NULL) {
@@ -60,21 +60,21 @@ const char *gpr_getenv_silent(const char *name, char **dst) {
   result = getenv(name);
   insecure_func_used = "getenv";
 #endif
-  *dst = result == NULL ? result : gpr_strdup(result);
+  *dst = result == nullptr ? result : gpr_strdup(result);
   return insecure_func_used;
 }
 
-char *gpr_getenv(const char *name) {
-  char *result = NULL;
-  const char *insecure_func_used = gpr_getenv_silent(name, &result);
-  if (insecure_func_used != NULL) {
+char* gpr_getenv(const char* name) {
+  char* result = nullptr;
+  const char* insecure_func_used = gpr_getenv_silent(name, &result);
+  if (insecure_func_used != nullptr) {
     gpr_log(GPR_DEBUG, "Warning: insecure environment read function '%s' used",
             insecure_func_used);
   }
   return result;
 }
 
-void gpr_setenv(const char *name, const char *value) {
+void gpr_setenv(const char* name, const char* value) {
   int res = setenv(name, value, 1);
   GPR_ASSERT(res == 0);
 }