grpc 1.62.0 → 1.64.0

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

@@ -17,6 +17,7 @@
 
 #include <memory>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -49,6 +50,13 @@
 namespace grpc_event_engine {
 namespace experimental {
 
+namespace {
+EventEngine::OnConnectCallback CreateCrashingOnConnectCallback() {
+  return [](absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>) {
+    grpc_core::Crash("Internal Error: OnConnect callback called when unset");
+  };
+}
+}  // namespace
 // ---- IOCPWorkClosure ----
 
 WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(ThreadPool* thread_pool,
@@ -107,7 +115,7 @@ WindowsEventEngine::WindowsEventEngine()
       iocp_worker_(thread_pool_.get(), &iocp_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
-  GPR_ASSERT(status == 0);
+  CHECK_EQ(status, 0);
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
@@ -136,13 +144,13 @@ WindowsEventEngine::~WindowsEventEngine() {
         task_mu_.Lock();
       }
     }
-    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    CHECK(GPR_LIKELY(known_handles_.empty()));
     task_mu_.Unlock();
   }
   iocp_.Kick();
   iocp_worker_.WaitForShutdown();
   iocp_.Shutdown();
-  GPR_ASSERT(WSACleanup() == 0);
+  CHECK_EQ(WSACleanup(), 0);
   timer_manager_.Shutdown();
   thread_pool_->Quiesce();
 }
@@ -250,6 +258,7 @@ void WindowsEventEngine::OnConnectCompleted(
     // Connection attempt complete!
     grpc_core::MutexLock lock(&state->mu);
     cb = std::move(state->on_connected_user_callback);
+    state->on_connected_user_callback = CreateCrashingOnConnectCallback();
     state->on_connected = nullptr;
     {
       grpc_core::MutexLock handle_lock(&connection_mu_);
@@ -298,7 +307,10 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
   if (ResolvedAddressToV4Mapped(addr, &addr6_v4mapped)) {
     address = addr6_v4mapped;
   }
-  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
+  const int addr_family =
+      (address.address()->sa_family == AF_UNIX) ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  SOCKET sock = WSASocket(addr_family, SOCK_STREAM, protocol, nullptr, 0,
                           IOCP::GetDefaultSocketFlags());
   if (sock == INVALID_SOCKET) {
     Run([on_connect = std::move(on_connect),
@@ -307,7 +319,11 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
-  status = PrepareSocket(sock);
+  if (addr_family == AF_UNIX) {
+    status = SetSocketNonBlock(sock);
+  } else {
+    status = PrepareSocket(sock);
+  }
   if (!status.ok()) {
     Run([on_connect = std::move(on_connect), status]() mutable {
       on_connect(status);
@@ -332,7 +348,16 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     return EventEngine::ConnectionHandle::kInvalid;
   }
   // bind the local address
-  auto local_address = ResolvedAddressMakeWild6(0);
+  ResolvedAddress local_address;
+  if (addr_family == AF_UNIX) {
+    // For ConnectEx() to work for AF_UNIX, the sock needs to be bound to
+    // the local address of an unnamed socket.
+    sockaddr addr = {};
+    addr.sa_family = AF_UNIX;
+    local_address = ResolvedAddress(&addr, sizeof(addr));
+  } else {
+    local_address = ResolvedAddressMakeWild6(0);
+  }
   istatus = bind(sock, local_address.address(), local_address.size());
   if (istatus != 0) {
     Run([on_connect = std::move(on_connect),
@@ -345,7 +370,7 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
   auto connection_state = std::make_shared<ConnectionState>();
   grpc_core::MutexLock lock(&connection_state->mu);
   connection_state->socket = iocp_.Watch(sock);
-  GPR_ASSERT(connection_state->socket != nullptr);
+  CHECK(connection_state->socket != nullptr);
   auto* info = connection_state->socket->write_info();
   connection_state->address = address;
   connection_state->allocator = std::move(memory_allocator);
@@ -356,10 +381,13 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
       });
   connection_state->timer_handle =
       RunAfter(timeout, [this, connection_state]() {
-        grpc_core::MutexLock lock(&connection_state->mu);
+        grpc_core::ReleasableMutexLock lock(&connection_state->mu);
         if (CancelConnectFromDeadlineTimer(connection_state.get())) {
-          connection_state->on_connected_user_callback(
-              absl::DeadlineExceededError("Connection timed out"));
+          auto cb = std::move(connection_state->on_connected_user_callback);
+          connection_state->on_connected_user_callback =
+              CreateCrashingOnConnectCallback();
+          lock.Release();
+          cb(absl::DeadlineExceededError("Connection timed out"));
         }
         // else: The connection attempt could not be canceled. We can assume
         // the connection callback will be called.
@@ -380,8 +408,14 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
       connection_state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
       Run([connection_state = std::move(connection_state),
            status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
-        grpc_core::MutexLock lock(&connection_state->mu);
-        connection_state->on_connected_user_callback(status);
+        EventEngine::OnConnectCallback cb;
+        {
+          grpc_core::MutexLock lock(&connection_state->mu);
+          cb = std::move(connection_state->on_connected_user_callback);
+          connection_state->on_connected_user_callback =
+              CreateCrashingOnConnectCallback();
+        }
+        cb(status);
       });
       return EventEngine::ConnectionHandle::kInvalid;
     }
@@ -422,8 +456,8 @@ bool WindowsEventEngine::CancelConnectFromDeadlineTimer(
   // Erase the connection handle, which is guaranteed to exist.
   {
     grpc_core::MutexLock lock(&connection_mu_);
-    GPR_ASSERT(known_connection_handles_.erase(
-                   connection_state->connection_handle) == 1);
+    CHECK(known_connection_handles_.erase(
+              connection_state->connection_handle) == 1);
   }
   return CancelConnectInternalStateLocked(connection_state);
 }

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

@@ -15,6 +15,7 @@
 
 #ifdef GPR_WINDOWS
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -27,6 +28,7 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/port.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -46,7 +48,7 @@ WindowsEventEngineListener::SinglePortSocketListener::AsyncIOState::
 
 void WindowsEventEngineListener::SinglePortSocketListener::
     OnAcceptCallbackWrapper::Run() {
-  GPR_ASSERT(io_state_ != nullptr);
+  CHECK_NE(io_state_, nullptr);
   grpc_core::ReleasableMutexLock lock(&io_state_->mu);
   if (io_state_->listener_socket->IsShutdown()) {
     GRPC_EVENT_ENGINE_TRACE(
@@ -67,11 +69,39 @@ void WindowsEventEngineListener::SinglePortSocketListener::
 
 // ---- SinglePortSocketListener ----
 
+// TODO(hork): This may be refactored to share with posix engine.
+void UnlinkIfUnixDomainSocket(
+    const EventEngine::ResolvedAddress& resolved_addr) {
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  if (resolved_addr.address()->sa_family != AF_UNIX) {
+    return;
+  }
+  struct sockaddr_un* un = reinterpret_cast<struct sockaddr_un*>(
+      const_cast<sockaddr*>(resolved_addr.address()));
+  // There is nothing to unlink for an abstract unix socket.
+  if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
+    return;
+  }
+  // For windows we need to remove the file instead of unlink.
+  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  if (attr == INVALID_FILE_ATTRIBUTES) {
+    return;
+  }
+  if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
+    return;
+  }
+  ::DeleteFileA(un->sun_path);
+#else
+  (void)resolved_addr;
+#endif
+}
+
 WindowsEventEngineListener::SinglePortSocketListener::
     ~SinglePortSocketListener() {
   grpc_core::MutexLock lock(&io_state_->mu);
   io_state_->listener_socket->Shutdown(DEBUG_LOCATION,
                                        "~SinglePortSocketListener");
+  UnlinkIfUnixDomainSocket(listener_sockname());
   GRPC_EVENT_ENGINE_TRACE("~SinglePortSocketListener::%p", this);
 }
 
@@ -95,7 +125,7 @@ WindowsEventEngineListener::SinglePortSocketListener::Create(
   }
   auto result = SinglePortSocketListener::PrepareListenerSocket(sock, addr);
   GRPC_RETURN_IF_ERROR(result.status());
-  GPR_ASSERT(result->port >= 0);
+  CHECK_GE(result->port, 0);
   // Using `new` to access non-public constructor
   return absl::WrapUnique(new SinglePortSocketListener(
       listener, AcceptEx, /*win_socket=*/listener->iocp_->Watch(sock),
@@ -109,7 +139,11 @@ absl::Status WindowsEventEngineListener::SinglePortSocketListener::Start() {
 
 absl::Status
 WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
-  SOCKET accept_socket = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  const EventEngine::ResolvedAddress addr = listener_sockname();
+  const int addr_family =
+      (addr.address()->sa_family == AF_UNIX) ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  SOCKET accept_socket = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                                    IOCP::GetDefaultSocketFlags());
   if (accept_socket == INVALID_SOCKET) {
     return GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
@@ -118,11 +152,17 @@ WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
     if (accept_socket != INVALID_SOCKET) closesocket(accept_socket);
     return error;
   };
-  auto error = PrepareSocket(accept_socket);
+  absl::Status error;
+  if (addr_family == AF_UNIX) {
+    error = SetSocketNonBlock(accept_socket);
+  } else {
+    error = PrepareSocket(accept_socket);
+  }
   if (!error.ok()) return fail(error);
   // Start the "accept" asynchronously.
   io_state_->listener_socket->NotifyOnRead(&io_state_->on_accept_cb);
-  DWORD addrlen = sizeof(sockaddr_in6) + 16;
+  DWORD addrlen =
+      sizeof(addresses_) / 2;  // half of the buffer is for remote addr.
   DWORD bytes_received = 0;
   int success =
       AcceptEx(io_state_->listener_socket->raw_socket(), accept_socket,
@@ -151,8 +191,8 @@ void WindowsEventEngineListener::SinglePortSocketListener::
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu) {
             if (do_close_socket) closesocket(io_state_->accept_socket);
             io_state_->accept_socket = INVALID_SOCKET;
-            GPR_ASSERT(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start",
-                                         StartLocked()));
+            CHECK(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start",
+                                    StartLocked()));
           };
   const auto& overlapped_result =
       io_state_->listener_socket->read_info()->result();
@@ -226,7 +266,7 @@ absl::StatusOr<WindowsEventEngineListener::SinglePortSocketListener::
 WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket(
     SOCKET sock, const EventEngine::ResolvedAddress& addr) {
   auto fail = [&](absl::Status error) -> absl::Status {
-    GPR_ASSERT(!error.ok());
+    CHECK(!error.ok());
     auto addr_uri = ResolvedAddressToURI(addr);
     error = grpc_error_set_int(
         grpc_error_set_str(
@@ -238,8 +278,14 @@ WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket(
     if (sock != INVALID_SOCKET) closesocket(sock);
     return error;
   };
-  auto error = PrepareSocket(sock);
+  absl::Status error;
+  if (addr.address()->sa_family == AF_UNIX) {
+    error = SetSocketNonBlock(sock);
+  } else {
+    error = PrepareSocket(sock);
+  }
   if (!error.ok()) return fail(error);
+  UnlinkIfUnixDomainSocket(addr);
   if (bind(sock, addr.address(), addr.size()) == SOCKET_ERROR) {
     return fail(GRPC_WSA_ERROR(WSAGetLastError(), "bind"));
   }
@@ -309,11 +355,14 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
     out_addr = tmp_addr;
   }
   // Treat :: or 0.0.0.0 as a family-agnostic wildcard.
-  if (ResolvedAddressIsWildcard(out_addr)) {
+  if (MaybeGetWildcardPortFromAddress(out_addr).has_value()) {
     out_addr = ResolvedAddressMakeWild6(out_port);
   }
   // open the socket
-  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nullptr, 0,
+  const int addr_family =
+      (out_addr.address()->sa_family == AF_UNIX) ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  SOCKET sock = WSASocket(addr_family, SOCK_STREAM, protocol, nullptr, 0,
                           IOCP::GetDefaultSocketFlags());
   if (sock == INVALID_SOCKET) {
     auto error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
@@ -326,7 +375,7 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
 }
 
 absl::Status WindowsEventEngineListener::Start() {
-  GPR_ASSERT(!started_.exchange(true));
+  CHECK(!started_.exchange(true));
   grpc_core::MutexLock lock(&port_listeners_mu_);
   for (auto& port_listener : port_listeners_) {
     GRPC_RETURN_IF_ERROR(port_listener->Start());

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

@@ -30,6 +30,14 @@
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_HAVE_UNIX_SOCKET
+// clang-format off
+#include <ws2def.h>
+#include <afunix.h>
+// clang-format on
+#endif
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -120,9 +128,15 @@ class WindowsEventEngineListener : public EventEngine::Listener {
 
     // The cached AcceptEx for that port.
     LPFN_ACCEPTEX AcceptEx;
+    // Buffer to hold the local and remote address.
     // This seemingly magic number comes from AcceptEx's documentation. each
     // address buffer needs to have at least 16 more bytes at their end.
+#ifdef GRPC_HAVE_UNIX_SOCKET
+    // unix addr is larger than ip addr.
+    uint8_t addresses_[(sizeof(sockaddr_un) + 16) * 2] = {};
+#else
     uint8_t addresses_[(sizeof(sockaddr_in6) + 16) * 2] = {};
+#endif
     // The parent listener
     WindowsEventEngineListener* listener_;
     // shared state for asynchronous cleanup of overlapped operations

data/src/core/lib/event_engine/work_queue/basic_work_queue.cc

@@ -11,12 +11,12 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
 
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/gprpp/sync.h"
 

data/src/core/lib/event_engine/work_queue/basic_work_queue.h

@@ -13,8 +13,6 @@
 // limitations under the License.
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_BASIC_WORK_QUEUE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_BASIC_WORK_QUEUE_H
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <deque>
@@ -23,6 +21,7 @@
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/work_queue/work_queue.h"
 #include "src/core/lib/gprpp/sync.h"

data/src/core/lib/event_engine/work_queue/work_queue.h

@@ -14,13 +14,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_WORK_QUEUE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_WORK_QUEUE_WORK_QUEUE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include "absl/functional/any_invocable.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/experiments/config.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/experiments/config.h"
 
 #include <string.h>
@@ -25,12 +23,14 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/strings/str_cat.h"
+#include "absl/log/check.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"
 #include "src/core/lib/experiments/experiments.h"
@@ -49,9 +49,16 @@ struct ForcedExperiment {
   bool forced = false;
   bool value;
 };
-ForcedExperiment g_forced_experiments[kNumExperiments];
 
-std::atomic<bool> g_loaded(false);
+ForcedExperiment* ForcedExperiments() {
+  static NoDestruct<ForcedExperiment> forced_experiments[kNumExperiments];
+  return &**forced_experiments;
+}
+
+std::atomic<bool>* Loaded() {
+  static NoDestruct<std::atomic<bool>> loaded(false);
+  return &*loaded;
+}
 
 absl::AnyInvocable<bool(struct ExperimentMetadata)>* g_check_constraints_cb =
     nullptr;
@@ -98,7 +105,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
   // Set defaults from metadata.
   Experiments experiments;
   for (size_t i = 0; i < kNumExperiments; i++) {
-    if (!g_forced_experiments[i].forced) {
+    if (!ForcedExperiments()[i].forced) {
       if (g_check_constraints_cb != nullptr) {
         experiments.enabled[i] =
             (*g_check_constraints_cb)(g_experiment_metadata[i]);
@@ -106,7 +113,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
         experiments.enabled[i] = g_experiment_metadata[i].default_value;
       }
     } else {
-      experiments.enabled[i] = g_forced_experiments[i].value;
+      experiments.enabled[i] = ForcedExperiments()[i].value;
     }
   }
   // For each comma-separated experiment in the global config:
@@ -140,7 +147,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
          j++) {
       // Require that we can check dependent requirements with a linear sweep
       // (implies the experiments generator must DAG sort the experiments)
-      GPR_ASSERT(g_experiment_metadata[i].required_experiments[j] < i);
+      CHECK(g_experiment_metadata[i].required_experiments[j] < i);
       if (!experiments
                .enabled[g_experiment_metadata[i].required_experiments[j]]) {
         experiments.enabled[i] = false;
@@ -151,7 +158,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
 }
 
 Experiments LoadExperimentsFromConfigVariable() {
-  g_loaded.store(true, std::memory_order_relaxed);
+  Loaded()->store(true, std::memory_order_relaxed);
   return LoadExperimentsFromConfigVariableInner();
 }
 
@@ -187,54 +194,65 @@ bool IsTestExperimentEnabled(size_t experiment_id) {
 }
 
 void PrintExperimentsList() {
-  size_t max_experiment_length = 0;
-  // Populate visitation order into a std::map so that iteration results in a
-  // lexical ordering of experiment names.
-  // The lexical ordering makes it nice and easy to find the experiment you're
-  // looking for in the output spam that we generate.
-  std::map<absl::string_view, size_t> visitation_order;
+  std::map<std::string, std::string> experiment_status;
+  std::set<std::string> defaulted_on_experiments;
   for (size_t i = 0; i < kNumExperiments; i++) {
-    max_experiment_length =
-        std::max(max_experiment_length, strlen(g_experiment_metadata[i].name));
-    visitation_order[g_experiment_metadata[i].name] = i;
+    const char* name = g_experiment_metadata[i].name;
+    const bool enabled = IsExperimentEnabled(i);
+    const bool default_enabled = g_experiment_metadata[i].default_value;
+    const bool forced = ForcedExperiments()[i].forced;
+    if (!default_enabled && !enabled) continue;
+    if (default_enabled && enabled) {
+      defaulted_on_experiments.insert(name);
+      continue;
+    }
+    if (enabled) {
+      if (g_check_constraints_cb != nullptr &&
+          (*g_check_constraints_cb)(g_experiment_metadata[i])) {
+        experiment_status[name] = "on:constraints";
+        continue;
+      }
+      if (forced && ForcedExperiments()[i].value) {
+        experiment_status[name] = "on:forced";
+        continue;
+      }
+      experiment_status[name] = "on";
+    } else {
+      if (forced && !ForcedExperiments()[i].value) {
+        experiment_status[name] = "off:forced";
+        continue;
+      }
+      experiment_status[name] = "off";
+    }
   }
-  for (auto name_index : visitation_order) {
-    const size_t i = name_index.second;
-    gpr_log(
-        GPR_DEBUG, "%s",
-        absl::StrCat(
-            "gRPC EXPERIMENT ", g_experiment_metadata[i].name,
-            std::string(max_experiment_length -
-                            strlen(g_experiment_metadata[i].name) + 1,
-                        ' '),
-            IsExperimentEnabled(i) ? "ON " : "OFF",
-            " (default:", g_experiment_metadata[i].default_value ? "ON" : "OFF",
-            (g_check_constraints_cb != nullptr
-                 ? absl::StrCat(
-                       " + ", g_experiment_metadata[i].additional_constaints,
-                       " => ",
-                       (*g_check_constraints_cb)(g_experiment_metadata[i])
-                           ? "ON "
-                           : "OFF")
-                 : std::string()),
-            g_forced_experiments[i].forced
-                ? absl::StrCat(" force:",
-                               g_forced_experiments[i].value ? "ON" : "OFF")
-                : std::string(),
-            ")")
-            .c_str());
+  if (experiment_status.empty()) {
+    if (!defaulted_on_experiments.empty()) {
+      gpr_log(GPR_INFO, "gRPC experiments enabled: %s",
+              absl::StrJoin(defaulted_on_experiments, ", ").c_str());
+    }
+  } else {
+    if (defaulted_on_experiments.empty()) {
+      gpr_log(GPR_INFO, "gRPC experiments: %s",
+              absl::StrJoin(experiment_status, ", ", absl::PairFormatter(":"))
+                  .c_str());
+    } 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());
+    }
   }
 }
 
 void ForceEnableExperiment(absl::string_view experiment, bool enable) {
-  GPR_ASSERT(g_loaded.load(std::memory_order_relaxed) == false);
+  CHECK(Loaded()->load(std::memory_order_relaxed) == false);
   for (size_t i = 0; i < kNumExperiments; i++) {
     if (g_experiment_metadata[i].name != experiment) continue;
-    if (g_forced_experiments[i].forced) {
-      GPR_ASSERT(g_forced_experiments[i].value == enable);
+    if (ForcedExperiments()[i].forced) {
+      CHECK(ForcedExperiments()[i].value == enable);
     } else {
-      g_forced_experiments[i].forced = true;
-      g_forced_experiments[i].value = enable;
+      ForcedExperiments()[i].forced = true;
+      ForcedExperiments()[i].value = enable;
     }
     return;
   }

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

@@ -15,14 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
 #define GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 // #define GRPC_EXPERIMENTS_ARE_FINAL
 
 namespace grpc_core {