tcp.h

这个是目前国际上比较怪异的一种长距离高带宽环境下的拥塞控制算法

	int less_careful_;  /* 1 for Less Careful variant of bug_fix_, */
				/*  for illustration only  */
	int ts_option_;     /* use RFC1323-like timestamps? */
	int maxburst_;      /* max # packets can send back-2-back */
	int maxcwnd_;       /* max # cwnd can ever be */
		int numdupacks_;    /* dup ACKs before fast retransmit */
	int numdupacksFrac_;    /* for a larger numdupacks_ with large */
				/* windows */
	double maxrto_;     /* max value of an RTO */
	double minrto_;         /* min value of an RTO */
	int old_ecn_;       /* For backwards compatibility with the 
				 * old ECN implementation, which never
				 * reduced the congestion window below
				 * one packet. */ 
	FILE *plotfile_;
	/*
	 * Dynamic state.
	 */
	TracedInt dupacks_; /* number of duplicate acks */
	TracedInt curseq_;  /* highest seqno "produced by app" */
	int last_ack_;      /* largest consecutive ACK, frozen during
				 *      Fast Recovery */
	TracedInt highest_ack_; /* not frozen during Fast Recovery */
	int recover_;       /* highest pkt sent before dup acks, */
				/*   timeout, or source quench/ecn */
	int last_cwnd_action_;  /* CWND_ACTION_{TIMEOUT,DUPACK,ECN} */
	TracedDouble cwnd_; /* current window */
	double base_cwnd_;  /* base window (for experimental purposes) */
	double awnd_;       /* averaged window */
	TracedInt ssthresh_;    /* slow start threshold */
	int count_;     /* used in window increment algorithms */
	double fcnt_;       /* used in window increment algorithms */
	int rtt_active_;    /* 1 if a rtt sample is pending */
	int rtt_seq_;       /* seq # of timed seg if rtt_active_ is 1 */
	double rtt_ts_;     /* time at which rtt_seq_ was sent */
	TracedInt maxseq_;  /* used for Karn algorithm */
				/* highest seqno sent so far */
	int ecn_;       /* Explicit Congestion Notification */
	int cong_action_;   /* Congestion Action.  True to indicate
				   that the sender responded to congestion. */
		int ecn_burst_;     /* True when the previous ACK packet
				 *  carried ECN-Echo. */
	int ecn_backoff_;   /* True when retransmit timer should begin
					to be backed off.  */
	int ect_;           /* turn on ect bit now? */
		int eln_;               /* Explicit Loss Notification (wireless) */
		int eln_rxmit_thresh_;  /* Threshold for ELN-triggered rxmissions */
		int eln_last_rxmit_;    /* Last packet rxmitted due to ELN info */
	double firstsent_;  /* When first packet was sent  --Allman */
	double lastreset_;  /* W.N. Last time connection was reset - for */
				/* detecting pkts from previous incarnations */
	int slow_start_restart_; /* boolean: re-init cwnd after connection 
					goes idle.  On by default. */
	int restart_bugfix_;    /* ssthresh is cut down because of
				   timeouts during a connection's idle period.
				   Setting this boolean fixes this problem.
				   For now, it is off by default. */ 
	int closed_;            /* whether this connection has closed */
		TracedInt ndatapack_;   /* number of data packets sent */
		TracedInt ndatabytes_;  /* number of data bytes sent */
		TracedInt nackpack_;    /* number of ack packets received */
		TracedInt nrexmit_;     /* number of retransmit timeouts 
				   when there was data outstanding */
		TracedInt nrexmitpack_; /* number of retransmited packets */
		TracedInt nrexmitbytes_; /* number of retransmited bytes */
		TracedInt necnresponses_; /* number of times cwnd was reduced
				   in response to an ecn packet -- sylvia */
		TracedInt ncwndcuts_;   /* number of times cwnd was reduced 
				   for any reason -- sylvia */
	int trace_all_oneline_; /* TCP tracing vars all in one line or not? */
	int nam_tracevar_;      /* Output nam's variable trace or just plain 
				   text variable trace? */
	int first_decrease_;    /* First decrease of congestion window.  */
				/* Used for decrease_num_ != 0.5. */
		TracedInt singledup_;   /* Send on a single dup ack.  */
	int noFastRetrans_; /* No Fast Retransmit option.  */
	int oldCode_;       /* Use old code. */
	int useHeaders_;    /* boolean: Add TCP/IP header sizes */

	/* for experimental high-speed TCP */
	/* These four parameters define the HighSpeed response function. */
	int low_window_;    /* window for turning on high-speed TCP */
	int high_window_;   /* target window for new response function */
	double high_p_;     /* target drop rate for new response function */
	double high_decrease_;  /* decrease rate at target window */
	/* The next parameter is for Limited Slow-Start. */
	int max_ssthresh_;  /* max value for ssthresh_ */

	/* These three functions are just an easy structuring of the code. */ 
	double increase_param();  /* get increase parameter for current cwnd */
	double decrease_param();  /* get decrease parameter for current cwnd */
	double compute_p(); /* compute p for calculating parameters */
	/* The next three parameters are for CPU overhead, for computing */
	/*   the HighSpeed parameters less frequently.  A better solution */
	/*   might be just to have a look-up array.  */
	double cwnd_last_;  /* last cwnd for computed parameters */
		double increase_last_;  /* increase param for cwnd_last_ */
	double cwnd_frac_;  /* for determining when to recompute params. */
		/* end of section for experimental high-speed TCP */
	
	double dl_count_;        /* number of RTT's since last backoff */
	double dl_minrtt_;       /* minimum coarse RTT timestamp */
	double dl_maxrtt_;       /* maximum smoothed RTT */
	double dl_alpha_;        /* current AIMD increase parameter */
	double dl_rtti_;         /* current coarse RTT timestamp */
	double dl_modecount_;    /* used for adaptive backoff mode switch */
	double dl_thresh_;       /* start time of current RTT for packet counting purposes */
	double dl_packetcount_;  /* number of packets ACK'd in current round trip time */
	double dl_mode_;         /* 0 - backoff, 1 - slowstart, 2 - cong avoid */
	double dl_maxB_, dl_Bi_, dl_oldmaxB_, dl_minB_; /* throughput variables */
			  
	/* for Quick-Start, experimental. */
	int rate_request_;  /* Rate request in pps, for QuickStart. */
	int qs_enabled_; /* to enable QuickStart. */
	int qs_requested_;
	int qs_approved_;
	int ttl_diff_;
		/* end of section for Quick-Start. */

		/* support for event-tracing */
		//EventTrace *et_;
		void trace_event(char *eventtype);

	/* these function are now obsolete, see other above */
	void closecwnd(int how);
	void quench(int how);

	void process_qoption_after_send() ;
	void process_qoption_after_ack(int seqno) ;

	int QOption_ ; /* TCP quiescence option */
	int EnblRTTCtr_ ; /* are we using a corase grained timer? */
	int T_full ; /* last time the window was full */
	int T_last ;
	int T_prev ;
	int T_start ;
	int RTT_count ;
	int RTT_prev ;
	int RTT_goodcount ;
	int F_counting ;
	int W_used ; 
	int W_timed ;
	int F_full ; 
	int Backoffs ;

	int control_increase_ ; /* If true, don't increase cwnd if sender */
				/*  is not window-limited.  */
	int prev_highest_ack_ ; /* Used to determine if sender is */
				/*  window-limited.  */
};

/* TCP Reno */
class RenoTcpAgent : public virtual TcpAgent {
 public:
	RenoTcpAgent();
	virtual int window();
	virtual double windowd();
	virtual void recv(Packet *pkt, Handler*);
	virtual void timeout(int tno);
	virtual void dupack_action();
 protected:
	int allow_fast_retransmit(int last_cwnd_action_);
	unsigned int dupwnd_;
};

/* TCP New Reno */
class NewRenoTcpAgent : public virtual RenoTcpAgent {
 public:
	NewRenoTcpAgent();
	virtual void recv(Packet *pkt, Handler*);
	virtual void partialnewack_helper(Packet* pkt);
	virtual void dupack_action();
 protected:
	int newreno_changes_;   /* 0 for fixing unnecessary fast retransmits */
				/* 1 for additional code from Allman, */
				/* to implement other algorithms from */
				/* Hoe's paper, including sending a new */
				/* packet for every two duplicate ACKs. */
				/* The default is set to 0. */
	int newreno_changes1_;  /* Newreno_changes1_ set to 0 gives the */
				/* Slow-but-Steady variant of NewReno from */
				/* RFC 2582, with the retransmit timer reset */
				/* after each partial new ack. */  
				/* Newreno_changes1_ set to 1 gives the */
				/* Impatient variant of NewReno from */
				/* RFC 2582, with the retransmit timer reset */
				/* only for the first partial new ack. */
				/* The default is set to 0 */
	void partialnewack(Packet *pkt);
	int allow_fast_retransmit(int last_cwnd_action_);
	int acked_, new_ssthresh_;  /* used if newreno_changes_ == 1 */
	double ack2_, ack3_, basertt_; /* used if newreno_changes_ == 1 */
	int firstpartial_;  /* For the first partial ACK. */ 
	int partial_window_deflation_; /* 0 if set cwnd to ssthresh upon */
					   /* partial new ack (default) */
					   /* 1 if deflate (cwnd + dupwnd) by */
					   /* amount of data acked */
					   /* "Partial window deflation" is */
					   /* discussed in RFC 2582. */
	int exit_recovery_fix_;  /* 0 for setting cwnd to ssthresh upon */
				 /* leaving fast recovery (default) */
				 /* 1 for setting cwnd to min(ssthresh, */
				 /* amnt. of data in network) when leaving */
};

/* TCP vegas (VegasTcpAgent) */
class VegasTcpAgent : public virtual TcpAgent {
 public:
	VegasTcpAgent();
	~VegasTcpAgent();
	virtual void recv(Packet *pkt, Handler *);
	virtual void timeout(int tno);
protected:
	double vegastime() {
		return(Scheduler::instance().clock() - firstsent_);
	}
	virtual void output(int seqno, int reason = 0);
	virtual void recv_newack_helper(Packet*);
	int vegas_expire(Packet*); 
	void reset();
	void vegas_inflate_cwnd(int win, double current_time);

	virtual void delay_bind_init_all();
	virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer);

	double t_cwnd_changed_; // last time cwnd changed
	double firstrecv_;  // time recv the 1st ack

	int    v_alpha_;        // vegas thruput thresholds in pkts
	int    v_beta_;             

	int    v_gamma_;        // threshold to change from slow-start to
				// congestion avoidance, in pkts

	int    v_slowstart_;    // # of pkts to send after slow-start, deflt(2)
	int    v_worried_;      // # of pkts to chk after dup ack (1 or 2)

	double v_timeout_;      // based on fine-grained timer
	double v_rtt_;      
	double v_sa_;       
	double v_sd_;   

	int    v_cntRTT_;       // # of rtt measured within one rtt
	double v_sumRTT_;       // sum of rtt measured within one rtt

	double v_begtime_;  // tagged pkt sent
	int    v_begseq_;   // tagged pkt seqno

	double* v_sendtime_;    // each unacked pkt's sendtime is recorded.
	int*   v_transmits_;    // # of retx for an unacked pkt

	int    v_maxwnd_;   // maxwnd size for v_sendtime_[]
	double v_newcwnd_;  // record un-inflated cwnd

	double v_baseRTT_;  // min of all rtt

	double v_incr_;     // amount cwnd is increased in the next rtt
	int    v_inc_flag_; // if cwnd is allowed to incr for this rtt

	double v_actual_;   // actual send rate (pkt/s; needed for tcp-rbp)

	int ns_vegas_fix_level_;   // see comment at end of tcp-vegas.cc for details of fixes
};

// Local Variables:
// mode:c++
// End:

#endif