solanaceae_ngc_ft1/solanaceae/ngc_ft1/ledbat.hpp

131 lines
3.9 KiB
C++
Raw Normal View History

#pragma once
2023-08-23 13:04:54 +02:00
#include "./cca.hpp"
#include <chrono>
#include <deque>
#include <vector>
#include <cstdint>
// LEDBAT: https://www.rfc-editor.org/rfc/rfc6817
// LEDBAT++: https://www.ietf.org/archive/id/draft-irtf-iccrg-ledbat-plus-plus-01.txt
// LEDBAT++ implementation
2023-12-13 19:38:55 +01:00
struct LEDBAT : public CCAI {
public: // config
2023-08-23 13:04:54 +02:00
#if 0
using SeqIDType = std::pair<uint8_t, uint16_t>; // tf_id, seq_id
static constexpr size_t IPV4_HEADER_SIZE {20};
static constexpr size_t IPV6_HEADER_SIZE {40}; // bru
static constexpr size_t UDP_HEADER_SIZE {8};
// TODO: tcp AND IPv6 will be different
static constexpr size_t SEGMENT_OVERHEAD {
4+ // ft overhead
46+ // tox?
UDP_HEADER_SIZE+
IPV4_HEADER_SIZE
};
// TODO: make configurable, set with tox ngc lossy packet size
//const size_t MAXIMUM_SEGMENT_DATA_SIZE {1000-4};
const size_t MAXIMUM_SEGMENT_DATA_SIZE {500-4};
//static constexpr size_t maximum_segment_size {496 + segment_overhead}; // tox 500 - 4 from ft
const size_t MAXIMUM_SEGMENT_SIZE {MAXIMUM_SEGMENT_DATA_SIZE + SEGMENT_OVERHEAD}; // tox 500 - 4 from ft
//static_assert(maximum_segment_size == 574); // mesured in wireshark
2023-08-23 13:04:54 +02:00
#endif
// ledbat++ says 60ms, we might need other values if relayed
//const float target_delay {0.060f};
const float target_delay {0.030f};
//const float target_delay {0.120f}; // 2x if relayed?
// TODO: use a factor for multiple of rtt
static constexpr size_t current_delay_filter_window {16*4};
//static constexpr size_t rtt_buffer_size_max {2000};
public:
LEDBAT(size_t maximum_segment_data_size);
virtual ~LEDBAT(void) {}
// return the current believed window in bytes of how much data can be inflight,
// without overstepping the delay requirement
float getWindow(void) const override {
return _cwnd;
}
// TODO: api for how much data we should send
// take time since last sent into account
// respect max_byterate_allowed
int64_t canSend(float time_delta) override;
// get the list of timed out seq_ids
2023-08-23 13:04:54 +02:00
std::vector<SeqIDType> getTimeouts(void) const override;
public: // callbacks
// data size is without overhead
2023-08-23 13:04:54 +02:00
void onSent(SeqIDType seq, size_t data_size) override;
2023-08-23 13:04:54 +02:00
void onAck(std::vector<SeqIDType> seqs) override;
// if discard, not resent, not inflight
2023-08-23 13:04:54 +02:00
void onLoss(SeqIDType seq, bool discard) override;
private:
using clock = std::chrono::steady_clock;
// make values relative to algo start for readability (and precision)
// get timestamp in seconds
float getTimeNow(void) const {
return std::chrono::duration<float>{clock::now() - _time_start_offset}.count();
}
// moving avg over the last few delay samples
// VERY sensitive to bundling acks
2023-09-01 17:34:05 +02:00
float getCurrentDelay(void) const override;
void addRTT(float new_delay);
void updateWindows(void);
private: // state
//float _cto {2.f}; // congestion timeout value in seconds
float _cwnd {2.f * MAXIMUM_SEGMENT_SIZE}; // in bytes
float _base_delay {2.f}; // lowest mesured delay in _rtt_buffer in seconds
float _last_cwnd {0.f}; // timepoint of last cwnd correction
int64_t _recently_acked_data {0}; // reset on _last_cwnd
int64_t _recently_sent_bytes {0};
2023-08-24 01:28:13 +02:00
bool _recently_lost_data {false};
float _last_congestion_event {0.f};
float _last_congestion_rtt {0.5f};
// initialize to low value, will get corrected very fast
float _fwnd {0.01f * max_byterate_allowed}; // in bytes
// ssthresh
// spec recomends 10min
// TODO: optimize and devide into spans of 1min (spec recom)
std::deque<float> _tmp_rtt_buffer;
std::deque<std::pair<float, float>> _rtt_buffer; // timepoint, delay
std::deque<float> _rtt_buffer_minutes;
// list of sequence ids and timestamps of when they where sent
std::deque<std::tuple<SeqIDType, float, size_t>> _in_flight;
int64_t _in_flight_bytes {0};
2023-08-24 18:04:25 +02:00
SeqIDType _last_ack_got {0xff, 0xffff}; // some default
private: // helper
clock::time_point _time_start_offset;
};