grpc 1.69.0 → 1.71.0

data/src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.h

@@ -26,8 +26,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // An asynchronous DNS resolver which uses the native platform's getaddrinfo
 // API. Only supports A/AAAA records.
@@ -49,8 +48,7 @@ class NativePosixDNSResolver : public EventEngine::DNSResolver {
   std::shared_ptr<EventEngine> event_engine_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -27,6 +27,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 
@@ -36,7 +37,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
@@ -46,6 +46,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/telemetry/stats.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/load_file.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -91,8 +92,7 @@
 
 #define MAX_READ_IOVEC 64
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
@@ -103,6 +103,7 @@ ssize_t TcpSend(int fd, const struct msghdr* msg, int* saved_errno,
   GRPC_LATENT_SEE_PARENT_SCOPE("TcpSend");
   ssize_t sent_length;
   do {
+    grpc_core::global_stats().IncrementSyscallWrite();
     sent_length = sendmsg(fd, msg, SENDMSG_FLAGS | additional_flags);
   } while (sent_length < 0 && (*saved_errno = errno) == EINTR);
   return sent_length;
@@ -328,7 +329,11 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
     }
     msg.msg_flags = 0;
 
+    grpc_core::global_stats().IncrementTcpReadOffer(incoming_buffer_->Length());
+    grpc_core::global_stats().IncrementTcpReadOfferIovSize(
+        incoming_buffer_->Count());
     do {
+      grpc_core::global_stats().IncrementSyscallRead();
       read_bytes = recvmsg(fd_, &msg, 0);
     } while (read_bytes < 0 && errno == EINTR);
 
@@ -361,6 +366,7 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
       return true;
     }
 
+    grpc_core::global_stats().IncrementTcpReadSize(read_bytes);
     AddToEstimate(static_cast<size_t>(read_bytes));
     DCHECK((size_t)read_bytes <= incoming_buffer_->Length() - total_read_bytes);
 
@@ -465,7 +471,7 @@ void PosixEndpointImpl::MaybePostReclaimer() {
     memory_owner_.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
         [self = Ref(DEBUG_LOCATION, "Posix Reclaimer")](
-            absl::optional<grpc_core::ReclamationSweep> sweep) {
+            std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             self->PerformReclamation();
           }
@@ -533,12 +539,14 @@ void PosixEndpointImpl::MaybeMakeReadSlices() {
         extra_wanted -= kBigAlloc;
         incoming_buffer_->AppendIndexed(
             Slice(memory_owner_.MakeSlice(kBigAlloc)));
+        grpc_core::global_stats().IncrementTcpReadAlloc64k();
       }
     } else {
       while (extra_wanted > 0) {
         extra_wanted -= kSmallAlloc;
         incoming_buffer_->AppendIndexed(
             Slice(memory_owner_.MakeSlice(kSmallAlloc)));
+        grpc_core::global_stats().IncrementTcpReadAlloc8k();
       }
     }
     MaybePostReclaimer();
@@ -862,6 +870,7 @@ bool PosixEndpointImpl::WriteWithTimestamps(struct msghdr* msg,
   msg->msg_controllen = CMSG_SPACE(sizeof(uint32_t));
 
   // If there was an error on sendmsg the logic in tcp_flush will handle it.
+  grpc_core::global_stats().IncrementTcpWriteSize(sending_length);
   ssize_t length = TcpSend(fd_, msg, saved_errno, additional_flags);
   *sent_length = length;
   // Only save timestamps if all the bytes were taken by sendmsg.
@@ -958,6 +967,8 @@ bool PosixEndpointImpl::DoFlushZerocopy(TcpZerocopySendRecord* record,
     if (!tried_sending_message) {
       msg.msg_control = nullptr;
       msg.msg_controllen = 0;
+      grpc_core::global_stats().IncrementTcpWriteSize(sending_length);
+      grpc_core::global_stats().IncrementTcpWriteIovSize(iov_size);
       sent_length = TcpSend(fd_, &msg, &saved_errno, MSG_ZEROCOPY);
     }
     if (tcp_zerocopy_send_ctx_->UpdateZeroCopyOptMemStateAfterSend(
@@ -1075,6 +1086,8 @@ bool PosixEndpointImpl::TcpFlush(absl::Status& status) {
     if (!tried_sending_message) {
       msg.msg_control = nullptr;
       msg.msg_controllen = 0;
+      grpc_core::global_stats().IncrementTcpWriteSize(sending_length);
+      grpc_core::global_stats().IncrementTcpWriteIovSize(iov_size);
       sent_length = TcpSend(fd_, &msg, &saved_errno);
     }
 
@@ -1347,13 +1360,11 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
                                          std::move(allocator), options);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     EventHandle* /*handle*/, PosixEngineClosure* /*on_shutdown*/,
@@ -1362,7 +1373,6 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
   grpc_core::Crash("Cannot create PosixEndpoint on this platform");
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/posix_engine/posix_endpoint.h

@@ -63,8 +63,7 @@ typedef size_t msg_iovlen_type;
 
 #endif  //  GRPC_POSIX_SOCKET_TCP
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
@@ -721,7 +720,6 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     grpc_event_engine::experimental::MemoryAllocator&& allocator,
     const PosixTcpOptions& options);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENDPOINT_H

data/src/core/lib/event_engine/posix_engine/posix_engine.cc

@@ -48,6 +48,7 @@
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/utils.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/sync.h"
@@ -77,8 +78,7 @@
 
 using namespace std::chrono_literals;
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
@@ -361,7 +361,9 @@ PosixEnginePollerManager::~PosixEnginePollerManager() {
 }
 
 PosixEventEngine::PosixEventEngine(std::shared_ptr<PosixEventPoller> poller)
-    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
+    : grpc_core::KeepsGrpcInitialized(
+          /*enabled=*/!grpc_core::IsPosixEeSkipGrpcInitEnabled()),
+      connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
   g_timer_fork_manager->RegisterForkable(
@@ -374,7 +376,9 @@ PosixEventEngine::PosixEventEngine(std::shared_ptr<PosixEventPoller> poller)
 }
 
 PosixEventEngine::PosixEventEngine()
-    : connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
+    : grpc_core::KeepsGrpcInitialized(
+          /*enabled=*/!grpc_core::IsPosixEeSkipGrpcInitEnabled()),
+      connection_shards_(std::max(2 * gpr_cpu_num_cores(), 1u)),
       executor_(MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 4u, 16u))),
       timer_manager_(std::make_shared<TimerManager>(executor_)) {
   g_timer_fork_manager->RegisterForkable(
@@ -737,5 +741,4 @@ PosixEventEngine::CreatePosixListener(
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

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

@@ -48,8 +48,7 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif  // GRPC_POSIX_SOCKET_TCP
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 // A helper class to handle asynchronous connect operations.
@@ -132,8 +131,6 @@ class PosixEnginePollerManager
 
 // An iomgr-based Posix EventEngine implementation.
 // All methods require an ExecCtx to already exist on the thread's stack.
-// TODO(ctiller): KeepsGrpcInitialized is an interim measure to ensure that
-// EventEngine is shut down before we shut down iomgr.
 class PosixEventEngine final : public PosixEventEngineWithFdSupport,
                                public grpc_core::KeepsGrpcInitialized {
  public:
@@ -262,7 +259,6 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 #endif  // GRPC_POSIX_SOCKET_TCP
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_H

data/src/core/lib/event_engine/posix_engine/posix_engine_closure.h

@@ -22,8 +22,7 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // The callbacks for Endpoint read and write take an absl::Status as
 // argument - this is important for the tcp code to function correctly. We need
@@ -73,7 +72,6 @@ class PosixEngineClosure final
   absl::Status status_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_CLOSURE_H

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -27,6 +27,7 @@
 #include <unistd.h>      // IWYU pragma: keep
 
 #include <atomic>
+#include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
@@ -37,7 +38,6 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
@@ -49,8 +49,7 @@
 #include "src/core/util/strerror.h"
 #include "src/core/util/time.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 PosixEngineListenerImpl::PosixEngineListenerImpl(
     PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
@@ -330,7 +329,6 @@ PosixEngineListenerImpl::~PosixEngineListenerImpl() {
   }
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.h

@@ -43,8 +43,7 @@
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 class PosixEngineListenerImpl
@@ -278,6 +277,5 @@ class PosixEngineListener : public PosixListenerWithFdSupport {
 
 #endif
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.cc

@@ -46,8 +46,7 @@
 #include <unistd.h>      // IWYU pragma: keep
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 
@@ -390,5 +389,4 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
 
 #endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.h

@@ -20,8 +20,7 @@
 #include "absl/status/statusor.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // This interface exists to allow different EventEngines to implement different
 // custom interception operations while a socket is Appended. The
@@ -83,7 +82,6 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -21,10 +21,11 @@
 #include <grpc/support/port_platform.h>
 #include <limits.h>
 
+#include <optional>
+
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 #include "src/core/util/time.h"
@@ -65,13 +66,12 @@
 #endif  // GPR_WINDOWS
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
 int AdjustValue(int default_value, int min_value, int max_value,
-                absl::optional<int> actual_value) {
+                std::optional<int> actual_value) {
   if (!actual_value.has_value() || *actual_value < min_value ||
       *actual_value > max_value) {
     return default_value;
@@ -922,5 +922,4 @@ PosixSocketWrapper::CreateAndPrepareTcpClientSocket(
 
 #endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h

@@ -46,8 +46,7 @@
 #endif
 #endif  // ifdef GRPC_LINUX_ERRQUEUE
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct PosixTcpOptions {
   static constexpr int kDefaultReadChunkSize = 8192;
@@ -323,7 +322,6 @@ struct PosixSocketWrapper::PosixSocketCreateResult {
 
 bool SetSocketDualStack(int fd);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H

data/src/core/lib/event_engine/posix_engine/timer.cc

@@ -30,8 +30,7 @@
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 static const size_t kInvalidHeapIndex = std::numeric_limits<size_t>::max();
 static const double kAddDeadlineScale = 0.33;
@@ -280,7 +279,7 @@ std::vector<experimental::EventEngine::Closure*> TimerList::FindExpiredTimers(
   return done;
 }
 
-absl::optional<std::vector<experimental::EventEngine::Closure*>>
+std::optional<std::vector<experimental::EventEngine::Closure*>>
 TimerList::TimerCheck(grpc_core::Timestamp* next) {
   // prelude
   grpc_core::Timestamp now = host_->Now();
@@ -298,7 +297,7 @@ TimerList::TimerCheck(grpc_core::Timestamp* next) {
     return std::vector<experimental::EventEngine::Closure*>();
   }
 
-  if (!checker_mu_.TryLock()) return absl::nullopt;
+  if (!checker_mu_.TryLock()) return std::nullopt;
   std::vector<experimental::EventEngine::Closure*> run =
       FindExpiredTimers(now, next);
   checker_mu_.Unlock();
@@ -306,5 +305,4 @@ TimerList::TimerCheck(grpc_core::Timestamp* next) {
   return std::move(run);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/timer.h

@@ -26,17 +26,16 @@
 #include <atomic>
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/event_engine/posix_engine/timer_heap.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/time_averaged_stats.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct Timer {
   int64_t deadline;
@@ -97,7 +96,7 @@ class TimerList {
   // *next is never guaranteed to be updated on any given execution; however,
   // with high probability at least one thread in the system will see an update
   // at any time slice.
-  absl::optional<std::vector<experimental::EventEngine::Closure*>> TimerCheck(
+  std::optional<std::vector<experimental::EventEngine::Closure*>> TimerCheck(
       grpc_core::Timestamp* next);
 
  private:
@@ -158,7 +157,6 @@ class TimerList {
   const std::unique_ptr<Shard*[]> shard_queue_ ABSL_GUARDED_BY(mu_);
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H

data/src/core/lib/event_engine/posix_engine/timer_heap.cc

@@ -25,8 +25,7 @@
 
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // 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
@@ -102,5 +101,4 @@ Timer* TimerHeap::Top() { return timers_[0]; }
 
 void TimerHeap::Pop() { Remove(Top()); }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/timer_heap.h

@@ -24,8 +24,7 @@
 #include <cstddef>
 #include <vector>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct Timer;
 
@@ -50,7 +49,6 @@ class TimerHeap {
   std::vector<Timer*> timers_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H

data/src/core/lib/event_engine/posix_engine/timer_manager.cc

@@ -22,18 +22,17 @@
 #include <grpc/support/time.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 
 static thread_local bool g_timer_thread;
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 void TimerManager::RunSomeTimers(
     std::vector<experimental::EventEngine::Closure*> timers) {
@@ -64,8 +63,8 @@ bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
 
 void TimerManager::MainLoop() {
   grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
-  absl::optional<std::vector<experimental::EventEngine::Closure*>>
-      check_result = timer_list_->TimerCheck(&next);
+  std::optional<std::vector<experimental::EventEngine::Closure*>> check_result =
+      timer_list_->TimerCheck(&next);
   CHECK(check_result.has_value())
       << "ERROR: More than one MainLoop is running.";
   bool timers_found = !check_result->empty();
@@ -150,5 +149,4 @@ void TimerManager::PrepareFork() { Shutdown(); }
 void TimerManager::PostforkParent() { RestartPostFork(); }
 void TimerManager::PostforkChild() { RestartPostFork(); }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/timer_manager.h

@@ -24,10 +24,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
@@ -35,8 +35,7 @@
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // Timer Manager tries to keep only one thread waiting for the next timeout at
 // all times, and thus effectively preventing the thundering herd problem.
@@ -99,10 +98,9 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
   // actual timer implementation
   std::unique_ptr<TimerList> timer_list_;
   std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool_;
-  absl::optional<grpc_core::Notification> main_loop_exit_signal_;
+  std::optional<grpc_core::Notification> main_loop_exit_signal_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.cc

@@ -33,8 +33,7 @@
 #include <linux/netlink.h>
 #include <sys/socket.h>  // IWYU pragma: keep
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 // Fills gpr_timespec gts based on values from timespec ts.
@@ -310,22 +309,19 @@ void TcpSetWriteTimestampsCallback(
   g_timestamps_callback = std::move(fn);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #else  // GRPC_LINUX_ERRQUEUE
 
 #include "src/core/util/crash.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 void TcpSetWriteTimestampsCallback(
     absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> /*fn*/) {
   grpc_core::Crash("Timestamps callback is not enabled for this platform");
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_LINUX_ERRQUEUE