buffer_list.h

Go to the documentation of this file.

/*
 *
 * Copyright 2018 gRPC authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * 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.
 *
 */
 
#ifndef GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H
#define GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H
 
#include <grpc/support/port_platform.h>
 
#include "absl/types/optional.h"
 
#include <grpc/support/time.h>
 
#include "src/core/lib/gprpp/memory.h"
#include "src/core/lib/iomgr/error.h"
#include "src/core/lib/iomgr/internal_errqueue.h"
#include "src/core/lib/iomgr/port.h"
 
namespace grpc_core {
 
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. */
  absl::optional<bool> is_delivery_rate_app_limited;
  /* Total packets retransmitted. */
  absl::optional<uint32_t> 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. */
  absl::optional<uint32_t> packet_sent;
  /* 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. */
  absl::optional<uint32_t> packet_delivered_ce;
  /* Total bytes lost so far. */
  absl::optional<uint64_t> data_retx;
  /* Total bytes sent so far. */
  absl::optional<uint64_t> data_sent;
  /* Total bytes in write queue but not sent. */
  absl::optional<uint64_t> data_notsent;
  /* Pacing rate of the connection in Bps */
  absl::optional<uint64_t> pacing_rate;
  /* Minimum RTT observed in usec. */
  absl::optional<uint32_t> min_rtt;
  /* Smoothed RTT in usec */
  absl::optional<uint32_t> srtt;
  /* Send congestion window. */
  absl::optional<uint32_t> congestion_window;
  /* 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. */
  absl::optional<uint32_t> reordering;
  /* 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. */
  absl::optional<uint64_t> busy_usec;
  /* 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. */
  absl::optional<uint64_t> sndbuf_limited_usec;
};
 
struct BufferTimestamp {
  gpr_timespec time;
  ConnectionMetrics metrics; /* Metrics collected with this timestamp */
};
 
struct Timestamps {
  BufferTimestamp sendmsg_time;
  BufferTimestamp scheduled_time;
  BufferTimestamp sent_time;
  BufferTimestamp acked_time;
 
  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 */
};
 
#ifdef GRPC_LINUX_ERRQUEUE
class TracedBuffer {
 public:
  TracedBuffer(uint32_t seq_no, void* arg)
      : seq_no_(seq_no), arg_(arg), next_(nullptr) {}
 
  static void AddNewEntry(TracedBuffer** head, uint32_t seq_no, int fd,
                          void* arg);
 
  static void ProcessTimestamp(TracedBuffer** head,
                               struct sock_extended_err* serr,
                               struct cmsghdr* opt_stats,
                               struct scm_timestamping* tss);
 
  static void Shutdown(TracedBuffer** head, void* remaining,
                       grpc_error_handle shutdown_err);
 
 private:
  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 */
  TracedBuffer* next_; /* The next TracedBuffer in the list */
};
#else  /* GRPC_LINUX_ERRQUEUE */
class TracedBuffer {
 public:
  /* Phony shutdown function */
  static void Shutdown(TracedBuffer** /*head*/, void* /*remaining*/,
                       grpc_error_handle shutdown_err) {
    GRPC_ERROR_UNREF(shutdown_err);
  }
};
#endif /* GRPC_LINUX_ERRQUEUE */
 
void grpc_tcp_set_write_timestamps_callback(
    void (*fn)(void*, Timestamps*, grpc_error_handle error));
 
} /* namespace grpc_core */
 
#endif /* GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H */