grpc 1.63.0 → 1.66.0

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/log/log.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,11 +334,11 @@ 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)) {
-    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(),
-            closure, closure->cb);
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
+    VLOG(2) << "TIMER " << timer << ": SET "
+            << deadline.milliseconds_after_process_epoch() << " now "
+            << grpc_core::Timestamp::Now().milliseconds_after_process_epoch()
+            << " call " << closure << "[" << closure->cb << "]";
   }
 
   if (!g_shared_mutables.initialized) {
@@ -373,13 +370,11 @@ 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)) {
-    gpr_log(GPR_DEBUG,
-            "  .. add to shard %d with queue_deadline_cap=%" PRId64
-            " => is_first_timer=%s",
-            static_cast<int>(shard - g_shards),
-            shard->queue_deadline_cap.milliseconds_after_process_epoch(),
-            is_first_timer ? "true" : "false");
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
+    VLOG(2) << "  .. add to shard " << (shard - g_shards)
+            << " with queue_deadline_cap="
+            << shard->queue_deadline_cap.milliseconds_after_process_epoch()
+            << " => is_first_timer=" << (is_first_timer ? "true" : "false");
   }
   gpr_mu_unlock(&shard->mu);
 
@@ -396,9 +391,9 @@ 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)) {
-      gpr_log(GPR_DEBUG, "  .. old shard min_deadline=%" PRId64,
-              shard->min_deadline.milliseconds_after_process_epoch());
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
+      VLOG(2) << "  .. old shard min_deadline="
+              << shard->min_deadline.milliseconds_after_process_epoch();
     }
     if (deadline < shard->min_deadline) {
       grpc_core::Timestamp old_min_deadline = g_shard_queue[0]->min_deadline;
@@ -438,9 +433,9 @@ 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)) {
-    gpr_log(GPR_DEBUG, "TIMER %p: CANCEL pending=%s", timer,
-            timer->pending ? "true" : "false");
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
+    VLOG(2) << "TIMER " << timer
+            << ": CANCEL pending=" << (timer->pending ? "true" : "false");
   }
 
   if (timer->pending) {
@@ -479,10 +474,10 @@ 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)) {
-    gpr_log(GPR_DEBUG, "  .. shard[%d]->queue_deadline_cap --> %" PRId64,
-            static_cast<int>(shard - g_shards),
-            shard->queue_deadline_cap.milliseconds_after_process_epoch());
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+    VLOG(2) << "  .. shard[" << (shard - g_shards)
+            << "]->queue_deadline_cap --> "
+            << shard->queue_deadline_cap.milliseconds_after_process_epoch();
   }
   for (timer = shard->list.next; timer != &shard->list; timer = next) {
     next = timer->next;
@@ -491,9 +486,10 @@ 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)) {
-        gpr_log(GPR_DEBUG, "  .. add timer with deadline %" PRId64 " to heap",
-                timer_deadline.milliseconds_after_process_epoch());
+      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+        VLOG(2) << "  .. add timer with deadline "
+                << timer_deadline.milliseconds_after_process_epoch()
+                << " to heap";
       }
       list_remove(timer);
       grpc_timer_heap_add(&shard->heap, timer);
@@ -508,10 +504,9 @@ 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)) {
-      gpr_log(GPR_DEBUG, "  .. shard[%d]: heap_empty=%s",
-              static_cast<int>(shard - g_shards),
-              grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+      VLOG(2) << "  .. shard[" << (shard - g_shards) << "]: heap_empty="
+              << (grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
     }
     if (grpc_timer_heap_is_empty(&shard->heap)) {
       if (now < shard->queue_deadline_cap) return nullptr;
@@ -521,16 +516,15 @@ 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)) {
-      gpr_log(GPR_DEBUG,
-              "  .. check top timer deadline=%" PRId64 " now=%" PRId64,
-              timer_deadline.milliseconds_after_process_epoch(),
-              now.milliseconds_after_process_epoch());
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+      VLOG(2) << "  .. check top timer deadline="
+              << timer_deadline.milliseconds_after_process_epoch()
+              << " now=" << now.milliseconds_after_process_epoch();
     }
     if (timer_deadline > now) return nullptr;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
-      gpr_log(GPR_DEBUG, "TIMER %p: FIRE %" PRId64 "ms late", timer,
-              (now - timer_deadline).millis());
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
+      VLOG(2) << "TIMER " << timer << ": FIRE "
+              << (now - timer_deadline).millis() << "ms late";
     }
     timer->pending = false;
     grpc_timer_heap_pop(&shard->heap);
@@ -552,9 +546,8 @@ 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)) {
-    gpr_log(GPR_DEBUG, "  .. shard[%d] popped %" PRIdPTR,
-            static_cast<int>(shard - g_shards), n);
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+    VLOG(2) << "  .. shard[" << (shard - g_shards) << "] popped " << n;
   }
   return n;
 }
@@ -591,11 +584,11 @@ 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)) {
-      gpr_log(
-          GPR_DEBUG, "  .. shard[%d]->min_deadline = %" PRId64,
-          static_cast<int>(g_shard_queue[0] - g_shards),
-          g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch());
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+      VLOG(2)
+          << "  .. shard[" << (g_shard_queue[0] - g_shards)
+          << "]->min_deadline = "
+          << g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch();
     }
 
     while (g_shard_queue[0]->min_deadline < now ||
@@ -610,16 +603,13 @@ static grpc_timer_check_result run_some_expired_timers(
         result = GRPC_TIMERS_FIRED;
       }
 
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-        gpr_log(
-            GPR_DEBUG,
-            "  .. result --> %d"
-            ", shard[%d]->min_deadline %" PRId64 " --> %" PRId64
-            ", now=%" PRId64,
-            result, static_cast<int>(g_shard_queue[0] - g_shards),
-            g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch(),
-            new_min_deadline.milliseconds_after_process_epoch(),
-            now.milliseconds_after_process_epoch());
+      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+        VLOG(2)
+            << "  .. result --> " << result << ", shard["
+            << (g_shard_queue[0] - g_shards) << "]->min_deadline "
+            << g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch()
+            << " --> " << new_min_deadline.milliseconds_after_process_epoch()
+            << ", now=" << now.milliseconds_after_process_epoch();
       }
 
       // An grpc_timer_init() on the shard could intervene here, adding a new
@@ -670,10 +660,10 @@ 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)) {
-      gpr_log(GPR_DEBUG, "TIMER CHECK SKIP: now=%" PRId64 " min_timer=%" PRId64,
-              now.milliseconds_after_process_epoch(),
-              min_timer.milliseconds_after_process_epoch());
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+      VLOG(2) << "TIMER CHECK SKIP: now="
+              << now.milliseconds_after_process_epoch()
+              << " min_timer=" << min_timer.milliseconds_after_process_epoch();
     }
     return GRPC_TIMERS_CHECKED_AND_EMPTY;
   }
@@ -684,7 +674,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";
@@ -692,34 +682,32 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
       next_str = absl::StrCat(next->milliseconds_after_process_epoch());
     }
 #if GPR_ARCH_64
-    gpr_log(
-        GPR_DEBUG,
-        "TIMER CHECK BEGIN: now=%" PRId64 " next=%s tls_min=%" PRId64
-        " glob_min=%" PRId64,
-        now.milliseconds_after_process_epoch(), next_str.c_str(),
-        min_timer.milliseconds_after_process_epoch(),
-        grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
-            gpr_atm_no_barrier_load((gpr_atm*)(&g_shared_mutables.min_timer)))
-            .milliseconds_after_process_epoch());
+    VLOG(2) << "TIMER CHECK BEGIN: now="
+            << now.milliseconds_after_process_epoch() << " next=" << next_str
+            << " tls_min=" << min_timer.milliseconds_after_process_epoch()
+            << " glob_min="
+            << grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
+                   gpr_atm_no_barrier_load(
+                       (gpr_atm*)(&g_shared_mutables.min_timer)))
+                   .milliseconds_after_process_epoch();
 #else
-    gpr_log(GPR_DEBUG,
-            "TIMER CHECK BEGIN: now=%" PRId64 " next=%s min=%" PRId64,
-            now.milliseconds_after_process_epoch(), next_str.c_str(),
-            min_timer.milliseconds_after_process_epoch());
+    VLOG(2) << "TIMER CHECK BEGIN: now="
+            << now.milliseconds_after_process_epoch() << " next=" << next_str
+            << " min=" << min_timer.milliseconds_after_process_epoch();
 #endif
   }
   // actual code
   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";
     } else {
       next_str = absl::StrCat(next->milliseconds_after_process_epoch());
     }
-    gpr_log(GPR_DEBUG, "TIMER CHECK END: r=%d; next=%s", r, next_str.c_str());
+    VLOG(2) << "TIMER CHECK END: r=" << r << "; next=" << next_str.c_str();
   }
   return r;
 }

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,15 @@
 //
 //
 
-#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 +36,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 +82,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 +120,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,27 +179,26 @@ 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());
+          LOG(INFO) << "sleep for a " << wait_time.millis() << " milliseconds";
         }
       } else {  // g_timed_waiter == true && next >= g_timed_waiter_deadline
         next = grpc_core::Timestamp::InfFuture();
       }
     }
 
-    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)) {
-      gpr_log(GPR_INFO, "wait ended: was_timed:%d kicked:%d",
-              my_timed_waiter_generation == g_timed_waiter_generation,
-              g_kicked);
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
+      LOG(INFO) << "wait ended: was_timed:"
+                << (my_timed_waiter_generation == g_timed_waiter_generation)
+                << " kicked:" << g_kicked;
     }
     // if this was the timed waiter, then we need to check timers, and flag
     // that there's now no timed waiter... we'll look for a replacement if
@@ -249,9 +241,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 +266,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 +305,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
 }
 

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H
 #define GRPC_SRC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -24,6 +24,8 @@
 
 #include <string>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -32,7 +34,7 @@ void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   // TODO: Either implement this for the non-Unix socket case or make
   // sure that it is never called in any such case. Until then, leave an
   // assertion to notify if this gets called inadvertently
-  GPR_ASSERT(0);
+  CHECK(0);
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>

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

@@ -15,10 +15,10 @@
 // limitations under the License.
 //
 //
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/vsock.h"
 
+#include <grpc/support/port_platform.h>
+
 #ifdef GRPC_HAVE_VSOCK
 
 #include <string.h>
@@ -31,10 +31,10 @@
 #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/transport/error_utils.h"
+#include "src/core/util/useful.h"
 
 absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
     absl::string_view name) {

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
 #define GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -26,7 +26,7 @@
 #include <string.h>
 #include <unistd.h>
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/strerror.h"
@@ -38,8 +38,8 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   int pipefd[2];
   int r = pipe(pipefd);
   if (0 != r) {
-    gpr_log(GPR_ERROR, "pipe creation failed (%d): %s", errno,
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "pipe creation failed (" << errno
+               << "): " << grpc_core::StrError(errno);
     return GRPC_OS_ERROR(errno, "pipe");
   }
   grpc_error_handle err;

data/src/core/lib/matchers/matchers.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/matchers/matchers.h"
 
 #include <utility>
@@ -25,6 +23,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 //

data/src/core/lib/matchers/matchers.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_MATCHERS_MATCHERS_H
 #define GRPC_SRC_CORE_LIB_MATCHERS_MATCHERS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <memory>
@@ -27,6 +25,8 @@
 #include "absl/types/optional.h"
 #include "re2/re2.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 class StringMatcher {