many_tcp.tcl

跑leach需要的

# Get the number of the node pair
Main instproc get_node_number { client_number } {
        global opts
        if {$opts(node-number) > 0} {
                set node [expr $client_number % $opts(node-number)]
        } else {
                set node $client_number
        }
        return $node
}

# return the client index
Main instproc create_a_client {} {
	global opts
	$self instvar cs_l_ cs_r_ sources_ cs_count_ ns_ rng_

	# Get the client number for the new client.
	set now [$ns_ now]
	set i $cs_count_
	incr cs_count_
	set node $i
	if {[expr $i % 100] == 0} {
		puts "t=[format %.3f $now]: client $i created"
	}

	# Get the source and sink nodes.
	if {$opts(node-number) > 0} {
		if {$node < $opts(node-number) } {
			$self create_client_nodes $node
		} else {
			set node [$self get_node_number $i]
		}
	} else {
		$self create_client_nodes $node
	}
	if {$opts(debug)} {
		# puts "t=[format %.3f $now]: client $i uses node pair $node"
	}
	
	# create sources and sinks in both directions
	# (actually, only one source per connection, for now)
	if {[$rng_ integer 100] < $opts(client-reverse-chance)} {
		set sources_($i) [$ns_ create-connection-list $opts(source-tcp-method) $cs_r_($node) $opts(sink-ack-method) $cs_l_($node) $i]
	} else {
		set sources_($i) [$ns_ create-connection-list $opts(source-tcp-method) $cs_l_($node) $opts(sink-ack-method) $cs_r_($node) $i]
	}
	[lindex $sources_($i) 0] set maxpkts_ 0
	[lindex $sources_($i) 0] set packetSize_ $opts(client-pkt-size)

	# Set up a callback when this client ends.
	[lindex $sources_($i) 0] proc done {} "$self finish_a_client $i"

	if {$opts(debug)} {
		# puts "t=[$ns_ now]: client $i created"
	}

	return $i
}

#
# Make a batch of clients to amortize the cost of routing recomputation
# (actually no longer improtant).
#
Main instproc create_some_clients {} {
	global opts
	$self instvar idle_clients_ ns_ cs_count_

	set now [$ns_ now]
	set step 16
	if {$opts(debug)} {
		puts "t=[format %.3f $now]: creating clients $cs_count_ to [expr $cs_count_ + $step - 1]"
	}

	for {set i 0} {$i < $step} {incr i} {
		lappend idle_clients_ [$self create_a_client]
	}

	# debugging:
	# puts "after client_create:"
	# $ns_ gen-map
	# $self instvar bottle_l_ bottle_r_
	# puts "bottle_l_ classifier_:"
	# [$bottle_l_ set classifier_] dump
	# puts "bottle_r_ classifier_:"
	# [$bottle_r_ set classifier_] dump
}

Main instproc start_a_client {} {
	global opts
	$self instvar idle_clients_ ns_ sources_ rng_ source_start_ source_size_ clients_started_

	set i ""
	set now [$ns_ now]
	# can we reuse a dead client?
	if {![info exists idle_clients_]} {
		set idle_clients_ ""
	}
	while {$idle_clients_ == ""} {
		$self create_some_clients
	}
	set i [lindex $idle_clients_ 0]
	set idle_clients_ [lrange $idle_clients_ 1 end]

	# Reset the connection.
	[lindex $sources_($i) 0] reset
	[lindex $sources_($i) 1] reset 

	# Start traffic for that client.
	if {[$rng_ integer 100] < $opts(client-mouse-chance)} {
		set len $opts(client-mouse-packets)
	} else {
		set len $opts(client-elephant-packets)
	}

	[lindex $sources_($i) 0] advanceby $len
	set source_start_($i) $now
	set source_size_($i) $len

	if {$opts(debug)} {
		 # puts "t=[$ns_ now]: client $i started, ldelay=[format %.6f $ldelay], rdelay=[format %.6f $rdelay]"
		puts "t=[format %.3f $now]: client $i started"
	}
	incr clients_started_
}

Main instproc finish_a_client {i} {
	global opts
	$self instvar ns_ idle_clients_ source_start_ source_size_ clients_finished_

	set now [$ns_ now]
	if {$opts(debug)} {
		set delta [expr $now - $source_start_($i)]
		puts "t=[format %.3f $now]: client $i finished ($source_size_($i) pkts, $delta s)"
	}

	lappend idle_clients_ $i
	incr clients_finished_
}

Main instproc schedule_continuing_traffic {} {
	global opts
	$self instvar ns_ rng_

	$self start_a_client
	# schedule the next one
	set next [expr [$ns_ now]+([$rng_ exponential]/$opts(client-arrival-rate))]
	if {$opts(debug)} {
		# puts "t=[$ns_ now]: next continuing traffic at $next"
	}
	$ns_ at $next "$self schedule_continuing_traffic"
}

Main instproc schedule_initial_traffic {} {
	global opts

	# Start with no pending clients.
	$self instvar idle_clients_

	# Start initial clients.
	for {set i 0} {$i < $opts(initial-client-count)} {incr i} {
		$self start_a_client
	}
}

Main instproc open_trace { stop_time } {
	global opts
	$self instvar ns_ trace_file_ nam_trace_file_ trace_filename_
	set trace_filename_ $opts(trace-filename)
	exec rm -f "$trace_filename_.tr"
	set trace_file_ [open "$trace_filename_.tr" w]
	set stop_actions "close $trace_file_"
	if {$opts(namtrace-some) || $opts(namtrace-all)} {
		exec rm -f "$trace_filename_.nam"
		set nam_trace_file_ [open "$trace_filename_.nam" w]
		set $stop_actions "$stop_actions; close $nam_trace_file_"
	} else {
		set nam_trace_file_ ""
	}
	$ns_ at $stop_time "$stop_actions; $self finish"
	return "$trace_file_ $nam_trace_file_"
}

# There seems to be a problem with the foll function, so quit plotting 
# with -a -q, use just -a.

Main instproc finish {} {
        global opts fmon PERL
	$self instvar trace_filename_ ns_ cs_count_ clients_started_ clients_finished_

	puts "total clients started: $clients_started_"
	puts "total clients finished: $clients_finished_"
	if {$opts(print-drop-rate)} {
		set drops [$fmon set pdrops_]
		set pkts [$fmon set parrivals_]
		puts "total_drops $drops total_packets $pkts"
		set droprate [expr 100.0*$drops / $pkts ]
		puts [format "drop_percentage %7.4f" $droprate]
	}
        if {$opts(trace-filename) != "none"} {
		set title $opts(title)
                set flow_factor 1
                if {$opts(graph-scale) == "2"} {
                        set flow_factor 100
                }
		# Make sure that we run in place even without raw2xg in our path
		# (for the test suites).
		set raw2xg raw2xg
		if [file exists ../../bin/raw2xg] {
			set raw2xg ../../bin/raw2xg
		}
		set raw2xg_opts ""
		if {$opts(graph-join-queueing)} {
			set raw2xg_opts "$raw2xg_opts -q"
		}
		# always run raw2xg because maybe we need the output
		set cmd "$raw2xg -a $raw2xg_opts -n $flow_factor < $trace_filename_.tr >$trace_filename_.xg"
		eval "exec $PERL $cmd"
		if {$opts(graph-results)} {
			if {$opts(graph-join-queueing)} {
				exec xgraph -t $title  < $trace_filename_.xg &
			} else {
				exec xgraph -tk -nl -m -bb -t $title < $trace_filename_.xg &
			}
		}
		if {$opts(test-suite)} {
			exec cp $trace_filename_.xg $opts(test-suite-file)
		}
	#	exec raw2xg -a < out.tr | xgraph -t "$opts(server-tcp-method)" &
	}

	if {$opts(mem-trace)} {
		$ns_ clearMemTrace
	}
	exit 0
}

Main instproc trace_stuff {} {
	global opts

	$self instvar bottle_l_ bottle_r_ ns_ trace_file_ nam_trace_file_
	$self open_trace $opts(duration)

	if {$opts(trace-all)} {
		$ns_ trace-all $trace_file_
	}

	if {$opts(namtrace-all)} {
		$ns_ namtrace-all $nam_trace_file_
	} elseif {$opts(namtrace-some)} {
# xxx
		$bottle_l_ dump-namconfig
		$bottle_r_ dump-namconfig
		[$ns_ link $bottle_l_ $bottle_r_] dump-namconfig
		$ns_ namtrace-queue $bottle_l_ $bottle_r_ $nam_trace_file_
		$ns_ namtrace-queue $bottle_r_ $bottle_l_ $nam_trace_file_
	}

	# regular tracing.
	# trace left-to-right only
       	$ns_ trace-queue $bottle_l_ $bottle_r_ $trace_file_
       	$ns_ trace-queue $bottle_r_ $bottle_l_ $trace_file_
	
	# Currently tracing is somewhat broken because
	# of how the plumbing happens.
}

Main instproc init {av} {
	global opts

	$self process_args $av

	$self instvar ns_ 
	set ns_ [new Simulator]

        # Seed random no. generator; ns-random with arg of 0 heuristically
        # chooses a random number that changes on each invocation.
	$self instvar rng_
	set rng_ [new RNG]
	$rng_ seed $opts(ns-random-seed)
	$rng_ next-random

	$self init_network
	if {$opts(trace-filename) == "none"} {
		$ns_ at $opts(duration) "$self finish"
	} else {
		$self trace_stuff
	}

	# xxx: hack (next line)
#	$self create_some_clients
	$ns_ at 0 "$self schedule_initial_traffic"
	if {$opts(client-arrival-rate) != 0} {
		$ns_ at 0 "$self schedule_continuing_traffic"
	}

	if {$opts(gen-map)} {
		$ns_ gen-map
	}       
	Agent/TCP set syn_ true
	Agent/TCP set delay_growth_ true
	Agent/TCP set windowInit_ 1
	Agent/TCP set windowInitOption_ 1
	if {$opts(init-win) == "0"} {
		Agent/TCP set windowInitOption_ 2
	} elseif {$opts(init-win) == "10"} {
		Agent/TCP set windowInitOption_ 1
		Agent/TCP set windowInit_ 10
	} elseif {$opts(init-win) == "20"} {
		Agent/TCP set windowInitOption_ 1
		Agent/TCP set windowInit_ 20
		puts "init-win 20"
	}
	$ns_ run
}

global in_test_suite
if {![info exists in_test_suite]} {
	global $argv
	new Main $argv
}