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 :