grpc 1.63.0 → 1.66.0

data/src/core/{lib/gpr → util}/posix/log.cc

@@ -38,10 +38,6 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/examine_stack.h"
 
-int gpr_should_log_stacktrace(gpr_log_severity severity);
-
-static intptr_t sys_gettid(void) { return (intptr_t)pthread_self(); }
-
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
   // Avoid message construction if gpr_log_message won't log
@@ -70,42 +66,4 @@ void gpr_log(const char* file, int line, gpr_log_severity severity,
   gpr_free(allocated);
 }
 
-void gpr_platform_log(gpr_log_func_args* args) {
-  const char* final_slash;
-  const char* display_file;
-  char time_buffer[64];
-  time_t timer;
-  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
-  struct tm tm;
-
-  timer = (time_t)now.tv_sec;
-  final_slash = strrchr(args->file, '/');
-  if (final_slash == nullptr)
-    display_file = args->file;
-  else
-    display_file = final_slash + 1;
-
-  if (!localtime_r(&timer, &tm)) {
-    strcpy(time_buffer, "error:localtime");
-  } else if (0 ==
-             strftime(time_buffer, sizeof(time_buffer), "%m%d %H:%M:%S", &tm)) {
-    strcpy(time_buffer, "error:strftime");
-  }
-
-  std::string prefix = absl::StrFormat(
-      "%s%s.%09d %7" PRIdPTR " %s:%d]", gpr_log_severity_string(args->severity),
-      time_buffer, (int)(now.tv_nsec), sys_gettid(), display_file, args->line);
-
-  absl::optional<std::string> stack_trace =
-      gpr_should_log_stacktrace(args->severity)
-          ? grpc_core::GetCurrentStackTrace()
-          : absl::nullopt;
-  if (stack_trace) {
-    fprintf(stderr, "%-70s %s\n%s\n", prefix.c_str(), args->message,
-            stack_trace->c_str());
-  } else {
-    fprintf(stderr, "%-70s %s\n", prefix.c_str(), args->message);
-  }
-}
-
 #endif  // defined(GPR_POSIX_LOG)

data/src/core/{lib/gpr → util}/posix/sync.cc

@@ -24,6 +24,8 @@
 #include <errno.h>
 #include <time.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -33,36 +35,36 @@
 
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_init(&mu->mutex, nullptr) == 0);
+  CHECK_EQ(pthread_mutex_init(&mu->mutex, nullptr), 0);
   mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
-  GPR_ASSERT(mu->leak_checker != nullptr);
+  CHECK_NE(mu->leak_checker, nullptr);
 #else
-  GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0);
+  CHECK_EQ(pthread_mutex_init(mu, nullptr), 0);
 #endif
 }
 
 void gpr_mu_destroy(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_destroy(&mu->mutex) == 0);
+  CHECK_EQ(pthread_mutex_destroy(&mu->mutex), 0);
   free(mu->leak_checker);
 #else
-  GPR_ASSERT(pthread_mutex_destroy(mu) == 0);
+  CHECK_EQ(pthread_mutex_destroy(mu), 0);
 #endif
 }
 
 void gpr_mu_lock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_lock(&mu->mutex) == 0);
+  CHECK_EQ(pthread_mutex_lock(&mu->mutex), 0);
 #else
-  GPR_ASSERT(pthread_mutex_lock(mu) == 0);
+  CHECK_EQ(pthread_mutex_lock(mu), 0);
 #endif
 }
 
 void gpr_mu_unlock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_unlock(&mu->mutex) == 0);
+  CHECK_EQ(pthread_mutex_unlock(&mu->mutex), 0);
 #else
-  GPR_ASSERT(pthread_mutex_unlock(mu) == 0);
+  CHECK_EQ(pthread_mutex_unlock(mu), 0);
 #endif
 }
 
@@ -73,7 +75,7 @@ int gpr_mu_trylock(gpr_mu* mu) {
 #else
   err = pthread_mutex_trylock(mu);
 #endif
-  GPR_ASSERT(err == 0 || err == EBUSY);
+  CHECK(err == 0 || err == EBUSY);
   return err == 0;
 }
 
@@ -81,26 +83,26 @@ int gpr_mu_trylock(gpr_mu* mu) {
 
 void gpr_cv_init(gpr_cv* cv) {
   pthread_condattr_t attr;
-  GPR_ASSERT(pthread_condattr_init(&attr) == 0);
+  CHECK_EQ(pthread_condattr_init(&attr), 0);
 #if GPR_LINUX
-  GPR_ASSERT(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0);
+  CHECK_EQ(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC), 0);
 #endif  // GPR_LINUX
 
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_init(&cv->cond_var, &attr) == 0);
+  CHECK_EQ(pthread_cond_init(&cv->cond_var, &attr), 0);
   cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
-  GPR_ASSERT(cv->leak_checker != nullptr);
+  CHECK_NE(cv->leak_checker, nullptr);
 #else
-  GPR_ASSERT(pthread_cond_init(cv, &attr) == 0);
+  CHECK_EQ(pthread_cond_init(cv, &attr), 0);
 #endif
 }
 
 void gpr_cv_destroy(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_destroy(&cv->cond_var) == 0);
+  CHECK_EQ(pthread_cond_destroy(&cv->cond_var), 0);
   free(cv->leak_checker);
 #else
-  GPR_ASSERT(pthread_cond_destroy(cv) == 0);
+  CHECK_EQ(pthread_cond_destroy(cv), 0);
 #endif
 }
 
@@ -129,30 +131,30 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     err = pthread_cond_timedwait(cv, mu, &abs_deadline_ts);
 #endif
   }
-  GPR_ASSERT(err == 0 || err == ETIMEDOUT || err == EAGAIN);
+  CHECK(err == 0 || err == ETIMEDOUT || err == EAGAIN);
   return err == ETIMEDOUT;
 }
 
 void gpr_cv_signal(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_signal(&cv->cond_var) == 0);
+  CHECK_EQ(pthread_cond_signal(&cv->cond_var), 0);
 #else
-  GPR_ASSERT(pthread_cond_signal(cv) == 0);
+  CHECK_EQ(pthread_cond_signal(cv), 0);
 #endif
 }
 
 void gpr_cv_broadcast(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_broadcast(&cv->cond_var) == 0);
+  CHECK_EQ(pthread_cond_broadcast(&cv->cond_var), 0);
 #else
-  GPR_ASSERT(pthread_cond_broadcast(cv) == 0);
+  CHECK_EQ(pthread_cond_broadcast(cv), 0);
 #endif
 }
 
 //----------------------------------------
 
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
-  GPR_ASSERT(pthread_once(once, init_function) == 0);
+  CHECK_EQ(pthread_once(once, init_function), 0);
 }
 
 #endif  // defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) &&

data/src/core/{lib/gpr → util}/posix/time.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/time_precise.h"
+#include "src/core/util/time_precise.h"
 
 #ifdef GPR_POSIX_TIME
 
@@ -28,6 +28,8 @@
 #ifdef __linux__
 #include <sys/syscall.h>
 #endif
+#include "absl/log/check.h"
+
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
@@ -38,7 +40,8 @@ static struct timespec timespec_from_gpr(gpr_timespec gts) {
   struct timespec rv;
   if (sizeof(time_t) < sizeof(int64_t)) {
     // fine to assert, as this is only used in gpr_sleep_until
-    GPR_ASSERT(gts.tv_sec <= INT32_MAX && gts.tv_sec >= INT32_MIN);
+    CHECK(gts.tv_sec <= INT32_MAX);
+    CHECK(gts.tv_sec >= INT32_MIN);
   }
   rv.tv_sec = static_cast<time_t>(gts.tv_sec);
   rv.tv_nsec = gts.tv_nsec;
@@ -67,7 +70,7 @@ void gpr_time_init(void) { gpr_precise_clock_init(); }
 
 static gpr_timespec now_impl(gpr_clock_type clock_type) {
   struct timespec now;
-  GPR_ASSERT(clock_type != GPR_TIMESPAN);
+  CHECK(clock_type != GPR_TIMESPAN);
   if (clock_type == GPR_CLOCK_PRECISE) {
     gpr_timespec ret;
     gpr_precise_clock_now(&ret);
@@ -87,12 +90,12 @@ gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type) = now_impl;
 
 gpr_timespec gpr_now(gpr_clock_type clock_type) {
   // validate clock type
-  GPR_ASSERT(clock_type == GPR_CLOCK_MONOTONIC ||
-             clock_type == GPR_CLOCK_REALTIME ||
-             clock_type == GPR_CLOCK_PRECISE);
+  CHECK(clock_type == GPR_CLOCK_MONOTONIC || clock_type == GPR_CLOCK_REALTIME ||
+        clock_type == GPR_CLOCK_PRECISE);
   gpr_timespec ts = gpr_now_impl(clock_type);
   // tv_nsecs must be in the range [0, 1e9).
-  GPR_ASSERT(ts.tv_nsec >= 0 && ts.tv_nsec < 1e9);
+  CHECK(ts.tv_nsec >= 0);
+  CHECK(ts.tv_nsec < 1e9);
   return ts;
 }
 

data/src/core/{lib/gpr → util}/posix/tmpfile.cc

@@ -25,14 +25,16 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/tmpfile.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/strerror.h"
+#include "src/core/util/string.h"
+#include "src/core/util/tmpfile.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   FILE* result = nullptr;
@@ -42,18 +44,18 @@ FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   if (tmp_filename != nullptr) *tmp_filename = nullptr;
 
   gpr_asprintf(&filename_template, "/tmp/%s_XXXXXX", prefix);
-  GPR_ASSERT(filename_template != nullptr);
+  CHECK_NE(filename_template, nullptr);
 
   fd = mkstemp(filename_template);
   if (fd == -1) {
-    gpr_log(GPR_ERROR, "mkstemp failed for filename_template %s with error %s.",
-            filename_template, grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "mkstemp failed for filename_template " << filename_template
+               << " with error " << grpc_core::StrError(errno);
     goto end;
   }
   result = fdopen(fd, "w+");
   if (result == nullptr) {
-    gpr_log(GPR_ERROR, "Could not open file %s from fd %d (error = %s).",
-            filename_template, fd, grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "Could not open file " << filename_template << " from fd "
+               << fd << " (error = " << grpc_core::StrError(errno) << ").";
     unlink(filename_template);
     close(fd);
     goto end;

data/src/core/{lib/gpr → util}/spinlock.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPR_SPINLOCK_H
-#define GRPC_SRC_CORE_LIB_GPR_SPINLOCK_H
+#ifndef GRPC_SRC_CORE_UTIL_SPINLOCK_H
+#define GRPC_SRC_CORE_UTIL_SPINLOCK_H
 
 #include <grpc/support/port_platform.h>
 
@@ -50,4 +50,4 @@ struct gpr_spinlock {
   do {                          \
   } while (!gpr_spinlock_trylock((lock)))
 
-#endif  // GRPC_SRC_CORE_LIB_GPR_SPINLOCK_H
+#endif  // GRPC_SRC_CORE_UTIL_SPINLOCK_H

data/src/core/{lib/gpr → util}/string.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/string.h"
+#include "src/core/util/string.h"
 
 #include <ctype.h>
 #include <limits.h>
@@ -34,8 +34,8 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/useful.h"
 
 char* gpr_strdup(const char* src) {
   char* dst;

data/src/core/{lib/gpr → util}/string.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPR_STRING_H
-#define GRPC_SRC_CORE_LIB_GPR_STRING_H
+#ifndef GRPC_SRC_CORE_UTIL_STRING_H
+#define GRPC_SRC_CORE_UTIL_STRING_H
 
 #include <grpc/support/port_platform.h>
 
@@ -109,4 +109,4 @@ void* gpr_memrchr(const void* s, int c, size_t n);
 // Otherwise, it returns false.
 bool gpr_parse_bool_value(const char* value, bool* dst);
 
-#endif  // GRPC_SRC_CORE_LIB_GPR_STRING_H
+#endif  // GRPC_SRC_CORE_UTIL_STRING_H

data/src/core/{lib/gpr → util}/sync.cc

@@ -22,6 +22,8 @@
 
 #include <assert.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -59,11 +61,11 @@ void gpr_event_init(gpr_event* ev) {
 void gpr_event_set(gpr_event* ev, void* value) {
   struct sync_array_s* s = hash(ev);
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(gpr_atm_acq_load(&ev->state) == 0);
+  CHECK_EQ(gpr_atm_acq_load(&ev->state), 0);
   gpr_atm_rel_store(&ev->state, (gpr_atm)value);
   gpr_cv_broadcast(&s->cv);
   gpr_mu_unlock(&s->mu);
-  GPR_ASSERT(value != nullptr);
+  CHECK_NE(value, nullptr);
 }
 
 void* gpr_event_get(gpr_event* ev) {
@@ -102,7 +104,7 @@ void gpr_refn(gpr_refcount* r, int n) {
 
 int gpr_unref(gpr_refcount* r) {
   gpr_atm prior = gpr_atm_full_fetch_add(&r->count, -1);
-  GPR_ASSERT(prior > 0);
+  CHECK_GT(prior, 0);
   return prior == 1;
 }
 

data/src/core/{lib/gpr → util}/time.cc

@@ -24,6 +24,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
@@ -31,7 +33,7 @@
 
 int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
   int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
-  GPR_ASSERT(a.clock_type == b.clock_type);
+  CHECK(a.clock_type == b.clock_type);
   if (cmp == 0 && a.tv_sec != INT64_MAX && a.tv_sec != INT64_MIN) {
     cmp = (a.tv_nsec > b.tv_nsec) - (a.tv_nsec < b.tv_nsec);
   }
@@ -79,7 +81,7 @@ static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units,
   } else if (time_in_units == INT64_MIN) {
     out = gpr_inf_past(type);
   } else {
-    GPR_DEBUG_ASSERT(GPR_NS_PER_SEC % units_per_sec == 0);
+    DCHECK_EQ(GPR_NS_PER_SEC % units_per_sec, 0);
 
     out.tv_sec = time_in_units / units_per_sec;
     out.tv_nsec =
@@ -139,11 +141,11 @@ gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type) {
 gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b) {
   gpr_timespec sum;
   int64_t inc = 0;
-  GPR_ASSERT(b.clock_type == GPR_TIMESPAN);
+  CHECK(b.clock_type == GPR_TIMESPAN);
   // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
   // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
   // as {-3, 5e8, GPR_TIMESPAN}
-  GPR_ASSERT(b.tv_nsec >= 0);
+  CHECK_GE(b.tv_nsec, 0);
   sum.clock_type = a.clock_type;
   sum.tv_nsec = a.tv_nsec + b.tv_nsec;
   if (sum.tv_nsec >= GPR_NS_PER_SEC) {
@@ -177,9 +179,9 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
     // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
     // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
     // as {-3, 5e8, GPR_TIMESPAN}
-    GPR_ASSERT(b.tv_nsec >= 0);
+    CHECK_GE(b.tv_nsec, 0);
   } else {
-    GPR_ASSERT(a.clock_type == b.clock_type);
+    CHECK(a.clock_type == b.clock_type);
     diff.clock_type = GPR_TIMESPAN;
   }
   diff.tv_nsec = a.tv_nsec - b.tv_nsec;
@@ -210,8 +212,8 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
 int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold) {
   int cmp_ab;
 
-  GPR_ASSERT(a.clock_type == b.clock_type);
-  GPR_ASSERT(threshold.clock_type == GPR_TIMESPAN);
+  CHECK(a.clock_type == b.clock_type);
+  CHECK(threshold.clock_type == GPR_TIMESPAN);
 
   cmp_ab = gpr_time_cmp(a, b);
   if (cmp_ab == 0) return 1;

data/src/core/{lib/gpr → util}/time_precise.cc

@@ -25,11 +25,12 @@
 
 #include <algorithm>
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
+
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/time_precise.h"
 
 #ifndef GPR_CYCLE_COUNTER_CUSTOM
 #if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64
@@ -72,7 +73,7 @@ static bool is_fake_clock() {
 }
 
 void gpr_precise_clock_init(void) {
-  gpr_log(GPR_DEBUG, "Calibrating timers");
+  VLOG(2) << "Calibrating timers";
 
 #if GPR_LINUX
   if (read_freq_from_kernel(&cycles_per_second)) {
@@ -110,7 +111,7 @@ void gpr_precise_clock_init(void) {
     last_freq = freq;
   }
   cycles_per_second = last_freq;
-  gpr_log(GPR_DEBUG, "... cycles_per_second = %f\n", cycles_per_second);
+  VLOG(2) << "... cycles_per_second = " << cycles_per_second << "\n";
 }
 
 gpr_timespec gpr_cycle_counter_to_time(gpr_cycle_counter cycles) {

data/src/core/{lib/gpr → util}/time_precise.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPR_TIME_PRECISE_H
-#define GRPC_SRC_CORE_LIB_GPR_TIME_PRECISE_H
+#ifndef GRPC_SRC_CORE_UTIL_TIME_PRECISE_H
+#define GRPC_SRC_CORE_UTIL_TIME_PRECISE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -66,4 +66,4 @@ void gpr_precise_clock_now(gpr_timespec* clk);
 gpr_timespec gpr_cycle_counter_to_time(gpr_cycle_counter cycles);
 gpr_timespec gpr_cycle_counter_sub(gpr_cycle_counter a, gpr_cycle_counter b);
 
-#endif  // GRPC_SRC_CORE_LIB_GPR_TIME_PRECISE_H
+#endif  // GRPC_SRC_CORE_UTIL_TIME_PRECISE_H

data/src/core/{lib/gpr → util}/tmpfile.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPR_TMPFILE_H
-#define GRPC_SRC_CORE_LIB_GPR_TMPFILE_H
+#ifndef GRPC_SRC_CORE_UTIL_TMPFILE_H
+#define GRPC_SRC_CORE_UTIL_TMPFILE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -29,4 +29,4 @@
 // unless an error occurs in which case it will be set to NULL.
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename);
 
-#endif  // GRPC_SRC_CORE_LIB_GPR_TMPFILE_H
+#endif  // GRPC_SRC_CORE_UTIL_TMPFILE_H

data/src/core/{ext/xds → util}/upb_utils.h

@@ -14,10 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_UPB_UTILS_H
-#define GRPC_SRC_CORE_EXT_XDS_UPB_UTILS_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_UTIL_UPB_UTILS_H
+#define GRPC_SRC_CORE_UTIL_UPB_UTILS_H
 
 #include <string>
 
@@ -42,4 +40,4 @@ inline std::string UpbStringToStdString(const upb_StringView& str) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_UPB_UTILS_H
+#endif  // GRPC_SRC_CORE_UTIL_UPB_UTILS_H

data/src/core/{lib/gpr → util}/useful.h

@@ -16,13 +16,15 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPR_USEFUL_H
-#define GRPC_SRC_CORE_LIB_GPR_USEFUL_H
+#ifndef GRPC_SRC_CORE_UTIL_USEFUL_H
+#define GRPC_SRC_CORE_UTIL_USEFUL_H
 
 #include <grpc/support/port_platform.h>
 
 #include <cstddef>
 
+#include "absl/log/check.h"
+#include "absl/numeric/bits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 
@@ -37,16 +39,6 @@ T Clamp(T val, T min, T max) {
   return val;
 }
 
-/// rotl, rotr assume x is unsigned
-template <typename T>
-constexpr T RotateLeft(T x, T n) {
-  return ((x << n) | (x >> (sizeof(x) * 8 - n)));
-}
-template <typename T>
-constexpr T RotateRight(T x, T n) {
-  return ((x >> n) | (x << (sizeof(x) * 8 - n)));
-}
-
 // Set the n-th bit of i
 template <typename T>
 T SetBit(T* i, size_t n) {
@@ -65,43 +57,29 @@ bool GetBit(T i, size_t n) {
   return (i & (T(1) << n)) != 0;
 }
 
-namespace useful_detail {
-inline constexpr uint32_t HexdigitBitcount(uint32_t x) {
-  return (x - ((x >> 1) & 0x77777777) - ((x >> 2) & 0x33333333) -
-          ((x >> 3) & 0x11111111));
-}
-}  // namespace useful_detail
-
-inline constexpr uint32_t BitCount(uint32_t i) {
-  return (((useful_detail::HexdigitBitcount(i) +
-            (useful_detail::HexdigitBitcount(i) >> 4)) &
-           0x0f0f0f0f) %
-          255);
-}
-
-inline constexpr uint32_t BitCount(uint64_t i) {
-  return BitCount(static_cast<uint32_t>(i)) +
-         BitCount(static_cast<uint32_t>(i >> 32));
-}
-
-inline constexpr uint32_t BitCount(uint16_t i) {
-  return BitCount(static_cast<uint32_t>(i));
+#if GRPC_HAS_BUILTIN(__builtin_ctz)
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint32_t i) {
+  DCHECK_NE(i, 0u);  // __builtin_ctz returns undefined behavior for 0
+  return __builtin_ctz(i);
 }
-inline constexpr uint32_t BitCount(uint8_t i) {
-  return BitCount(static_cast<uint32_t>(i));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint64_t i) {
+  DCHECK_NE(i, 0u);  // __builtin_ctz returns undefined behavior for 0
+  return __builtin_ctzll(i);
 }
-inline constexpr uint32_t BitCount(int64_t i) {
-  return BitCount(static_cast<uint64_t>(i));
+#else
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint32_t i) {
+  DCHECK_NE(i, 0);  // __builtin_ctz returns undefined behavior for 0
+  return absl::popcount((i & -i) - 1);
 }
-inline constexpr uint32_t BitCount(int32_t i) {
-  return BitCount(static_cast<uint32_t>(i));
-}
-inline constexpr uint32_t BitCount(int16_t i) {
-  return BitCount(static_cast<uint16_t>(i));
-}
-inline constexpr uint32_t BitCount(int8_t i) {
-  return BitCount(static_cast<uint8_t>(i));
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
+    uint64_t i) {
+  DCHECK_NE(i, 0);  // __builtin_ctz returns undefined behavior for 0
+  return absl::popcount((i & -i) - 1);
 }
+#endif
 
 // This function uses operator< to implement a qsort-style comparison, whereby:
 // if a is smaller than b, a number smaller than 0 is returned.
@@ -163,7 +141,7 @@ inline int64_t SaturatingAdd(int64_t a, int64_t b) {
 }
 
 inline uint32_t MixHash32(uint32_t a, uint32_t b) {
-  return RotateLeft(a, 2u) ^ b;
+  return absl::rotl(a, 2u) ^ b;
 }
 
 inline uint32_t RoundUpToPowerOf2(uint32_t v) {
@@ -177,8 +155,25 @@ inline uint32_t RoundUpToPowerOf2(uint32_t v) {
   return v;
 }
 
+// Return a value with only the lowest bit left on.
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint8_t LowestOneBit(uint8_t x) {
+  return x & -x;
+}
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint16_t LowestOneBit(uint16_t x) {
+  return x & -x;
+}
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t LowestOneBit(uint32_t x) {
+  return x & -x;
+}
+
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint64_t LowestOneBit(uint64_t x) {
+  return x & -x;
+}
+
 }  // namespace grpc_core
 
 #define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))
 
-#endif  // GRPC_SRC_CORE_LIB_GPR_USEFUL_H
+#endif  // GRPC_SRC_CORE_UTIL_USEFUL_H