LCOV - code coverage report
Current view: top level - root/contrail/src/contrail-common/io - tcp_message_write.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 73 73 100.0 %
Date: 2026-11-16 02:06:09 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #include "boost/asio/detail/recycling_allocator.hpp"
       7             : 
       8             : #include "io/tcp_message_write.h"
       9             : 
      10             : #include "base/util.h"
      11             : #include "base/logging.h"
      12             : #include "io/tcp_session.h"
      13             : #include "io/io_log.h"
      14             : 
      15             : using boost::asio::buffer;
      16             : using boost::asio::buffer_cast;
      17             : using boost::asio::mutable_buffer;
      18             : using boost::system::error_code;
      19             : using std::min;
      20             : 
      21             : const int TcpMessageWriter::kDefaultWriteBufferSize;
      22             : const int TcpMessageWriter::kMaxPendingBufferSize;
      23             : const int TcpMessageWriter::kMinPendingBufferSize;
      24             : 
      25        1309 : TcpMessageWriter::TcpMessageWriter(TcpSession *session,
      26        1309 :                                    size_t buffer_send_size) :
      27        1310 :     offset_(0), last_write_(0), buffer_send_size_(buffer_send_size),
      28        1309 :     session_(session) {
      29        1310 : }
      30             : 
      31        1309 : TcpMessageWriter::~TcpMessageWriter() {
      32        1309 :     for (BufferQueue::iterator iter = buffer_queue_.begin();
      33        1310 :          iter != buffer_queue_.end(); ++iter) {
      34           1 :         DeleteBuffer(*iter);
      35             :     }
      36        1309 :     buffer_queue_.clear();
      37        1309 : }
      38             : 
      39      133951 : int TcpMessageWriter::AsyncSend(const uint8_t *data, size_t len, error_code *ec) {
      40             : 
      41      133951 :     int write = len;
      42             : 
      43      133951 :     if (buffer_queue_.empty()) {
      44      117871 :         BufferAppend(data, len);
      45      117823 :         if (session_->io_strand_) {
      46      117823 :             boost::asio::detail::recycling_allocator<void> allocator;
      47      235716 :             session_->io_strand_->post(bind(&TcpSession::AsyncWriteInternal,
      48      235667 :                                        session_, TcpSessionPtr(session_)), allocator);
      49             :         }
      50             :     } else {
      51       16072 :         BufferAppend(data, len);
      52             :     }
      53             : 
      54      133957 :     if ((GetBufferQueueSize() - offset_) > TcpMessageWriter::kMaxPendingBufferSize) {
      55          14 :         if (!session_->write_blocked_) {
      56             :             /* throttle the sender */
      57           4 :             session_->stats_.write_blocked++;
      58           4 :             session_->server_->stats_.write_blocked++;
      59           4 :             session_->stats_.write_block_start_time = UTCTimestampUsec();
      60           4 :             session_->write_blocked_ = true;
      61             :         }
      62          14 :         write = 0;
      63             :     }
      64             : 
      65      133846 :     return write;
      66             : }
      67             : 
      68      136213 : void TcpMessageWriter::TriggerAsyncWrite() {
      69             : 
      70             :     /* assert if there is an async write in progress */
      71      136213 :     assert(last_write_ == 0);
      72      136213 :     assert(!buffer_queue_.empty());
      73             : 
      74      136213 :     boost::asio::mutable_buffer head = buffer_queue_.front();
      75      136213 :     size_t remaining = buffer_size(head) - offset_;
      76      136213 :     last_write_  = min(buffer_send_size_, remaining);
      77             : 
      78             :     // Update socket write call statistics.
      79      136213 :     session_->stats_.write_calls++;
      80      136213 :     session_->server_->stats_.write_calls++;
      81             : 
      82      136213 :     const uint8_t *data = buffer_cast<const uint8_t *>(head) + offset_;
      83      136213 :     session_->AsyncWrite(data, last_write_);
      84      136213 : }
      85             : 
      86      136212 : bool TcpMessageWriter::UpdateBufferQueue(size_t wrote, bool *send_ready) {
      87             : 
      88      136212 :     assert(last_write_ == wrote);
      89      136212 :     assert(!buffer_queue_.empty());
      90             : 
      91      136212 :     bool more_write = true;
      92      136212 :     last_write_ = 0;
      93      136212 :     *send_ready = false;
      94             : 
      95      136212 :     boost::asio::mutable_buffer head = buffer_queue_.front();
      96      136212 :     if ((offset_ + wrote) == buffer_size(head)) {
      97      133981 :         offset_ = 0;
      98      133981 :         DeleteBuffer(head);
      99      133981 :         buffer_queue_.pop_front();
     100             :     } else {
     101        2231 :         offset_ += wrote;
     102             :     }
     103             : 
     104      136212 :     if (session_->write_blocked_ && ((GetBufferQueueSize() - offset_)  <
     105      136212 :                                      TcpMessageWriter::kMinPendingBufferSize)) {
     106           4 :         uint64_t blocked_usecs =  UTCTimestampUsec() -
     107           4 :                 session_->stats_.write_block_start_time;
     108           4 :         session_->stats_.write_blocked_duration_usecs += blocked_usecs;
     109           4 :         session_->server_->stats_.write_blocked_duration_usecs += blocked_usecs;
     110           4 :         session_->write_blocked_ = false;
     111           4 :         *send_ready = true;
     112             :     }
     113             : 
     114      136212 :     if (buffer_queue_.empty()) {
     115      117897 :         buffer_queue_.clear();
     116      117897 :         more_write = false;
     117             :     }
     118             : 
     119      136212 :     return more_write;
     120             : }
     121             : 
     122      133924 : void TcpMessageWriter::BufferAppend(const uint8_t *src, int bytes) {
     123      133924 :     uint8_t *data = new uint8_t[bytes];
     124      133963 :     memcpy(data, src, bytes);
     125      133963 :     mutable_buffer buffer = mutable_buffer(data, bytes);
     126      133922 :     buffer_queue_.push_back(buffer);
     127      133860 : }
     128             : 
     129      133982 : void TcpMessageWriter::DeleteBuffer(mutable_buffer buffer) {
     130      133982 :     const uint8_t *data = buffer_cast<const uint8_t *>(buffer);
     131      133982 :     delete[] data;
     132      133982 :     return;
     133             : }
     134             : 

Generated by: LCOV version 1.14