src/vfer_ccontrol.c

Go to the documentation of this file.

/*
 * Copyright 2005, 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */
/**
 *
 * @file   vfer_ccontrol.c
 * @author Ivan Beschastnikh
 * @brief  Implements congestion control hooks for control.c
 *
 * This file contains functions that are called from control.c
 * whenever cc needs to be done or queried for advice. For now this
 * file is included in control.c and all functions are inlined for
 * efficiency.
 *
 * -     05/28/06        ivan            Moved to use btree instead of minhist structure for delay tracking
 * -     03/25/06        ivan            Joined with ccontrol.h, functions renamed, delay-based cc functions created.
 * -     03/20-24/06     ivan            Lots of work and everything is revamped to do delay based CC
 * -     02/19/06        ivan            Added minhist addition of delay values
 * -     02/18/06        ivan            Created
 */

#include "vfer_ccontrol.h"

/**
 * Takes appropriate CC action after having sent a control packet
 *
 * @param p control packet
 * @param sock socket whose cc we are dealing with
 */
void CC_Sent_CtlPack(packet* p, vfer_sock* sock) {
        sock->ccontrol.s_inflight++;
        sock->ccontrol.s_last_seq = sock->l_seq + 1;
        DEBUG_CC(DEBUG_CCTL, "ccontrol.c", "CC_Sent_CtlPack", sock);
} /* CC_Sent_CtlPack() */

/**
 * Takes appropriate CC action upon receiving a close packet
 *
 * @param p cc ack packet
 * @param sock socket whose cc we are dealing with
 */
void CC_Recvd_Close(packet* p, vfer_sock* sock) {
        ccontrol_t* c;
        struct timeval tv;
        c = &(sock->ccontrol);
        GET_TIME_OF_DAY(&tv);
        Tree_Insert(&(c->rev_path_base_delayhist), p->delay, tv);
        Tree_Insert(&(c->rev_path_curr_delayhist), p->delay, tv);
        //sock->delay = p->delay;
        sock->ccontrol.r_last_seq = p->seq + 1;
} /* CC_Recvd_Close() */

/**
 * Determines if a data packet of specific size can be sent at this
 * time on a socket, uses byte accounting.
 *
 * @param data_size data size that control.c would like to send as a data packet
 * @param sock socket whose cc we are dealing with
 *
 * @return 0 if CC doesn't allow for sending of data_size bytes
 * @return 1 if CC does allow for sending of data_size bytes
 */
inline int CC_Can_Send_Data(size_t data_size, vfer_sock* sock) {
        if ((data_size + sock->ccontrol.s_cwnd_sent) > sock->ccontrol.s_cwnd) {
                return 0;
        }
        return 1;
} /* CC_Can_Send_Data() */

/**
 * Takes appropriate CC action after having sent a data packet
 *
 * @param p data packet which was sent
 * @param frame frame pointer of which the data packet is carrying a fragment
 * @param sock socket whose cc we are dealing with
 */
inline void CC_Sent_Data(packet* p, frame_link* frame, vfer_sock* sock) {
        sock->ccontrol.s_cwnd_sent              += p->u.data.data_len;  /* window in byte accounting */
        sock->ccontrol.s_last_seq               = sock->l_seq + 1;
        /* s_last_unacked_data timestamp is set in control.c : ControlT */
        sock->ccontrol.s_last_data_frame        = frame;
        sock->ccontrol.s_last_data_offset       = p->u.data.data_offset;
        sock->ccontrol.s_inflight++;
//      DEBUG_CC(DEBUG_CCTL, "ccontrol.c", "CC_Sent_Data", sock);
} /* CC_Sent_Data() */

/**
 * Takes appropriate CC action upon receiving a data packet
 *
 * @param p data packet
 * @param sock socket whose cc we are dealing with
 */
void CC_Recvd_Data(packet* p, vfer_sock* sock) {
        ccontrol_t* c;
        struct timeval tv;

        c = &(sock->ccontrol);
        GET_TIME_OF_DAY(&tv);
        Tree_Insert(&(c->rev_path_base_delayhist), p->delay, tv);
        Tree_Insert(&(c->rev_path_curr_delayhist), p->delay, tv);
        
        if (p->seq >= c->r_last_seq) {
                /* received a consecutive packet ; stretch the current rtt receiving window
                   and figure out the number of missed packets between the current boundary and the new boundary */
                /* DEBUG_PRINT(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Data", "data packet [%d bytes] with future seq, expanding receiving window", p->u.data.data_len); */
                c->r_packets_lost       += (p->seq - c->r_last_seq);
                c->r_last_seq            = p->seq+1;
        } else if (p->seq >= c->r_first_seq) {
                /* received a packet that was previous counted as lost
                   update the lost count by -1 for current rtt ; do not stretch the receiving window */
                DEBUG_PRINT(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Data", "data packet [%d bytes] that was counted as lost", p->u.data.data_len);
                c->r_packets_lost--;
        } else {
                DEBUG_PRINT(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Data", "data packet from the past");
                return;
        }

        c->r_bytes_total += p->u.data.data_len;
        c->r_unacked_bytes += p->u.data.data_len;

        /* DEBUG_CC(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Data", sock); */
} /* CC_Recvd_Data() */


/**
 * Takes appropriate CC action upon receiving a cc ack packet.
 * Currently implements a delay based CC.
 *
 * @param p cc ack packet
 * @param sock socket whose cc we are dealing with
 */
void CC_Recvd_Ack(packet* p, vfer_sock* sock) {
        int packets_acked;
        int new_rtt;
        uint16_t packets_lost;
        uint32_t bytes_acked;
        ccontrol_t* c;
        struct timeval tv;
        double off_target;
        int lost;
        double scaled_gain;

        c = &(sock->ccontrol);

        /* make sure that this ack acknowledges a packet in our sending range */
        if (!((p->u.ccack.last_seq >= (c->s_first_seq - 1) &&
               p->u.ccack.last_seq < c->s_last_seq))) {
                DEBUG_PRINT(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Ack", "ack acknowledges a packet[s] outside of current window range ; ignoring");
                return;
        }

        DEBUG_PACK(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Ack", p, ":");
        GET_TIME_OF_DAY(&tv);
        Tree_Insert(&(c->rev_path_base_delayhist), p->delay, tv);
        Tree_Insert(&(c->rev_path_curr_delayhist), p->delay, tv);

        c->delay_delta          = p->u.ccack.delay_delta;
        c->delay                = p->u.ccack.delay;

        /* compute the rtt from the cc ack information and update the avg,max,min rtt stats */
        new_rtt = abs(p->u.ccack.delay - p->delay);
        if (new_rtt == 0) new_rtt = 1;
        sock->stats.avg_rtt = ((sock->stats.avg_rtt * sock->stats.rtt_measurements) + new_rtt) / (sock->stats.rtt_measurements + 1);
        if (sock->stats.max_rtt < new_rtt) sock->stats.max_rtt = new_rtt;
        if (sock->stats.min_rtt > new_rtt) sock->stats.min_rtt = new_rtt;
        sock->stats.rtt_measurements++;

        /* compute packet loss */
        if (c->last_packets_lost < p->u.ccack.packets_lost) {
                packets_lost = p->u.ccack.packets_lost - c->last_packets_lost;
        } else {
                packets_lost = 0;
        }

        /* compute packets_acked and update packet inflight */
        packets_acked = p->u.ccack.last_seq - c->s_first_seq + 1;
        if (packets_acked > c->s_inflight) {
                ERROR_PRINT("ccontrol.c","CC_Recvd_Ack","packets_acked > c->s_inflight !");
                c->s_inflight = 0;
        } else {
                c->s_inflight -= packets_acked;
}

        /* compute bytes_acked */
        if ((p->u.ccack.bytes_total - c->last_bytes_total) != 0) {
                bytes_acked = p->u.ccack.bytes_total - c->last_bytes_total;
        } else {
                bytes_acked = 0;
        }

        off_target = CCONTROL_TARGET - (c->delay_delta);
        /* GAIN = rate increase or (MAX_CWND_INCREASE_PACKETS_PER_RTT * UNACKED_THRESH * MTU * MTU) / TARGET
           scaled_gain = GAIN * off_target / CWND */
        scaled_gain = (MAX_CWND_INCREASE_PACKETS_PER_RTT * c->mtu * c->mtu * off_target * UNACKED_THRESH) / (CCONTROL_TARGET * (double)(c->s_cwnd));

        // printf("mtu[%d] off_target[%f] scaled_gain[%f] old_cwnd[%d]\n", c->mtu, off_target, scaled_gain, c->s_cwnd);
        
        if (scaled_gain < 0 && ((scaled_gain * -1) > c->s_cwnd)) {
                c->s_cwnd = 4 * c->mtu;
        } else {
                if (scaled_gain > c->s_maxw ||
                    (c->s_maxw - c->s_cwnd) < scaled_gain) {
                        c->s_cwnd = c->s_maxw;
                } else {
                        c->s_cwnd += scaled_gain;
                }
        }

        if (packets_lost != 0) {
                lost = 0;
                if (c->r_last_loss.tv_sec == 0) {
                        c->s_cwnd /= 2;
                        lost = 1;
                        c->r_last_loss = tv;
                }
        }

        /* make sure that the congestion window is below max */
        if (c->s_cwnd > c->s_maxw) {
                DEBUG_PRINT(DEBUG_CCTL, "ccontrol.c","CC_Recvd_Ack","cwin too large, setting to [%u]", c->s_maxw);
                c->s_cwnd = c->s_maxw;
        }

        /* make sure that we don't shrink our window too small: min of 4*MSS */
        if (c->s_cwnd < 4 * c->mtu) {
                c->s_cwnd = 4 * c->mtu;
        }

        c->last_bytes_total = p->u.ccack.bytes_total;

        /* update the reverse CC - this is done to track all losses*/
        if (p->seq >= c->r_last_seq) {
                /* received a consecutive packet ; stretch the current rtt receiving window
                   and figure out the number of missed packets between the current boundary and the new boundary */
                c->r_packets_lost       += (p->seq - c->r_last_seq);
                c->r_last_seq            = p->seq+1;
        } else if (p->seq >= c->r_first_seq) {
                /* received a packet that was previous counted as lost
                   update the lost count by -1 for current rtt ; do not stretch the receiving window */
                DEBUG_PRINT(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Ack", "received ack previously counted as lost");
                c->r_packets_lost--;
        }

        c->s_first_seq          = p->u.ccack.last_seq + 1;
        c->last_packets_lost    = p->u.ccack.packets_lost;

        /* PMTUD: determine if interval has elapsed in which PMTU should resume */
        if((sock->pmtu.probe_state == MTU_FOUND) 
                && (sock->pmtu.search_low != (sock->pmtu.common_mtus + COMMON_MTU_MAX_INDEX)) 
                && (sock->pmtu.next_probe_time <= tv.tv_sec)){
                        sock->pmtu.search_high = sock->pmtu.common_mtus + COMMON_MTU_MAX_INDEX;
                        sock->pmtu.probe_state = NO_PROBE_SENT;
        }
        
        DEBUG_CC(DEBUG_CCTL, "ccontrol.c", "CC_Recvd_Ack", sock);
        // DEBUG_CC(1, "ccontrol.c", "CC_Recvd_Ack", sock);
        // printf("%u\t%u\t%f\n", packets_lost, sock->ccontrol.s_cwnd, (c->delay_delta)/1000.0);
        return;
} /* CC_Recvd_Ack() */

---