[Codel] Codel code

[Codel] Codel code

[kanu monga]

[-- Attachment #1: Type: text/plain, Size: 12694 bytes --]

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
###################################################################

[-- Attachment #2: Type: text/html, Size: 21363 bytes --]

Re: [Codel] Codel code

[Kathleen Nichols]

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@lists.bufferbloat.net
> https://lists.bufferbloat.net/listinfo/codel
> 

Re: [Codel] Codel code

[Dave Taht]

I am fairly happy with the example codel code that is now in the ns3 branch,
which is pure c++, and quite a bit easier to understand than tcl, to my eye.

https://www.nsnam.org/doxygen/codel-vs-droptail-asymmetric_8cc.html

regrettably the fq_codel version for ns3 is still out of tree.