mtp.tcl

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

          $RAW2XG -s 0.01 -m $wrap -r >> plot.xgr
        exec $GETRC -s $did -d $sid -f 1 out.tr  | \
          $RAW2XG -s 0.01 -m $wrap -a  >> plot.xgr

	exec ./xg2gp.awk plot.xgr

        if {!$opt(quiet)} {
                exec xgraph -bb -tk -nl -m -x time -y packets plot.xgr &
        }
 	exit 0
}
#
proc pingSend {ag int} {
 global ns 
 $ag send
 $ns after $int "pingSend $ag $int"
}
#Define a 'recv' function for the class 'Agent/Ping'
Agent/Ping instproc recv {from seq ff bf} {
        $self instvar node_ 
	global rttf
#        puts "node [$node_ id] received ping answer from \
              $from seq $seq with forward delay $ff and backward $bf ms."
	puts $rttf "$seq [expr $ff/1000] [expr $bf/1000]" 
}
#
source web.tcl
#
proc insertDelay {} {
        global ns dl_dist di_dist delayerUL delayerDL

	$delayerUL block	
	$delayerDL block	

        set len [$dl_dist value]
        $ns after $len "$delayerUL unblock"
        $ns after $len "$delayerDL unblock"
	set next [expr $len + [$di_dist value]]
        $ns after $next "insertDelay"
#        puts "[$ns now]: delay for $len, next after $next"; flush stdout
}
#
proc bwOscilate {bw_up} {
        global ns opt nodes
	set dl_link [[$ns link $nodes(bs) $nodes(ms)] link]
	set bw [$dl_link set bandwidth_]
	
	if {$bw_up} {
		set bw [expr $bw / $opt(bwScale)]
		set bw_up 0
		set next $opt(bwLowLen)
	} else {
		set bw [expr $bw * $opt(bwScale)]
		set next $opt(bwHighLen)
		set bw_up 1
	}		
	$dl_link set bandwidth_ $bw

        $ns after $next "bwOscilate $bw_up"
        puts "[$ns now]: new bandwidth $bw, next after $next"; flush stdout
}
#
proc setError {low errmodel rate slot burst} {
  if {$low} {
	set newrate [expr $rate / $burst ]
	set next [expr $slot * $burst]
  } else {
	set newrate $rate
	set next $slot
  }
  puts "setError: newrate $newrate slot $slot low $low"
  $errmodel set rate_ $newrate 
  ns after $next "setError [expr !$low] $errmodel $rate $slot $burst]"
}

# perform vertical handover
proc makeVho {} {
	global ns opt nodes delayerUL delayerDL buf
	if {$opt(vhoLoss)} {
	 	$ns queue-limit $nodes(bs) $nodes(ms) [expr $buf($opt(type))*(1-$opt(vhoLoss))]
		$ns queue-limit $nodes(ms) $nodes(bs) [expr $buf($opt(type))*(1-$opt(vhoLoss))]
	        [[$ns link $nodes(bs) $nodes(ms)] queue] shrink-queue
	        [[$ns link $nodes(ms) $nodes(bs)] queue] shrink-queue
	}
	set_link_params $opt(vhoTarget)
	$delayerUL block; $delayerDL block
        $ns after $opt(vhoDelay) "$delayerUL unblock; $delayerDL unblock"
}

proc parseDist {s} {
	set d ""
	set k [scan $s "%c(%f,%f)" dist arg1 arg2]
	if { $k != 3 } {
		set k [scan $s "%c(%f)" dist arg1]
		if { $k != 2 } {
			puts "wrong distribution $s"
			exit 1
		}
	}	
	switch $dist {
		85 {
  		 	set d [new RandomVariable/Uniform]
			$d set min_ $arg1
			$d set max_ $arg2
		}
		69 {
  		 	set d [new RandomVariable/Exponential]
			$d set avg_ $arg1
		}
		default {
			puts "unkown distribution"
			exit 1
		}
	}
#	puts "$arg1 $arg2"
	return $d
}

#************************************* MAIN ******************************************
set ns [new Simulator]
variable delayerUL 
variable delayerDL


#
# RED and TCP parameters
#
if {$opt(ecn) == 1} {
   Queue/RED set setbit_ true
}
Queue/RED set summarystats_ true
Queue/DropTail set summarystats_ true
Queue/RED set adaptive_ $opt(adaptive)
Queue/RED set q_weight_ 0.0
Queue/RED set thresh_ $opt(minth)
Queue/RED set maxthresh_ $opt(maxth)

Queue/DropTail set shrink_drops_ true

Agent/TCP set ecn_ $opt(ecn) 
Agent/TCP set packetSize_ $pktsize
Agent/TCP set window_ $opt(window)

DelayLink set avoidReordering_ true

# Create trace, rttf is for latency measured with ping
set tf [open out.tr w]
set rttf [open rtt.tr w]
$ns trace-all $tf

# Complex WLAN needs nodes with hierarhical routing and has no params
if {$opt(type) != "wlan_complex"} {
	set nodes(lp) [$ns node]
	set nodes(ms) [$ns node]
	set nodes(bs) [$ns node]
	set nodes(is) [$ns node]
	
	# Overwrite defaults from command line params
	if {$opt(bwUL)} {set bwUL($opt(type)) $opt(bwUL)}
	if {$opt(bwDL)} {set bwDL($opt(type)) $opt(bwDL)}
	if {$opt(propUL)} {set propUL($opt(type)) $opt(propUL)}
	if {$opt(propDL)} {set propDL($opt(type)) $opt(propDL)}
}
if {$opt(qsize)} {set buf($opt(type)) $opt(qsize)}

# Create topology 
switch $opt(type) {
 gsm -
 gprs -
 umts {cell_topo}
 geo  {sat_topo}
 wlan_complex {wlan_topo_complex}
 wlan_duplex -
 wlan_ether {wlan_topo_simple}
}
if {$opt(type) != "wlan_complex" && $opt(type) != "wlan_ether"} {
  set_link_params $opt(type)
  set delayerDL [new Delayer]
  set delayerUL [new Delayer]
#  $delayerDL set debug_ true
#  $delayerUL set debug_ true
  $ns insert-delayer $nodes(ms) $nodes(bs) $delayerUL
  $ns insert-delayer $nodes(bs) $nodes(ms) $delayerDL
}


#$ns trace-queue $nodes(is) $nodes(bs) $tf
#$ns trace-queue $nodes(bs) $nodes(is) $tf

#
# Set up forward TCP connection
#
if {$opt(flows) > 0} {
	set tcp1 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
	set ftp1 [[set tcp1] attach-app FTP]
	$ns at 0.8 "[set ftp1] start"
}

if {$opt(shortflows) > 0} {
    set tcp1 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
    set ftp1 [[set tcp1] attach-app FTP]
    $tcp1 set window_ 100
    $ns at 0.0  "[set ftp1] start"
    $ns at 3.5  "[set ftp1] stop"
    set tcp2 [$ns create-connection TCP/Sack1 $nodes(is) TCPSink/Sack1 $nodes(lp) 0]
    set ftp2 [[set tcp2] attach-app FTP]
    $tcp2 set window_ 3
    $ns at 1.0  "[set ftp2] start"
    $ns at 8.0  "[set ftp2] stop"
}

#
# Set up forward TFRC connection
#
if {$opt(flowsTfrc) > 0} {
	set tfrc1 [$ns create-connection TFRC $nodes(is) TFRCSink $nodes(lp) 0]
	set ftp3 [[set tfrc1] attach-app FTP]
	$ns at 0.1 "[set ftp3] start"
}

#
# Set up ping for delay measurement
#
if {$opt(pingInt)} {
	set ping1 [$ns create-connection Ping $nodes(is) Ping $nodes(lp) 0]
	$ping1 oneway 		; # enable ping extensions
	$ns after 1 "pingSend $ping1 $opt(pingInt)"
}

#
# Traffic on the reverse path.
#
# Reverse-path traffic is half the number of flows as for the forward path.
if {$opt(flowsRev) > 0} {
	set tcp2 [$ns create-connection TCP/Sack1 $nodes(lp) TCPSink/Sack1 $nodes(is) 1]
	set ftp2 [[set tcp2] attach-app FTP]
	$ns at 2 "[set ftp2] start"
}

#
# Add forward web traffic.
#
set req_trace_ 0
set count $opt(webers)
if ($count) {
  add_web_traffic $opt(secondDelay) $opt(web) $opt(interpage) $opt(pagesize) $opt(objSize) $opt(shape) 1
  add_web_traffic $opt(secondDelay) [expr $opt(web)/2] $opt(interpage) $opt(pagesize) $opt(objSize) $opt(shape) 0
}

#
# Set up channel allocation delay
#
# Downlink
if {$opt(allocLenDL) != "" && $opt(allocHoldDL) != ""} {
	set al_dl [parseDist $opt(allocLenDL)]
	set ah_dl [parseDist $opt(allocHoldDL)]
	$delayerDL alloc $ah_dl $al_dl 
}
# Uplink
if {$opt(allocLenUL) != "" && $opt(allocHoldUL) != ""} {
	set al_ul [parseDist $opt(allocLenUL)]
	set ah_ul [parseDist $opt(allocHoldUL)]
	$delayerUL alloc $ah_ul $al_ul 
}

#
# Set up delay variation (due to ARQ or delay spikes)
#
if {$opt(delayInt) != "" && $opt(delayLen) != ""} {
	set di_dist [parseDist $opt(delayInt)]
	set dl_dist [parseDist $opt(delayLen)]
	$ns after [$di_dist value] "insertDelay"
}

#
# Set up bandwidth oscillation
#
if {$opt(bwLowLen) && $opt(bwHighLen) && $opt(bwScale)} {
	$ns after $opt(bwHighLen) "bwOscilate 1"
}

#
# Set up reordering
#
if {$opt(reorderLen) && $opt(reorderRate)} {
	ErrorModel set delay_pkt_ true
	ErrorModel set drop_ false
	ErrorModel set delay_ $opt(reorderLen)

#	set errmodelDL [new ErrorModel]
#        $errmodelDL set rate_ $opt(errRateDL)
#        $errmodelDL set unit_ $opt(errUnit)
#        $ns lossmodel $errmodelDL $nodes(bs) $nodes(ms)


	set em [new ErrorModule Fid]
	[$ns link $nodes(bs) $nodes(ms)] errormodule $em
	set errmodel [new ErrorModel/Uniform $opt(reorderRate)]
	$errmodel unit pkt
	$em insert $errmodel
	$em bind $errmodel 0
}

#
# Set up error losses (bursty or uniform)
#
if {$opt(errRateUL)} {
	set errmodelUL [new ErrorModel]
	$errmodelUL set rate_ $opt(errRateUL)
	$errmodelUL set unit_ $opt(errUnit)
	$ns lossmodel $errmodelUL $nodes(ms) $nodes(bs)
	$ns after $opt(errSlotUL) "setError 1 $errmodelUL $opt(errRateUL) $opt(errSlotUL) $opt(errBurstUL)"
}
if {$opt(errRateDL)} {
	set errmodelDL [new ErrorModel]
	$errmodelDL set rate_ $opt(errRateDL)
	$errmodelDL set unit_ $opt(errUnit)
	$ns lossmodel $errmodelDL $nodes(bs) $nodes(ms)
	$ns after $opt(errSlotDL) "setError 1 $errmodelDL $opt(errRateDL) $opt(errSlotDL) $opt(errBurstDL)"
}

## set emL [new ErrorModule Fid]
## set linkL [$ns link $nodes(bs) $nodes(ms)] 
## set errmodelL [new ErrorModel/List]
## $errmodelL droplist {5} 
## $linkL errormodule $emL
## #$emL insert $errmodelL
## #$emL bind $errmodelL 1
	
#
# Set up vertical handover
#
if {$opt(vhoTarget) != "none"} {
	set hoTime $opt(vhoTime)
	$ns after $hoTime makeVho
}	

$ns at $opt(stop) "stop"
$ns run