Changeset 4753

Show
Ignore:
Timestamp:
03/31/10 20:40:15 (4 years ago)
Author:
soohyunc
Message:

(this commit re-writes the packet re-ordering policy done by Revision 4730)

when packet re-ordering occurred (or ack re-ordering) and it is beyond 3
DUPACKS, then we need to revert to the previous state (reverting to the earlier
average loss interval and re-mark the timestamp).

in short, in Revision 4730, we trigger a packet out when this happens.
with this commit, instead of clocking a packet out, we revert ALI and timestamp
to the previous stage if:

-- this re-ordered seqno is beyond 3 DUPACKS
-- and that seqno actually changed ALI earlier

Location:
vic/branches/cc/cc
Files:
2 modified

Legend:

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

    r4752 r4753  
    6464        rtx_timer_(this), 
    6565        aoa_(0), 
    66         t_now_(0), 
    67         t_ts_(0), 
    68         t_ts_echo_(0), 
    6966        now_(0), 
    7067        so_recv_(0), 
     
    134131        clear_pvec(num_vec_); 
    135132        __jacked_ = 0; 
     133        // previous average loss intervals 
     134        prev_interval_ = (double *)malloc(sizeof(double) * RSZ); 
     135        clear_prev_interval(RSZ); 
     136        new_hist_seqno_ = (u_int16_t *)malloc(sizeof(u_int16_t) * RSZ); 
     137        clear_new_hist_seqno(RSZ); 
     138        new_hist_seqno_size_ = 0; 
    136139 
    137140        // packet reordering 
     
    187190        bool outofack = false;  
    188191        UNUSED(outofack); 
     192        // revert to the previous history? 
     193        bool revert = false; 
    189194 
    190195        // get start/end seqno that this XR chunk reports 
     
    234239                  // trigger packets out to keep Jacob's packet conservation rule 
    235240                  if(shift >= DUPACKS) 
    236                   packet_clocking(pb, recv_by_ch); 
     241                  revert = revert_interval(jacked_); 
     242                  cwnd_in_packets(revert); 
     243                  print_cwnd(); 
    237244                  return; 
    238245                } 
     
    293300                // triggering only if the disorder is beyond 3 dupack rule, 
    294301                if (shift >= DUPACKS) 
    295                 packet_clocking(pb, recv_by_ch); 
     302                revert = revert_interval(jacked_); 
     303                cwnd_in_packets(revert); 
     304                print_cwnd(); 
    296305                reset_var(); 
    297306                return; 
     
    301310        if(!is_tfwc_on_) { 
    302311                if(detect_loss()) 
    303                 dupack_action();  
     312                dupack_action(first_lost_pkt_);  
    304313                else 
    305314                cwnd_++; // TCP-like AIMD 
     
    307316        // TFWC is turned on, so compute congestion window 
    308317        else { 
    309                 cwnd_in_packets(); 
     318                cwnd_in_packets(revert); 
    310319        } 
    311320        print_cwnd(); 
     
    533542 * (cwnd is in packets) 
    534543 */ 
    535 void TfwcSndr::cwnd_in_packets() { 
     544void TfwcSndr::cwnd_in_packets(bool revert) { 
     545        if(!revert) { 
    536546        loss_history(); 
    537547        avg_loss_interval(); 
     548        } 
    538549 
    539550        // loss event rate (p) 
     
    614625 *   o  marking pseudo loss history and loss rate 
    615626 */ 
    616 void TfwcSndr::dupack_action() { 
     627void TfwcSndr::dupack_action(int seqno) { 
    617628        // this is the very first packet loss 
    618629        is_first_loss_seen_ = true; 
     
    636647 
    637648        // finally, record the very first lost packet's timestamp 
    638         ts_ = tsvec_[first_lost_pkt_%TSZ]; 
     649        ts_ = tsvec_[seqno%TSZ]; 
    639650        // then, turn on TFWC algo 
    640651        is_tfwc_on_ = true; 
     
    699710                        // this is a new loss event! 
    700711 
     712                        // store previous ALI before changing history 
     713                        record_history(refvec_[i], avg_interval_, ts_); 
     714 
    701715                        // increase current history size 
    702716                        hsz_ = (hsz_ < HSZ) ? ++hsz_ : HSZ; 
     
    757771 
    758772/* 
     773 * store loss interval and timestamp 
     774 */ 
     775void TfwcSndr::record_history(int seqno, double interval, double ts) { 
     776        // store seqno 
     777        new_hist_seqno_[new_hist_seqno_size_++] = seqno; 
     778        // store average loss interval 
     779        prev_interval_[seqno%RSZ] = interval; 
     780        // store timestamp 
     781        prev_ts_ = ts; 
     782        // copy history 
     783        for(int i = 0; i < hsz_; i++) 
     784        prev_history_[i] = history_[i]; 
     785} 
     786 
     787/* 
     788 * revert average loss interval on packet re-ordering 
     789 */ 
     790bool TfwcSndr::revert_interval(int reseq) { 
     791        // we didn't see the first lost packet yet. 
     792        if(!is_first_loss_seen_) { 
     793                dupack_action(reseq); 
     794                return (false); 
     795        } 
     796 
     797        // check if this re-ordered seqno actually triggered a new loss event 
     798        // if yes, revert to the previous state 
     799        if(find_seqno(new_hist_seqno_, new_hist_seqno_size_, reseq)) { 
     800                // reverting to the previous ALI 
     801                avg_interval_ = prev_interval_[reseq%RSZ]; 
     802                // reverting to the previous timestamp 
     803                ts_ = prev_ts_; 
     804                // reverting to the previous history 
     805                for (int i = 0; i < hsz_; i++) 
     806                history_[i] = prev_history_[i]; 
     807 
     808                print_ALI(); 
     809 
     810                // finally, clear up the state variables 
     811                clear_prev_interval(RSZ); 
     812                clear_new_hist_seqno(new_hist_seqno_size_); 
     813                return (true); 
     814        } 
     815        return (false); 
     816} 
     817 
     818/* 
     819 * find seqno in the array 
     820 */ 
     821bool TfwcSndr::find_seqno (u_int16_t *v, int n, int target) { 
     822        for (int i = 0; i < n; i++) { 
     823                if (v[i] == target) 
     824                return true; 
     825        } 
     826        return false; 
     827} 
     828 
     829/* 
    759830 * print history item 
    760831 */ 
  • vic/branches/cc/cc/tfwc_sndr.h

    r4752 r4753  
    187187        u_int16_t *pvec_;       // previous (stored) AckVec 
    188188        u_int16_t aoa_;         // ack of ack 
    189         u_int32_t t_now_;       // the time when the data packet sent 
    190         u_int32_t t_ts_;                // time stamp (u_int32_t type) 
    191         u_int32_t t_ts_echo_;   // echo time stamp from the receiver 
    192189        double ts_;                     // time stamp (double type) 
    193190        double ts_echo_;        // time stamp echo (double type) 
     
    195192        double so_recv_;        // SO_TIMESTAMP (XR packet reception) 
    196193        double tao_;            // sampled RTT 
     194        double prev_ts_; 
    197195 
    198196private: 
     
    206204        // TFWC congestion window 
    207205        void cwnd_in_bytes(); 
    208         void cwnd_in_packets(); 
     206        void cwnd_in_packets(bool revert); 
    209207 
    210208        // calcuate average loss interval 
     
    212210        void print_history_item (int); 
    213211        void print_history_item (int, int); 
     212        bool revert_interval(int reseq); 
     213        void record_history(int seqno, double interval, double ts); 
    214214 
    215215        // calculate loss history 
     
    224224 
    225225        // dupack action 
    226         void dupack_action(); 
     226        void dupack_action(int seqno); 
    227227 
    228228        // new RTO 
     
    283283        } 
    284284 
     285        // clear seqno that triggered a new loss event 
     286        inline void clear_prev_interval (int n) { 
     287                for (int i = 0; i < n; i++) 
     288                prev_interval_[i] = 0; 
     289        } 
     290 
     291        // clear seqno that triggered a new loss event 
     292        inline void clear_new_hist_seqno (int n) { 
     293                for (int i = 0; i < n; i++) 
     294                new_hist_seqno_[i] = 0; 
     295                new_hist_seqno_size_ = 0; 
     296        } 
     297 
    285298        // number of ackvec chunks 
    286299        inline int get_numvec(int n) { 
     
    302315                __jacked_ = highest; 
    303316        } 
     317 
     318        // find seqno 
     319        bool find_seqno(u_int16_t *v, int n, int target); 
    304320 
    305321        // print cwnd for debugging 
     
    344360 
    345361        double ts_off_;         // timestamp offset for gettimeofday 
    346         u_int32_t ref_t_time_;  // reference time (uint32 format) 
    347362 
    348363        u_int32_t *seqvec_;             // generated seqno vec 
     
    360375        double avg_interval_;   // average loss interval 
    361376        int history_[HSZ+1];    // loss interval history 
     377        int prev_history_[HSZ];// previous loss interval history 
    362378        double weight_[HSZ+1];  // weight for calculating avg loss interval 
    363379        double I_tot_;          // total sum 
     
    404420        // highest/lowest packet sequence numbers (prev ackvec) 
    405421        u_int16_t __jacked_;    // previous highest packet sequence number 
     422        double *prev_interval_; // previous avgerage intervals 
     423        u_int16_t *new_hist_seqno_;     // seqno that introduced a new loss event 
     424        int new_hist_seqno_size_; 
    406425 
    407426        // record of packet size in bytes