grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/executor.h

@@ -21,6 +21,10 @@
 
 #include "src/core/lib/iomgr/closure.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum {
   GRPC_EXECUTOR_SHORT,
   GRPC_EXECUTOR_LONG
@@ -31,18 +35,22 @@ typedef enum {
  * This mechanism is meant to outsource work (grpc_closure instances) to a
  * thread, for those cases where blocking isn't an option but there isn't a
  * non-blocking solution available. */
-void grpc_executor_init(grpc_exec_ctx *exec_ctx);
+void grpc_executor_init(grpc_exec_ctx* exec_ctx);
 
-grpc_closure_scheduler *grpc_executor_scheduler(grpc_executor_job_length);
+grpc_closure_scheduler* grpc_executor_scheduler(grpc_executor_job_length);
 
 /** Shutdown the executor, running all pending work as part of the call */
-void grpc_executor_shutdown(grpc_exec_ctx *exec_ctx);
+void grpc_executor_shutdown(grpc_exec_ctx* exec_ctx);
 
 /** Is the executor multi-threaded? */
 bool grpc_executor_is_threaded();
 
 /* enable/disable threading - must be called after grpc_executor_init and before
    grpc_executor_shutdown */
-void grpc_executor_set_threading(grpc_exec_ctx *exec_ctx, bool enable);
+void grpc_executor_set_threading(grpc_exec_ctx* exec_ctx, bool enable);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_EXECUTOR_H */

data/src/core/lib/iomgr/gethostname.h

@@ -19,8 +19,16 @@
 #ifndef GRPC_CORE_LIB_IOMGR_GETHOSTNAME_H
 #define GRPC_CORE_LIB_IOMGR_GETHOSTNAME_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 // Returns the hostname of the local machine.
 // Caller takes ownership of result.
-char *grpc_gethostname();
+char* grpc_gethostname();
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_GETHOSTNAME_H */

data/src/core/lib/iomgr/{gethostname_fallback.c → gethostname_fallback.cc}

@@ -16,12 +16,13 @@
  *
  */
 
+#include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_GETHOSTNAME_FALLBACK
 
 #include <stddef.h>
 
-char *grpc_gethostname() { return NULL; }
+char* grpc_gethostname() { return NULL; }
 
 #endif  // GRPC_GETHOSTNAME_FALLBACK

data/src/core/lib/iomgr/{gethostname_host_name_max.c → gethostname_host_name_max.cc}

@@ -16,6 +16,7 @@
  *
  */
 
+#include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_HOST_NAME_MAX
@@ -25,11 +26,11 @@
 
 #include <grpc/support/alloc.h>
 
-char *grpc_gethostname() {
-  char *hostname = (char *)gpr_malloc(HOST_NAME_MAX);
+char* grpc_gethostname() {
+  char* hostname = (char*)gpr_malloc(HOST_NAME_MAX);
   if (gethostname(hostname, HOST_NAME_MAX) != 0) {
     gpr_free(hostname);
-    return NULL;
+    return nullptr;
   }
   return hostname;
 }

data/src/core/lib/iomgr/{gethostname_sysconf.c → gethostname_sysconf.cc}

@@ -16,6 +16,7 @@
  *
  */
 
+#include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SYSCONF
@@ -24,9 +25,9 @@
 
 #include <grpc/support/alloc.h>
 
-char *grpc_gethostname() {
+char* grpc_gethostname() {
   size_t host_name_max = (size_t)sysconf(_SC_HOST_NAME_MAX);
-  char *hostname = (char *)gpr_malloc(host_name_max);
+  char* hostname = (char*)gpr_malloc(host_name_max);
   if (gethostname(hostname, host_name_max) != 0) {
     gpr_free(hostname);
     return NULL;

data/src/core/lib/iomgr/{iocp_windows.c → iocp_windows.cc}

@@ -21,11 +21,13 @@
 #ifdef GRPC_WINSOCK_SOCKET
 
 #include <winsock2.h>
+#include <limits>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
 #include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
@@ -40,36 +42,32 @@ static gpr_atm g_custom_events = 0;
 
 static HANDLE g_iocp;
 
-static DWORD deadline_to_millis_timeout(gpr_timespec deadline,
-                                        gpr_timespec now) {
-  gpr_timespec timeout;
-  static const int64_t max_spin_polling_us = 10;
-  if (gpr_time_cmp(deadline, gpr_inf_future(deadline.clock_type)) == 0) {
+static DWORD deadline_to_millis_timeout(grpc_exec_ctx* exec_ctx,
+                                        grpc_millis deadline) {
+  if (deadline == GRPC_MILLIS_INF_FUTURE) {
     return INFINITE;
   }
-  if (gpr_time_cmp(deadline, gpr_time_add(now, gpr_time_from_micros(
-                                                   max_spin_polling_us,
-                                                   GPR_TIMESPAN))) <= 0) {
-    return 0;
-  }
-  timeout = gpr_time_sub(deadline, now);
-  return (DWORD)gpr_time_to_millis(gpr_time_add(
-      timeout, gpr_time_from_nanos(GPR_NS_PER_MS - 1, GPR_TIMESPAN)));
+  grpc_millis now = grpc_exec_ctx_now(exec_ctx);
+  if (deadline < now) return 0;
+  grpc_millis timeout = deadline - now;
+  if (timeout > std::numeric_limits<DWORD>::max()) return INFINITE;
+  return static_cast<DWORD>(deadline - now);
 }
 
-grpc_iocp_work_status grpc_iocp_work(grpc_exec_ctx *exec_ctx,
-                                     gpr_timespec deadline) {
+grpc_iocp_work_status grpc_iocp_work(grpc_exec_ctx* exec_ctx,
+                                     grpc_millis deadline) {
   BOOL success;
   DWORD bytes = 0;
   DWORD flags = 0;
   ULONG_PTR completion_key;
   LPOVERLAPPED overlapped;
-  grpc_winsocket *socket;
-  grpc_winsocket_callback_info *info;
+  grpc_winsocket* socket;
+  grpc_winsocket_callback_info* info;
   GRPC_STATS_INC_SYSCALL_POLL(exec_ctx);
-  success = GetQueuedCompletionStatus(
-      g_iocp, &bytes, &completion_key, &overlapped,
-      deadline_to_millis_timeout(deadline, gpr_now(deadline.clock_type)));
+  success =
+      GetQueuedCompletionStatus(g_iocp, &bytes, &completion_key, &overlapped,
+                                deadline_to_millis_timeout(exec_ctx, deadline));
+  grpc_exec_ctx_invalidate_now(exec_ctx);
   if (success == 0 && overlapped == NULL) {
     return GRPC_IOCP_WORK_TIMEOUT;
   }
@@ -84,7 +82,7 @@ grpc_iocp_work_status grpc_iocp_work(grpc_exec_ctx *exec_ctx,
     abort();
   }
 
-  socket = (grpc_winsocket *)completion_key;
+  socket = (grpc_winsocket*)completion_key;
   if (overlapped == &socket->write_info.overlapped) {
     info = &socket->write_info;
   } else if (overlapped == &socket->read_info.overlapped) {
@@ -121,7 +119,7 @@ void grpc_iocp_flush(void) {
   grpc_iocp_work_status work_status;
 
   do {
-    work_status = grpc_iocp_work(&exec_ctx, gpr_inf_past(GPR_CLOCK_MONOTONIC));
+    work_status = grpc_iocp_work(&exec_ctx, GRPC_MILLIS_INF_PAST);
   } while (work_status == GRPC_IOCP_WORK_KICK ||
            grpc_exec_ctx_flush(&exec_ctx));
 }
@@ -129,20 +127,20 @@ void grpc_iocp_flush(void) {
 void grpc_iocp_shutdown(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (gpr_atm_acq_load(&g_custom_events)) {
-    grpc_iocp_work(&exec_ctx, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+    grpc_iocp_work(&exec_ctx, GRPC_MILLIS_INF_FUTURE);
     grpc_exec_ctx_flush(&exec_ctx);
   }
   grpc_exec_ctx_finish(&exec_ctx);
   GPR_ASSERT(CloseHandle(g_iocp));
 }
 
-void grpc_iocp_add_socket(grpc_winsocket *socket) {
+void grpc_iocp_add_socket(grpc_winsocket* socket) {
   HANDLE ret;
   if (socket->added_to_iocp) return;
   ret = CreateIoCompletionPort((HANDLE)socket->socket, g_iocp,
                                (uintptr_t)socket, 0);
   if (!ret) {
-    char *utf8_message = gpr_format_message(WSAGetLastError());
+    char* utf8_message = gpr_format_message(WSAGetLastError());
     gpr_log(GPR_ERROR, "Unable to add socket to iocp: %s", utf8_message);
     gpr_free(utf8_message);
     __debugbreak();

data/src/core/lib/iomgr/iocp_windows.h

@@ -21,20 +21,34 @@
 
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_WINSOCK_SOCKET
+
 #include "src/core/lib/iomgr/socket_windows.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum {
   GRPC_IOCP_WORK_WORK,
   GRPC_IOCP_WORK_TIMEOUT,
   GRPC_IOCP_WORK_KICK
 } grpc_iocp_work_status;
 
-grpc_iocp_work_status grpc_iocp_work(grpc_exec_ctx *exec_ctx,
-                                     gpr_timespec deadline);
+grpc_iocp_work_status grpc_iocp_work(grpc_exec_ctx* exec_ctx,
+                                     grpc_millis deadline);
 void grpc_iocp_init(void);
 void grpc_iocp_kick(void);
 void grpc_iocp_flush(void);
 void grpc_iocp_shutdown(void);
-void grpc_iocp_add_socket(grpc_winsocket *);
+void grpc_iocp_add_socket(grpc_winsocket*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_IOCP_WINDOWS_H */

data/src/core/lib/iomgr/{iomgr.c → iomgr.cc}

@@ -16,8 +16,11 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/iomgr.h"
 
+#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -42,23 +45,23 @@ static gpr_cv g_rcv;
 static int g_shutdown;
 static grpc_iomgr_object g_root_object;
 
-void grpc_iomgr_init(grpc_exec_ctx *exec_ctx) {
+void grpc_iomgr_init(grpc_exec_ctx* exec_ctx) {
   g_shutdown = 0;
   gpr_mu_init(&g_mu);
   gpr_cv_init(&g_rcv);
   grpc_exec_ctx_global_init();
   grpc_executor_init(exec_ctx);
-  grpc_timer_list_init(gpr_now(GPR_CLOCK_MONOTONIC));
+  grpc_timer_list_init(exec_ctx);
   g_root_object.next = g_root_object.prev = &g_root_object;
-  g_root_object.name = (char *)"root";
+  g_root_object.name = (char*)"root";
   grpc_network_status_init();
   grpc_iomgr_platform_init();
 }
 
-void grpc_iomgr_start(grpc_exec_ctx *exec_ctx) { grpc_timer_manager_init(); }
+void grpc_iomgr_start(grpc_exec_ctx* exec_ctx) { grpc_timer_manager_init(); }
 
 static size_t count_objects(void) {
-  grpc_iomgr_object *obj;
+  grpc_iomgr_object* obj;
   size_t n = 0;
   for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next) {
     n++;
@@ -66,14 +69,14 @@ static size_t count_objects(void) {
   return n;
 }
 
-static void dump_objects(const char *kind) {
-  grpc_iomgr_object *obj;
+static void dump_objects(const char* kind) {
+  grpc_iomgr_object* obj;
   for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next) {
     gpr_log(GPR_DEBUG, "%s OBJECT: %s %p", kind, obj->name, obj);
   }
 }
 
-void grpc_iomgr_shutdown(grpc_exec_ctx *exec_ctx) {
+void grpc_iomgr_shutdown(grpc_exec_ctx* exec_ctx) {
   gpr_timespec shutdown_deadline = gpr_time_add(
       gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_seconds(10, GPR_TIMESPAN));
   gpr_timespec last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
@@ -95,8 +98,9 @@ void grpc_iomgr_shutdown(grpc_exec_ctx *exec_ctx) {
       }
       last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
     }
-    if (grpc_timer_check(exec_ctx, gpr_inf_future(GPR_CLOCK_MONOTONIC), NULL) ==
-        GRPC_TIMERS_FIRED) {
+    exec_ctx->now_is_valid = true;
+    exec_ctx->now = GRPC_MILLIS_INF_FUTURE;
+    if (grpc_timer_check(exec_ctx, nullptr) == GRPC_TIMERS_FIRED) {
       gpr_mu_unlock(&g_mu);
       grpc_exec_ctx_flush(exec_ctx);
       grpc_iomgr_platform_flush();
@@ -105,9 +109,10 @@ void grpc_iomgr_shutdown(grpc_exec_ctx *exec_ctx) {
     }
     if (g_root_object.next != &g_root_object) {
       if (grpc_iomgr_abort_on_leaks()) {
-        gpr_log(GPR_DEBUG, "Failed to free %" PRIuPTR
-                           " iomgr objects before shutdown deadline: "
-                           "memory leaks are likely",
+        gpr_log(GPR_DEBUG,
+                "Failed to free %" PRIuPTR
+                " iomgr objects before shutdown deadline: "
+                "memory leaks are likely",
                 count_objects());
         dump_objects("LEAKED");
         abort();
@@ -117,9 +122,10 @@ void grpc_iomgr_shutdown(grpc_exec_ctx *exec_ctx) {
       if (gpr_cv_wait(&g_rcv, &g_mu, short_deadline)) {
         if (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), shutdown_deadline) > 0) {
           if (g_root_object.next != &g_root_object) {
-            gpr_log(GPR_DEBUG, "Failed to free %" PRIuPTR
-                               " iomgr objects before shutdown deadline: "
-                               "memory leaks are likely",
+            gpr_log(GPR_DEBUG,
+                    "Failed to free %" PRIuPTR
+                    " iomgr objects before shutdown deadline: "
+                    "memory leaks are likely",
                     count_objects());
             dump_objects("LEAKED");
           }
@@ -144,7 +150,7 @@ void grpc_iomgr_shutdown(grpc_exec_ctx *exec_ctx) {
   gpr_cv_destroy(&g_rcv);
 }
 
-void grpc_iomgr_register_object(grpc_iomgr_object *obj, const char *name) {
+void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name) {
   obj->name = gpr_strdup(name);
   gpr_mu_lock(&g_mu);
   obj->next = &g_root_object;
@@ -153,7 +159,7 @@ void grpc_iomgr_register_object(grpc_iomgr_object *obj, const char *name) {
   gpr_mu_unlock(&g_mu);
 }
 
-void grpc_iomgr_unregister_object(grpc_iomgr_object *obj) {
+void grpc_iomgr_unregister_object(grpc_iomgr_object* obj) {
   gpr_mu_lock(&g_mu);
   obj->next->prev = obj->prev;
   obj->prev->next = obj->next;
@@ -163,7 +169,7 @@ void grpc_iomgr_unregister_object(grpc_iomgr_object *obj) {
 }
 
 bool grpc_iomgr_abort_on_leaks(void) {
-  char *env = gpr_getenv("GRPC_ABORT_ON_LEAKS");
+  char* env = gpr_getenv("GRPC_ABORT_ON_LEAKS");
   bool should_we = gpr_is_true(env);
   gpr_free(env);
   return should_we;

data/src/core/lib/iomgr/iomgr.h

@@ -22,14 +22,22 @@
 #include <grpc/impl/codegen/exec_ctx_fwd.h>
 #include "src/core/lib/iomgr/port.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** Initializes the iomgr. */
-void grpc_iomgr_init(grpc_exec_ctx *exec_ctx);
+void grpc_iomgr_init(grpc_exec_ctx* exec_ctx);
 
 /** Starts any background threads for iomgr. */
-void grpc_iomgr_start(grpc_exec_ctx *exec_ctx);
+void grpc_iomgr_start(grpc_exec_ctx* exec_ctx);
 
 /** Signals the intention to shutdown the iomgr. Expects to be able to flush
  * exec_ctx. */
-void grpc_iomgr_shutdown(grpc_exec_ctx *exec_ctx);
+void grpc_iomgr_shutdown(grpc_exec_ctx* exec_ctx);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_IOMGR_H */

data/src/core/lib/iomgr/iomgr_internal.h

@@ -23,14 +23,18 @@
 
 #include "src/core/lib/iomgr/iomgr.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_iomgr_object {
-  char *name;
-  struct grpc_iomgr_object *next;
-  struct grpc_iomgr_object *prev;
+  char* name;
+  struct grpc_iomgr_object* next;
+  struct grpc_iomgr_object* prev;
 } grpc_iomgr_object;
 
-void grpc_iomgr_register_object(grpc_iomgr_object *obj, const char *name);
-void grpc_iomgr_unregister_object(grpc_iomgr_object *obj);
+void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name);
+void grpc_iomgr_unregister_object(grpc_iomgr_object* obj);
 
 void grpc_iomgr_platform_init(void);
 /** flush any globally queued work from iomgr */
@@ -40,4 +44,8 @@ void grpc_iomgr_platform_shutdown(void);
 
 bool grpc_iomgr_abort_on_leaks(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_IOMGR_INTERNAL_H */

data/src/core/lib/iomgr/{iomgr_posix.c → iomgr_posix.cc}

@@ -28,7 +28,6 @@
 void grpc_iomgr_platform_init(void) {
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
-  grpc_register_tracer(&grpc_tcp_trace);
 }
 
 void grpc_iomgr_platform_flush(void) {}