grpc 1.65.1 → 1.66.0.pre3

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -22,7 +22,6 @@
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -49,7 +48,8 @@ WinSocket::WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept
 
 WinSocket::~WinSocket() {
   CHECK(is_shutdown_.load());
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p destroyed", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WinSocket::" << this << " destroyed";
 }
 
 SOCKET WinSocket::raw_socket() { return socket_; }
@@ -57,8 +57,8 @@ SOCKET WinSocket::raw_socket() { return socket_; }
 void WinSocket::Shutdown() {
   // if already shutdown, return early. Otherwise, set the shutdown flag.
   if (is_shutdown_.exchange(true)) {
-    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p already shutting down",
-                                     this);
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << "WinSocket::" << this << " already shutting down";
     return;
   }
   // Grab the function pointer for DisconnectEx for that specific socket.
@@ -71,7 +71,8 @@ void WinSocket::Shutdown() {
                         &ioctl_num_bytes, NULL, NULL);
   if (status != 0) {
     char* utf8_message = gpr_format_message(WSAGetLastError());
-    LOG(INFO) << "Unable to retrieve DisconnectEx pointer : " << utf8_message;
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << "Unable to retrieve DisconnectEx pointer : " << utf8_message;
     gpr_free(utf8_message);
   } else if (DisconnectEx(socket_, NULL, 0, 0) == FALSE) {
     auto last_error = WSAGetLastError();
@@ -79,19 +80,21 @@ void WinSocket::Shutdown() {
     // error, and log all others.
     if (last_error != WSAENOTCONN) {
       char* utf8_message = gpr_format_message(last_error);
-      LOG(INFO) << "DisconnectEx failed: " << utf8_message;
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "DisconnectEx failed: " << utf8_message;
       gpr_free(utf8_message);
     }
   }
   closesocket(socket_);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p socket closed", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WinSocket::" << this << " socket closed";
 }
 
 void WinSocket::Shutdown(const grpc_core::DebugLocation& location,
                          absl::string_view reason) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
-      "WinSocket::%p Shut down from %s:%d. Reason: %s", this, location.file(),
-      location.line(), reason.data());
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WinSocket::" << this << " Shut down from " << location.file() << ":"
+      << location.line() << ". Reason: " << reason.data();
   Shutdown();
 }
 
@@ -170,10 +173,11 @@ void WinSocket::OpState::GetOverlappedResult(SOCKET sock) {
 bool WinSocket::IsShutdown() { return is_shutdown_.load(); }
 
 WinSocket::OpState* WinSocket::GetOpInfoForOverlapped(OVERLAPPED* overlapped) {
-  GRPC_EVENT_ENGINE_POLLER_TRACE(
-      "WinSocket::%p looking for matching OVERLAPPED::%p. "
-      "read(%p) write(%p)",
-      this, overlapped, &read_info_.overlapped_, &write_info_.overlapped_);
+  GRPC_TRACE_LOG(event_engine_poller, INFO)
+      << "WinSocket::" << this
+      << " looking for matching OVERLAPPED::" << overlapped << ". read("
+      << &read_info_.overlapped_ << ") write(" << &write_info_.overlapped_
+      << ")";
   if (overlapped == &read_info_.overlapped_) return &read_info_;
   if (overlapped == &write_info_.overlapped_) return &write_info_;
   return nullptr;

data/src/core/lib/event_engine/windows/windows_endpoint.cc

@@ -18,6 +18,7 @@
 #include "absl/cleanup/cleanup.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -26,7 +27,6 @@
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/status_helper.h"
@@ -42,8 +42,8 @@ constexpr int kMaxWSABUFCount = 16;
 void DumpSliceBuffer(SliceBuffer* buffer, absl::string_view context_string) {
   for (size_t i = 0; i < buffer->Count(); i++) {
     auto str = buffer->MutableSliceAt(i).as_string_view();
-    gpr_log(GPR_INFO, "%s: %.*s", context_string.data(), str.length(),
-            str.data());
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << context_string << ": " << str;
   }
 }
 
@@ -74,11 +74,12 @@ WindowsEndpoint::WindowsEndpoint(
 
 WindowsEndpoint::~WindowsEndpoint() {
   io_state_->socket->Shutdown(DEBUG_LOCATION, "~WindowsEndpoint");
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("~WindowsEndpoint::%p", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO) << "~WindowsEndpoint::" << this;
 }
 
 void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", endpoint);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << endpoint << " reading";
   if (socket->IsShutdown()) {
     socket->read_info()->SetErrorStatus(
         absl::InternalError("Socket is shutting down."));
@@ -148,7 +149,8 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
 
 bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
                             SliceBuffer* data, const WriteArgs* /* args */) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p writing", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << this << " writing";
   if (io_state_->socket->IsShutdown()) {
     io_state_->thread_pool->Run(
         [on_writable = std::move(on_writable)]() mutable {
@@ -159,8 +161,9 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (GRPC_TRACE_FLAG_ENABLED(event_engine_endpoint_data)) {
     for (size_t i = 0; i < data->Count(); i++) {
       auto str = data->RefSlice(i).as_string_view();
-      gpr_log(GPR_INFO, "WindowsEndpoint::%p WRITE (peer=%s): %.*s", this,
-              peer_address_string_.c_str(), str.length(), str.data());
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "WindowsEndpoint::" << this
+          << " WRITE (peer=" << peer_address_string_ << "): " << str;
     }
   }
   CHECK(data->Count() <= UINT_MAX);
@@ -278,8 +281,8 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   // Deletes the shared_ptr when this closure returns
   // Note that the endpoint may have already been destroyed.
   auto io_state = std::move(io_state_);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Read Event",
-                                   io_state->endpoint);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << io_state->endpoint << " Handling Read Event";
   const auto result = io_state->socket->read_info()->result();
   if (!result.error_status.ok()) {
     buffer_->Clear();
@@ -339,8 +342,8 @@ void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
 void WindowsEndpoint::HandleWriteClosure::Run() {
   // Deletes the shared_ptr when this closure returns
   auto io_state = std::move(io_state_);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Write Event",
-                                   io_state->endpoint);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << io_state->endpoint << " Handling Write Event";
   const auto result = io_state->socket->write_info()->result();
   if (!result.error_status.ok()) {
     buffer_->Clear();

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -36,7 +36,6 @@
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/grpc_polled_fd_windows.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
@@ -190,9 +189,8 @@ struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
   EventEngine::TaskHandle handle;
 
   void Run() override {
-    GRPC_EVENT_ENGINE_TRACE(
-        "WindowsEventEngine:%p executing callback:%s", engine,
-        HandleToString<EventEngine::TaskHandle>(handle).c_str());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "WindowsEventEngine:" << engine << " executing callback:" << handle;
     {
       grpc_core::MutexLock lock(&engine->task_mu_);
       engine->known_handles_.erase(handle);
@@ -214,16 +212,15 @@ WindowsEventEngine::WindowsEventEngine()
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
-  GRPC_EVENT_ENGINE_TRACE("~WindowsEventEngine::%p", this);
+  GRPC_TRACE_LOG(event_engine, INFO) << "~WindowsEventEngine::" << this;
   {
     task_mu_.Lock();
     if (!known_handles_.empty()) {
       if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
         for (auto handle : known_handles_) {
-          gpr_log(GPR_ERROR,
-                  "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
-                  this,
-                  HandleToString<EventEngine::TaskHandle>(handle).c_str());
+          LOG(ERROR) << "WindowsEventEngine:" << this
+                     << " uncleared TaskHandle at shutdown:"
+                     << HandleToString<EventEngine::TaskHandle>(handle);
         }
       }
       // Allow a small grace period for timers to be run before shutting down.
@@ -231,8 +228,8 @@ WindowsEventEngine::~WindowsEventEngine() {
           timer_manager_.Now() + grpc_core::Duration::FromSecondsAsDouble(10);
       while (!known_handles_.empty() && timer_manager_.Now() < deadline) {
         if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
-          GRPC_LOG_EVERY_N_SEC(1, GPR_DEBUG, "Waiting for timers. %d remaining",
-                               known_handles_.size());
+          VLOG_EVERY_N_SEC(2, 1) << "Waiting for timers. "
+                                 << known_handles_.size() << " remaining";
         }
         task_mu_.Unlock();
         absl::SleepFor(absl::Milliseconds(200));
@@ -253,9 +250,8 @@ WindowsEventEngine::~WindowsEventEngine() {
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
   grpc_core::MutexLock lock(&task_mu_);
   if (!known_handles_.contains(handle)) return false;
-  GRPC_EVENT_ENGINE_TRACE(
-      "WindowsEventEngine::%p cancelling %s", this,
-      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "WindowsEventEngine::" << this << " cancelling " << handle;
   auto* cd = reinterpret_cast<TimerClosure*>(handle.keys[0]);
   bool r = timer_manager_.TimerCancel(&cd->timer);
   known_handles_.erase(handle);
@@ -292,9 +288,8 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
   grpc_core::MutexLock lock(&task_mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE(
-      "WindowsEventEngine:%p scheduling callback:%s", this,
-      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "WindowsEventEngine:" << this << " scheduling callback:" << handle;
   timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }
@@ -326,21 +321,24 @@ void WindowsEventEngine::WindowsDNSResolver::LookupTXT(
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 WindowsEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& options) {
+  if (ShouldUseAresDnsResolver()) {
 #if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
-  auto ares_resolver = AresResolver::CreateAresResolver(
-      options.dns_server,
-      std::make_unique<GrpcPolledFdFactoryWindows>(poller()),
-      shared_from_this());
-  if (!ares_resolver.ok()) {
-    return ares_resolver.status();
+    GRPC_TRACE_LOG(event_engine_dns, INFO)
+        << "WindowsEventEngine::" << this << " creating AresResolver";
+    auto ares_resolver = AresResolver::CreateAresResolver(
+        options.dns_server,
+        std::make_unique<GrpcPolledFdFactoryWindows>(poller()),
+        shared_from_this());
+    if (!ares_resolver.ok()) {
+      return ares_resolver.status();
+    }
+    return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
+        std::move(*ares_resolver));
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   }
-  return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
-      std::move(*ares_resolver));
-#else   // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   GRPC_TRACE_LOG(event_engine_dns, INFO)
       << "WindowsEventEngine::" << this << " creating NativeWindowsDNSResolver";
   return std::make_unique<NativeWindowsDNSResolver>(shared_from_this());
-#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }
 
 bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
@@ -360,8 +358,8 @@ void WindowsEventEngine::OnConnectCompleted(
           known_connection_handles_.erase(state->connection_handle());
     }
     if (erased_handles != 1 || !Cancel(state->timer_handle())) {
-      GRPC_EVENT_ENGINE_TRACE(
-          "%s", "Not accepting connection since the deadline timer has fired");
+      GRPC_TRACE_LOG(event_engine, INFO)
+          << "Not accepting connection since the deadline timer has fired";
       return;
     }
     // Release refs held by the deadline timer.
@@ -413,8 +411,8 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
-  GRPC_EVENT_ENGINE_TRACE("EventEngine::%p connecting to %s", this,
-                          uri->c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::" << this << " connecting to " << *uri;
   // Use dualstack sockets where available.
   ResolvedAddress address = addr;
   ResolvedAddress addr6_v4mapped;
@@ -540,17 +538,16 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
 
 bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   if (handle == EventEngine::ConnectionHandle::kInvalid) {
-    GRPC_EVENT_ENGINE_TRACE("%s",
-                            "Attempted to cancel an invalid connection handle");
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "Attempted to cancel an invalid connection handle";
     return false;
   }
   // Erase the connection handle, which may be unknown
   {
     grpc_core::MutexLock lock(&connection_mu_);
     if (known_connection_handles_.erase(handle) != 1) {
-      GRPC_EVENT_ENGINE_TRACE(
-          "Unknown connection handle: %s",
-          HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+      GRPC_TRACE_LOG(event_engine, INFO)
+          << "Unknown connection handle: " << handle;
       return false;
     }
   }
@@ -581,10 +578,8 @@ bool WindowsEventEngine::CancelConnectInternalStateLocked(
     ConnectionState* connection_state) {
   connection_state->socket()->Shutdown(DEBUG_LOCATION, "CancelConnect");
   // Release the connection_state shared_ptr owned by the connected callback.
-  GRPC_EVENT_ENGINE_TRACE("Successfully cancelled connection %s",
-                          HandleToString<EventEngine::ConnectionHandle>(
-                              connection_state->connection_handle())
-                              .c_str());
+  GRPC_TRACE_LOG(event_engine, INFO) << "Successfully cancelled connection "
+                                     << connection_state->connection_handle();
   return true;
 }
 

data/src/core/lib/event_engine/windows/windows_listener.cc

@@ -21,7 +21,6 @@
 #include "absl/strings/str_format.h"
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
@@ -52,10 +51,9 @@ void WindowsEventEngineListener::SinglePortSocketListener::
   CHECK_NE(io_state_, nullptr);
   grpc_core::ReleasableMutexLock lock(&io_state_->mu);
   if (io_state_->listener_socket->IsShutdown()) {
-    GRPC_EVENT_ENGINE_TRACE(
-        "SinglePortSocketListener::%p listener socket is shut down. Shutting "
-        "down listener.",
-        io_state_->port_listener);
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "SinglePortSocketListener::" << io_state_->port_listener
+        << " listener socket is shut down. Shutting down listener.";
     lock.Release();
     io_state_.reset();
     return;
@@ -103,7 +101,7 @@ WindowsEventEngineListener::SinglePortSocketListener::
   io_state_->listener_socket->Shutdown(DEBUG_LOCATION,
                                        "~SinglePortSocketListener");
   UnlinkIfUnixDomainSocket(listener_sockname());
-  GRPC_EVENT_ENGINE_TRACE("~SinglePortSocketListener::%p", this);
+  GRPC_TRACE_LOG(event_engine, INFO) << "~SinglePortSocketListener::" << this;
 }
 
 absl::StatusOr<
@@ -179,9 +177,9 @@ WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
     }
   }
   io_state_->accept_socket = accept_socket;
-  GRPC_EVENT_ENGINE_TRACE(
-      "SinglePortSocketListener::%p listening. listener_socket::%p", this,
-      io_state_->listener_socket.get());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "SinglePortSocketListener::" << this
+      << " listening. listener_socket::" << io_state_->listener_socket.get();
   return absl::OkStatus();
 }
 
@@ -311,8 +309,7 @@ WindowsEventEngineListener::WindowsEventEngineListener(
       on_shutdown_(std::move(on_shutdown)) {}
 
 WindowsEventEngineListener::~WindowsEventEngineListener() {
-  GRPC_EVENT_ENGINE_TRACE(
-      "%s", absl::StrFormat("~WindowsEventEngineListener::%p", this).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO) << "~WindowsEventEngineListener::" << this;
   ShutdownListeners();
   on_shutdown_(absl::OkStatus());
 }

data/src/core/lib/experiments/config.cc

@@ -24,12 +24,12 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -137,8 +137,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
     // If not found log an error, but don't take any other action.
     // Allows us an easy path to disabling experiments.
     if (!found) {
-      gpr_log(GPR_ERROR, "Unknown experiment: %s",
-              std::string(experiment).c_str());
+      LOG(ERROR) << "Unknown experiment: " << experiment;
     }
   }
   for (size_t i = 0; i < kNumExperiments; i++) {
@@ -171,6 +170,7 @@ Experiments& ExperimentsSingleton() {
 }  // namespace
 
 void TestOnlyReloadExperimentsFromConfigVariables() {
+  ExperimentFlags::TestOnlyClear();
   ExperimentsSingleton() = LoadExperimentsFromConfigVariable();
   PrintExperimentsList();
 }
@@ -181,8 +181,35 @@ void LoadTestOnlyExperimentsFromMetadata(
       new TestExperiments(experiment_metadata, num_experiments);
 }
 
-bool IsExperimentEnabled(size_t experiment_id) {
-  return ExperimentsSingleton().enabled[experiment_id];
+std::atomic<uint64_t>
+    ExperimentFlags::experiment_flags_[kNumExperimentFlagsWords];
+
+bool ExperimentFlags::LoadFlagsAndCheck(size_t experiment_id) {
+  static_assert(kNumExperiments < kNumExperimentFlagsWords * kFlagsPerWord,
+                "kNumExperiments must be less than "
+                "kNumExperimentFlagsWords*kFlagsPerWord; if this fails then "
+                "make kNumExperimentFlagsWords bigger.");
+  const auto& experiments = ExperimentsSingleton();
+  uint64_t building[kNumExperimentFlagsWords];
+  for (size_t i = 0; i < kNumExperimentFlagsWords; i++) {
+    building[i] = kLoadedFlag;
+  }
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    if (!experiments.enabled[i]) continue;
+    auto bit = i % kFlagsPerWord;
+    auto word = i / kFlagsPerWord;
+    building[word] |= 1ull << bit;
+  }
+  for (size_t i = 0; i < kNumExperimentFlagsWords; i++) {
+    experiment_flags_[i].store(building[i], std::memory_order_relaxed);
+  }
+  return experiments.enabled[experiment_id];
+}
+
+void ExperimentFlags::TestOnlyClear() {
+  for (size_t i = 0; i < kNumExperimentFlagsWords; i++) {
+    experiment_flags_[i].store(0, std::memory_order_relaxed);
+  }
 }
 
 bool IsExperimentEnabledInConfiguration(size_t experiment_id) {
@@ -227,19 +254,20 @@ void PrintExperimentsList() {
   }
   if (experiment_status.empty()) {
     if (!defaulted_on_experiments.empty()) {
-      gpr_log(GPR_INFO, "gRPC experiments enabled: %s",
-              absl::StrJoin(defaulted_on_experiments, ", ").c_str());
+      VLOG(2) << "gRPC experiments enabled: "
+              << absl::StrJoin(defaulted_on_experiments, ", ");
     }
   } else {
     if (defaulted_on_experiments.empty()) {
-      gpr_log(GPR_INFO, "gRPC experiments: %s",
-              absl::StrJoin(experiment_status, ", ", absl::PairFormatter(":"))
-                  .c_str());
+      VLOG(2) << "gRPC experiments: "
+              << absl::StrJoin(experiment_status, ", ",
+                               absl::PairFormatter(":"));
     } else {
-      gpr_log(GPR_INFO, "gRPC experiments: %s; default-enabled: %s",
-              absl::StrJoin(experiment_status, ", ", absl::PairFormatter(":"))
-                  .c_str(),
-              absl::StrJoin(defaulted_on_experiments, ", ").c_str());
+      VLOG(2) << "gRPC experiments: "
+              << absl::StrJoin(experiment_status, ", ",
+                               absl::PairFormatter(":"))
+              << "; default-enabled: "
+              << absl::StrJoin(defaulted_on_experiments, ", ");
     }
   }
 }
@@ -256,8 +284,8 @@ void ForceEnableExperiment(absl::string_view experiment, bool enable) {
     }
     return;
   }
-  gpr_log(GPR_INFO, "gRPC EXPERIMENT %s not found to force %s",
-          std::string(experiment).c_str(), enable ? "enable" : "disable");
+  LOG(INFO) << "gRPC EXPERIMENT " << experiment << " not found to force "
+            << (enable ? "enable" : "disable");
 }
 
 void RegisterExperimentConstraintsValidator(

data/src/core/lib/experiments/config.h

@@ -18,6 +18,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <atomic>
+
 #include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 
@@ -38,16 +40,68 @@ struct ExperimentMetadata {
 };
 
 #ifndef GRPC_EXPERIMENTS_ARE_FINAL
+class ExperimentFlags {
+ public:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsExperimentEnabled(
+      size_t experiment_id) {
+    auto bit = experiment_id % kFlagsPerWord;
+    auto word = experiment_id / kFlagsPerWord;
+    auto cur = experiment_flags_[word].load(std::memory_order_relaxed);
+    if (cur & (1ull << bit)) return true;
+    if (cur & kLoadedFlag) return false;
+    return LoadFlagsAndCheck(experiment_id);
+  }
+
+  template <size_t kExperimentId>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsExperimentEnabled() {
+    auto bit = kExperimentId % kFlagsPerWord;
+    auto word = kExperimentId / kFlagsPerWord;
+    auto cur = experiment_flags_[word].load(std::memory_order_relaxed);
+    if (cur & (1ull << bit)) return true;
+    if (cur & kLoadedFlag) return false;
+    return LoadFlagsAndCheck(kExperimentId);
+  }
+
+  static void TestOnlyClear();
+
+ private:
+  static bool LoadFlagsAndCheck(size_t experiment_id);
+
+  // We layout experiment flags in groups of 63... each 64 bit word contains
+  // 63 enablement flags (one per experiment), and the high bit which indicates
+  // whether the flags have been loaded from the configuration.
+  // Consequently, with one load, we can tell if the experiment is definitely
+  // enabled (the bit is set), or definitely disabled (the bit is clear, and the
+  // loaded flag is set), or if we need to load the flags and re-check.
+
+  static constexpr size_t kNumExperimentFlagsWords = 8;
+  static constexpr size_t kFlagsPerWord = 63;
+  static constexpr uint64_t kLoadedFlag = 0x8000000000000000ull;
+  static std::atomic<uint64_t> experiment_flags_[kNumExperimentFlagsWords];
+};
+
 // Return true if experiment \a experiment_id is enabled.
 // Experiments are numbered by their order in the g_experiment_metadata array
 // declared in experiments.h.
-bool IsExperimentEnabled(size_t experiment_id);
+inline bool IsExperimentEnabled(size_t experiment_id) {
+  return ExperimentFlags::IsExperimentEnabled(experiment_id);
+}
+
+template <size_t kExperimentId>
+inline bool IsExperimentEnabled() {
+  return ExperimentFlags::IsExperimentEnabled<kExperimentId>();
+}
 
 // Given a test experiment id, returns true if the test experiment is enabled.
 // Test experiments can be loaded using the LoadTestOnlyExperimentsFromMetadata
 // method.
 bool IsTestExperimentEnabled(size_t experiment_id);
 
+template <size_t kExperimentId>
+inline bool IsTestExperimentEnabled() {
+  return IsTestExperimentEnabled(kExperimentId);
+}
+
 // Slow check for if a named experiment is enabled.
 // Parses the configuration and looks up the experiment in that, so it does not
 // affect any global state, but it does require parsing the configuration every