grpc 1.19.0 → 1.20.0.pre1

data/src/core/lib/gprpp/thd_posix.cc

@@ -44,13 +44,14 @@ struct thd_arg {
   void (*body)(void* arg); /* body of a thread */
   void* arg;               /* argument to a thread */
   const char* name;        /* name of thread. Can be nullptr. */
+  bool joinable;
+  bool tracked;
 };
 
-class ThreadInternalsPosix
-    : public grpc_core::internal::ThreadInternalsInterface {
+class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
  public:
   ThreadInternalsPosix(const char* thd_name, void (*thd_body)(void* arg),
-                       void* arg, bool* success)
+                       void* arg, bool* success, const Thread::Options& options)
       : started_(false) {
     gpr_mu_init(&mu_);
     gpr_cv_init(&ready_);
@@ -63,11 +64,20 @@ class ThreadInternalsPosix
     info->body = thd_body;
     info->arg = arg;
     info->name = thd_name;
-    grpc_core::Fork::IncThreadCount();
+    info->joinable = options.joinable();
+    info->tracked = options.tracked();
+    if (options.tracked()) {
+      Fork::IncThreadCount();
+    }
 
     GPR_ASSERT(pthread_attr_init(&attr) == 0);
-    GPR_ASSERT(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) ==
-               0);
+    if (options.joinable()) {
+      GPR_ASSERT(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) ==
+                 0);
+    } else {
+      GPR_ASSERT(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) ==
+                 0);
+    }
 
     *success =
         (pthread_create(&pthread_id_, &attr,
@@ -97,8 +107,14 @@ class ThreadInternalsPosix
                           }
                           gpr_mu_unlock(&arg.thread->mu_);
 
+                          if (!arg.joinable) {
+                            Delete(arg.thread);
+                          }
+
                           (*arg.body)(arg.arg);
-                          grpc_core::Fork::DecThreadCount();
+                          if (arg.tracked) {
+                            Fork::DecThreadCount();
+                          }
                           return nullptr;
                         },
                         info) == 0);
@@ -108,9 +124,11 @@ class ThreadInternalsPosix
     if (!(*success)) {
       /* don't use gpr_free, as this was allocated using malloc (see above) */
       free(info);
-      grpc_core::Fork::DecThreadCount();
+      if (options.tracked()) {
+        Fork::DecThreadCount();
+      }
     }
-  };
+  }
 
   ~ThreadInternalsPosix() override {
     gpr_mu_destroy(&mu_);
@@ -136,15 +154,15 @@ class ThreadInternalsPosix
 }  // namespace
 
 Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
-               bool* success) {
+               bool* success, const Options& options)
+    : options_(options) {
   bool outcome = false;
-  impl_ =
-      grpc_core::New<ThreadInternalsPosix>(thd_name, thd_body, arg, &outcome);
+  impl_ = New<ThreadInternalsPosix>(thd_name, thd_body, arg, &outcome, options);
   if (outcome) {
     state_ = ALIVE;
   } else {
     state_ = FAILED;
-    grpc_core::Delete(impl_);
+    Delete(impl_);
     impl_ = nullptr;
   }
 

data/src/core/lib/gprpp/thd_windows.cc

@@ -33,10 +33,8 @@
 
 #if defined(_MSC_VER)
 #define thread_local __declspec(thread)
-#define WIN_LAMBDA
 #elif defined(__GNUC__)
 #define thread_local __thread
-#define WIN_LAMBDA WINAPI
 #else
 #error "Unknown compiler - please file a bug report"
 #endif
@@ -48,6 +46,7 @@ struct thd_info {
   void (*body)(void* arg); /* body of a thread */
   void* arg;               /* argument to a thread */
   HANDLE join_event;       /* the join event */
+  bool joinable;           /* whether it is joinable */
 };
 
 thread_local struct thd_info* g_thd_info;
@@ -55,7 +54,8 @@ thread_local struct thd_info* g_thd_info;
 class ThreadInternalsWindows
     : public grpc_core::internal::ThreadInternalsInterface {
  public:
-  ThreadInternalsWindows(void (*thd_body)(void* arg), void* arg, bool* success)
+  ThreadInternalsWindows(void (*thd_body)(void* arg), void* arg, bool* success,
+                         const grpc_core::Thread::Options& options)
       : started_(false) {
     gpr_mu_init(&mu_);
     gpr_cv_init(&ready_);
@@ -65,36 +65,24 @@ class ThreadInternalsWindows
     info_->thread = this;
     info_->body = thd_body;
     info_->arg = arg;
-
-    info_->join_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
-    if (info_->join_event == nullptr) {
-      gpr_free(info_);
-      *success = false;
-    } else {
-      handle = CreateThread(
-          nullptr, 64 * 1024,
-          [](void* v) WIN_LAMBDA -> DWORD {
-            g_thd_info = static_cast<thd_info*>(v);
-            gpr_mu_lock(&g_thd_info->thread->mu_);
-            while (!g_thd_info->thread->started_) {
-              gpr_cv_wait(&g_thd_info->thread->ready_, &g_thd_info->thread->mu_,
-                          gpr_inf_future(GPR_CLOCK_MONOTONIC));
-            }
-            gpr_mu_unlock(&g_thd_info->thread->mu_);
-            g_thd_info->body(g_thd_info->arg);
-            BOOL ret = SetEvent(g_thd_info->join_event);
-            GPR_ASSERT(ret);
-            return 0;
-          },
-          info_, 0, nullptr);
-      if (handle == nullptr) {
-        destroy_thread();
+    info_->join_event = nullptr;
+    info_->joinable = options.joinable();
+    if (info_->joinable) {
+      info_->join_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+      if (info_->join_event == nullptr) {
+        gpr_free(info_);
         *success = false;
-      } else {
-        CloseHandle(handle);
-        *success = true;
+        return;
       }
     }
+    handle = CreateThread(nullptr, 64 * 1024, thread_body, info_, 0, nullptr);
+    if (handle == nullptr) {
+      destroy_thread();
+      *success = false;
+    } else {
+      CloseHandle(handle);
+      *success = true;
+    }
   }
 
   ~ThreadInternalsWindows() override {
@@ -116,8 +104,32 @@ class ThreadInternalsWindows
   }
 
  private:
+  static DWORD WINAPI thread_body(void* v) {
+    g_thd_info = static_cast<thd_info*>(v);
+    gpr_mu_lock(&g_thd_info->thread->mu_);
+    while (!g_thd_info->thread->started_) {
+      gpr_cv_wait(&g_thd_info->thread->ready_, &g_thd_info->thread->mu_,
+                  gpr_inf_future(GPR_CLOCK_MONOTONIC));
+    }
+    gpr_mu_unlock(&g_thd_info->thread->mu_);
+    if (!g_thd_info->joinable) {
+      grpc_core::Delete(g_thd_info->thread);
+      g_thd_info->thread = nullptr;
+    }
+    g_thd_info->body(g_thd_info->arg);
+    if (g_thd_info->joinable) {
+      BOOL ret = SetEvent(g_thd_info->join_event);
+      GPR_ASSERT(ret);
+    } else {
+      gpr_free(g_thd_info);
+    }
+    return 0;
+  }
+
   void destroy_thread() {
-    CloseHandle(info_->join_event);
+    if (info_ != nullptr && info_->joinable) {
+      CloseHandle(info_->join_event);
+    }
     gpr_free(info_);
   }
 
@@ -132,14 +144,15 @@ class ThreadInternalsWindows
 namespace grpc_core {
 
 Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
-               bool* success) {
+               bool* success, const Options& options)
+    : options_(options) {
   bool outcome = false;
-  impl_ = grpc_core::New<ThreadInternalsWindows>(thd_body, arg, &outcome);
+  impl_ = New<ThreadInternalsWindows>(thd_body, arg, &outcome, options);
   if (outcome) {
     state_ = ALIVE;
   } else {
     state_ = FAILED;
-    grpc_core::Delete(impl_);
+    Delete(impl_);
     impl_ = nullptr;
   }
 

data/src/core/lib/http/httpcli.cc

@@ -121,7 +121,7 @@ static void append_error(internal_request* req, grpc_error* error) {
 }
 
 static void do_read(internal_request* req) {
-  grpc_endpoint_read(req->ep, &req->incoming, &req->on_read);
+  grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, /*urgent=*/true);
 }
 
 static void on_read(void* user_data, grpc_error* error) {
@@ -229,7 +229,8 @@ static void internal_request_begin(grpc_httpcli_context* context,
                                    const grpc_httpcli_request* request,
                                    grpc_millis deadline, grpc_closure* on_done,
                                    grpc_httpcli_response* response,
-                                   const char* name, grpc_slice request_text) {
+                                   const char* name,
+                                   const grpc_slice& request_text) {
   internal_request* req =
       static_cast<internal_request*>(gpr_malloc(sizeof(internal_request)));
   memset(req, 0, sizeof(*req));

data/src/core/lib/http/httpcli_security_connector.cc

@@ -59,7 +59,6 @@ class grpc_httpcli_ssl_channel_security_connector final
   tsi_result InitHandshakerFactory(const char* pem_root_certs,
                                    const tsi_ssl_root_certs_store* root_store) {
     tsi_ssl_client_handshaker_options options;
-    memset(&options, 0, sizeof(options));
     options.pem_root_certs = pem_root_certs;
     options.root_store = root_store;
     return tsi_create_ssl_client_handshaker_factory_with_options(

data/src/core/lib/http/parser.cc

@@ -351,7 +351,8 @@ void grpc_http_response_destroy(grpc_http_response* response) {
   gpr_free(response->hdrs);
 }
 
-grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
+grpc_error* grpc_http_parser_parse(grpc_http_parser* parser,
+                                   const grpc_slice& slice,
                                    size_t* start_of_body) {
   for (size_t i = 0; i < GRPC_SLICE_LENGTH(slice); i++) {
     bool found_body_start = false;

data/src/core/lib/http/parser.h

@@ -101,7 +101,8 @@ void grpc_http_parser_init(grpc_http_parser* parser, grpc_http_type type,
 void grpc_http_parser_destroy(grpc_http_parser* parser);
 
 /* Sets \a start_of_body to the offset in \a slice of the start of the body. */
-grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
+grpc_error* grpc_http_parser_parse(grpc_http_parser* parser,
+                                   const grpc_slice& slice,
                                    size_t* start_of_body);
 grpc_error* grpc_http_parser_eof(grpc_http_parser* parser);
 

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

@@ -160,6 +160,6 @@ void grpc_tcp_set_write_timestamps_callback(void (*fn)(void*,
                                                        grpc_core::Timestamps*,
                                                        grpc_error* error));
 
-}; /* namespace grpc_core */
+} /* namespace grpc_core */
 
 #endif /* GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H */

data/src/core/lib/iomgr/endpoint.cc

@@ -23,8 +23,8 @@
 grpc_core::TraceFlag grpc_tcp_trace(false, "tcp");
 
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb) {
-  ep->vtable->read(ep, slices, cb);
+                        grpc_closure* cb, bool urgent) {
+  ep->vtable->read(ep, slices, cb, urgent);
 }
 
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,

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

@@ -36,7 +36,8 @@ typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
 class Timestamps;
 
 struct grpc_endpoint_vtable {
-  void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb);
+  void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
+               bool urgent);
   void (*write)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
                 void* arg);
   void (*add_to_pollset)(grpc_endpoint* ep, grpc_pollset* pollset);
@@ -56,7 +57,7 @@ struct grpc_endpoint_vtable {
    Valid slices may be placed into \a slices even when the callback is
    invoked with error != GRPC_ERROR_NONE. */
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb);
+                        grpc_closure* cb, bool urgent);
 
 char* grpc_endpoint_get_peer(grpc_endpoint* ep);
 

data/src/core/lib/iomgr/error.cc

@@ -150,13 +150,12 @@ static void unref_errs(grpc_error* err) {
   }
 }
 
-static void unref_slice(grpc_slice slice) { grpc_slice_unref_internal(slice); }
-
 static void unref_strs(grpc_error* err) {
   for (size_t which = 0; which < GRPC_ERROR_STR_MAX; ++which) {
     uint8_t slot = err->strs[which];
     if (slot != UINT8_MAX) {
-      unref_slice(*reinterpret_cast<grpc_slice*>(err->arena + slot));
+      grpc_slice_unref_internal(
+          *reinterpret_cast<grpc_slice*>(err->arena + slot));
     }
   }
 }
@@ -231,7 +230,7 @@ static void internal_set_int(grpc_error** err, grpc_error_ints which,
 }
 
 static void internal_set_str(grpc_error** err, grpc_error_strs which,
-                             grpc_slice value) {
+                             const grpc_slice& value) {
   uint8_t slot = (*err)->strs[which];
   if (slot == UINT8_MAX) {
     slot = get_placement(err, sizeof(value));
@@ -243,7 +242,8 @@ static void internal_set_str(grpc_error** err, grpc_error_strs which,
       return;
     }
   } else {
-    unref_slice(*reinterpret_cast<grpc_slice*>((*err)->arena + slot));
+    grpc_slice_unref_internal(
+        *reinterpret_cast<grpc_slice*>((*err)->arena + slot));
   }
   (*err)->strs[which] = slot;
   memcpy((*err)->arena + slot, &value, sizeof(value));
@@ -313,8 +313,8 @@ void grpc_enable_error_creation() {
   gpr_atm_no_barrier_store(&g_error_creation_allowed, true);
 }
 
-grpc_error* grpc_error_create(const char* file, int line, grpc_slice desc,
-                              grpc_error** referencing,
+grpc_error* grpc_error_create(const char* file, int line,
+                              const grpc_slice& desc, grpc_error** referencing,
                               size_t num_referencing) {
   GPR_TIMER_SCOPE("grpc_error_create", 0);
   uint8_t initial_arena_capacity = static_cast<uint8_t>(
@@ -472,7 +472,7 @@ bool grpc_error_get_int(grpc_error* err, grpc_error_ints which, intptr_t* p) {
 }
 
 grpc_error* grpc_error_set_str(grpc_error* src, grpc_error_strs which,
-                               grpc_slice str) {
+                               const grpc_slice& str) {
   GPR_TIMER_SCOPE("grpc_error_set_str", 0);
   grpc_error* new_err = copy_error_and_unref(src);
   internal_set_str(&new_err, which, str);
@@ -620,7 +620,7 @@ static char* key_str(grpc_error_strs which) {
   return gpr_strdup(error_str_name(which));
 }
 
-static char* fmt_str(grpc_slice slice) {
+static char* fmt_str(const grpc_slice& slice) {
   char* s = nullptr;
   size_t sz = 0;
   size_t cap = 0;

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

@@ -138,8 +138,9 @@ void grpc_enable_error_creation();
 const char* grpc_error_string(grpc_error* error);
 
 /// Create an error - but use GRPC_ERROR_CREATE instead
-grpc_error* grpc_error_create(const char* file, int line, grpc_slice desc,
-                              grpc_error** referencing, size_t num_referencing);
+grpc_error* grpc_error_create(const char* file, int line,
+                              const grpc_slice& desc, grpc_error** referencing,
+                              size_t num_referencing);
 /// Create an error (this is the preferred way of generating an error that is
 ///   not due to a system call - for system calls, use GRPC_OS_ERROR or
 ///   GRPC_WSA_ERROR as appropriate)
@@ -200,7 +201,7 @@ bool grpc_error_get_int(grpc_error* error, grpc_error_ints which, intptr_t* p);
 /// This call takes ownership of the slice; the error is responsible for
 /// eventually unref-ing it.
 grpc_error* grpc_error_set_str(grpc_error* src, grpc_error_strs which,
-                               grpc_slice str) GRPC_MUST_USE_RESULT;
+                               const grpc_slice& str) GRPC_MUST_USE_RESULT;
 /// Returns false if the specified string is not set.
 /// Caller does NOT own the slice.
 bool grpc_error_get_str(grpc_error* error, grpc_error_strs which,

data/src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -1246,6 +1246,11 @@ static bool is_any_background_poller_thread(void) { return false; }
 
 static void shutdown_background_closure(void) {}
 
+static bool add_closure_to_background_poller(grpc_closure* closure,
+                                             grpc_error* error) {
+  return false;
+}
+
 static void shutdown_engine(void) {
   fd_global_shutdown();
   pollset_global_shutdown();
@@ -1292,6 +1297,7 @@ static const grpc_event_engine_vtable vtable = {
     is_any_background_poller_thread,
     shutdown_background_closure,
     shutdown_engine,
+    add_closure_to_background_poller,
 };
 
 /* Called by the child process's post-fork handler to close open fds, including

data/src/core/lib/iomgr/ev_epollex_linux.cc

@@ -447,14 +447,12 @@ static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
     // Otherwise, we will receive epoll events after we release the FD.
     epoll_event ev_fd;
     memset(&ev_fd, 0, sizeof(ev_fd));
-    if (release_fd != nullptr) {
-      if (pollable_obj != nullptr) {  // For PO_FD.
-        epoll_ctl(pollable_obj->epfd, EPOLL_CTL_DEL, fd->fd, &ev_fd);
-      }
-      for (size_t i = 0; i < fd->pollset_fds.size(); ++i) {  // For PO_MULTI.
-        const int epfd = fd->pollset_fds[i];
-        epoll_ctl(epfd, EPOLL_CTL_DEL, fd->fd, &ev_fd);
-      }
+    if (pollable_obj != nullptr) {  // For PO_FD.
+      epoll_ctl(pollable_obj->epfd, EPOLL_CTL_DEL, fd->fd, &ev_fd);
+    }
+    for (size_t i = 0; i < fd->pollset_fds.size(); ++i) {  // For PO_MULTI.
+      const int epfd = fd->pollset_fds[i];
+      epoll_ctl(epfd, EPOLL_CTL_DEL, fd->fd, &ev_fd);
     }
     *release_fd = fd->fd;
   } else {
@@ -614,6 +612,7 @@ static void pollable_unref(pollable* p, int line, const char* reason) {
     close(p->epfd);
     grpc_wakeup_fd_destroy(&p->wakeup);
     gpr_mu_destroy(&p->owner_orphan_mu);
+    gpr_mu_destroy(&p->mu);
     gpr_free(p);
   }
 }
@@ -1295,7 +1294,7 @@ static grpc_error* pollset_as_multipollable_locked(grpc_pollset* pollset,
 static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) {
   GPR_TIMER_SCOPE("pollset_add_fd", 0);
 
-  // We never transition from PO_MULTI to other modes (i.e., PO_FD or PO_EMOPTY)
+  // We never transition from PO_MULTI to other modes (i.e., PO_FD or PO_EMPTY)
   // and, thus, it is safe to simply store and check whether the FD has already
   // been added to the active pollable previously.
   if (gpr_atm_acq_load(&pollset->active_pollable_type) == PO_MULTI &&
@@ -1579,6 +1578,11 @@ static bool is_any_background_poller_thread(void) { return false; }
 
 static void shutdown_background_closure(void) {}
 
+static bool add_closure_to_background_poller(grpc_closure* closure,
+                                             grpc_error* error) {
+  return false;
+}
+
 static void shutdown_engine(void) {
   fd_global_shutdown();
   pollset_global_shutdown();
@@ -1620,6 +1624,7 @@ static const grpc_event_engine_vtable vtable = {
     is_any_background_poller_thread,
     shutdown_background_closure,
     shutdown_engine,
+    add_closure_to_background_poller,
 };
 
 const grpc_event_engine_vtable* grpc_init_epollex_linux(