test-suite-mcache.tcl

ns-2的文件包。多多下载

		Http set REQSize_ $opts(client-req-size)
	}
}

# Allow global options to preempt, and derived classes to overwrite.
Test-mcache instproc set-server-type { servertype } {
	$self instvar serverType_ 
	global opts
	if [info exists opts(server)] {
		set serverType_ $opts(server)
	} else {
		set serverType_ $servertype
	}
}

Test-mcache instproc set-cache-type { cachetype } {
	$self instvar cacheType_ 
	global opts
	if [info exists opts(cache)] {
		set cacheType_ $opts(cache)
	} else {
		set cacheType_ $cachetype
	}
}

Test-mcache instproc set-client-type { clienttype } {
	$self instvar clientType_
	global opts
	if [info exists opts(client)] {
		set clientType_ $opts(client)
	} else {
		set clientType_ $clienttype
	}
}

Test-mcache instproc set-pagepool {} {
	$self instvar startTime_ finishTime_ pgp_
	global opts

	# Use PagePool/Media
	set pgp_ [new PagePool/Media]
	# PagePool/Media MUST know the duration of the simulation; it needs
	# the info to set correct page modification time. 
	$pgp_ set-duration $opts(duration)
	# Number of streams
	$pgp_ set-num-pages $opts(num-pages)
	# Page sizes
	# XXX Should be overwritten later
	for {set i 0} {$i < $opts(num-pages)} {incr i} {
		$pgp_ set-pagesize $i $opts(avg-page-size)
	}
	# Layers
	$pgp_ set-layer $opts(obj-layer)

	# Request generator
	set tmp [new RandomVariable/Uniform]
	$tmp set min_ 0
	$tmp set max_ $opts(num-pages)
	$pgp_ ranvar-req $tmp
	
	$pgp_ set-start-time $startTime_
	set finishTime_ [expr $startTime_ + $opts(duration)]
}

Test-mcache instproc set-req-generator { client } {
	$self instvar pgp_ reqRNG_

	global opts
	if ![info exists reqRNG_] {
		set reqRNG_ [new RNG]
		$reqRNG_ seed $opts(ns-random-seed)
	}
	
	switch $opts(req-dist) {
		Poisson {
			set tmp [new RandomVariable/Exponential]
			$tmp set avg_ $opts(avg-req-interval)
		}
		Pareto {
			set tmp [new RandomVariable/Pareto]
			$tmp set avg_ $opts(avg-req-interval)
			$tmp set shape_ $opts(req-rv-shape)
		}
		Uniform {
			set tmp [new RandomVariable/Uniform]
			set opts(min-req-interval) \
				[expr $opts(avg-req-interval)*0.84]
			set opts(max-req-interval) \
				[expr $opts(avg-req-interval)*1.17]
			$tmp set min_ $opts(min-req-interval)
			$tmp set max_ $opts(max-req-interval)
		}
		default {
			puts "Unkown page request distribution $opts(req-dist)"
			exit 1
		}
	}
	$tmp use-rng $reqRNG_
	$client set-interval-generator $tmp
	$client set-page-generator $pgp_
}

Test-mcache instproc flush-trace {} {
	$self instvar log_
	flush $log_
	[Simulator instance] flush-trace
}

Test-mcache instproc create-members {} {
	$self instvar client_ server_ cache_ log_ test_ pgp_ node_ ns_ \
		serverType_ cacheType_ clientType_

	set st $serverType_
	set lt $clientType_
	# We may not have cache
	if [info exists cacheType_] {
		set ct $cacheType_
	}

	global opts
	foreach n [array names node_] {
		set type [string range $n 0 0]
		set num [string range $n 1 end]
		if {$num == ""} {
			set num 0
		}
		switch $type {
			s {
			 set server_($num) [new Http/Server$st $ns_ $node_($n)]
			 if $opts(enable-log) {
				 $server_($num) log $log_
			 }
			 $server_($num) set-page-generator $pgp_
			}
			e {
			 set cache_($num) [new Http/Cache$ct $ns_ $node_($n)]
			 if $opts(enable-log) {
				 $cache_($num) log $log_
			 }
			}
			c {
			  set client_($num) [new Http/Client$lt $ns_ $node_($n)]
			  $self set-req-generator $client_($num)
			  if $opts(enable-log) {
				  $client_($num) log $log_
			  }
			}
		}
	}
}

Test-mcache instproc set-routing {} {
	$self instvar ns_ 
	$ns_ rtproto Session
}

Test-mcache instproc set-members {} {
	$self instvar ns_ finishTime_ startTime_
	$ns_ at $startTime_ "$self start-connection"
}

# Create media contents in servers
Test-mcache instproc populate-server {} {
	$self instvar pgp_ cache_ server_ 
	for {set i 0} {$i < [$pgp_ get-poolsize]} {incr i} {
		set pageid $server_(0):$i
		$server_(0) gen-page $pageid
	}
}

Test-mcache instproc start-connection {} {
	$self instvar ns_

	$self create-members
	$self populate-server
	$self set-connections

	# Let initializations settles down, then start requests
	$ns_ at [expr [$ns_ now] + 10] "$self start-requests"
}

Test-mcache instproc finish {} {
	$self instvar log_
	if [info exists log_] {
		close $log_
	}
	$self next
}



# Transmitting a single stream from a client to a server via a bottleneck 
# 56Kb link. NO quality adaptation
Class Test/media1 -superclass Test-mcache

Test/media1 instproc init {} {
	$self set-defnet 3node

	global opts
	set opts(avg-page-size) 102400
	# Since we are NOT doing QA, must use a single layer!!
	set opts(obj-layer) 1

	$self next

	$self set-server-type /Media
	$self set-client-type /Media
	Http set TRANSPORT_ FullTcp
	Http set MEDIA_TRANSPORT_ RAP
}

Test/media1 instproc set-connections {} {
	$self instvar client_ server_ cache_
	$client_(0) connect $server_(0)
}

Test/media1 instproc start-requests {} {
	$self instvar client_ cache_ server_ ns_
	$client_(0) start-session $server_(0) $server_(0)
}



# Simple test of client/cache/server, no quality adaptation
# Bottleneck link (56Kb) is near the client
Class Test/media2 -superclass Test-mcache

Test/media2 instproc init {} {
	$self set-defnet cache0

	global opts
	set opts(avg-page-size) 4096
	set opts(avg-req-interval) 600
	# Since we are NOT doing QA, must use a single layer!!
	set opts(obj-layer) 1

	$self next

	$self set-server-type /Media
	$self set-client-type /Media
	$self set-cache-type /Media
	Http set TRANSPORT_ FullTcp
	Http set MEDIA_TRANSPORT_ RAP
}

Test/media2 instproc set-connections {} {
	$self instvar client_ server_ cache_
	$client_(0) connect $cache_(0)
	$cache_(0) connect $server_(0)
}

Test/media2 instproc start-requests {} {
	$self instvar client_ cache_ server_ ns_
	$client_(0) start-session $cache_(0) $server_(0)
}


# Simple test of QA, one server, one client, 56Kb bottleneck link
Class Test/media3 -superclass Test-mcache

Test/media3 instproc init {} {
	$self set-defnet 3node

	global opts
	set opts(avg-page-size) 524288
	set opts(avg-req-interval) 2000
	set opts(obj-layer) 4
	set opts(duration) 800

	$self next

	$self set-server-type /Media
	$self set-client-type /Media
	Http set TRANSPORT_ FullTcp
	Http set MEDIA_TRANSPORT_ RAP
	Http set MEDIA_APP_ MediaApp/QA
}

Test/media3 instproc set-connections {} {
	$self instvar client_ server_ cache_
	$client_(0) connect $server_(0)
}

Test/media3 instproc start-requests {} {
	$self instvar client_ server_ ns_
	$client_(0) set-cache $server_(0)
	$client_(0) send-request $server_(0) GET $server_(0):0 
}

# Same as above, but 10Mb bottleneck link (basically high enough to hold
# all 8 layers)
Class Test/media3a -superclass Test/media3

Test/media3a instproc init {} {
	$self set-defnet 2node
	$self next
}


# One server, one cache and one client. 
# 56Kb bottleneck link between client and cache.
Class Test/media4 -superclass Test-mcache

Test/media4 instproc init {} {
	$self set-defnet cache0

	global opts
	set opts(avg-req-interval) 60
	set opts(duration) 400
	# Page size set to 300 seconds
	set opts(avg-page-size) 600000
	set opts(obj-layer) 8

	$self next

	$self set-server-type /Media
	$self set-client-type /Media
	$self set-cache-type /Media
	Http set TRANSPORT_ FullTcp
	Http set MEDIA_TRANSPORT_ RAP
	Http set MEDIA_APP_ MediaApp/QA
}

Test/media4 instproc set-connections {} {
	$self instvar client_ server_ cache_
	$client_(0) connect $cache_(0)
	$cache_(0) connect $server_(0)
}

Test/media4 instproc start-requests {} {
	$self instvar client_ cache_ server_ ns_
	$client_(0) set-cache $cache_(0)

	# First request
	$client_(0) send-request $cache_(0) GET $server_(0):0 

	# 5 additional requests
	set time [$ns_ now]
	for {set i 1} {$i < 15} {incr i} {
		incr time 50
		$ns_ at $time "$client_(0) send-request $cache_(0) GET \
$server_(0):0"
	}
}

# Same as media4, but with 56Kb bottleneck link between server and cache.
#Class Test/media4a -superclass Test/media4

#Test/media4a instproc init {} {
#	$self set-defnet cache1
#	$self next
#}


# Test cache replacement
# Clients with heterogeneous bandwidth to the cache: client0-cache is 1.5Mb,
# client1-cache is 56Kb, cache-server is the same as in media5, 56Kb.
#
# We distribute 95% of the requests to the low-bw client 1
Class Test/media5 -superclass Test-mcache

Test/media5 instproc init {} {
	$self set-defnet 4node-h

	global opts
	set opts(num-pages) 3
	set opts(obj-layer) 8
	set opts(cache-sizefac) 0.4
	set opts(total-requests) 10
	set opts(duration) [expr 50*$opts(total-requests)+50]

	$self next

	$self set-server-type /Media
	$self set-client-type /Media
	$self set-cache-type /Media
	Http set TRANSPORT_ FullTcp
	Http set MEDIA_TRANSPORT_ RAP
	Http set MEDIA_APP_ MediaApp/QA
}

Test/media5 instproc set-pagepool {} {
	$self next

	# Set sizes of the pages
	$self instvar pgp_ ns_
	global opts
	set layer $opts(obj-layer)
	set lbw [Application/MediaApp/QA set LAYERBW_]

	# Uniformly distribute stream lengths
	set rv [new RandomVariable/Uniform]
	$rv set min_ 10
	$rv set max_ 20

	$self instvar totalSize_ log_
	set totalSize_ 0
	for {set i 0} {$i < $opts(num-pages)} {incr i} {
		set tmp [expr int([$rv value]*$layer*$lbw)]
		puts $log_ "# Page $i has size $tmp"
		incr totalSize_ $tmp
		$pgp_ set-pagesize $i $tmp
	}
	delete $rv
}

Test/media5 instproc set-connections {} {
	$self instvar client_ server_ cache_ totalSize_

	# Set cache size to be 
	global opts
	set np $opts(num-pages)
	set layer $opts(obj-layer)
	set lbw [Application/MediaApp/QA set LAYERBW_]
	# Set cache size to be 0.5 times total page size
	$cache_(0) set-cachesize [expr $opts(cache-sizefac) * $totalSize_]

	# Establish connection
	$client_(0) connect $cache_(0)
	$client_(1) connect $cache_(0)
	$cache_(0) connect $server_(0)
}

Test/media5 instproc start-requests {} {
	$self instvar client_ cache_ server_ ns_ log_

	# Client setting parent caches
	$client_(0) set-cache $cache_(0)
	$client_(1) set-cache $cache_(0)

	# Generate non-overlapping request sequence
	global opts
	set np $opts(num-pages)
	set time [$ns_ now]
	set tr $opts(total-requests)

	# Build page popularity table according to total requests and 
	# Zipf's law
	set omega 0
	for {set i 1} {$i <= $np} {incr i} {
		set omega [expr $omega + 1.0/$i]
	}
	set omega [expr 1.0 / $omega]
	# Calculate number of requests for each page
	set j 0
	for {set i 0} {$i < $np} {incr i} {
		set nreq($i) [expr round($omega*$tr/($i+1.0))]
		for {set ii 0} {$ii < $nreq($i)} {incr ii} {
			set tmp1($j) 0	;# Whether this request is occupied
			set tmp2($j) $i ;# which page this request belong to
			incr j
		}
		puts $log_ "# Total $nreq($i) requests for page $i"
	}
	if {$j != $tr} {
		error "Mis-calculated number of requests: this $j orig $tr"
	}
	# Build request sequence, uniform distribution
	set rv [new RandomVariable/Uniform]
	$rv set min_ 0
	$rv set max_ $j
	set i 0
	set time 0
	$self instvar reqlist_
	# Schedule requests, 500s interval should suffice for 56K bottleneck
	# link and 600s stream with 8 layers of 2.5K bw.
	while {$i < $j} {
		set rid [expr int([$rv value])]
		if {$tmp1($rid) != 0} {
			# Already allocated
			continue
		}
		set tmp1($rid) 1
		# Determine client ID
		set cid [$self req2client $tmp2($rid) [$rv value] $j]

		# Instead of scheduling a request right now, let's do it
		# step by step so that scheduler won't complain.
		lappend reqlist_ $cid $tmp2($rid)

		# XXX Interval 500 second. Should adjust it according to 
		# maximum page size
		incr time 50
		incr i
	}
	$self next-request
}

# Get the first request from reqlist_
Test/media5 instproc next-request {} {
	$self instvar server_ cache_ client_ reqlist_ ns_
	set cid [lindex $reqlist_ 0]
	set pagenum [lindex $reqlist_ 1]
	set reqlist_ [lrange $reqlist_ 2 end]

	$client_($cid) send-request $cache_(0) GET $server_(0):$pagenum

	# Do our next request 50 seconds later
	if {[llength $reqlist_] > 0} {
		# If we still have more requests, continue
		$ns_ at [expr [$ns_ now] + 50] "$self next-request"
	}
}

# Use a random number and the upper bound of the random number to 
# decide whether the request goes to client 0 or 1
Test/media5 instproc req2client { pagenum ran max } {
	# Most requests go to the low-bw client
	set thresh [expr $max * 0.95]
	if {$ran > $thresh} {
		return 0
	} else {
		return 1
	}
}

# 95% requests go to the high-bw client
#Class Test/media5a -superclass Test/media5 

#Test/media5a instproc req2client { pagenum ran max } {
#	# Distribute 95% requests of all pages to the high-bw client, 
#	# and 5% to the low-bw client
#	set thresh [expr $max*0.05]
#	if {$ran > $thresh} {
#		return 0
#	} else {
#		return 1
#	}
#}

# 50:50 distribution among 2 clients
#Class Test/media5b -superclass Test/media5
#
#Test/media5b instproc req2client { pagenum ran max } {
#	# Uniformly distribute requests of all pages
#	set thresh [expr $max*0.5]
#	if {$ran > $thresh} {
#		return 0
#	} else {
#		return 1
#	}
#}


# Configurations
global raw_opt_info
set raw_opt_info {
	# Random number seed; default is 0, so ns will give a 
	# diff. one on each invocation.
	# XXX Get a "good" seed from predef_seeds[] in rng.cc
	ns-random-seed 188312339
		
	# Animation options; complete traces are useful
	# for nam only, so do those only when a tracefile
	# is being used for nam
	enable-log 1
	duration 500

	# Packet size configurations
	cache-ims-size	50
	cache-ref-size	50
	server-inv-size	43
	client-req-size 43

	# request intervals
	avg-req-interval 1000
	req-dist Poisson

	# Cache size factor, i.e., what % of the total stream size
	cache-sizefac 0.5
	# Object layers
	obj-layer 8
	# One media stream takes 5 layers, and 512K in total
	avg-page-size 512000
	# Number of pages 
	num-pages 1
	# Total number of requests
	total-requests 10
}


#----------------------------------------------------------------------
# Execution starts...
#----------------------------------------------------------------------
run