[Codel] [Reply] tcl code of CoDel (Anjali Chawla)
Mohit P. Tahiliani
tahiliani.nitk at gmail.com
Thu Feb 19 09:18:09 EST 2015
Hi Anjali,
You can test CoDel on wired as well as wireless networks.
CoDel's code is available for Linux, ns-2 and ns-3.
See the following link for more details:
http://www.bufferbloat.net/projects/codel/wiki/Wiki/#Simulations
Hope it helps.
Best Regards,
Mohit P. Tahiliani
On Thu, Feb 19, 2015 at 12:50 PM, <codel-request at lists.bufferbloat.net>
wrote:
> Send Codel mailing list submissions to
> codel at lists.bufferbloat.net
>
> To subscribe or unsubscribe via the World Wide Web, visit
> https://lists.bufferbloat.net/listinfo/codel
> or, via email, send a message with subject or body 'help' to
> codel-request at lists.bufferbloat.net
>
> You can reach the person managing the list at
> codel-owner at lists.bufferbloat.net
>
> When replying, please edit your Subject line so it is more specific
> than "Re: Contents of Codel digest..."
>
>
> Today's Topics:
>
> 1. tcl code of CoDel (Anjali Chawla)
> 2. Codel code (kanu monga)
>
>
> ----------------------------------------------------------------------
>
> Message: 1
> Date: Thu, 19 Feb 2015 11:59:50 +0530
> From: Anjali Chawla <anjaliachawla013 at gmail.com>
> To: codel at lists.bufferbloat.net
> Subject: [Codel] tcl code of CoDel
> Message-ID:
> <CAL6QuG_pujPYrB6r0gcOhyPUgy6SV0gGFCTfsuQ_i35E=
> qYsjQ at mail.gmail.com>
> Content-Type: text/plain; charset="utf-8"
>
> Hi
> i want to know can we test CoDel with wired network???
> or should we go for wireless only???
> anybody please reply because i am new to all this.
> your suggestions can help me in taking one step further.
> Thanks
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <
> https://lists.bufferbloat.net/pipermail/codel/attachments/20150219/5c072359/attachment-0001.html
> >
>
> ------------------------------
>
> Message: 2
> Date: Thu, 19 Feb 2015 12:49:34 +0530
> From: kanu monga <kanumonga013 at gmail.com>
> To: codel at lists.bufferbloat.net
> Subject: [Codel] Codel code
> Message-ID:
> <CAJ0uZqx6aWUTEuHHAn1g--5H3nwQv-mR8GbWD7wubt=
> H0fB3+g at mail.gmail.com>
> Content-Type: text/plain; charset="utf-8"
>
> 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 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 w]
> #set fname f${num_ftps}w${web_rate}b${bottleneck}.tr
> set fname 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
> ###################################################################
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <
> https://lists.bufferbloat.net/pipermail/codel/attachments/20150219/e21c3125/attachment.html
> >
>
> ------------------------------
>
> _______________________________________________
> Codel mailing list
> Codel at lists.bufferbloat.net
> https://lists.bufferbloat.net/listinfo/codel
>
>
> End of Codel Digest, Vol 29, Issue 1
> ************************************
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.bufferbloat.net/pipermail/codel/attachments/20150219/b67e540c/attachment-0002.html>
More information about the Codel
mailing list