开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
http-mult.tcl
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：23k
源码类别：

通讯编程

开发平台：

Visual C++

http-mult.tcl：源码内容
  1. #
  2. # Copyright (c) 1997 Regents of the University of California.
  3. # All rights reserved.
  4. # 
  5. # Redistribution and use in source and binary forms, with or without
  6. # modification, are permitted provided that the following conditions
  7. # are met:
  8. # 1. Redistributions of source code must retain the above copyright
  9. #    notice, this list of conditions and the following disclaimer.
  10. # 2. Redistributions in binary form must reproduce the above copyright
  11. #    notice, this list of conditions and the following disclaimer in the
  12. #    documentation and/or other materials provided with the distribution.
  13. # 3. All advertising materials mentioning features or use of this software
  14. #    must display the following acknowledgement:
  15. #  This product includes software developed by the MASH Research
  16. #  Group at the University of California Berkeley.
  17. # 4. Neither the name of the University nor of the Research Group may be
  18. #    used to endorse or promote products derived from this software without
  19. #    specific prior written permission.
  20. # 
  21. # THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22. # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23. # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24. # ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25. # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26. # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27. # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28. # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29. # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30. # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31. # SUCH DAMAGE.
  32. #
  33. # This file was contributed by Curtis Villamizar <curtis@ans.net>, May 1997.
  34. # Maintainer: John Heidemann <johnh@isi.edu>.
  35. #
  37. #
  38. # WARNING:  This code uses the compatibility library and so should not
  39. # be used as an example.  Hopefully at some time in the future it will
  40. # be updated.
  41. #
  43. #
  44. # Start with the idea of a four node test environment.
  45. #
  46. #  cN -------- ispN -------- nsp1 -------- nsp2 -------- sN
  47. #      28.8kb        1.54mb        44.2mb        1.54mb
  48. #     modemdelay    ispdelay      netdelay      taildelay
  49. #
  50. # Assume there are http N clients c(n) and N servers s(n) and
  51. # each of the clients is served by a different providers isp(n).  The
  52. # delay from the modem is fixes at modemdelay.  There is a random
  53. # delay in the range of zero to ispdelay between the ISP and the
  54. # bottleneck link nsp1-nsp2.  The bottleneck has a delay of netdelay.
  55. # There is also a random delay between the bottleneck link and each
  56. # server in the range of taildelay_lo to taildelay_hi.
  57. #
  59. proc create_testnet {} {
  60.     global testnet flows background
  62.     # use a fixed seed - change if multiple tests needed
  63.     ns-random $testnet(seed)
  65.     set testnet(nsp1) [ns node]
  66.     set testnet(nsp2) [ns node]
  67.     if {$testnet(verbose)} {
  68. puts "ttestnet(nsp1)t$testnet(nsp1)"
  69. puts "ttestnet(nsp2)t$testnet(nsp2)"
  70.     }
  72.     set netlink [ns_duplex $testnet(nsp1) $testnet(nsp2) 
  73.     $testnet(netspeed) $testnet(netdelay) $testnet(netqtype)]
  74.     if {$testnet(netqtype) == "red"} {
  75. set redlink [ns link $testnet(nsp1) $testnet(nsp2)]
  76. $redlink set thresh [expr $testnet(netqueue) * 0.25]
  77. $redlink set maxthresh [expr $testnet(netqueue) * 0.85]
  78. $redlink set q_weight 0.001
  79. $redlink set wait_ 1
  80. $redlink set dropTail_ 1
  81.     } elseif {$testnet(netqtype) == "sfq"} {
  82. set sfqlink [ns link $testnet(nsp1) $testnet(nsp2)]
  83. $sfqlink set limit $testnet(netqueue)
  84. $sfqlink set buckets [expr $testnet(netqueue) >> 2]
  85.     } else {
  86. [lindex $netlink 0] set queue-limit $testnet(netqueue)
  87. [lindex $netlink 1] set queue-limit $testnet(netqueue)
  88.     }
  89.     if {$testnet(quiet) == 0} {
  90. puts [format "creating %d links for clickers" $testnet(clickers)]
  91.     }
  92.     for {set pair 0} {$pair < $testnet(numisp)} {incr pair} {
  93. set ispdelay [format "%dms" 
  94. [expr ( $testnet(ispdelay) * ( [ns-random] >> 16 ) ) >> 16]]
  95. set isp [format "isp%d" $pair]
  96. set testnet($isp) [ns node]
  97. if {$testnet(verbose) != 0} {
  98.     puts "ttestnet(isp=$isp)t$testnet($isp)"
  99. }
  100.     }
  101.     for {set pair 0} {$pair < $testnet(clickers)} {incr pair} {
  102. set client [format "c%d" $pair]
  103. set server [format "s%d" $pair]
  104. set testnet($server) [ns node]
  105. if {$testnet(verbose) != 0} {
  106.     puts "ttestnet(server=$server)t$testnet($isp)"
  107. }
  108. set isp [format "isp%d" [expr $pair % $testnet(numisp)]]
  109. set dest [format "d%d" $pair]
  110. set taildelay [format "%dms" 
  111. [expr $testnet(taildelay_lo) + 
  112. ( ( ( $testnet(taildelay_hi) - $testnet(taildelay_lo) ) 
  113. * ( [ns-random] >> 16 ) ) >> 16 )]]
  114. if {$testnet(doproxy) == 0} {
  115.     set testnet($client) [ns node]
  116.     if {$testnet(verbose) != 0} {
  117. puts "ttestnet(client=$client)t$testnet($client)"
  118.     }
  119.     set modemlink 
  120.     [ns_duplex $testnet($client) $testnet($isp) 
  121.     $testnet(modemspeed) $testnet(modemdelay) 
  122.     $testnet(modemqtype)]
  123.     [lindex $modemlink 0] set queue-limit $testnet(modemqueue)
  124.     [lindex $modemlink 1] set queue-limit $testnet(modemqueue)
  125.     ns_duplex $testnet($isp) $testnet(nsp1) 
  126.     $testnet(ispspeed) $ispdelay $testnet(netqtype)
  127.     set testnet($dest) $testnet($client)
  128. } else {
  129.     # this is a hack - make the isp the actual client
  130.     ns_duplex $testnet($isp) $testnet(nsp1) 
  131.     $testnet(ispspeed) $ispdelay $testnet(netqtype)
  132.     set testnet($dest) $testnet($isp)
  133. }
  134. ns_duplex $testnet(nsp2) $testnet($server) 
  135. $testnet(ispspeed) $taildelay $testnet(netqtype)
  136.     }
  137.     if {$testnet(quiet) == 0} {
  138. puts [format "creating %d links for background" $background(nflows)]
  139.     }
  140.     set ident [expr $testnet(clickers) * (1 + $flows(inlines_needed))]
  141.     for {set pair 0} {$pair < $background(numisp)} {incr pair} {
  142. set client [format "c%d" $ident]
  143. set server [format "s%d" $ident]
  144. set isp [format "isp%d" $ident]
  145. incr ident;
  146. set testnet($client) [ns node]
  147. set testnet($server) [ns node]
  148. if {$testnet(verbose) != 0} {
  149.     puts "ttestnet(client=$client)t$testnet($client)"
  150.     puts "ttestnet(server=$server)t$testnet($server)"
  151. }
  152. set ispdelay [format "%dms" 
  153. [expr ( $testnet(ispdelay) * ( [ns-random] >> 16 ) ) >> 16]]
  154. set taildelay [format "%dms" 
  155. [expr $testnet(taildelay_lo) + 
  156. ( ( ( $testnet(taildelay_hi) - $testnet(taildelay_lo) ) 
  157. * ( [ns-random] >> 16 ) ) >> 16 )]]
  158. if {$testnet(bkgproxy) == 0} {
  159.     set testnet($isp) [ns node]
  160.     if {$testnet(verbose) != 0} {
  161. puts "ttestnet(isp=$isp)t$testnet($isp)"
  162.     }
  163.     set modemlink 
  164.     [ns_duplex $testnet($client) $testnet($isp) 
  165.     $testnet(modemspeed) $testnet(modemdelay) 
  166.     $testnet(modemqtype)]
  167.     [lindex $modemlink 0] set queue-limit $testnet(modemqueue)
  168.     [lindex $modemlink 1] set queue-limit $testnet(modemqueue)
  169.     ns_duplex $testnet($isp) $testnet(nsp1) 
  170.     $testnet(ispspeed) $ispdelay $testnet(netqtype)
  171. } else {
  172.     ns_duplex $testnet($client) $testnet(nsp1) 
  173.     $testnet(ispspeed) $ispdelay $testnet(netqtype)
  174. }
  175. ns_duplex $testnet(nsp2) $testnet($server) 
  176. $testnet(ispspeed) $taildelay $testnet(netqtype)
  177.     }
  178.     if {$testnet(quiet) == 0} {
  179. puts "testnet topology completed"
  180.     }
  181. }
  183. proc trigger { xresults } {
  184.     global testnet flows
  186.     # NEEDSWORK:  should we really indirect once down results like this?
  187.     set results "[lindex $xresults 0]"
  189.     set type [lindex $results 0]
  190.     if { $type != "-" && $type != "d" } {
  191. return;
  192.     }
  193.     set id [lindex $results 7]
  194.     if {$id > $testnet(clickers) * (1 + $flows(inlines_needed))} {
  195. return;
  196.     }
  197.     set counter [format "count%d" $id]
  198.     if { [info exists flows($counter)] } {
  199. incr flows($counter)
  200.     } else {
  201. set flows($counter) 1
  202.     }
  203.     set last last$id
  204.     set flows($last) [ns now]
  205.     if { $type != "-" } {
  206. return;
  207.     }
  208.     set base [expr $id - ( $id % $flows(flows_per) )]
  209.     set got [expr 1 + [lindex $results 10]]
  210.     set isrunning isrunning$id
  211.     if {$flows($isrunning)} {
  212. if { $id == $base } {
  213.     if { $got == $testnet(httpsize) } {
  214. if {$testnet(quiet) == 0} {
  215.     puts [format "http flow completed at %s" 
  216.     [lindex $results 1]]
  217. }
  218. set flows_running [format "flows_running%d" $base]
  219. incr flows($flows_running) -1
  220. incr flows(total_running) -1
  221. set flows($isrunning) 0
  222.     }
  223. } else {
  224.     if { $got == $testnet(inlinesize) } {
  225. if {$testnet(quiet) == 0} {
  226.     puts [format "inline%d completed at %s" 
  227.     $id [lindex $results 1]]
  228. }
  229. set flows_running [format "flows_running%d" $base]
  230. incr flows($flows_running) -1
  231. set inlines_running [format "inlines_running%d" $base]
  232. incr flows($inlines_running) -1
  233. incr flows(total_running) -1
  234. set flows($isrunning) 0
  235.     }
  236. }
  237.     }
  238.     set basecount count$base
  239.     if { $flows($basecount) > 1 } {
  240. set inlines_started [format "inlines_started%d" $base]
  241. set flows_running [format "flows_running%d" $base]
  242. set inlines_running [format "inlines_running%d" $base]
  243. while {$flows($inlines_started) < $flows(inlines_needed) 
  244. && $flows($flows_running) < $flows(flows_allowed) 
  245. && $flows($inlines_running) < $flows(inlines_allowed) } {
  246.     incr flows($inlines_started)
  247.     incr flows($flows_running)
  248.     incr flows($inlines_running)
  249.     incr flows(total_running)
  250.     set ident [expr $base + $flows($inlines_started)]
  251.     set nextflow [format "tcp%d" $ident]
  252.     if {$testnet(quiet) == 0} {
  253. puts [format "at %7.3f start %s : %d running" 
  254. [lindex $results 1] $nextflow $flows(total_running)]
  255.     }
  256.     if {$flows(persist)} {
  257. for {set j $base} {$j < $ident} {incr j} {
  258.     set isrunning isrunning$j
  259.     if {$flows($isrunning) == 0} {
  260. set thisflow flow$ident
  261. set otherflow flow$j
  262. $flows($thisflow) persist $flows($otherflow)
  263. break
  264.     }
  265. }
  266.     }
  267.     $flows($nextflow) start
  268.     incr testnet(needed) $testnet(inlinesize)
  269.     set isrunning isrunning$ident
  270.     set flows($isrunning) 1
  271.     set first first$ident
  272.     set flows($first) [ns now]
  273.     set last last$ident
  274.     set flows($last) flows($first)
  275. }
  276.     }
  277. }
  279. proc openTrace { stopTime testName } {
  280.     exec rm -f out.tr
  281.     set traceFile [open out.tr w]
  282.     ns at $stopTime "stopsource $traceFile $testName"
  283.     set T [ns trace]
  284.     $T attach $traceFile
  285.     return $T
  286. }
  288. proc stopsource { traceFile testName } {
  289.     global flows testnet
  290.     set flows(startnew) 0
  291.     if {$flows(total_running) == 0} {
  292. close $traceFile
  293. finish $testName"
  294.     # "  hack for emacs fontification
  295. exit 0
  296.     } else {
  297. if {$testnet(quiet) == 0} {
  298.     puts [format "at [ns now] %d flows still running" 
  299.     $flows(total_running)]
  300. }
  301. ns at [expr [ns now] + 100] "stopsource $traceFile $testName"
  302.     }
  303. }
  305. proc finish file {
  306.     global testnet flows
  308.     set total 0
  309.     set ident 0
  310.     for {set pair 0} {$pair < $testnet(clickers)} {incr pair} {
  311. set first first$ident
  312. set firstpkt $flows($first)
  313. set lastpkt $firstpkt
  314. set lastimg $firstpkt
  315. for { set i 0 } { $i <= $flows(inlines_needed) } { incr i } {
  316.     set counter [format "count%d" $ident]
  317.     set got $flows($counter)
  318.     incr total $got
  319.     set last last$ident
  320.     set elapsed [expr $flows($last) - $firstpkt]
  321.     if {$testnet(quiet) == 0} {
  322. puts [format "flow %3d %d : %3d packets, elapsed %7.3f" 
  323. $ident $i $got $elapsed]
  324.     }
  325.     if {$flows($last) > $lastpkt} {
  326. set lastpkt $flows($last)
  327.     }
  328.     if {$i <= 1 && $flows($last) > $lastimg} {
  329. set lastimg $flows($last)
  330.     }
  331.     incr ident
  332. }
  333. set elapsed [expr $lastpkt - $firstpkt]
  334. set elapsimg [expr $lastimg - $firstpkt]
  335. if {$testnet(quiet) == 0} {
  336.     puts [format "clicker %3d : elapsed %7.3f %7.3f" 
  337.     $pair $elapsimg $elapsed]
  338. }
  339. set bucket [expr int((10 * $elapsed) + 0.999)]
  340. if {[info exists histogram($bucket)]} {
  341.     incr histogram($bucket)
  342. } else {
  343.     set histogram($bucket) 1
  344. }
  345. set bucket [expr int((10 * $elapsimg) + 0.999)]
  346. if {[info exists histimg($bucket)]} {
  347.     incr histimg($bucket)
  348. } else {
  349.     set histimg($bucket) 1
  350. }
  351.     }
  352.     set needed $testnet(needed)
  353.     set discard [expr $total - $needed]
  354.     puts [format "%d sent : %d needed : %d discarded : %d %%" 
  355.     $total $needed $discard [expr 100 * $discard / $needed]]
  356.     puts "histogram of http plus first image times"
  357.     foreach bucket [lsort -integer [array names histimg]] {
  358. puts [format "1st image  seconds:occurances  %6.1f : %4d" 
  359. [expr 0.1 * $bucket] $histimg($bucket)]
  360.     }
  361.     puts "histogram of complete clicker transfer time"
  362.     foreach bucket [lsort -integer [array names histogram]] {
  363. puts [format "clicker  seconds:occurances  %6.1f : %4d" 
  364. [expr 0.1 * $bucket] $histogram($bucket)]
  365.     }
  366. }
  368. proc init_tcp_flow {size pair ident} {
  369.     global testnet flows
  371.     set taskid [format "tcp%d" $ident ]
  372.     set flowid [format "flow%d" $ident]
  373.     set dest [format "d%d" $pair]
  374.     set server [format "s%d" $pair]
  375.     set flow [ns_create_connection tcp-reno 
  376.     $testnet($server) tcp-sink $testnet($dest) $ident]
  377.     $flow set window $testnet(window)
  378.     $flow set packet-size $testnet(mss)
  379.     $flow set maxcwnd $testnet(window)
  380.     set flows($flowid) $flow 
  381.     set flows($taskid) [$flow source ftp]
  382.     $flows($taskid) set maxpkts_ $size
  383. }
  385. proc setup_http_test {} {
  386.     global testnet flows background
  388.     create_testnet
  390.     set trigger $testnet(starttime)
  391.     for {set pair 0} {$pair < $testnet(clickers)} {incr pair} {
  392. set base [expr $pair * $flows(flows_per)]
  393. set ident $base
  394. set inlines_started [format "inlines_started%d" $base]
  395. set flows_running [format "flows_running%d" $base]
  396. set inlines_running [format "inlines_running%d" $base]
  397. set counter [format "count%d" $ident]
  398. set flows($inlines_started) 0
  399. set flows($flows_running) 0
  400. set flows($inlines_running) 0
  401. init_tcp_flow $testnet(httpsize) $pair $ident
  402. set flows($counter) 0
  403. for { set i 1 } { $i <= $flows(inlines_needed) } { incr i } {
  404.     incr ident
  405.     init_tcp_flow $testnet(inlinesize) $pair $ident
  406. }
  407. ns at $trigger "start_http $base"
  408. set addms [expr ($testnet(clickdelay) * ([ns-random] >> 16)) >> 16]
  409. set trigger [expr $trigger + (0.001 * $addms)]
  411.     }
  412.     set testnet(needed) 0
  413.     set flows(total_running) 0
  415.     set trigger $background(start)
  416.     set offset [expr $testnet(clickers) * (1 + $flows(inlines_needed))]
  417.     for {set pair 0} {$pair < $background(nflows)} {incr pair} {
  418. set ident [expr $offset + ($pair % $background(numisp))]
  419. set client [format "c%d" $ident]
  420. set server [format "s%d" $ident]
  421. set isp [format "isp%d" $ident]
  422. set ident [expr $offset + $pair + 1]
  423. set flow [ns_create_connection tcp-reno 
  424. $testnet($server) tcp-sink $testnet($client) $ident]
  425. $flow set window $background(window)
  426. $flow set packet-size $background(mss)
  427. $flow set maxcwnd $background(window)
  428. set tcp_id [$flow source ftp]
  429. set bkgsize [expr $background(minsize) 
  430. + ((($background(maxsize) - $background(minsize)) 
  431. * ([ns-random] >> 16)) >> 16)]
  432. $tcp_id set maxpkts_ $bkgsize
  433. if {$testnet(quiet) == 0} {
  434.     puts [format "at %7.3f start background flow %d - %d" 
  435.     $trigger $pair $bkgsize]
  436. }
  437. ns at $trigger "$tcp_id start"
  438. set addms [expr ($background(delay) * ([ns-random] >> 16)) >> 16]
  439. set trigger [expr $trigger + (0.001 * $addms)]
  440.     }
  442.     # trace only the NSP bottleneck link
  444.     set traceme [openTrace $testnet(testlimit) test_http]
  445.     set bottleneck [ns link $testnet(nsp2) $testnet(nsp1)]
  446.     $bottleneck trace $traceme
  447.     $bottleneck callback { trigger }
  449.     if {$testnet(gen_map)} {
  450. ns gen-map
  451.     }
  452. }
  454. proc start_http { base } {
  455.     global testnet flows
  457.     set flows_running [format "flows_running%d" $base]
  458.     incr flows($flows_running)
  459.     set flow tcp$base
  460.     if {$testnet(quiet) == 0} {
  461. puts [format "at %7.3f start http%d" [ns now] $base]
  462.     }
  463.     $flows($flow) start
  464.     incr testnet(needed) $testnet(httpsize)
  465.     incr flows(total_running)
  466.     set isrunning isrunning$base
  467.     set flows($isrunning) 1
  468.     set first first$base
  469.     set flows($first) [ns now]
  470.     set last last$base
  471.     set flows($last) flows($first)
  472. }
  474. proc set_globals {} {
  475.     global testnet flows background
  477.     set testnet(starttime) 10.0
  478.     set testnet(netdelay) 35ms
  479.     set testnet(modemdelay) 50ms
  480.     set testnet(ispdelay) 25
  481.     set testnet(taildelay_lo) 1
  482.     set testnet(taildelay_hi) 25
  483.     set testnet(netspeed) 512kb
  484.     set testnet(modemspeed) 28.8kb
  485.     set testnet(ispspeed) 1.54mb
  486.     set testnet(window) 64
  487.     set testnet(mss) 512
  488.     set testnet(httpsize) 6
  489.     set testnet(inlinesize) 40
  490.     set testnet(modemqueue) 24
  491.     set testnet(netqueue) 40
  492.     set testnet(clickers) 10
  493.     set testnet(clickdelay) 500
  494.     set testnet(testlimit) 500.0
  495.     set testnet(quiet) 0
  496.     set testnet(verbose) 1
  497.     set testnet(seed) 1
  498.     set testnet(netqtype) drop-tail
  499.     set testnet(modemqtype) drop-tail
  500.     set testnet(doproxy) 0
  501.     set testnet(bkgproxy) 0
  502.     set testnet(numisp) 2
  503.     set testnet(gen_map) 0
  505.     set flows(inlines_started) 0
  506.     set flows(inlines_needed) 3
  507.     set flows(flows_running) 0
  508.     set flows(flows_allowed) 4
  509.     set flows(inlines_running) 0
  510.     set flows(inlines_allowed) $flows(flows_allowed)
  511.     set flows(flows_per) [expr $flows(inlines_needed) + 1]
  512.     set flows(persist) 0
  514.     set background(nflows) 150
  515.     set background(start) 0.0
  516.     set background(window) 64
  517.     set background(mss) 512
  518.     set background(minsize) 2
  519.     set background(maxsize) 120
  520.     set background(delay) 2000
  521.     set background(numisp) [expr $background(nflows) >> 4]
  522. }
  524. proc process_args {} {
  525.     global argc argv testnet flows background
  527.     for {set i 0} {$i < $argc} {incr i} {
  528. set arg [lindex $argv $i]
  529. switch x$arg {
  530.     x-delayN {
  531. incr i
  532. set testnet(netdelay) [lindex $argv $i]
  533.     }
  534.     x-delayM {
  535. incr i
  536. set testnet(modemdelay) [lindex $argv $i]
  537.     }
  538.     x-delayI {
  539. incr i
  540. set testnet(ispdelay) [lindex $argv $i]
  541.     }
  542.     x-delayTlo {
  543. incr i
  544. set testnet(taildelay_lo) [lindex $argv $i]
  545.     }
  546.     x-delayThi {
  547. incr i
  548. set testnet(taildelay_hi) [lindex $argv $i]
  549.     }
  550.     x-delayT {
  551. incr i
  552. set testnet(taildelay_hi) [lindex $argv $i]
  553. set testnet(taildelay_lo) 0
  554.     }
  555.     x-netspeed {
  556. incr i
  557. set testnet(netspeed) [lindex $argv $i]
  558.     }
  559.     x-ispspeed {
  560. incr i
  561. set testnet(ispspeed) [lindex $argv $i]
  562.     }
  563.     x-modemspeed {
  564. incr i
  565. set testnet(modemspeed) [lindex $argv $i]
  566.     }
  567.     x-window {
  568. incr i
  569. set testnet(window) [lindex $argv $i]
  570. if {$testnet(bkgproxy)} {
  571.     set background(window) [lindex $argv $i]
  572. }
  573.     }
  574.     x-mss {
  575. incr i
  576. set testnet(mss) [lindex $argv $i]
  577.     }
  578.     x-httpsize {
  579. incr i
  580. set testnet(httpsize) [lindex $argv $i]
  581.     }
  582.     x-inlinesize {
  583. incr i
  584. set testnet(inlinesize) [lindex $argv $i]
  585.     }
  586.     x-modemqueue {
  587. incr i
  588. set testnet(modemqueue) [lindex $argv $i]
  589.     }
  590.     x-netqueue {
  591. incr i
  592. set testnet(netqueue) [lindex $argv $i]
  593.     }
  594.     x-testlimit {
  595. incr i
  596. set testnet(testlimit) [lindex $argv $i]
  597.     }
  598.     x-clickers {
  599. incr i
  600. set testnet(clickers) [lindex $argv $i]
  601.     }
  602.     x-clickdelay {
  603. incr i
  604. set testnet(clickdelay) [lindex $argv $i]
  605.     }
  606.     x-inlines {
  607. incr i
  608. set flows(inlines_needed) [lindex $argv $i]
  609.     }
  610.     x-maxflow {
  611. incr i
  612. set flows(flows_allowed) [lindex $argv $i]
  613.     }
  614.     x-maxinline {
  615. incr i
  616. set flows(inlines_allowed) [lindex $argv $i]
  617.     }
  618.     x-bkg-flows {
  619. incr i
  620. set background(nflows) [lindex $argv $i]
  621.     }
  622.     x-bkg-window {
  623. incr i
  624. set background(window) [lindex $argv $i]
  625.     }
  626.     x-bkg-mss {
  627. incr i
  628. set background(mss) [lindex $argv $i]
  629.     }
  630.     x-bkg-minsize {
  631. incr i
  632. set background(minsize) [lindex $argv $i]
  633.     }
  634.     x-bkg-maxsize {
  635. incr i
  636. set background(maxsize) [lindex $argv $i]
  637.     }
  638.     x-bkg-delay {
  639. incr i
  640. set background(delay) [lindex $argv $i]
  641.     }
  642.     x-start {
  643. incr i
  644. set testnet(starttime) [lindex $argv $i]
  645.     }
  646.     x-bkg-start {
  647. incr i
  648. set background(start) [lindex $argv $i]
  649.     }
  650.     x-numisp {
  651. incr i
  652. set testnet(numisp) [lindex $argv $i]
  653.     }
  654.     x-bkgisp {
  655. incr i
  656. set background(numisp) [lindex $argv $i]
  657.     }
  658.     x-seed {
  659. incr i
  660. set testnet(seed) [lindex $argv $i]
  661.     }
  662.     x-modemred {
  663. set testnet(modemqtype) red
  664.     }
  665.     x-netred {
  666. set testnet(netqtype) red
  667.     }
  668.     x-red {
  669. set testnet(netqtype) red
  670. set testnet(modemqtype) red
  671.     }
  672.     x-sfq {
  673. set testnet(netqtype) sfq
  674.     }
  675.     x-proxy {
  676. set testnet(doproxy) 1
  677.     }
  678.     x-bkgproxy {
  679. set testnet(bkgproxy) 1
  680. set background(window) 16
  681.     }
  682.     x-allproxy {
  683. set testnet(doproxy) 1
  684. set testnet(bkgproxy) 1
  685. set background(window) 16
  686.     }
  687.     x-tail {
  688. set testnet(netqtype) drop-tail
  689. set testnet(modemqtype) drop-tail
  690.     }
  691.     x-persist {
  692. set flows(persist) 1
  693.     }
  694.     x-nopersist {
  695. set flows(persist) 0
  696.     }
  697.     x-quiet {
  698. set testnet(quiet) 1
  699.     }
  700.     x-ns-gen-map {
  701. set testnet(gen_map) 1
  702.     }
  703.     default {
  704. puts [format "unrecognized argument: %s" [lindex $argv $i]]
  705. exit 1
  706.     }
  707. }
  708.     }
  709. }
  711. proc report_conditions {} {
  712.     global testnet flows background
  714.     if {$flows(inlines_allowed) > $flows(flows_allowed)} {
  715. set flows(inlines_allowed) $flows(flows_allowed)
  716.     }
  717.     puts [format "delays: net %s, modem %s, isp 0-%dms, tail %d-%dms" 
  718.     $testnet(netdelay) $testnet(modemdelay) $testnet(ispdelay) 
  719.     $testnet(taildelay_lo) $testnet(taildelay_hi)]
  720.     puts [format "link speeds: net %s, modem %s, isp %s" 
  721.     $testnet(netspeed) $testnet(modemspeed) $testnet(ispspeed)]
  722.     puts [format "queues: modem %d, net %d, (isp and tail not congested)" 
  723.     $testnet(modemqueue) $testnet(netqueue)]
  724.     if {$flows(persist)} {
  725. set ispersistant "HTTP 1.1 (persistent)"
  726.     } else {
  727. set ispersistant "pre- HTTP 1.1"
  728.     }
  729.     puts [format "window %d, mss %d, %s, http %d(%d), inline %d(%d)" 
  730.     $testnet(window) $testnet(mss) $ispersistant 
  731.     $testnet(httpsize) [expr $testnet(mss) * $testnet(httpsize)] 
  732.     $testnet(inlinesize) [expr $testnet(mss) * $testnet(inlinesize)]]
  733.     puts [format "sources: %d clickers, spaced 0-%dms, seed for random= %d" 
  734.     $testnet(clickers) $testnet(clickdelay) $testnet(seed)]
  735.     puts [format 
  736.     "%d inlines per page, %d flows per client, %d inlines running" 
  737.     $flows(inlines_needed) $flows(flows_allowed) 
  738.     $flows(inlines_allowed)]
  739.     puts [format 
  740.     "%d bkg flows, window %d, mss %d, size %d-%d pkts, every 0-%dms" 
  741.     $background(nflows) $background(window) $background(mss) 
  742.     $background(minsize) $background(maxsize) $background(delay)]
  743.     puts [format "start bkg at %s, test at %s, run test for %s seconds" 
  744.     $background(start) $testnet(starttime) $testnet(testlimit)]
  745.     if {$testnet(doproxy)} {
  746. set doingproxy "proxy HTTP"
  747.     } else {
  748. set doingproxy "no proxy HTTP"
  749.     }
  750.     if {$testnet(bkgproxy) > 1} {
  751. set dobkgproxy "bkg proxy HTTP"
  752.     } else {
  753. set dobkgproxy "no bkg proxy"
  754.     }
  755.     puts [format "queue: modem= %s, net= %s, %s, %s" 
  756.     $testnet(modemqtype) $testnet(netqtype) $doingproxy $dobkgproxy]
  757. }
  759. set_globals
  760. process_args
  761. report_conditions
  762. setup_http_test
  763. ns run