mirror of
https://github.com/ton-blockchain/ton
synced 2025-02-12 19:22:37 +00:00
114 lines
4.1 KiB
C++
114 lines
4.1 KiB
C++
/*
|
|
This file is part of TON Blockchain Library.
|
|
|
|
TON Blockchain Library is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
TON Blockchain Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
Copyright 2017-2020 Telegram Systems LLP
|
|
*/
|
|
|
|
#include "RldpSender.h"
|
|
|
|
#include "RttStats.h"
|
|
#include "LossStats.h"
|
|
#include "BdwStats.h"
|
|
|
|
#include "td/utils/misc.h"
|
|
|
|
namespace ton {
|
|
namespace rldp2 {
|
|
td::Variant<RldpSender::ActionWait, RldpSender::ActionSend> RldpSender::next_action(td::Timestamp now,
|
|
bool only_probe) {
|
|
if (!only_probe && extra_symbols_ > get_inflight_symbols_count()) {
|
|
//LOG(ERROR) << fec_helper_.symbols_count << " " << fec_helper_.get_extra_symbols_count();
|
|
return ActionSend{packets_.next_seqno(), false};
|
|
}
|
|
|
|
return next_probe(now);
|
|
}
|
|
|
|
td::Variant<RldpSender::ActionWait, RldpSender::ActionSend> RldpSender::next_probe(td::Timestamp now) {
|
|
if (probe_timeout_.is_in_past(now)) {
|
|
return ActionSend{packets_.next_seqno(), true};
|
|
}
|
|
return ActionWait{probe_timeout_};
|
|
}
|
|
|
|
SenderPackets::Update RldpSender::on_ack(const Ack &ack, double ack_delay, td::Timestamp now, RttStats &rtt_stats,
|
|
BdwStats &bdw_stats, LossStats &loss_stats) {
|
|
//LOG(ERROR) << "ON ACK " << ack.max_seqno << " " << ack.received_mask << " " << ack.received_count;
|
|
auto update = packets_.on_ack(ack);
|
|
if (!update.was_max_updated) {
|
|
CHECK(!update.new_received);
|
|
return update;
|
|
}
|
|
|
|
// update rtt
|
|
ack_delay = td::clamp(ack_delay, 0.0, config_.max_ack_delay);
|
|
auto rtt_sample = now.at() - packets_.max_packet().sent_at.at();
|
|
rtt_stats.on_rtt_sample(rtt_sample, ack_delay, now);
|
|
|
|
bdw_stats.on_update(now, update.new_received);
|
|
bdw_stats.on_packet_ack(packets_.max_packet().bdw_packet_info, packets_.max_packet().sent_at, now);
|
|
|
|
// drop ready packets
|
|
SenderPackets::Limits limits;
|
|
limits.sent_at = td::Timestamp::at(now.at() - get_loss_delay(rtt_stats));
|
|
limits.seqno = sub_or_zero(packets_.max_packet().seqno, get_loss_seqno_delay());
|
|
update.drop_update = packets_.drop_packets(limits);
|
|
|
|
loss_stats.on_update(update.drop_update.new_ack, update.drop_update.new_lost);
|
|
|
|
fec_helper_.received_symbols_count = packets_.received_count();
|
|
extra_symbols_ = loss_stats.prob.send_n(fec_helper_.get_left_fec_symbols_count());
|
|
return update;
|
|
}
|
|
|
|
void RldpSender::on_send(td::uint32 seqno, td::Timestamp now, bool is_probe, const RttStats &rtt_stats,
|
|
const BdwStats &bdw_stats) {
|
|
SenderPackets::Packet packet;
|
|
packet.is_in_flight = true;
|
|
packet.sent_at = now;
|
|
packet.seqno = seqno;
|
|
packet.size = 0;
|
|
packet.bdw_packet_info = bdw_stats.on_packet_send(packets_.first_sent_at(now));
|
|
packets_.send(packet);
|
|
|
|
probe_timeout_ = td::Timestamp::at(now.at() + get_probe_delay(rtt_stats));
|
|
|
|
if (is_probe) {
|
|
//LOG(ERROR) << get_probe_delay(rtt_stats) << " " << rtt_stats.last_rtt << " " << packets_.in_flight_count() << " "
|
|
//<< packets_.received_count();
|
|
probe_k_ = std::min(probe_k_ * 2, 10u);
|
|
} else {
|
|
probe_k_ = 1;
|
|
}
|
|
}
|
|
|
|
double RldpSender::get_loss_delay(const RttStats &rtt_stats) {
|
|
auto rtt = std::max(rtt_stats.last_rtt, rtt_stats.smoothed_rtt);
|
|
if (rtt < 0) {
|
|
rtt = config_.initial_rtt;
|
|
}
|
|
return rtt * 8 / 7;
|
|
}
|
|
|
|
double RldpSender::get_probe_delay(const RttStats &rtt_stats) {
|
|
if (rtt_stats.last_rtt < 0) {
|
|
return config_.initial_rtt * 2;
|
|
} else {
|
|
return (rtt_stats.smoothed_rtt + rtt_stats.rtt_var * 4 + config_.max_ack_delay) * probe_k_;
|
|
}
|
|
}
|
|
} // namespace rldp2
|
|
} // namespace ton
|