test-suite-xcp.tcl

ns-2的文件包。多多下载

	}
}


GeneralSender instproc trace-xcp parameters {
	$self instvar tcp_ id_ tcpTrace_
	set ftracetcp$id_ [open  xcp$id_.tr w]
	set tcpTrace_ [set ftracetcp$id_]
	$tcp_ attach-trace $tcpTrace_
	if { -1 < [lsearch $parameters cwnd]  } { $tcp_ tracevar cwnd_ }
	if { -1 < [lsearch $parameters seqno] } { $tcp_ tracevar t_seqno_ }
	if { -1 < [lsearch $parameters ackno] } { $tcp_ tracevar ack_ }
	if { -1 < [lsearch $parameters rtt]	 } { $tcp_ tracevar rtt_ }
	if { -1 < [lsearch $parameters ssthresh]  } { $tcp_ tracevar ssthresh_ }
}


Class Test/simple-xcp -superclass TestSuite

Test/simple-xcp instproc init {} {
 	$self instvar ns_ testName_ qType_ qSize_ BW_ delay_ nXCPs_ \
 	    SimStopTime_ tracedFlows_

 	set testName_ simple-xcp
 	set qType_	XCP
 	set BW_	20; # in Mb/s
 	set delay_	10; # in ms
 	set	 qSize_	 [expr round([expr ($BW_ / 8.0) * 4 * $delay_ * 1.0])];#set buffer to the pipe size
 	set SimStopTime_	  30
 	set nXCPs_		  3
 	set tracedFlows_	   "0 1 2"
 	$self next
}

Test/simple-xcp instproc run {} {
 	global R1 n all_links Bottleneck
 	$self instvar ns_ SimStopTime_ nXCPs_ qSize_ delay_ rtg_ \
 	    tracedFlows_ src_

 	set numsidelinks 3
 	set deltadelay 0.0
	
 	$self create-Bottleneck
 	$self create-sidelinks $numsidelinks $deltadelay

 	foreach link $all_links {
 		set queue [$link queue]
 		if {[$queue info class] == "Queue/XCP"} {
 			$queue set-link-capacity [[$link set link_] set bandwidth_];  
 		}
 	}

 	# Create sources:
 	set i 0
 	while { $i < $nXCPs_  } {
 		set StartTime [expr [$rtg_ integer 1000] * 0.001 * (0.01 * $delay_) + $i  * 0.0] 
 		set src_($i) [new GeneralSender $ns_ $i [set n($i)] $R1 "$StartTime TCP/Reno/XCP"]
		set pktSize_  1000
 		[[set src_($i)] set tcp_]  set	 packetSize_ $pktSize_
 		[[set src_($i)] set tcp_]  set	 window_     [expr $qSize_]
 		incr i
 	}
	
 	# trace bottleneck queue, if needed
 	#foreach queue_name "Bottleneck" {
	#set queue [set "$queue_name"]
	#if {[$queue info class] == "Queue/XCP"} {
	# $queue attach $tracefd_
 	#	} 
 	#}
	
 	# trace sources
 	foreach i $tracedFlows_ {
 		[set src_($i)] trace-xcp "cwnd"
 	}
       
 	$ns_ at $SimStopTime_ "$self finish"
 	$ns_ run
	
 	$self post-process cwnd_ 0.0

}

Class Test/xcp-tcp -superclass TestSuite

Test/xcp-tcp instproc init {} {
	$self instvar ns_ testName_ qType_ qSize_ BW_ delay_ nXCPs_ \
	    SimStopTime_ tracedFlows_

	# set RED parameters for TCP queue
	Queue/RED set maxthresh_ [expr 0.8 * [Queue set limit_]]
	Queue/RED set thresh_ [expr 0.6 * [Queue set limit_]]
	Queue/RED set q_weight_ 0.001
	Queue/RED set linterm_ 10
	
	set testName_   xcp-tcp
	set qType_	XCP
	set BW_	20;         # in Mb/s
	set delay_	10; # in ms
	set qSize_      [expr round([expr ($BW_ / 8.0) * 4 * $delay_ * 1.0])];#set buffer to the pipe size
	set SimStopTime_	  30
	set nXCPs_		  3
	set tracedFlows_	  "0 1 2 3"

	$self next
}

Test/xcp-tcp instproc run {} {
	global R1 n all_links Bottleneck
	$self instvar ns_ tracefd_ SimStopTime_ nXCPs_ qSize_ delay_ rtg_ \
	    tracedFlows_ src_
	
	Queue/XCP set tcp_xcp_on_ 1
	set numsidelinks 4
	set deltadelay 0.0
	
	$self create-Bottleneck
	$self create-sidelinks $numsidelinks $deltadelay

	foreach link $all_links {
		set queue [$link queue]
		if {[$queue info class] == "Queue/XCP"} {
			$queue set-link-capacity [[$link set link_] set bandwidth_];  
		}
	}
	
	# Create sources:
	set i 0
	while { $i < $nXCPs_  } {
		set StartTime [expr [$rtg_ integer 1000] * 0.001 * (0.01 * $delay_) + $i  * 0.0] 
		set src_($i) [new GeneralSender $ns_ $i [set n($i)] $R1 "$StartTime TCP/Reno/XCP"]
		set pktSize_              1000
		[[set src_($i)] set tcp_]  set	 packetSize_ $pktSize_
		[[set src_($i)] set tcp_]  set	 window_     [expr $qSize_ * 10]
		incr i
	}
	
	set StartTime [expr [$rtg_ integer 1000] * 0.001 * (0.01 * $delay_) + $i  * 0.0] 
	set src_($i) [new GeneralSender $ns_ $i [set n($i)] $R1 "$StartTime TCP/Reno"]
	set pktSize_              1000
	[[set src_($i)] set tcp_]  set	 packetSize_ $pktSize_
	[[set src_($i)] set tcp_]  set	 window_     [expr $qSize_ * 10]
	
	
	# trace sources
	foreach i $tracedFlows_ {
		[set src_($i)] trace-xcp "cwnd"
	}
	
	$ns_ at $SimStopTime_ "$self finish"
	$ns_ run

	$self post-process cwnd_ 0.0

}

Class Test/parking-lot-topo -superclass TestSuite
# This is a downsized version of Dina's original test. We use around 30 flows
# compared to 300 flows in the original version.

Test/parking-lot-topo instproc init {} {
   	$self instvar ns_ testName_ delay_ BW_list_ qType_list_ delay_list_ qSize_list_ nTCPsPerHop_list_ rTCPs_ nAllHopsTCPs_ qEffective_RTT_ numHops_ SimStopTime_ qSize_
	
   	set testName_   parking-lot-topo
   	set qType_	XCP
   	set BW_	        30;                 #in Mb/s
   	set BBW_         [expr $BW_ / 2.0]  ; #BW of bottleneck
   	set delay_	10;                 #in ms
   	set qSize_      [expr round([expr ($BW_ / 8.0) * 2.0 * $delay_ * 4.5])];
   	set SimStopTime_	  20
   	set qEffective_RTT_        [expr  20 * $delay_ * 0.001]
   	set nAllHopsTCPs_          10
   	set numHops_               9
   	set BW_list_     " $BW_ $BW_ $BBW_ $BW_ $BW_ $BW_ $BW_ $BW_ $BW_"
   	set qType_list_  " $qType_ $qType_  $qType_ $qType_  $qType_ $qType_ $qType_ $qType_ $qType_"
   	set delay_list_  "$delay_ $delay_ $delay_ $delay_ $delay_ $delay_ $delay_ $delay_ $delay_"
   	set qSize_list_  "$qSize_ $qSize_ $qSize_ $qSize_ $qSize_ $qSize_ $qSize_ $qSize_ $qSize_"
   	set nTCPsPerHop_list_     "1 1 1 1 1 1 1 1 1"
   	set rTCPs_                1; #traverse all of the reverse path

   	$self next
	
}


Test/parking-lot-topo instproc run {} {
	$self instvar ns_ rtg_ numHops_ BW_list_ qType_list_ delay_ delay_list_ qSize_list_ nTCPsPerHop_list_ rTCPs_ nAllHopsTCPs_ qtraces_ qEffective_RTT_ SimStopTime_ qSize_
	
   	global n all_links
	
	#all except the first are lists
   	$self create-string-topology $numHops_ $BW_list_ $delay_list_ $qType_list_ $qSize_list_;
	
   	 #set BW for xcp queue
   	foreach link $all_links {
   		set queue [$link queue]
   		if {[$queue info class] == "Queue/XCP"} {
   			$queue set-link-capacity [[$link set link_] set bandwidth_];  
   		}
   	}
	
	#Create sources: 1) Long TCPs
   	set i 0
   	while { $i < $nAllHopsTCPs_  } {
   		set StartTime     [expr [$rtg_ integer 1000] * 0.001 * (0.01 * $numHops_ * $delay_)] 
   		set src_($i)      [new GeneralSender $ns_ $i $n(0) [set n($numHops_)] "$StartTime TCP/Reno/XCP"]
		
   		[[set src_($i)] set tcp_]  set  window_     [expr $qSize_ * 10]
   		incr i
   	}

   	 #2) jth Hop TCPs; start at j*1000
   	set i 0;
   	while {$i < $numHops_} {
   		set j [expr (1000 * $i) + 1000 ]; 
   		while { $j < [expr [lindex $nTCPsPerHop_list_ $i] + ($i + 1) * 1000]  } {
   			set StartTime     [expr [$rtg_ integer 1000] * 0.001 * (0.01 * $numHops_ * $delay_)] 
   			set src_($j)      [new GeneralSender $ns_ $j [set n($i)] [set n([expr $i+1])] "$StartTime TCP/Reno/XCP"]
   			[[set src_($j)] set tcp_] set window_ [expr $qSize_ * 10]
   			incr j
   		}
   		incr i   	}
	
   	 #3) reverse TCP; ids follow directly allhops TCPs

	
   	set i 0
   	while {$i < $numHops_} {
   		set l 0
   		while { $l < $rTCPs_} {
   			set s [expr $l + $nAllHopsTCPs_ + ( $i * $rTCPs_ ) ] 
   			set StartTime     [expr [$rtg_ integer 1000] * 0.001 * (0.01 * $numHops_ * $delay_)+ 0.0] 
   			set src_($s)      [new GeneralSender $ns_ $s [set n([expr $i + 1])] [set n($i)] "$StartTime TCP/Reno/XCP"]
		
   			[[set src_($s)] set tcp_] set window_ [expr $qSize_ * 10]
   			incr l
   		}
   		incr i
   	}

   	 #Trace Queues
   	set i 0;
   	while { $i < $numHops_ } {
   		set qtype [lindex $qType_list_ $i]
   		global q$i rq$i
   		foreach queue_name "q$i rq$i" {
   			set queue [set "$queue_name"]
   			switch $qtype {
   				"XCP" {
   					set qtrace [open ft_red_[set queue_name].tr w]
   					$queue attach $qtrace
					lappend qtraces_ $qtrace
   				}
   			}
   		}
 		#sample parameters at queue at a given time interval of qeffective_RTT
   		foreach queue_name "q$i" {
   			set queue [set "$queue_name"]
   			$queue queue-sample-everyrtt $qEffective_RTT_
   		}
   		incr i
   	}
	
   	$ns_ at $SimStopTime_ "$self finish"
   	$ns_ run
	
   	set flows "0 1 2 3 4 5 6 7 8"
	#use utilisation as validation output
	$self process-parking-lot-data "u" "Utilisation" $flows 0.0
	#$self process-parking-lot-data "q" "Average Queue" $flows 0.0


}

proc runtest {arg} {
	global quiet
	set quiet 0
	
	set b [llength $arg]
	if {$b == 1} {
		set test $arg
	} elseif {$b == 2} {
		set test [lindex $arg 0]
		if {[lindex $arg 1] == "QUIET"} {
			set quiet 1
		}
	} else {
		usage
	}
	set t [new Test/$test]
	$t run
}

global argv arg0
runtest $argv