[Codel] Codel code
Kathleen Nichols
nichols at pollere.com
Thu Feb 19 16:34:14 EST 2015
I'll reply list in case anyone else is interested. Just delete if you
are fortunate enough to
have nothing to do with ns-2.
First of all, I'm as much a victim of ns-2's tcl as the next person and
secondly, I will
tell you what I remember without looking at the c++ code, but would
recommend
you take a look at that for some of the settings.
The first commented line just shows how you can set stuff on the command
line and what
the different variables are. This particular script is using PackMime to
generate web
traffic though there is also an update of a web script I wrote many
years ago and
CableLabs paid me to update. I also used that for some codel tests. So
this can run
a mix of f ftp connections, w web connections per sec, c constant bit
rate connections
through a bottleneck of b Mbps. Use s to set the file size that the ftps
transfer and if
set to -1 the ftps are infinite, that is don't terminate over the
simulation run. This avoids
lots of slow starts. d is something I used to get the dynamic bandwidth
thing to work,
that is it makes the bottleneck link change periodically (you can see
the plot of this
in the ACM CoDel paper). Reverse ftps are sourced at the opposite end of
the bottleneck
so they create acks in the "forward" direction.
There is a routine called build_cbr and that's where the rate and packet
size for the CBRs is set. This sets dynamic bw to 0 so the bandwidth
doesn't change unless set in the command line to do so. I don't remember
off hand what greedy is. I think it sets one
ftp to be "greedy".
A bunch of this you should try to figure out for yourself by looking at
ns2 documentation
and perhaps at the agent .cc files.
The nominal RTT is what is "expected" and is used as the interval but
the real rtt is what
is actually experienced in the particular experiment. I will use this
opportunity once again
to note that CoDel is actually more sensitive to this parameter than to
target in the sense
that excess drops will happen if the real rtt is longer than the
interval (I keep trying to
explain this but no one hears it.)
Code to set the random seed. Sometimes you want different runs to use
different random
seeds and sometimes you want to run exactly the same scenario.
There's a bunch of parameters to the TCP agents. Some of these are in
ns2 documentation,
but you can find it in the code also.
Just a note that I couldn't get the ns2 TCP/Linux code to work the way
it was supposed to,
specifically the idle() routine never seemed to get called. (This sort
of thing is pretty
common with ns2) and I didn't want to waste a lot of time untangling the
tcl-c++
relationship in ns2. Anyway, so I wrote those tcl procedures to get the
ftps to restart.
I wanted to run more modern TCPs, hence use of the Linux TCP.
The dynamic bandwidth thing changes the bandwidth and preset times. It
does it by multiplying the original bandwidth so I set up an array of
the mulipliers. I'm sure there's
a more elegant way to do it but, at this stage of my life, I have
accepted that I don't do
elegant. I'm more of a "get the job done" kind of coder. And I really
don't like ns2 so I
generally find it works better to just whack it with a hammer rather
than to try to do
something beautifully. Note, as above, that a lot of the stuff in ns2
just doesn't work.
There is code to build up the topology which shouldn't be that hard to
figure out.
Kathie
On 2/18/15 11:19 PM, kanu monga wrote:
> is there anyone who can help me in understanding tcl code of codel(given
> below)
> This one is quite complex for me.
> please help if you can.
> Thanks in advance.
>
> ###################################################################
>
>
> # ns codel.tcl f w c {b}Mb s d r
> # where:
> #f = # ftps
> #w = # PackMime connections per second
> #c = # CBRs
> #b = bottleneck bandwidth in Mbps
> #s = filesize for ftp, -1 for infinite
> #d = dynamic bandwidth, if non-zero, changes (kind of kludgey)
> #have to set the specific change ratios in this file (below)
> #r = number of "reverse" ftps
>
> set stopTime 300
> set ns [new Simulator]
>
> # These are defaults if values not set on command line
>
> set num_ftps 1
> set web_rate 0
> set revftp 0
> set num_cbrs 0
> #rate and packetSize set in build_cbr
> set bottleneck 3Mb
> #for a 10MB ftp
> set filesize 10000000
> set dynamic_bw 0
> set greedy 0
>
> # Parse command line
>
> if {$argc >= 1} {
> set num_ftps [lindex $argv 0]
> if {$argc >= 2} {
> set web_rate [lindex $argv 1]
> if {$argc >= 3} {
> set num_cbrs [lindex $argv 2]
> if {$argc >= 4} {
> set bottleneck [lindex $argv 3]
> if {$argc >= 5} {
> set filesize [lindex $argv 4]
> if {$argc >= 6} {
> set dynamic_bw [lindex $argv 5]
> if {$argc >= 7} {
> set revftp [lindex $argv 6]
> }
> }
> }
> }
> }
> }
> }
>
> set bw [bw_parse $bottleneck]
> if { $revftp >= 1} {
> set num_revs $revftp
> } else {
> set num_revs 0
> }
> puts "ftps $num_ftps webrate $web_rate cbrs $num_cbrs bw $bw filesize
> $filesize reverse $num_revs"
>
> # experiment settings
> set psize 1500
> if { $bw < 1000000} { set psize 500 }
> set nominal_rtt [delay_parse 100ms]
> set accessdly 20
> set bdelay 10
> set realrtt [expr 2*(2*$accessdly + $bdelay)]
> puts "accessdly $accessdly bneckdly $bdelay realrtt $realrtt bneckbw $bw"
>
> # CoDel values
> # interval to keep min over
> set interval [delay_parse 100ms]
> # target in ms.
> set target [delay_parse 5ms]
>
> global defaultRNG
> $defaultRNG seed 0
> ns-random 0
> #$defaultRNG seed 54321
> #ns-random 23145
>
> # ------- config info is all above this line ----------
>
> #bdp in packets, based on the nominal rtt
> set bdp [expr round($bw*$nominal_rtt/(8*$psize))]
>
> Trace set show_tcphdr_ 1
> set startTime 0.0
>
> #TCP parameters - have to set both for FTPs and PackMime
>
> Agent/TCP set window_ [expr $bdp*16]
> Agent/TCP set segsize_ [expr $psize-40]
> Agent/TCP set packetSize_ [expr $psize-40]
> Agent/TCP set windowInit_ 4
> Agent/TCP set segsperack_ 1
> Agent/TCP set timestamps_ true
> set delack 0.4
> Agent/TCP set interval_ $delack
>
> Agent/TCP/FullTcp set window_ [expr $bdp*16]
> Agent/TCP/FullTcp set segsize_ [expr $psize-40]
> Agent/TCP/FullTcp set packetSize_ [expr $psize-40]
> Agent/TCP/FullTcp set windowInit_ 4
> Agent/TCP/FullTcp set segsperack_ 1
> Agent/TCP/FullTcp set timestamps_ true
> Agent/TCP/FullTcp set interval_ $delack
>
>
> Agent/TCP/Linux instproc done {} {
> global ns filesize
> #this doesn't seem to work, had to hack tcp-linux.cc to do repeat ftps
> $self set closed_ 0
> #needs to be delayed by at least .3sec to slow start
> puts "[$ns now] TCP/Linux proc done called"
> $ns at [expr [$ns now] + 0.3] "$self send $filesize"
> }
>
> # problem is that idle() in tcp.cc never seems to get called...
> Application/FTP instproc resume {} {
> puts "called resume"
> global filesize
> $self send $filesize
> #$ns at [expr [$ns now] + 0.5] "[$self agent] reset"
> $ns at [expr [$ns now] + 0.5] "[$self agent] send $filesize"
> }
>
> Application/FTP instproc fire {} {
> global filesize
> $self instvar maxpkts_
> set maxpkts_ $filesize
> [$self agent] set maxpkts_ $filesize
> $self send $maxpkts_
> puts "fire() FTP"
> }
>
> #buffersizes
> set buffersize [expr $bdp]
> set buffersize1 [expr $bdp*10]
>
> Queue/CoDel set target_ $target
> Queue/CoDel set interval_ $interval
>
> #set Flow_id 1
>
> proc build_topology { ns } {
> # nodes n0 and n1 are the server and client side gateways and
> # the link between them is the congested slow link. n0 -> n1
> # handles all the server to client traffic.
> #
> # if the web_rate is non-zero, node n2 will be the packmime server cloud
> # and node n3 will be the client cloud.
> #
> # num_ftps server nodes and client nodes are created for the ftp
> sessions.
> # the first client node is n{2+w} and the first server node is n{2+f+w}
> # where 'f' is num_ftps and 'w' is 1 if web_rate>0 and 0 otherwise.
> # servers will be even numbered nodes, clients odd
> # Warning: the numbering here is ridiculously complicated
>
> global bw bdelay accessdly buffersize buffersize1 filesize node_cnt
> set node_cnt 2
>
> # congested link
> global n0 n1
> set n0 [$ns node]
> set n1 [$ns node]
> $ns duplex-link $n0 $n1 $bw ${bdelay}ms CoDel
> $ns duplex-link-op $n0 $n1 orient right
> $ns duplex-link-op $n0 $n1 queuePos 0.5
> $ns duplex-link-op $n1 $n0 queuePos 1.5
> $ns queue-limit $n0 $n1 $buffersize
> $ns queue-limit $n1 $n0 $buffersize
> set node_cnt 2
>
> #dynamic bandwidth
> # these are the multipliers for changing bw, times initial set bw
> # edit these values to get different patterns
> global stopTime dynamic_bw
> array names bw_changes
> set bw_changes(1) 0.1
> set bw_changes(2) 0.01
> set bw_changes(3) 0.5
> set bw_changes(4) 0.01
> set bw_changes(5) 1.0
>
> puts "bottleneck starts at [[[$ns link $n0 $n1] link] set
> bandwidth_]bps"
> for {set k 1} {$k <= $dynamic_bw} {incr k 1} {
> set changeTime [expr $k*$stopTime/($dynamic_bw+1)]
> set f $bw_changes($k)
> set newBW [expr $f*$bw]
> puts "change at $changeTime to [expr $newBW/1000000.]Mbps"
> $ns at $changeTime "[[$ns link $n0 $n1] link] set bandwidth_ $newBW"
> $ns at $changeTime "[[$ns link $n1 $n0] link] set bandwidth_ $newBW"
> $ns at $changeTime "puts $newBW"
> }
>
> set li_10 [[$ns link $n1 $n0] queue]
> set li_01 [[$ns link $n0 $n1] queue]
>
> set tchan_ [open /tmp/redqvar.tr <http://redqvar.tr> w]
> $li_01 trace curq_
> $li_01 trace d_exp_
> $li_01 attach $tchan_
>
> global num_ftps web_rate num_cbrs greedy num_revs
> set linkbw [expr $bw*10]
>
> set w [expr $web_rate > 0]
> if {$w} {
> global n2 n3
> #server
> set n2 [$ns node]
> $ns duplex-link $n2 $n0 $linkbw ${accessdly}ms DropTail
> $ns queue-limit $n2 $n0 $buffersize1
> $ns queue-limit $n0 $n2 $buffersize1
>
> #client
> set n3 [$ns node]
> $ns duplex-link $n1 $n3 $linkbw ${accessdly}ms DropTail
> $ns queue-limit $n1 $n3 $buffersize1
> $ns queue-limit $n3 $n1 $buffersize1
> set node_cnt 4
> }
> #need to fix the angles if use nam
> for {set k 0} {$k < $num_ftps} {incr k 1} {
> # servers
> set j $node_cnt
> global n$j
> set n$j [$ns node]
> if {$greedy > 0 && $k == 0} {
> $ns duplex-link [set n$j] $n0 $linkbw 1ms DropTail
> } else {
> $ns duplex-link [set n$j] $n0 $linkbw ${accessdly}ms DropTail
> }
> $ns queue-limit [set n$j] $n0 $buffersize1
> $ns queue-limit $n0 [set n$j] $buffersize1
> set angle [expr $num_ftps>1? 0.75+($k-1)*.5/($num_ftps-1) : 1]
> $ns duplex-link-op $n0 [set n$j] orient $angle
> incr node_cnt
>
> # clients
> set j $node_cnt
> global n$j
> set n$j [$ns node]
> set dly [expr ${accessdly} +($k+1)]
> $ns duplex-link $n1 [set n$j] $linkbw ${dly}ms DropTail
> $ns queue-limit $n1 [set n$j] $buffersize1
> $ns queue-limit [set n$j] $n1 $buffersize1
> set angle [expr $num_ftps>1? fmod(2.25-($k-1)*.5/($num_ftps-1),
> 2) : 0]
> $ns duplex-link-op $n1 [set n$j] orient $angle
> incr node_cnt
> }
> for {set k 0} {$k < $num_cbrs} {incr k 1} {
> # servers
> set j $node_cnt
> global n$j
> set n$j [$ns node]
> $ns duplex-link [set n$j] $n0 $linkbw ${accessdly}ms DropTail
> $ns queue-limit [set n$j] $n0 $buffersize1
> $ns queue-limit $n0 [set n$j] $buffersize1
> # set angle [expr $num_cbrs>1? 0.75+($k-1)*.5/($num_cbrs-1) : 1]
> $ns duplex-link-op $n0 [set n$j] orient $angle
> incr node_cnt
>
> # clients
> set j $node_cnt
> global n$j
> set n$j [$ns node]
> $ns duplex-link $n1 [set n$j] $linkbw ${accessdly}ms DropTail
> $ns queue-limit $n1 [set n$j] $buffersize1
> $ns queue-limit [set n$j] $n1 $buffersize1
> # set angle [expr $num_cbrs>1? fmod(2.25-($k-1)*.5/($num_ftps-1),
> 2) : 0]
> $ns duplex-link-op $n1 [set n$j] orient $angle
> incr node_cnt
> }
> #reverse direction ftps
> for {set k 0} {$k < $num_revs} {incr k 1} {
> # clients
> set j $node_cnt
> global n$j
> set n$j [$ns node]
> $ns duplex-link [set n$j] $n0 $linkbw ${accessdly}ms DropTail
> $ns queue-limit [set n$j] $n0 $buffersize1
> $ns queue-limit $n0 [set n$j] $buffersize1
> set angle [expr $num_ftps>1? 0.75+($k-1)*.5/($num_ftps-1) : 1]
> $ns duplex-link-op $n0 [set n$j] orient $angle
> incr node_cnt
>
> # servers
> set j $node_cnt
> global n$j
> set n$j [$ns node]
> set dly [expr ($accessdly)*1.1 +($k+1)]
> $ns duplex-link $n1 [set n$j] $linkbw ${dly}ms DropTail
> $ns queue-limit $n1 [set n$j] $buffersize1
> $ns queue-limit [set n$j] $n1 $buffersize1
> set angle [expr $num_ftps>1? fmod(2.25-($k-1)*.5/($num_ftps-1),
> 2) : 0]
> $ns duplex-link-op $n1 [set n$j] orient $angle
> incr node_cnt
> }
> }
>
> proc build_cbr {cnd snd startTime timeToStop Flow_id} {
> global ns
> set udp [$ns create-connection UDP $snd LossMonitor $cnd $Flow_id]
> set cbr [new Application/Traffic/CBR]
> $cbr attach-agent $udp
> # change these for different types of CBRs
> $cbr set packetSize_ 100
> $cbr set rate_ 0.064Mb
> $ns at $startTime "$cbr start"
> $ns at $timeToStop "$cbr stop"
> }
>
> # cnd is client node, snd is server node
> proc build_ftpclient {cnd snd startTime timeToStop Flow_id} {
>
> global ns filesize greedy revftp
> set ctcp [$ns create-connection TCP/Linux $snd TCPSink/Sack1 $cnd
> $Flow_id]
> $ctcp select_ca cubic
> set ftp [$ctcp attach-app FTP]
> $ftp set enableResume_ true
> $ftp set type_ FTP
>
> #set up a single infinite ftp with smallest RTT
> if {$greedy > 0 || $filesize < 0} {
> $ns at $startTime "$ftp start"
> set greedy 0
> } else {
> $ns at $startTime "$ftp send $filesize"
> }
> $ns at $timeToStop "$ftp stop"
> }
>
> proc build_webs {cnd snd rate startTime timeToStop} {
> set CLIENT 0
> set SERVER 1
>
> # SETUP PACKMIME
> set pm [new PackMimeHTTP]
> $pm set-TCP Sack
> $pm set-client $cnd
> $pm set-server $snd
> $pm set-rate $rate; # new connections per second
> $pm set-http-1.1; # use HTTP/1.1
>
> # create RandomVariables
> set flow_arrive [new RandomVariable/PackMimeHTTPFlowArrive $rate]
> set req_size [new RandomVariable/PackMimeHTTPFileSize $rate $CLIENT]
> set rsp_size [new RandomVariable/PackMimeHTTPFileSize $rate $SERVER]
>
> # assign RNGs to RandomVariables
> $flow_arrive use-rng [new RNG]
> $req_size use-rng [new RNG]
> $rsp_size use-rng [new RNG]
>
> # set PackMime variables
> $pm set-flow_arrive $flow_arrive
> $pm set-req_size $req_size
> $pm set-rsp_size $rsp_size
>
> global ns
> $ns at $startTime "$pm start"
> $ns at $timeToStop "$pm stop"
> }
>
> proc uniform {a b} {
> expr $a + (($b- $a) * ([ns-random]*1.0/0x7fffffff))
> }
>
> proc finish {} {
> global ns
> $ns halt
> $ns flush-trace
> exit 0
> }
>
> # $ns namtrace-all [open out.nam w]
> # $ns color 2 blue
> # $ns color 3 red
> # $ns color 4 yellow
> # $ns color 5 green
>
> build_topology $ns
>
> #$ns trace-queue $n0 $n1 [open out_n0ton1.tr <http://out_n0ton1.tr> w]
> #set fname f${num_ftps}w${web_rate}b${bottleneck}.tr
> set fname f.tr <http://f.tr>
> puts $fname
> $ns trace-queue $n0 $n1 [open /tmp/$fname w]
> #reverse direction
> #$ns trace-queue $n1 $n0 [open /tmp/$fname w]
>
> set node_cnt 2
> if {$web_rate > 0} {
> build_webs $n3 $n2 $web_rate 0 $stopTime
> set node_cnt 4
> }
>
> for {set k 1} {$k <= $num_ftps} {incr k 1} {
> set j $node_cnt
> incr node_cnt
> set i $node_cnt
> build_ftpclient [set n$i] [set n$j] \
> $startTime $stopTime $i
> # [expr 1.0*($k-1)] $stopTime $i
> # [expr $startTime+($k-1)*[uniform 0.0 2.0]] $stopTime $i
> incr node_cnt
> }
>
> for {set k 1} {$k <= $num_cbrs} {incr k 1} {
> set j $node_cnt
> incr node_cnt
> set i $node_cnt
> build_cbr [set n$i] [set n$j] \
> [expr $startTime+($k-1)*[uniform 0.0 2.0]] $stopTime $i
> incr node_cnt
> }
>
> #for reverse direction, give client smaller number
> for {set k 1} {$k <= $num_revs} {incr k 1} {
> set j $node_cnt
> incr node_cnt
> set i $node_cnt
> build_ftpclient [set n$j] [set n$i] $startTime $stopTime $j
> incr node_cnt
> }
>
> $ns at [expr $stopTime ] "finish"
> $ns run
> exit 0
> ###################################################################
>
>
> _______________________________________________
> Codel mailing list
> Codel at lists.bufferbloat.net
> https://lists.bufferbloat.net/listinfo/codel
>
More information about the Codel
mailing list