Changeset 4859

Show
Ignore:
Timestamp:
06/10/10 16:34:11 (4 years ago)
Author:
soohyunc
Message:

*** finished TFRC/TFWC Retransmission Timer Mechanisms ***

min RTO - 200 ms (most Linux TCP implementation)
max RTO = 60 sec (RFC 2988)

Also, TfwcSndr? and TfrcSndr? can directly call functions defined in Transmitter.
This is specially usefule when TfwcSndr/TfrcSndr? want to call
Transmitter::output() method directly.

Location:
vic/branches/cc
Files:
10 modified

Legend:

Unmodified
Added
Removed
  • vic/branches/cc/cc/cc_timer.cpp

    r4751 r4859  
    4141 
    4242        msched((int)delay); 
    43         //status_ = TIMER_HANDLING; 
    44         set_timer_pending(); 
     43        set_timer_handling(); 
    4544} 
    4645 
     
    4948                return; 
    5049 
     50        cancel(); 
    5151        msched((int)delay); 
    52         //status_ = TIMER_HANDLING; 
    53         set_timer_pending(); 
     52        set_timer_handling(); 
    5453} 
    5554 
    56 void CcTimerHandler::cancel() { 
    57         if (status_ != TIMER_PENDING) 
     55void CcTimerHandler::stop() { 
     56        if (status_ != TIMER_HANDLING) 
    5857                abort(); 
    5958 
    60         //status_ = TIMER_IDLE; 
     59        cancel(); 
    6160        set_timer_idle(); 
    6261} 
  • vic/branches/cc/cc/cc_timer.h

    r4751 r4859  
    3535#define vic_cc_timer_h 
    3636 
     37#include <sys/time.h> 
    3738#include "timer.h" 
     39 
     40// timer related 
     41#define CC_TIMER_RTX    0 
     42#define CC_TIMER_RESET  1 
    3843 
    3944class CcTimerHandler : public Timer { 
     
    4449        void sched(double delay); 
    4550        void resched(double delay); 
    46         void cancel(); 
     51        void stop(); 
    4752        enum CcTimerStatus {TIMER_IDLE, TIMER_PENDING, TIMER_HANDLING}; 
    4853        inline int status() { return status_; }; 
     
    5055        inline void set_timer_pending() { status_ = TIMER_PENDING; }; 
    5156        inline void set_timer_handling() { status_ = TIMER_HANDLING; }; 
     57 
     58    // gettimeofday 
     59    inline double cc_now() { 
     60        timeval tv; 
     61        ::gettimeofday(&tv, NULL); 
     62        return ((double) tv.tv_sec + 1e-6 * (double) tv.tv_usec); 
     63    } 
    5264 
    5365protected: 
  • vic/branches/cc/cc/tfrc_rcvr.h

    r4804 r4859  
    5858        // TfrcRcvr instance 
    5959        static inline TfrcRcvr& instance() { return instance_; } 
     60        // Transmitter  
     61        inline void manager(Transmitter* tm) { tm_ = tm; } 
    6062 
    6163protected: 
    6264 
    6365        static TfrcRcvr instance_; 
     66        Transmitter *tm_; 
    6467 
    6568        /* 
  • vic/branches/cc/cc/tfrc_sndr.cpp

    r4855 r4859  
    5353 
    5454/* 
     55 * retransmission timer 
     56 */ 
     57void TfrcSndr::timeout() { 
     58    if((now() - set_time_) > rto_) 
     59    expire(CC_TIMER_RTX); 
     60} 
     61 
     62/* 
    5563 * TFRC Sender Constructor 
    5664 */ 
     
    8492 
    8593        // initialize variables 
    86         minrto_ = 0.0; 
    87         maxrto_ = 100000.0; 
     94        minrto_ = 0.2;  // Linux TCP implementation 
     95        maxrto_ = 60.0; // RFC 2988 
    8896        srtt_ = -1.0; 
    8997        rto_ = 3.0;     // RFC 1122 
     
    97105        k_ = 4; 
    98106        ts_ = 0.0; 
     107        set_time_ = 0.0; 
    99108 
    100109        is_tfrc_on_ = false; 
     
    131140        // the very first data packet 
    132141        if(seqno_ == 0) 
    133         ts_off_ = tx_ts_offset(); 
     142        ts_off_ = tm_->tx_ts_offset(); 
    134143 
    135144        // parse seqno and mark timestamp for this data packet 
     
    527536        } 
    528537 
    529         // 'rto' could be rounded by 'maxrto' 
     538        // 'rto' could be rounded by "min/maxrto" 
    530539        if (rto_ > maxrto_) 
    531540                rto_ = maxrto_; 
     541        if (rto_ < minrto_) 
     542                rto_ = minrto_; 
    532543 
    533544        print_rtt_info(); 
     
    657668} 
    658669 
     670/* 
     671 * retransmission timer-out 
     672 */ 
     673void TfrcSndr::expire(int option) { 
     674        if (option == CC_TIMER_RTX) { 
     675                // reset timer 
     676                reset_rtx_timer(1); 
     677                // send packets 
     678                tm_->tfrc_output(); 
     679        } 
     680} 
     681 
     682void TfrcSndr::reset_rtx_timer (int backoff) { 
     683        if(backoff) 
     684        backoff_timer(); 
     685 
     686        set_rtx_timer(); 
     687} 
     688 
     689/* 
     690 * backoff Rtx Timer 
     691 */ 
     692void TfrcSndr::backoff_timer() { 
     693        if (srtt_ < 0) srtt_ = 1.0; 
     694        rto_ = 2.0 * rto_; 
     695 
     696        if (rto_ > maxrto_) 
     697                rto_ = maxrto_; 
     698        if (rto_ < minrto_) 
     699                rto_ = minrto_; 
     700} 
     701 
     702/* 
     703 * set Rtx Timer 
     704 */ 
     705void TfrcSndr::set_rtx_timer() { 
     706        //print_rto_info(); 
     707         
     708        // mark time when setting timer 
     709        set_time_ = now_; 
     710        // resched() is basically msched(miliseconds) 
     711        resched(rto_ * 1000.); 
     712} 
  • vic/branches/cc/cc/tfrc_sndr.h

    r4858 r4859  
    4343 
    4444// TFRC sender class 
    45 class TfrcSndr { 
     45class TfrcSndr : public CcTimerHandler { 
    4646public: 
    4747        // constructor 
     
    5050 
    5151        // virtual functions 
    52         virtual void tfrc_output(bool ack_clock=0) {UNUSED(ack_clock);}; 
    53         virtual void tfrc_output(pktbuf*) {}; 
    54         virtual double tx_ts_offset() {}; 
    55         virtual int tx_buf_size() {}; 
     52        virtual void timeout(); 
    5653 
    5754        // parse seqno and timestamp 
     
    7269        double x_rate_;         // send rate (bytes/sec) 
    7370 
     71        // Rtx timer 
     72        void expire(int option); 
     73 
    7474        // TfrcSndr instance 
    7575        static inline TfrcSndr& instance() { return instance_; } 
    7676 
     77    // Transmitter  
     78        inline void manager(Transmitter* tm) { tm_ = tm; } 
     79 
    7780protected: 
    7881 
    7982        static TfrcSndr instance_; 
     83        Transmitter *tm_; 
    8084 
    8185        // generate sequence numbers 
     
    8690        void reset_var(bool reverted); 
    8791 
     92    // return the current time 
     93        inline double now() { return (cc_now()-ts_off_); } 
     94 
     95        void set_rtx_timer(); 
     96        void reset_rtx_timer(int backoff); 
     97        void backoff_timer(); 
     98 
    8899        u_int16_t *ackv_;       // received AckVec 
    89100        u_int16_t aoa_; // ack of ack 
     
    92103        double so_recv_;        // SO_TIMESTAMP 
    93104        double tao_;            // sampled RTT 
     105        double set_time_;       // set time for rtx_timer 
    94106 
    95107        // packet size 
  • vic/branches/cc/cc/tfwc_rcvr.h

    r4804 r4859  
    6262        static inline TfwcRcvr& instance() { return instance_; } 
    6363 
     64    // Transmitter  
     65        inline void manager(Transmitter* tm) { tm_ = tm; } 
     66 
    6467protected: 
    6568 
    6669        static TfwcRcvr instance_; 
     70        Transmitter *tm_; 
    6771 
    6872        /* 
  • vic/branches/cc/cc/tfwc_sndr.cpp

    r4852 r4859  
    4444#include "tfwc_sndr.h" 
    4545 
    46 /* 
    47  * retransmission timer 
    48  */ 
    49 void TfwcRtxTimer::timeout() { 
    50         debug_msg("\t*------ TIMEOUT! ------*\n"); 
    51         s_ -> expire(TFWC_TIMER_RTX); 
    52 } 
    53  
    5446// TfwcSndr instance 
    5547TfwcSndr TfwcSndr::instance_; 
     48 
     49/* 
     50 * retransmission timer 
     51 */ 
     52void TfwcSndr::timeout() { 
     53        if((now() - set_time_) > rto_) 
     54        expire(CC_TIMER_RTX); 
     55} 
    5656 
    5757/*  
     
    6262        cwnd_(1),               // initial cwnd in packet 
    6363        bcwnd_(MAX_RTP),// initial cwnd in byte 
    64         rtx_timer_(this), 
    6564        aoa_(0), 
    6665        now_(0), 
     
    9594                mvec_[i] = 0; 
    9695 
    97         minrto_ = 0.0; 
    98         maxrto_ = 100000.0; 
     96        minrto_ = 0.2;  // Linux TCP implementation 
     97        maxrto_ = 60.0; // RFC 2988 
    9998        srtt_ = -1.0; 
    10099        rto_ = 3.0;             // RFC 1122 
     
    109108        ts_ = 0.0; 
    110109        ts_echo_ = 0.0; 
     110        set_time_ = 0.0; 
    111111 
    112112        is_tfwc_on_ = false; 
     
    154154void TfwcSndr::send(pktbuf* pb, double now) { 
    155155        // the very first data packet 
    156         if(seqno_ == 0) 
    157         ts_off_ = tx_ts_offset(); 
     156        if(seqno_ < 1) 
     157        ts_off_ = tm_->tx_ts_offset(); 
    158158 
    159159        // parse seqno and mark timestamp for this data packet 
     
    581581        } 
    582582 
    583         // 'rto' could be rounded by 'maxrto' 
     583        // 'rto' could be rounded by "min/maxrto" 
    584584        if (rto_ > maxrto_) 
    585585                rto_ = maxrto_; 
     586        if (rto_ < minrto_) 
     587                rto_ = minrto_; 
    586588 
    587589        print_rtt_info(); 
     
    898900 */ 
    899901void TfwcSndr::expire(int option) { 
    900         if (option == TFWC_TIMER_RTX) { 
     902        if (option == CC_TIMER_RTX) { 
    901903                if(!to_driven_) 
    902904                reset_rtx_timer(1); 
     
    909911 
    910912                // trigger packet sending 
    911                 tfwc_output(); 
     913                tm_->tfwc_output(); 
    912914        } 
    913915} 
     
    918920void TfwcSndr::reset_rtx_timer (int backoff) { 
    919921        if(backoff) 
    920                 backoff_timer(); 
     922        backoff_timer(); 
    921923 
    922924        set_rtx_timer(); 
     
    928930void TfwcSndr::backoff_timer() { 
    929931        if (srtt_ < 0) srtt_ = 1.0; 
    930         rto_ = 2.0 * srtt_; 
    931  
     932        rto_ = 2.0 * rto_; 
     933         
    932934        if (rto_ > maxrto_) 
    933935                rto_ = maxrto_; 
     936        if (rto_ < minrto_) 
     937                rto_ = minrto_; 
    934938} 
    935939 
     
    938942 */ 
    939943void TfwcSndr::set_rtx_timer() { 
     944        //print_rto_info(); 
     945 
     946        // mark time when setting timer 
     947        set_time_ = now_; 
    940948        // resched() is basically msched(miliseconds) 
    941         rtx_timer_.resched(rto_ * 1000.); 
     949        resched(rto_ * 1000.); 
    942950} 
    943951 
     
    963971void TfwcSndr::packet_clocking (pktbuf* pb, bool flag) { 
    964972        if (flag) 
    965                 tfwc_trigger(); 
     973                tm_->tfwc_trigger(); 
    966974        else 
    967                 tfwc_trigger(pb); 
    968 } 
     975                tm_->tfwc_trigger(pb); 
     976} 
  • vic/branches/cc/cc/tfwc_sndr.h

    r4831 r4859  
    3939#include "cc_common.h" 
    4040#include "cc_timer.h" 
    41  
    42 // timer related 
    43 #define TFWC_TIMER_RTX          0 
    44 #define TFWC_TIMER_RESET        1 
     41#include "transmitter.h" 
    4542 
    4643class TfwcSndr; 
    47  
    48 // re-transmission timer 
    49 class TfwcRtxTimer : public CcTimerHandler { 
    50 public: 
    51         TfwcRtxTimer(TfwcSndr *s) : CcTimerHandler() { s_ = s;} 
    52         virtual void timeout(); 
    53  
    54 protected: 
    55         TfwcSndr *s_; 
    56 }; 
     44class Transmitter; 
    5745 
    5846// TFWC sender class 
    59 class TfwcSndr { 
     47class TfwcSndr : public CcTimerHandler { 
    6048public: 
    6149        // constructor 
     
    6452 
    6553        // virtual functions 
    66         virtual void tfwc_output(bool ack_clock=0) {UNUSED(ack_clock);}; 
    67         virtual void tfwc_output(pktbuf*, bool) {}; 
    68         virtual void tfwc_trigger(pktbuf* pb=0) {UNUSED(pb);}; 
    69         virtual double tx_ts_offset() {}; 
    70         virtual int tx_buf_size() {}; 
     54        virtual void timeout(); 
    7155 
    7256        // parse seqno and timestamp 
     
    8872        inline int b_magic() { return bcwnd_; } 
    8973 
    90         // set timestamp in double type (TfwcSndr) 
    91         inline double tfwc_sndr_now() { 
    92                 timeval tv; 
    93                 ::gettimeofday(&tv, NULL); 
    94                 return ((double) tv.tv_sec + 1e-6 * (double) tv.tv_usec); 
    95         } 
    96  
    9774        // return the current time 
    98         inline double now() { return (tfwc_sndr_now()-ts_off_); } 
     75        inline double now() { return (cc_now()-ts_off_); } 
    9976 
    10077        // variables 
     
    11087        static inline TfwcSndr& instance() { return instance_; } 
    11188 
     89        // Transmitter  
     90        inline void manager(Transmitter* tm) { tm_ = tm; } 
     91 
    11292protected: 
    11393 
    11494        static TfwcSndr instance_; 
     95        Transmitter *tm_; 
    11596 
    11697        // generate sequence numbers 
     
    150131                0 : (u_int16_t) (mvec_[DUPACKS - 1] - 1); 
    151132        } 
    152  
    153         // retransmission timer 
    154         TfwcRtxTimer rtx_timer_; 
    155133 
    156134        void set_rtx_timer(); 
     
    168146        double tao_;            // sampled RTT 
    169147        double prev_ts_; 
     148        double set_time_;       // set time for rtx_timer 
    170149 
    171150        // packet size 
     
    337316        "\t%s now_: %f tsvec_[%d]: %f rtt: %f srtt: %f\n", 
    338317        str, so_recv_, jacked_%TSZ, tsvec_[jacked_%TSZ], tao_, srtt_); 
     318        } 
     319        // print RTO info 
     320        inline void print_rto_info() { 
     321        fprintf(stderr, 
     322        "\t>> now_: %f rto: %f\n", now(), rto_); 
    339323        } 
    340324 
  • vic/branches/cc/rtp/transmitter.cpp

    r4835 r4859  
    108108                tfwc_sndr_ = TfwcSndr::instance(); 
    109109                tfwc_rcvr_ = TfwcRcvr::instance(); 
     110 
     111                tfwc_sndr_.manager(this); 
     112                tfwc_rcvr_.manager(this); 
     113 
    110114          break; 
    111115          case RBCC: 
    112116                tfrc_sndr_ = TfrcSndr::instance(); 
    113117                tfrc_rcvr_ = TfrcRcvr::instance(); 
     118 
     119                tfrc_sndr_.manager(this); 
     120                tfrc_rcvr_.manager(this); 
     121 
    114122          break; 
    115123        } 
  • vic/branches/cc/rtp/transmitter.h

    r4831 r4859  
    102102        inline bool is_cc_on() { return is_cc_active_; } 
    103103        // TFWC output 
    104         virtual void tfwc_output(bool ack_clock=0); 
    105         virtual void tfwc_output(pktbuf*, bool ack_clock); 
    106         virtual void tfwc_trigger(pktbuf*); 
     104        void tfwc_output(bool ack_clock=0); 
     105        void tfwc_output(pktbuf*, bool ack_clock); 
     106        void tfwc_trigger(pktbuf* pb=0); 
    107107        // TFRC output 
    108         virtual void tfrc_output(bool ack_clock=0); 
    109         virtual void tfrc_output(pktbuf*); 
     108        void tfrc_output(bool ack_clock=0); 
     109        void tfrc_output(pktbuf*); 
    110110 
    111111        /*