send_control.cpp

   1 /*
   2  *  send_control.cpp
   3  *  congestion control logic for the swift protocol
   4  *
   5  *  Created by Victor Grishchenko on 12/10/09.
   6  *  Copyright 2009 Delft University of Technology. All rights reserved.
   7  *
   8  */
   9
  10 #include "swift.h"
  11
  12 using namespace swift;
  13 using namespace std;
  14
  15 tint Channel::MIN_DEV = 50*TINT_MSEC;
  16 tint Channel::MAX_SEND_INTERVAL = TINT_SEC*58;
  17 tint Channel::LEDBAT_TARGET = TINT_MSEC*25;
  18 float Channel::LEDBAT_GAIN = 1.0/LEDBAT_TARGET;
  19 tint Channel::LEDBAT_DELAY_BIN = TINT_SEC*30;
  20 tint Channel::MAX_POSSIBLE_RTT = TINT_SEC*10;
  21 const char* Channel::SEND_CONTROL_MODES[] = {"keepalive", "pingpong",
  22     "slowstart", "standard_aimd", "ledbat", "closing"};
  23
  24
  25 tint    Channel::NextSendTime () {
  26     TimeoutDataOut(); // precaution to know free cwnd
  27     switch (send_control_) {
  28         case KEEP_ALIVE_CONTROL: return KeepAliveNextSendTime();
  29         case PING_PONG_CONTROL:  return PingPongNextSendTime();
  30         case SLOW_START_CONTROL: return SlowStartNextSendTime();
  31         case AIMD_CONTROL:       return AimdNextSendTime();
  32         case LEDBAT_CONTROL:     return LedbatNextSendTime();
  33         case CLOSE_CONTROL:      return TINT_NEVER;
  34         default:                 assert(false);
  35     }
  36 }
  37
  38 tint    Channel::SwitchSendControl (int control_mode) {
  39     dprintf("%s #%u sendctrl switch %s->%s\n",tintstr(),id(),
  40             SEND_CONTROL_MODES[send_control_],SEND_CONTROL_MODES[control_mode]);
  41     switch (control_mode) {
  42         case KEEP_ALIVE_CONTROL:
  43             send_interval_ = rtt_avg_; //max(TINT_SEC/10,rtt_avg_);
  44             dev_avg_ = max(TINT_SEC,rtt_avg_);
  45             data_out_cap_ = bin64_t::ALL;
  46             cwnd_ = 1;
  47             break;
  48         case PING_PONG_CONTROL:
  49             dev_avg_ = max(TINT_SEC,rtt_avg_);
  50             data_out_cap_ = bin64_t::ALL;
  51             cwnd_ = 1;
  52             break;
  53         case SLOW_START_CONTROL:
  54             cwnd_ = 1;
  55             break;
  56         case AIMD_CONTROL:
  57             break;
  58         case LEDBAT_CONTROL:
  59             break;
  60         case CLOSE_CONTROL:
  61             break;
  62         default:
  63             assert(false);
  64     }
  65     send_control_ = control_mode;
  66     return NextSendTime();
  67 }
  68
  69 tint    Channel::KeepAliveNextSendTime () {
  70     if (sent_since_recv_>=3 && last_recv_time_<NOW-TINT_MIN)
  71         return SwitchSendControl(CLOSE_CONTROL);
  72     if (ack_rcvd_recent_)
  73         return SwitchSendControl(SLOW_START_CONTROL);
  74     if (data_in_.time!=TINT_NEVER)
  75         return NOW;
  76     if (last_send_time_==NOW)
  77         send_interval_ <<= 1;
  78     if (send_interval_>MAX_SEND_INTERVAL)
  79         send_interval_ = MAX_SEND_INTERVAL;
  80     return last_send_time_ + send_interval_;
  81 }
  82
  83 tint    Channel::PingPongNextSendTime () { // FIXME INFINITE LOOP
  84     if (dgrams_sent_>=10)
  85         return SwitchSendControl(KEEP_ALIVE_CONTROL);
  86     if (ack_rcvd_recent_)
  87         return SwitchSendControl(SLOW_START_CONTROL);
  88     if (data_in_.time!=TINT_NEVER)
  89         return NOW;
  90     if (last_recv_time_>last_send_time_)
  91         return NOW;
  92     if (!last_send_time_)
  93         return NOW;
  94     return last_send_time_ + ack_timeout(); // timeout
  95 }
  96
  97 tint    Channel::CwndRateNextSendTime () {
  98     if (data_in_.time!=TINT_NEVER)
  99         return NOW; // TODO: delayed ACKs
 100     //if (last_recv_time_<NOW-rtt_avg_*4)
 101     //    return SwitchSendControl(KEEP_ALIVE_CONTROL);
 102     send_interval_ = rtt_avg_/cwnd_;
 103     if (send_interval_>max(rtt_avg_,TINT_SEC)*4)
 104         return SwitchSendControl(KEEP_ALIVE_CONTROL);
 105     if (data_out_.size()<cwnd_) {
 106         dprintf("%s #%u sendctrl next in %llius (cwnd %.2f, data_out %i)\n",
 107                 tintstr(),id_,send_interval_,cwnd_,(int)data_out_.size());
 108         return last_data_out_time_ + send_interval_;
 109     } else {
 110         assert(data_out_.front().time!=TINT_NEVER);
 111         return data_out_.front().time + ack_timeout();
 112     }
 113 }
 114
 115 void    Channel::BackOffOnLosses (float ratio) {
 116     ack_rcvd_recent_ = 0;
 117     ack_not_rcvd_recent_ =  0;
 118     if (last_loss_time_<NOW-rtt_avg_) {
 119         cwnd_ *= ratio;
 120         last_loss_time_ = NOW;
 121         dprintf("%s #%u sendctrl backoff %3.2f\n",tintstr(),id_,cwnd_);
 122     }
 123 }
 124
 125 tint    Channel::SlowStartNextSendTime () {
 126     if (ack_not_rcvd_recent_) {
 127         BackOffOnLosses();
 128         return SwitchSendControl(LEDBAT_CONTROL);//AIMD_CONTROL);
 129     }
 130     if (rtt_avg_/cwnd_<TINT_SEC/10)
 131         return SwitchSendControl(LEDBAT_CONTROL);//AIMD_CONTROL);
 132     cwnd_+=ack_rcvd_recent_;
 133     ack_rcvd_recent_=0;
 134     return CwndRateNextSendTime();
 135 }
 136
 137 tint    Channel::AimdNextSendTime () {
 138     if (ack_not_rcvd_recent_)
 139         BackOffOnLosses();
 140     if (ack_rcvd_recent_) {
 141         if (cwnd_>1)
 142             cwnd_ += ack_rcvd_recent_/cwnd_;
 143         else
 144             cwnd_ *= 2;
 145     }
 146     ack_rcvd_recent_=0;
 147     return CwndRateNextSendTime();
 148 }
 149
 150 tint Channel::LedbatNextSendTime () {
 151     tint owd_cur(TINT_NEVER), owd_min(TINT_NEVER);
 152     for(int i=0; i<4; i++) {
 153         if (owd_min>owd_min_bins_[i])
 154             owd_min = owd_min_bins_[i];
 155         if (owd_cur>owd_current_[i])
 156             owd_cur = owd_current_[i];
 157     }
 158     if (ack_not_rcvd_recent_)
 159         BackOffOnLosses(0.8);
 160     ack_rcvd_recent_ = 0;
 161     tint queueing_delay = owd_cur - owd_min;
 162     tint off_target = LEDBAT_TARGET - queueing_delay;
 163     cwnd_ += LEDBAT_GAIN * off_target / cwnd_;
 164     if (cwnd_<1)
 165         cwnd_ = 1;
 166     if (owd_cur==TINT_NEVER || owd_min==TINT_NEVER)
 167         cwnd_ = 1;
 168     dprintf("%s #%u sendctrl ledbat %lli-%lli => %3.2f\n",
 169             tintstr(),id_,owd_cur,owd_min,cwnd_);
 170     return CwndRateNextSendTime();
 171 }
 172
 173
 174