grpc 1.51.0 → 1.52.0

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

@@ -37,7 +37,7 @@
 #include <sys/socket.h>  // IWYU pragma: keep
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 namespace {
 // Fills gpr_timespec gts based on values from timespec ts.
@@ -198,6 +198,12 @@ void ExtractOptStatsFromCmsg(ConnectionMetrics* metrics,
 }
 }  // namespace.
 
+bool TracedBufferList::TracedBuffer::Finished(gpr_timespec ts) {
+  constexpr int kGrpcMaxPendingAckTimeMillis = 10000;
+  return gpr_time_to_millis(gpr_time_sub(ts, last_timestamp_)) >
+         kGrpcMaxPendingAckTimeMillis;
+}
+
 void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
   TracedBuffer* new_elem = new TracedBuffer(seq_no, arg);
   // Store the current time as the sendmsg time.
@@ -209,6 +215,7 @@ void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
     ExtractOptStatsFromTcpInfo(&(new_elem->ts_.sendmsg_time.metrics),
                                &(new_elem->ts_.info));
   }
+  new_elem->last_timestamp_ = new_elem->ts_.sendmsg_time.time;
   grpc_core::MutexLock lock(&mu_);
   if (!head_) {
     head_ = tail_ = new_elem;
@@ -223,6 +230,7 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
                                         struct scm_timestamping* tss) {
   grpc_core::MutexLock lock(&mu_);
   TracedBuffer* elem = head_;
+  TracedBuffer* prev = nullptr;
   while (elem != nullptr) {
     // The byte number refers to the sequence number of the last byte which this
     // timestamp relates to.
@@ -232,11 +240,13 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
           FillGprFromTimestamp(&(elem->ts_.scheduled_time.time), &(tss->ts[0]));
           ExtractOptStatsFromCmsg(&(elem->ts_.scheduled_time.metrics),
                                   opt_stats);
+          elem->last_timestamp_ = elem->ts_.scheduled_time.time;
           elem = elem->next_;
           break;
         case SCM_TSTAMP_SND:
           FillGprFromTimestamp(&(elem->ts_.sent_time.time), &(tss->ts[0]));
           ExtractOptStatsFromCmsg(&(elem->ts_.sent_time.metrics), opt_stats);
+          elem->last_timestamp_ = elem->ts_.sent_time.time;
           elem = elem->next_;
           break;
         case SCM_TSTAMP_ACK:
@@ -260,7 +270,26 @@ void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
       break;
     }
   }
-  tail_ = !head_ ? head_ : tail_;
+
+  elem = head_;
+  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
+  while (elem != nullptr) {
+    if (!elem->Finished(now)) {
+      prev = elem;
+      elem = elem->next_;
+      continue;
+    }
+    if (prev != nullptr) {
+      prev->next_ = elem->next_;
+      delete elem;
+      elem = prev->next_;
+    } else {
+      head_ = elem->next_;
+      delete elem;
+      elem = head_;
+    }
+  }
+  tail_ = (head_ == nullptr) ? head_ : prev;
 }
 
 void TracedBufferList::Shutdown(void* remaining, absl::Status shutdown_err) {
@@ -282,20 +311,22 @@ void TcpSetWriteTimestampsCallback(
   g_timestamps_callback = std::move(fn);
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#else /* GRPC_LINUX_ERRQUEUE */
+#else  // GRPC_LINUX_ERRQUEUE
+
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 void TcpSetWriteTimestampsCallback(
     absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> /*fn*/) {
-  GPR_ASSERT(false && "Timestamps callback is not enabled for this platform");
+  grpc_core::Crash("Timestamps callback is not enabled for this platform");
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE

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

@@ -23,67 +23,67 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
-struct ConnectionMetrics { /* Delivery rate in Bytes/s. */
+struct ConnectionMetrics {  // Delivery rate in Bytes/s.
   absl::optional<uint64_t> delivery_rate;
-  /* If the delivery rate is limited by the application, this is set to true. */
+  // If the delivery rate is limited by the application, this is set to true.
   absl::optional<bool> is_delivery_rate_app_limited;
-  /* Total packets retransmitted. */
+  // Total packets retransmitted.
   absl::optional<uint32_t> packet_retx;
-  /* Total packets retransmitted spuriously. This metric is smaller than or
-  equal to packet_retx. */
+  // Total packets retransmitted spuriously. This metric is smaller than or
+  // equal to packet_retx.
   absl::optional<uint32_t> packet_spurious_retx;
-  /* Total packets sent. */
+  // Total packets sent.
   absl::optional<uint32_t> packet_sent;
-  /* Total packets delivered. */
+  // Total packets delivered.
   absl::optional<uint32_t> packet_delivered;
-  /* Total packets delivered with ECE marked. This metric is smaller than or
-  equal to packet_delivered. */
+  // Total packets delivered with ECE marked. This metric is smaller than or
+  // equal to packet_delivered.
   absl::optional<uint32_t> packet_delivered_ce;
-  /* Total bytes lost so far. */
+  // Total bytes lost so far.
   absl::optional<uint64_t> data_retx;
-  /* Total bytes sent so far. */
+  // Total bytes sent so far.
   absl::optional<uint64_t> data_sent;
-  /* Total bytes in write queue but not sent. */
+  // Total bytes in write queue but not sent.
   absl::optional<uint64_t> data_notsent;
-  /* Pacing rate of the connection in Bps */
+  // Pacing rate of the connection in Bps
   absl::optional<uint64_t> pacing_rate;
-  /* Minimum RTT observed in usec. */
+  // Minimum RTT observed in usec.
   absl::optional<uint32_t> min_rtt;
-  /* Smoothed RTT in usec */
+  // Smoothed RTT in usec
   absl::optional<uint32_t> srtt;
-  /* Send congestion window. */
+  // Send congestion window.
   absl::optional<uint32_t> congestion_window;
-  /* Slow start threshold in packets. */
+  // Slow start threshold in packets.
   absl::optional<uint32_t> snd_ssthresh;
-  /* Maximum degree of reordering (i.e., maximum number of packets reodered)
-   on the connection. */
+  // Maximum degree of reordering (i.e., maximum number of packets reodered)
+  // on the connection.
   absl::optional<uint32_t> reordering;
-  /* Represents the number of recurring retransmissions of the first sequence
-  that is not acknowledged yet. */
+  // Represents the number of recurring retransmissions of the first sequence
+  // that is not acknowledged yet.
   absl::optional<uint8_t> recurring_retrans;
-  /* The cumulative time (in usec) that the transport protocol was busy
-   sending data. */
+  // The cumulative time (in usec) that the transport protocol was busy
+  // sending data.
   absl::optional<uint64_t> busy_usec;
-  /* The cumulative time (in usec) that the transport protocol was limited by
-   the receive window size. */
+  // The cumulative time (in usec) that the transport protocol was limited by
+  // the receive window size.
   absl::optional<uint64_t> rwnd_limited_usec;
-  /* The cumulative time (in usec) that the transport protocol was limited by
-   the send buffer size. */
+  // The cumulative time (in usec) that the transport protocol was limited by
+  // the send buffer size.
   absl::optional<uint64_t> sndbuf_limited_usec;
 };
 
 struct BufferTimestamp {
   gpr_timespec time;
-  ConnectionMetrics metrics; /* Metrics collected with this timestamp */
+  ConnectionMetrics metrics;  // Metrics collected with this timestamp
 };
 
 struct Timestamps {
@@ -92,11 +92,11 @@ struct Timestamps {
   BufferTimestamp sent_time;
   BufferTimestamp acked_time;
 
-  uint32_t byte_offset; /* byte offset relative to the start of the RPC */
+  uint32_t byte_offset;  // byte offset relative to the start of the RPC
 
 #ifdef GRPC_LINUX_ERRQUEUE
-  tcp_info info; /* tcp_info collected on sendmsg */
-#endif           /* GRPC_LINUX_ERRQUEUE */
+  tcp_info info;  // tcp_info collected on sendmsg
+#endif            // GRPC_LINUX_ERRQUEUE
 };
 
 // TracedBuffer is a class to keep track of timestamps for a specific buffer in
@@ -110,6 +110,8 @@ struct Timestamps {
 
 class TracedBufferList {
  public:
+  TracedBufferList() = default;
+  ~TracedBufferList() = default;
   // Add a new entry in the TracedBuffer list pointed to by head. Also saves
   // sendmsg_time with the current timestamp.
   void AddNewEntry(int32_t seq_no, int fd, void* arg);
@@ -138,13 +140,17 @@ class TracedBufferList {
   class TracedBuffer {
    public:
     TracedBuffer(uint32_t seq_no, void* arg) : seq_no_(seq_no), arg_(arg) {}
+    // Returns true if the TracedBuffer is considered stale at the given
+    // timestamp.
+    bool Finished(gpr_timespec ts);
 
    private:
     friend class TracedBufferList;
+    gpr_timespec last_timestamp_;
     TracedBuffer* next_ = nullptr;
-    uint32_t seq_no_; /* The sequence number for the last byte in the buffer */
-    void* arg_;       /* The arg to pass to timestamps_callback */
-    Timestamps ts_;   /* The timestamps corresponding to this buffer */
+    uint32_t seq_no_;  // The sequence number for the last byte in the buffer
+    void* arg_;        // The arg to pass to timestamps_callback
+    Timestamps ts_;    // The timestamps corresponding to this buffer
   };
   grpc_core::Mutex mu_;
   // TracedBuffers are ordered by sequence number and would need to be processed
@@ -155,7 +161,7 @@ class TracedBufferList {
   TracedBuffer* tail_ = nullptr;
 };
 
-#else  /* GRPC_LINUX_ERRQUEUE */
+#else   // GRPC_LINUX_ERRQUEUE
 // TracedBufferList implementation is a no-op for this platform.
 class TracedBufferList {
  public:
@@ -166,14 +172,14 @@ class TracedBufferList {
   int Size() { return 0; }
   void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/) {}
 };
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE
 
 // Sets the callback function to call when timestamps for a write are collected.
 // This is expected to be called atmost once.
 void TcpSetWriteTimestampsCallback(
     absl::AnyInvocable<void(void*, Timestamps*, absl::Status)>);
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif /* GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H */
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H

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

@@ -19,8 +19,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/log.h>  // IWYU pragma: keep
-
+#include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_LINUX_EVENTFD
@@ -36,7 +35,7 @@
 #include "src/core/lib/gprpp/strerror.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_LINUX_EVENTFD
 
@@ -105,13 +104,15 @@ EventFdWakeupFd::CreateEventFdWakeupFd() {
 
 #else  //  GRPC_LINUX_EVENTFD
 
-absl::Status EventFdWakeupFd::Init() { GPR_ASSERT(false && "unimplemented"); }
+#include "src/core/lib/gprpp/crash.h"
+
+absl::Status EventFdWakeupFd::Init() { grpc_core::Crash("unimplemented"); }
 
 absl::Status EventFdWakeupFd::ConsumeWakeup() {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-absl::Status EventFdWakeupFd::Wakeup() { GPR_ASSERT(false && "unimplemented"); }
+absl::Status EventFdWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
 
 bool EventFdWakeupFd::IsSupported() { return false; }
 
@@ -122,5 +123,5 @@ EventFdWakeupFd::CreateEventFdWakeupFd() {
 
 #endif  // GRPC_LINUX_EVENTFD
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -24,7 +24,7 @@
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class EventFdWakeupFd : public WakeupFd {
  public:
@@ -39,7 +39,7 @@ class EventFdWakeupFd : public WakeupFd {
   absl::Status Init();
 };
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_EVENTFD_H

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

@@ -20,8 +20,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/log.h>  // IWYU pragma: keep
-
+#include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_WAKEUP_FD
@@ -36,7 +35,7 @@
 #include "src/core/lib/gprpp/strerror.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
@@ -131,13 +130,13 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
 
 #else  //  GRPC_POSIX_WAKEUP_FD
 
-absl::Status PipeWakeupFd::Init() { GPR_ASSERT(false && "unimplemented"); }
+absl::Status PipeWakeupFd::Init() { grpc_core::Crash("unimplemented"); }
 
 absl::Status PipeWakeupFd::ConsumeWakeup() {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-absl::Status PipeWakeupFd::Wakeup() { GPR_ASSERT(false && "unimplemented"); }
+absl::Status PipeWakeupFd::Wakeup() { grpc_core::Crash("unimplemented"); }
 
 bool PipeWakeupFd::IsSupported() { return false; }
 
@@ -147,5 +146,5 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> PipeWakeupFd::CreatePipeWakeupFd() {
 
 #endif  //  GRPC_POSIX_WAKEUP_FD
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -24,7 +24,7 @@
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class PipeWakeupFd : public WakeupFd {
  public:
@@ -39,7 +39,7 @@ class PipeWakeupFd : public WakeupFd {
   absl::Status Init();
 };
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_PIPE_H

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

@@ -12,33 +12,33 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/*
- * WakeupFd abstracts the concept of a file descriptor for the purpose of
- * waking up a thread in select()/poll()/epoll_wait()/etc.
+//
+// WakeupFd abstracts the concept of a file descriptor for the purpose of
+// waking up a thread in select()/poll()/epoll_wait()/etc.
 
- * The poll() family of system calls provide a way for a thread to block until
- * there is activity on one (or more) of a set of file descriptors. An
- * application may wish to wake up this thread to do non file related work. The
- * typical way to do this is to add a pipe to the set of file descriptors, then
- * write to the pipe to wake up the thread in poll().
- *
- * Linux has a lighter weight eventfd specifically designed for this purpose.
- * WakeupFd abstracts the difference between the two.
- *
- * Setup:
- * 1. Call CreateWakeupFd() to crete an initialized WakeupFd.
- * 2. Add the result of WakeupFd::ReadFd() to the set of monitored file
- *    descriptors for the poll() style API you are using. Monitor the file
- *    descriptor for readability.
- * 3. To tear down, call WakeupFd::Destroy(). This closes the underlying
- *    file descriptor.
- *
- * Usage:
- * 1. To wake up a polling thread, call WakeupFd::Wakeup() on a wakeup_fd
- *    it is monitoring.
- * 2. If the polling thread was awakened by a WakeupFd event, call
- *    WakeupFd::Consume() on it.
- */
+// The poll() family of system calls provide a way for a thread to block until
+// there is activity on one (or more) of a set of file descriptors. An
+// application may wish to wake up this thread to do non file related work. The
+// typical way to do this is to add a pipe to the set of file descriptors, then
+// write to the pipe to wake up the thread in poll().
+//
+// Linux has a lighter weight eventfd specifically designed for this purpose.
+// WakeupFd abstracts the difference between the two.
+//
+// Setup:
+// 1. Call CreateWakeupFd() to crete an initialized WakeupFd.
+// 2. Add the result of WakeupFd::ReadFd() to the set of monitored file
+//    descriptors for the poll() style API you are using. Monitor the file
+//    descriptor for readability.
+// 3. To tear down, call WakeupFd::Destroy(). This closes the underlying
+//    file descriptor.
+//
+// Usage:
+// 1. To wake up a polling thread, call WakeupFd::Wakeup() on a wakeup_fd
+//    it is monitoring.
+// 2. If the polling thread was awakened by a WakeupFd event, call
+//    WakeupFd::Consume() on it.
+//
 #ifndef GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
 #define GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H
 
@@ -47,7 +47,7 @@
 #include "absl/status/status.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class WakeupFd {
  public:
@@ -70,7 +70,7 @@ class WakeupFd {
   int write_fd_;
 };
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_H

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

@@ -24,7 +24,7 @@
 #include "src/core/lib/iomgr/port.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_POSIX_WAKEUP_FD
 
@@ -53,7 +53,7 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
   return g_wakeup_fd_fn();
 }
 
-#else /* GRPC_POSIX_WAKEUP_FD */
+#else  // GRPC_POSIX_WAKEUP_FD
 
 bool SupportsWakeupFd() { return false; }
 
@@ -61,7 +61,7 @@ absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd() {
   return absl::NotFoundError("Wakeup-fd is not supported on this system");
 }
 
-#endif /* GRPC_POSIX_WAKEUP_FD */
+#endif  // GRPC_POSIX_WAKEUP_FD
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -21,7 +21,7 @@
 #include "absl/status/statusor.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class WakeupFd;
 
@@ -31,7 +31,7 @@ bool SupportsWakeupFd();
 // Create and return an initialized WakeupFd instance if supported.
 absl::StatusOr<std::unique_ptr<WakeupFd>> CreateWakeupFd();
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_WAKEUP_FD_POSIX_DEFAULT_H

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

@@ -52,4 +52,4 @@ class SocketNotifier {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_SOCKET_NOTIFIER_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_SOCKET_NOTIFIER_H