/* -*-	Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * tcp-fs: TCP with "fast start", a procedure for avoiding the penalty of
 * slow start when a connection resumes after a pause. The connection tries
 * to reuse values old values of variables such as cwnd_, ssthresh_, srtt_,
 * etc., with suitable modifications. The same procedure as used in tcp-asym
 * is used to clock out packets until ack clocking kicks in. A connection 
 * doing fast start protects itself and other connections in the network against 
 * the adverse consequences of stale information by (a) marking all packets sent 
 * during fast start as low priority for the purposes of a priority-drop router, 
 * and (b) quickly detecting the loss of several fast start packets and falling 
 * back to a regular slow start, almost as if a fast start had never been attempted
 * in the first place.
 * 
 * Contributed by Venkat Padmanabhan (padmanab@cs.berkeley.edu), 
 * Daedalus Research Group, U.C.Berkeley
 */

#include "tcp-fs.h"

void ResetTimer::expire(Event *) {
	a_->timeout(TCP_TIMER_RESET);
}

static class TcpFsClass : public TclClass {
public:
	TcpFsClass() : TclClass("Agent/TCP/FS") {}
	TclObject* create(int, const char*const*) {
		return (new TcpFsAgent());
	}
} class_tcpfs;

static class RenoTcpFsClass : public TclClass {
public:
	RenoTcpFsClass() : TclClass("Agent/TCP/Reno/FS") {}
	TclObject* create(int, const char*const*) {
		return (new RenoTcpFsAgent());
	}
} class_renotcpfs;	

static class NewRenoTcpFsClass : public TclClass {
public:
	NewRenoTcpFsClass() : TclClass("Agent/TCP/Newreno/FS") {}
	TclObject* create(int, const char*const*) {
		return (new NewRenoTcpFsAgent());
	}
} class_newrenotcpfs;	

#ifdef USE_FACK
static class FackTcpFsClass : public TclClass {
public:
	FackTcpFsClass() : TclClass("Agent/TCP/Fack/FS") {}
	TclObject* create(int, const char*const*) {
		return (new FackTcpFsAgent());
	}
} class_facktcpfs;	
#endif


/* mark packets sent as part of fast start */
void
TcpFsAgent::output_helper(Packet *pkt)
{
	hdr_tcp *tcph = hdr_tcp::access(pkt);
	double now = Scheduler::instance().clock();
	double idle_time = now - last_recv_time_;
	double timeout = ((t_srtt_ >> 3) + t_rttvar_) * tcp_tick_ ;
	maxseq_ = max(int(maxseq_), int(highest_ack_));

	/* 
	 * if the connection has been idle (with no outstanding data) for long 
	 * enough, we enter the fast start phase. We compute the start and end
	 * sequence numbers that define the fast start phase. Note that the
	 * first packet to be sent next is not included because it would have
	 * been sent even with regular slow start.
	 */
	if ((idle_time > timeout) && (maxseq_ == highest_ack_) && (cwnd_ > 1)){
		/*
		 * We set cwnd_ to a "safe" value: cwnd_/2 if the connection
		 * was in slow start before the start of the idle period and
		 * cwnd_-1 if it was in congestion avoidance phase.
		 */
/*		if (cwnd_ < ssthresh_+1)*/
		if (cwnd_ < ssthresh_)
			cwnd_ = int(cwnd_/2);
		else
			cwnd_ -= 1;
		/* set the start and end seq. nos. for the fast start phase */
		fs_startseq_ = highest_ack_+2;
		fs_endseq_ = highest_ack_+window()+1;
		fs_mode_ = 1;
	}
	/* initially set fs_ flag to 0 */
	hdr_flags::access(pkt)->fs_ = 0;
	/* check if packet belongs to the fast start phase. */
	if (tcph->seqno() >= fs_startseq_ && tcph->seqno() < fs_endseq_ && fs_mode_) {
		/* if not a retransmission, mark the packet */
		if (tcph->seqno() > maxseq_) {
			hdr_flags::access(pkt)->fs_ = 1;
		}
	}
}

/* update last_output_time_ */
void
TcpFsAgent::recv_helper(Packet *) 
{
	double now = Scheduler::instance().clock();
	last_recv_time_ = now;
}

/* schedule the next burst of data (of size at most maxburst) */
void 
TcpFsAgent::send_helper(int maxburst) 
{
	/* 
	 * If there is still data to be sent and there is space in the
	 * window, set a timer to schedule the next burst. Note that
	 * we wouldn't get here if TCP_TIMER_BURSTSEND were pending,
	 * so we do not need an explicit check here.
	 */
	if (t_seqno_ <= highest_ack_ + window() && t_seqno_ < curseq_) {
		burstsnd_timer_.resched(t_exact_srtt_*maxburst/window());
	}
}

#ifdef USE_FACK
/* schedule the next burst of data (of size at most maxburst) */
void 
FackTcpFsAgent::send_helper(int maxburst) 
{
	/* 
	 * If there is still data to be sent and there is space in the
	 * window, set a timer to schedule the next burst. Note that
	 * we wouldn't get here if TCP_TIMER_BURSTSEND were pending,
	 * so we do not need an explicit check here.
	 */
	if ((t_seqno_ <= fack_ + window() - retran_data_) && (!timeout_) && (t_seqno_ < curseq_)) {
		burstsnd_timer_.resched(t_exact_srtt_*maxburst/window());
	}
}
#endif

/* do appropriate processing depending on the length of idle time */
void
TcpFsAgent::send_idle_helper() 
{
	// Commented out because they are not used
	// XXX What processing belong here??? - haoboy

	//double now = Scheduler::instance().clock();
	//double idle_time = now - last_recv_time_;
}

/* update srtt estimate */
void
TcpFsAgent::recv_newack_helper(Packet *pkt) 
{
	hdr_tcp *tcph = hdr_tcp::access(pkt);
	double tao = Scheduler::instance().clock() - tcph->ts_echo();
	double g = 1/8; /* gain used for smoothing rtt */
	double h = 1/4; /* gain used for smoothing rttvar */
	double delta;
	int ackcount, i;

	/*
	 * If we are counting the actual amount of data acked, ackcount >= 1.
	 * Otherwise, ackcount=1 just as in standard TCP.
	 */
	if (count_bytes_acked_)
		ackcount = tcph->seqno() - last_ack_;
	else
		ackcount = 1;
	newack(pkt);
	maxseq_ = max(int(maxseq_), int(highest_ack_));
	if (t_exact_srtt_ != 0) {
		delta = tao - t_exact_srtt_;
		if (delta < 0)
			delta = -delta;
		/* update the fine-grained estimate of the smoothed RTT */
		if (t_exact_srtt_ != 0) 
			t_exact_srtt_ = g*tao + (1-g)*t_exact_srtt_;
		else
			t_exact_srtt_ = tao;
		/* update the fine-grained estimate of mean deviation in RTT */
		delta -= t_exact_rttvar_;
		t_exact_rttvar_ += h*delta;
	}
	else {
		t_exact_srtt_ = tao;
		t_exact_rttvar_ = tao/2;
	}
	/* grow cwnd. ackcount > 1 indicates that actual ack counting is enabled */
	for (i=0; i<ackcount; i++)
		opencwnd();
	/* check if we are out of fast start mode */
	if (fs_mode_ && (highest_ack_ >= fs_endseq_-1)) 
		fs_mode_ = 0;
	/* if the connection is done, call finish() */
	if ((highest_ack_ >= curseq_-1) && !closed_) {
		closed_ = 1;
		finish();
	}
}

void
NewRenoTcpFsAgent::partialnewack_helper(Packet* pkt)
{
	partialnewack(pkt);
	/* Do this because we may have retracted maxseq_ */
	maxseq_ = max(int(maxseq_), int(highest_ack_));
	if (fs_mode_ && fast_loss_recov_) {
		/* 
		 * A partial new ack implies that more than one packet has been lost
		 * in the window. Rather than recover one loss per RTT, we get out of
		 * fast start mode and do a slow start (no rtx timeout, though).
		 */
		timeout_nonrtx(TCP_TIMER_RESET);
	}
	else {
		output(last_ack_ + 1, 0);
	}
}

void 
TcpFsAgent::set_rtx_timer()
{
	if (rtx_timer_.status() == TIMER_PENDING)
		rtx_timer_.cancel();
	if (reset_timer_.status() == TIMER_PENDING)
		reset_timer_.cancel();
	if (fs_mode_ && fast_loss_recov_ && fast_reset_timer_)
		reset_timer_.resched(rtt_exact_timeout());
	else if (fs_mode_ && fast_loss_recov_)
		reset_timer_.resched(rtt_timeout());
	else 
		rtx_timer_.resched(rtt_timeout());
}

void 
TcpFsAgent::cancel_rtx_timer() 
{
	rtx_timer_.force_cancel();
	reset_timer_.force_cancel();
}

void 
TcpFsAgent::cancel_timers() 
{
	rtx_timer_.force_cancel();
	reset_timer_.force_cancel();
	burstsnd_timer_.force_cancel();
	delsnd_timer_.force_cancel();
}

void 
TcpFsAgent::timeout_nonrtx(int tno) 
{
	if (tno == TCP_TIMER_RESET) {
		fs_mode_ = 0;	/* out of fast start mode */
		dupacks_ = 0;	/* just to be safe */
		if (highest_ack_ == maxseq_ && !slow_start_restart_) {
			/*
			 * TCP option:
			 * If no outstanding data, then don't do anything.
			 */
			return;
		};
		/* 
		 * If the pkt sent just before the fast start phase has not
		 * gotten through, treat this as a regular rtx timeout.
		 */
		if (highest_ack_ < fs_startseq_-1) {
			maxseq_ = fs_startseq_ - 1;
			recover_ = maxseq_;
			timeout(TCP_TIMER_RTX);
		}
		/* otherwise decrease window size to 1 but don't back off rtx timer */
		else {
			if (highest_ack_ > last_ack_)
				last_ack_ = highest_ack_;
			maxseq_ = last_ack_;
			recover_ = maxseq_;
			last_cwnd_action_ = CWND_ACTION_TIMEOUT;
			slowdown(CLOSE_CWND_INIT);
			timeout_nonrtx_helper(tno);
		}
	}
	else {
		TcpAgent::timeout_nonrtx(tno);
	}
}

void 
TcpFsAgent::timeout_nonrtx_helper(int tno)
{
	if (tno == TCP_TIMER_RESET) {
		reset_rtx_timer(0,0);
		send_much(0, TCP_REASON_TIMEOUT, maxburst_);
	}
}

void 
RenoTcpFsAgent::timeout_nonrtx_helper(int tno)
{
	if (tno == TCP_TIMER_RESET) {
		dupwnd_ = 0;
		dupacks_ = 0;
		TcpFsAgent::timeout_nonrtx_helper(tno);
	}
}		

void 
NewRenoTcpFsAgent::timeout_nonrtx_helper(int tno)
{
	if (tno == TCP_TIMER_RESET) {
		dupwnd_ = 0;
		dupacks_ = 0;
		TcpFsAgent::timeout_nonrtx_helper(tno);
	}
}

#ifdef USE_FACK
void 
FackTcpFsAgent::timeout_nonrtx_helper(int tno)
{
	if (tno == TCP_TIMER_RESET) {
		timeout_ = FALSE;
		retran_data_ = 0;
		fack_ = last_ack_;
		t_seqno_ = last_ack_ + 1;
		reset_rtx_timer(TCP_REASON_TIMEOUT, 0);
		send_much(0, TCP_REASON_TIMEOUT);
	}
}
#endif