grpc 1.63.0 → 1.65.2

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

@@ -24,6 +24,9 @@
 
 #include <limits.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -31,8 +34,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -43,6 +44,8 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/util/string.h"
+#include "src/core/util/useful.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
 // Nasty workaround for nasty bug when using the 64 bits msys compiler
@@ -52,8 +55,6 @@
 #define GRPC_FIONBIO FIONBIO
 #endif
 
-extern grpc_core::TraceFlag grpc_tcp_trace;
-
 grpc_error_handle grpc_tcp_set_non_block(SOCKET sock) {
   int status;
   uint32_t param = 1;
@@ -122,7 +123,6 @@ typedef struct grpc_tcp {
   // to protect ourselves when requesting a shutdown.
   gpr_mu mu;
   int shutting_down;
-  grpc_error_handle shutdown_error;
 
   std::string peer_string;
   std::string local_address;
@@ -140,7 +140,7 @@ static void tcp_free(grpc_tcp* tcp) {
 #define TCP_REF(tcp, reason) tcp_ref((tcp), (reason), __FILE__, __LINE__)
 static void tcp_unref(grpc_tcp* tcp, const char* reason, const char* file,
                       int line) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "TCP unref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
@@ -153,7 +153,7 @@ static void tcp_unref(grpc_tcp* tcp, const char* reason, const char* file,
 
 static void tcp_ref(grpc_tcp* tcp, const char* reason, const char* file,
                     int line) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "TCP   ref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
@@ -180,7 +180,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->read_info;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_INFO, "TCP:%p on_read", tcp);
   }
 
@@ -190,7 +190,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {
-        GPR_ASSERT((size_t)info->bytes_transferred <= tcp->read_slices->length);
+        CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
         if (static_cast<size_t>(info->bytes_transferred) !=
             tcp->read_slices->length) {
           grpc_slice_buffer_trim_end(
@@ -199,29 +199,26 @@ static void on_read(void* tcpp, grpc_error_handle error) {
                   static_cast<size_t>(info->bytes_transferred),
               &tcp->last_read_buffer);
         }
-        GPR_ASSERT((size_t)info->bytes_transferred == tcp->read_slices->length);
+        CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
 
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
-            gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
+        if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
           size_t i;
           for (i = 0; i < tcp->read_slices->count; i++) {
             char* dump = grpc_dump_slice(tcp->read_slices->slices[i],
                                          GPR_DUMP_HEX | GPR_DUMP_ASCII);
-            gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp,
-                    tcp->peer_string.c_str(), dump);
+            VLOG(2) << "READ " << tcp << " (peer=" << tcp->peer_string
+                    << "): " << dump;
             gpr_free(dump);
           }
         }
       } else {
-        if (grpc_tcp_trace.enabled()) {
+        if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
           gpr_log(GPR_INFO, "TCP:%p unref read_slice", tcp);
         }
         grpc_slice_buffer_reset_and_unref(tcp->read_slices);
         error = grpc_error_set_int(
-            tcp->shutting_down
-                ? GRPC_ERROR_CREATE_REFERENCING("TCP stream shutting down",
-                                                &tcp->shutdown_error, 1)
-                : GRPC_ERROR_CREATE("End of TCP stream"),
+            tcp->shutting_down ? GRPC_ERROR_CREATE("TCP stream shutting down")
+                               : GRPC_ERROR_CREATE("End of TCP stream"),
             grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
       }
     }
@@ -246,17 +243,16 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   WSABUF buffers[MAX_WSABUF_COUNT];
   size_t i;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_INFO, "TCP:%p win_read", tcp);
   }
 
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION, cb,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_REFERENCING("TCP socket is shutting down",
-                                          &tcp->shutdown_error, 1),
-            grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE));
+        grpc_error_set_int(GRPC_ERROR_CREATE("TCP socket is shutting down"),
+                           grpc_core::StatusIntProperty::kRpcStatus,
+                           GRPC_STATUS_UNAVAILABLE));
     return;
   }
 
@@ -272,7 +268,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           GRPC_SLICE_MALLOC(DEFAULT_TARGET_READ_SIZE));
   }
 
-  GPR_ASSERT(tcp->read_slices->count <= MAX_WSABUF_COUNT);
+  CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
   for (i = 0; i < tcp->read_slices->count; i++) {
     buffers[i].len = (ULONG)GRPC_SLICE_LENGTH(
         tcp->read_slices->slices[i]);  // we know slice size fits in 32bit.
@@ -318,7 +314,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_winsocket_callback_info* info = &handle->write_info;
   grpc_closure* cb;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_INFO, "TCP:%p on_write", tcp);
   }
 
@@ -331,7 +327,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
-      GPR_ASSERT(info->bytes_transferred <= tcp->write_slices->length);
+      CHECK(info->bytes_transferred <= tcp->write_slices->length);
     }
   }
 
@@ -354,14 +350,13 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   WSABUF* buffers = local_buffers;
   size_t len, async_buffers_offset = 0;
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
-      gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
     size_t i;
     for (i = 0; i < slices->count; i++) {
       char* data =
           grpc_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp, tcp->peer_string.c_str(),
-              data);
+      VLOG(2) << "WRITE " << tcp << " (peer=" << tcp->peer_string
+              << "): " << data;
       gpr_free(data);
     }
   }
@@ -369,16 +364,15 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION, cb,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_REFERENCING("TCP socket is shutting down",
-                                          &tcp->shutdown_error, 1),
-            grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE));
+        grpc_error_set_int(GRPC_ERROR_CREATE("TCP socket is shutting down"),
+                           grpc_core::StatusIntProperty::kRpcStatus,
+                           GRPC_STATUS_UNAVAILABLE));
     return;
   }
 
   tcp->write_cb = cb;
   tcp->write_slices = slices;
-  GPR_ASSERT(tcp->write_slices->count <= UINT_MAX);
+  CHECK(tcp->write_slices->count <= UINT_MAX);
   if (tcp->write_slices->count > GPR_ARRAY_SIZE(local_buffers)) {
     buffers = (WSABUF*)gpr_malloc(sizeof(WSABUF) * tcp->write_slices->count);
     allocated = buffers;
@@ -386,7 +380,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   for (i = 0; i < tcp->write_slices->count; i++) {
     len = GRPC_SLICE_LENGTH(tcp->write_slices->slices[i]);
-    GPR_ASSERT(len <= ULONG_MAX);
+    CHECK(len <= ULONG_MAX);
     buffers[i].len = (ULONG)len;
     buffers[i].buf = (char*)GRPC_SLICE_START_PTR(tcp->write_slices->slices[i]);
   }
@@ -477,21 +471,14 @@ static void win_delete_from_pollset_set(grpc_endpoint* /* ep */,
 // we're not going to protect against these. However the IO Completion Port
 // callback will happen from another thread, so we need to protect against
 // concurrent access of the data structure in that regard.
-static void win_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
+static void win_destroy(grpc_endpoint* ep) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   gpr_mu_lock(&tcp->mu);
   // At that point, what may happen is that we're already inside the IOCP
   // callback. See the comments in on_read and on_write.
-  if (!tcp->shutting_down) {
-    tcp->shutting_down = 1;
-    tcp->shutdown_error = why;
-  }
+  tcp->shutting_down = 1;
   grpc_winsocket_shutdown(tcp->socket);
   gpr_mu_unlock(&tcp->mu);
-}
-
-static void win_destroy(grpc_endpoint* ep) {
-  grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);
   TCP_UNREF(tcp, "destroy");
 }
@@ -515,7 +502,6 @@ static grpc_endpoint_vtable vtable = {win_read,
                                       win_add_to_pollset,
                                       win_add_to_pollset_set,
                                       win_delete_from_pollset_set,
-                                      win_shutdown,
                                       win_destroy,
                                       win_get_peer,
                                       win_get_local_address,

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

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/timer_manager.h"
 
 grpc_timer_vtable* grpc_timer_impl;

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

@@ -19,11 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TIMER_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -16,23 +16,21 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/time.h"
@@ -41,6 +39,8 @@
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_heap.h"
+#include "src/core/util/spinlock.h"
+#include "src/core/util/useful.h"
 
 #define INVALID_HEAP_INDEX 0xffffffffu
 
@@ -48,9 +48,6 @@
 #define MIN_QUEUE_WINDOW_DURATION 0.01
 #define MAX_QUEUE_WINDOW_DURATION 1.0
 
-grpc_core::TraceFlag grpc_timer_trace(false, "timer");
-grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
-
 // A "timer shard". Contains a 'heap' and a 'list' of timers. All timers with
 // deadlines earlier than 'queue_deadline_cap' are maintained in the heap and
 // others are maintained in the list (unordered). This helps to keep the number
@@ -121,7 +118,7 @@ static bool is_in_ht(grpc_timer* t) {
 }
 
 static void add_to_ht(grpc_timer* t) {
-  GPR_ASSERT(!t->hash_table_next);
+  CHECK(!t->hash_table_next);
   size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
 
   gpr_mu_lock(&g_hash_mu[i]);
@@ -337,7 +334,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   timer->hash_table_next = nullptr;
 #endif
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG, "TIMER %p: SET %" PRId64 " now %" PRId64 " call %p[%p]",
             timer, deadline.milliseconds_after_process_epoch(),
             grpc_core::Timestamp::Now().milliseconds_after_process_epoch(),
@@ -373,7 +370,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
     timer->heap_index = INVALID_HEAP_INDEX;
     list_join(&shard->list, timer);
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG,
             "  .. add to shard %d with queue_deadline_cap=%" PRId64
             " => is_first_timer=%s",
@@ -396,7 +393,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   // grpc_timer_check.
   if (is_first_timer) {
     gpr_mu_lock(&g_shared_mutables.mu);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
       gpr_log(GPR_DEBUG, "  .. old shard min_deadline=%" PRId64,
               shard->min_deadline.milliseconds_after_process_epoch());
     }
@@ -438,7 +435,7 @@ static void timer_cancel(grpc_timer* timer) {
 
   timer_shard* shard = &g_shards[grpc_core::HashPointer(timer, g_num_shards)];
   gpr_mu_lock(&shard->mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG, "TIMER %p: CANCEL pending=%s", timer,
             timer->pending ? "true" : "false");
   }
@@ -479,7 +476,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
       std::max(now, shard->queue_deadline_cap) +
       grpc_core::Duration::FromSecondsAsDouble(deadline_delta);
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     gpr_log(GPR_DEBUG, "  .. shard[%d]->queue_deadline_cap --> %" PRId64,
             static_cast<int>(shard - g_shards),
             shard->queue_deadline_cap.milliseconds_after_process_epoch());
@@ -491,7 +488,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
             timer->deadline);
 
     if (timer_deadline < shard->queue_deadline_cap) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
         gpr_log(GPR_DEBUG, "  .. add timer with deadline %" PRId64 " to heap",
                 timer_deadline.milliseconds_after_process_epoch());
       }
@@ -508,7 +505,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
 static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
   grpc_timer* timer;
   for (;;) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_DEBUG, "  .. shard[%d]: heap_empty=%s",
               static_cast<int>(shard - g_shards),
               grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
@@ -521,14 +518,14 @@ static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
     auto timer_deadline =
         grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
             timer->deadline);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_DEBUG,
               "  .. check top timer deadline=%" PRId64 " now=%" PRId64,
               timer_deadline.milliseconds_after_process_epoch(),
               now.milliseconds_after_process_epoch());
     }
     if (timer_deadline > now) return nullptr;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
       gpr_log(GPR_DEBUG, "TIMER %p: FIRE %" PRId64 "ms late", timer,
               (now - timer_deadline).millis());
     }
@@ -552,7 +549,7 @@ static size_t pop_timers(timer_shard* shard, grpc_core::Timestamp now,
   }
   *new_min_deadline = compute_min_deadline(shard);
   gpr_mu_unlock(&shard->mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     gpr_log(GPR_DEBUG, "  .. shard[%d] popped %" PRIdPTR,
             static_cast<int>(shard - g_shards), n);
   }
@@ -591,7 +588,7 @@ static grpc_timer_check_result run_some_expired_timers(
     gpr_mu_lock(&g_shared_mutables.mu);
     result = GRPC_TIMERS_CHECKED_AND_EMPTY;
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(
           GPR_DEBUG, "  .. shard[%d]->min_deadline = %" PRId64,
           static_cast<int>(g_shard_queue[0] - g_shards),
@@ -610,7 +607,7 @@ static grpc_timer_check_result run_some_expired_timers(
         result = GRPC_TIMERS_FIRED;
       }
 
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
         gpr_log(
             GPR_DEBUG,
             "  .. result --> %d"
@@ -670,7 +667,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
     if (next != nullptr) {
       *next = std::min(*next, min_timer);
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_DEBUG, "TIMER CHECK SKIP: now=%" PRId64 " min_timer=%" PRId64,
               now.milliseconds_after_process_epoch(),
               min_timer.milliseconds_after_process_epoch());
@@ -684,7 +681,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
           : GRPC_ERROR_CREATE("Shutting down timer system");
 
   // tracing
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     std::string next_str;
     if (next == nullptr) {
       next_str = "NULL";
@@ -712,7 +709,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
   grpc_timer_check_result r =
       run_some_expired_timers(now, next, shutdown_error);
   // tracing
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     std::string next_str;
     if (next == nullptr) {
       next_str = "NULL";

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

@@ -20,7 +20,6 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_GENERIC_H
 
 #include <grpc/support/port_platform.h>
-
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -16,16 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer_heap.h"
 
 #include <string.h>
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/useful.h"
 
 // Adjusts a heap so as to move a hole at position i closer to the root,
 // until a suitable position is found for element t. Then, copies t into that

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

@@ -16,14 +16,16 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer_manager.h"
 
 #include <inttypes.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/crash.h"
@@ -35,8 +37,6 @@ struct completed_thread {
   completed_thread* next;
 };
 
-extern grpc_core::TraceFlag grpc_timer_check_trace;
-
 // global mutex
 static gpr_mu g_mu;
 // are we multi-threaded
@@ -83,13 +83,11 @@ static void gc_completed_threads(void) {
 }
 
 static void start_timer_thread_and_unlock(void) {
-  GPR_ASSERT(g_threaded);
+  CHECK(g_threaded);
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "Spawn timer thread");
-  }
+  GRPC_TRACE_LOG(timer_check, INFO) << "Spawn timer thread";
   completed_thread* ct =
       static_cast<completed_thread*>(gpr_malloc(sizeof(*ct)));
   ct->thd = grpc_core::Thread("grpc_global_timer", timer_thread, ct);
@@ -123,17 +121,13 @@ static void run_some_timers() {
     // if there's no thread waiting with a timeout, kick an existing untimed
     // waiter so that the next deadline is not missed
     if (!g_has_timed_waiter) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-        gpr_log(GPR_INFO, "kick untimed waiter");
-      }
+      GRPC_TRACE_LOG(timer_check, INFO) << "kick untimed waiter";
       gpr_cv_signal(&g_cv_wait);
     }
     gpr_mu_unlock(&g_mu);
   }
   // without our lock, flush the exec_ctx
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "flush exec_ctx");
-  }
+  GRPC_TRACE_LOG(timer_check, INFO) << "flush exec_ctx";
   grpc_core::ExecCtx::Get()->Flush();
   gpr_mu_lock(&g_mu);
   // garbage collect any threads that are dead
@@ -186,7 +180,7 @@ static bool wait_until(grpc_core::Timestamp next) {
         g_has_timed_waiter = true;
         g_timed_waiter_deadline = next;
 
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
           grpc_core::Duration wait_time = next - grpc_core::Timestamp::Now();
           gpr_log(GPR_INFO, "sleep for a %" PRId64 " milliseconds",
                   wait_time.millis());
@@ -196,14 +190,14 @@ static bool wait_until(grpc_core::Timestamp next) {
       }
     }
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace) &&
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check) &&
         next == grpc_core::Timestamp::InfFuture()) {
-      gpr_log(GPR_INFO, "sleep until kicked");
+      LOG(INFO) << "sleep until kicked";
     }
 
     gpr_cv_wait(&g_cv_wait, &g_mu, next.as_timespec(GPR_CLOCK_MONOTONIC));
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_INFO, "wait ended: was_timed:%d kicked:%d",
               my_timed_waiter_generation == g_timed_waiter_generation,
               g_kicked);
@@ -249,9 +243,8 @@ static void timer_main_loop() {
 
         // Consequently, we can just sleep forever here and be happy at some
         // saved wakeup cycles.
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-          gpr_log(GPR_INFO, "timers not checked: expect another thread to");
-        }
+        GRPC_TRACE_LOG(timer_check, INFO)
+            << "timers not checked: expect another thread to";
         next = grpc_core::Timestamp::InfFuture();
         ABSL_FALLTHROUGH_INTENDED;
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
@@ -275,9 +268,7 @@ static void timer_thread_cleanup(completed_thread* ct) {
   ct->next = g_completed_threads;
   g_completed_threads = ct;
   gpr_mu_unlock(&g_mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "End timer thread");
-  }
+  GRPC_TRACE_LOG(timer_check, INFO) << "End timer thread";
 }
 
 static void timer_thread(void* completed_thread_ptr) {
@@ -316,20 +307,17 @@ void grpc_timer_manager_init(void) {
 
 static void stop_threads(void) {
   gpr_mu_lock(&g_mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "stop timer threads: threaded=%d", g_threaded);
-  }
+  GRPC_TRACE_LOG(timer_check, INFO)
+      << "stop timer threads: threaded=" << g_threaded;
   if (g_threaded) {
     g_threaded = false;
     gpr_cv_broadcast(&g_cv_wait);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-      gpr_log(GPR_INFO, "num timer threads: %d", g_thread_count);
-    }
+    GRPC_TRACE_LOG(timer_check, INFO)
+        << "num timer threads: " << g_thread_count;
     while (g_thread_count > 0) {
       gpr_cv_wait(&g_cv_shutdown, &g_mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-        gpr_log(GPR_INFO, "num timer threads: %d", g_thread_count);
-      }
+      GRPC_TRACE_LOG(timer_check, INFO)
+          << "num timer threads: " << g_thread_count;
       gc_completed_threads();
     }
   }

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

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TIMER_MANAGER_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_MANAGER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdbool.h>
 
+#include <grpc/support/port_platform.h>
+
 // Timer Manager tries to keep only one thread waiting for the next timeout at
 // all times, and thus effectively preventing the thundering herd problem.
 

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

@@ -33,23 +33,24 @@
 #include <sys/un.h>
 #endif  // GPR_WINDOWS
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/useful.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
 #ifdef GPR_WINDOWS
   grpc_core::Crash("AF_UNIX socket pairs are not supported on Windows");
 #else
-  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
 #endif
 }