[ns] -TCP over OBS link question
giovanni sciotti
giobo1984 at hotmail.com
Tue May 20 09:09:46 PDT 2008
this script
# testo TCL per simulare un edge node con vari valori del Tout di burstificazione variando il numero di agent connessi
# al nodo d'ingresso (ingress edge node)
set ns [new Simulator]; #creo un oggetto della classe Simulator
set Bo 2500e6; #Banda Ottica in [bit/s]
set Bserial 1e12; #Banda accesso alla coda elettr in [bit/s]
set Payload [expr 512*128]; #dimensione del payload ottico in [Byte]
set Header 26; #dimensione dell'header del pacchetto ottico in [Byte]
set Timeout 0.003; #Timeout di pacchettizzazione in [sec]
set Wm 128; #dimensione max della finestra di congestione in byte
set p 0.001; #probabilita' di perdita per pacchetto ottico in sec
#(processo Bernoulliano con parametro p)
set rng [new RNG]; #per l'istante casuale di partenza
set casuale "si"
set SIM_TIME 600; #tempo di simulazione
set N 1; # numero sottoreti in ingresso
set M $N; # numero sottoreti in uscita
for {set i 1} {$i <= $N} {incr i} {
set Bf($i) [expr 100e6]; #Bf(i): banda di accesso della i-esima rete
}
set Tp [expr $Payload*8/$Bo]
#-----------------------------------------FILES DI TRACE----------------------------------------------------------------
set nf [open out.nam w]; #apro un file .nam in scrittura per il Network Animator
$ns namtrace-all $nf; #su tale file prendo traccia di tutti gli eventi
set sendrate [open sendrate.tr w]
set tempo [open tempo.tr w]
#set f [open seqno.tr w]; #apro un file .tr in scrittura per il trace degli eventi di simulazione
#$ns trace-all $f; #sul file .tr prendo traccia di tutti gli eventi
#set eventfile [open eventfile.tr w]; #file per il trace degli eventi intesi come cambio di stato dell'Agent TCP
#$ns eventtrace-all $eventfile;
#-----------------------------------------------------------------------------------------------------------------------
#-------------------------------------DEFINIZIONE DEI NODI DELLA RETE---------------------------------------------------
set IWUin_0 [$ns node]; # nodo sul quale creare la IWU d'ingresso
set IWUs_0 [$ns node]; # nodo interno alla IWU
set edge_node_0 [$ns node]; # edge node d'ingresso
set edge_node_1 [$ns node]; # edge node d'uscita
set IWUout_1 [$ns node]; # nodo virtuale per creare la IWU di uscita
#set nodopozzo [$ns node];
#set pozzo [new Agent/LossMonitor]
#$ns attach-agent $nodopozzo $pozzo
#proc record {} {
# global ns nf sendrate tempo pozzo
# set ns [Simulator instance]
# set periodo 0.7
# set bw0 [$pozzo set bytes_ ]
# set ora [$ns now]
# puts $sendrate "[expr $bw0/$periodo*8/1000000]"
# puts $tempo "$ora"
#$pozzo set bytes_ 0
#$ns at [expr $ora+$periodo] "record"
#}
#$ns at 0.0 "record"
#--------------------------------------MODIFICA DEI PARAMETRI DI DEFAULT DI NS------------------------------------------
Agent/TCP set packetSize_ 472; #setto la max dimensione del pacchetto TCP in [Byte]
#(esclusi header IP + TCP = 40 Byte)
Agent/TCP set maxcwnd_ $Wm; #setto la dimensione max della finestra di congestione in segmenti
Agent/TCP set window_ $Wm; #setto la dimensione della finestra di ricezione in segmenti
#(devo avere rwnd_>= cwnd_)
Agent/TCP set rfc2988_ false; #escludo tale algoritmo che vuole un rto minimo di 1 sec
Agent/TCP set minrto_ 0; #il valore di default è 1 sec !!!
#Agent/TCP set minrto_ $RTO
Agent/TCP set tcpTick_ 0.000001; #miglioro la precisione nel calcolo dei tempi
#Agent/TCP set rtxcur_init_ $RTO; #valore iniziale di rto ,[in sec]
Agent/TCP set rttvar_init_ 0; #valore iniziale
#Agent/TCP set srtt_init_ $RTO; #valore iniziale
Agent/TCP set syn_ false; #primo segmento di dati (non e' un syn ,che serve per stabilire la connessione)
Agent/TCP set trace_all_oneline_ true; #per creare un file di trace dell' Agent TCP con tutte le variabili sulla
#stessa linea
Queue set limit_ 300000000000000000; #setto la dimensione max di tutte le code FIFO in pacchetti
#-----------------------------------------------------------------------------------------------------------------------
#settaggio dei parametri del nuovo modulo creato e passati quindi al codice C++ di tale modulo
Queue/SlotGenerator set MaxQueueSize 1000000000000000; #in [Byte]
Queue/SlotGenerator set HeaderSize $Header
Queue/SlotGenerator set PayloadSize $Payload
Queue/SlotGenerator set TimeoutSG $Timeout
Queue/SlotGenerator set Sim_Time $SIM_TIME
Queue/SlotGenerator set OpticalBandwidth $Bo
Queue/SlotGenerator set Scarto [expr [Agent/TCP set packetSize_]+40];
Queue/SlotGenerator set Tot_Byte_Sent 0
Queue/SlotGenerator set SlotGen 0
Queue/SlotGenerator set Tass_Tot 0
Queue/OptSlot_TCP set OpticalDelay 0.005
Queue/OptSlot_TCP set Tp $Tp
Queue/OptSlot_TCP set Teta_Tot 0
Queue/OptSlot_TCP set SlotRec 0
# Colori per i diversi tipi di traffico
#$ns color 1 Red
#$ns color 2 Orange
$ns color 3 Yellow
$ns color 4 Green
$ns color 5 Cyan
$ns color 6 Blue
$ns color 7 Violet
$ns color 8 Black
$ns color 9 Brown
$ns color 10 Tan
#-------------------------------------PARTE IN TRASMISSIONE------------------------------------------------------------
for {set i 1} {$i <= $N} {incr i} {
set s($i) [$ns node]; #s1..sN rete locale in ingresso
set tcp($i) [new Agent/TCP/Sack1]; #creazione dell'agente TCP di tipo Newreno
$tcp($i) set fid_ $i
$tcp($i) set_Bf $Bf($i); #serve per comunicare alla IWUin la velocità
#della linea
set RTO [expr 0.6 + $Timeout + $Payload*8/$Bo + 512*8*2/$Bf($i) + 40*2*8/$Bf($i) + 40*8/$Bo];
#set RTO [expr 0.8 + $Timeout + ($Payload)*8/$Bo + 512*8/$Bf($i) + 40*2*8/$Bf($i) + (40)*8/$Bo];
#set RTO 0.00001;
$tcp($i) set rtxcur_init_ $RTO;
$tcp($i) set srtt_init_ $RTO;
#puts "RTO tcp($i) = $RTO sec"
$ns attach-agent $s($i) $tcp($i); #attacco l'agent TCP al nodo s(i)
$ns at $SIM_TIME "$ns detach-agent $s($i) $tcp($i)"; #stacco l'agent TCP dal nodo all' istante
#di fine simulazione
set app($i) [new Application/Traffic/CBR]; #creazione di una appl CBR a 500MByte/s,
#per tenere l'agent TCP sempre occupato
#$app($i) set rate_ 1mb
$app($i) set packet_size_ 500; #in [Byte]
$app($i) set interval_ 0.000001; #tempo tra un campionamento e l'altro (1 usec)
$app($i) attach-agent $tcp($i); #attacco l'applicazione all'agent TCP
$ns at 0 "$app($i) start";
#$ns at [$rng uniform 0 50] "$app($i) start"; #all'istante casuale parte l'applicazione
$ns at $SIM_TIME "$app($i) stop"; #che si fermera' alla fine della simulazione
#set link_in_A($i) [$ns simplex-link $s($i) $nodopozzo [set Bf($i)]b 100ms DropTail];
#set link_in_R($i) [$ns simplex-link $nodopozzo $s($i) [set Bf($i)]b 100ms DropTail];
#set link_in_A($i) [$ns simplex-link $nodopozzo $IWUin_0 [set Bf($i)]b 100ms DropTail];
#set link_in_R($i) [$ns simplex-link $IWUin_0 $nodopozzo [set Bf($i)]b 100ms DropTail];
set link_in_A($i) [$ns simplex-link $s($i) $IWUin_0 [set Bf($i)]b 0.05ms DropTail];
set link_in_R($i) [$ns simplex-link $IWUin_0 $s($i) [set Bf($i)]b 0.05ms DropTail];
#link s(i) e IWUin_0 (link d'accesso)
#andata e ritorno con:
#B=Bfi ; ritardo=100ms ;
#coda gestita a FIFO
}
#-------------------------------------------PARTE IN RICEZIONE----------------------------------------------------------
for {set i 1} {$i <= $M} {incr i} {
set d($i) [$ns node]; #d1..dN rete locale in uscita
set sink($i) [new Agent/TCPSink/Sack1]
#set sink($i) [new Agent/LossMonitor]
$ns attach-agent $d($i) $sink($i); #attacco sink1 al nodo n5
$ns at $SIM_TIME "$ns detach-agent $d($i) $sink($i)"; #...e lo stacco a fine simulazione
set link_out_A($i) [$ns simplex-link $IWUout_1 $d($i) [set Bf($i)]b 0.05ms DropTail];
set link_out_R($i) [$ns simplex-link $d($i) $IWUout_1 [set Bf($i)]b 0.05ms DropTail];
#link di uscita con B=Bfi,
#ritardo=100ms e code gestite a FIFO
$ns connect $tcp($i) $sink($i); #connetto gli agent
}
#-----------------------------------------------------------------------------------------------------------------------
#for {set i 1} {$i <= $N} {incr i} {
#agente monitor alla coda sul link s(i) IWUin_0 per contare i pacchetti TCP spediti dall'agent TCP
#set queueTCP($i) [$ns monitor-queue $s($i) $IWUin_0 [$ns get-ns-traceall]]
#}
#set queueTCP [$ns monitor-queue $edge_node_0 $edge_node_1 [$ns get-ns-traceall]]
set totric 0
set pozzo1 0
proc record {} {
global ns nf sendrate tempo pozzo queueTCP sendrate sink pozzo1 totric tempo edge_node_0 edge_node_1 N
set ns [Simulator instance]
set periodo 0.700
set pozzo 0
set now [$ns now]
for {set i 1} {$i <= $N} {incr i} {
set ric($i) [$queueTCP($i) set parrivals_]
set totale [expr $pozzo+$ric($i)]
#set ric($i) [$sink($i) set bytes_]
#set totale [expr $pozzo+$ric($i)]
#set ric($i) [$sink($i) set bytes_]
#set totale [expr $pozzo+$ric($i)]
}
puts $sendrate "[expr $totale/$periodo*([Agent/TCP set packetSize_]+40)]"
#puts $sendrate "[expr $totale/$periodo]"
set totric [expr $pozzo1+$totale]
set pozzo1 $totale
puts $tempo "[expr $totric/$now]"
set totale 0
for {set i 1} {$i <= $N} {incr i} {
$queueTCP($i) set parrivals_ 0
#$sink($i) set bytes_ 0
set ric($i) 0
}
$ns at [expr $now+$periodo] "record"
}
$ns at 0.1 "record"
#-----------------------------------------TRACE SUGLI AGENTI TCP---------------------------------------------------------
#for {set i 1} {$i <= $N} {incr i} {
#set TCPtracefile [open TCPtracefile.tr w]
#$ns trace-all $TCPtracefile
#$tcp($i) attach $TCPtracefile; # oppure " $tcp0 attach-trace $TCPtracefile "
#$tcp($i) trace ndatabytes_($i)
# $tcp0 trace ssthresh_
# $tcp($i) trace rtt_($i)
# $tcp0 trace nrexmit_; #number of retransmit timeouts
# $tcp0 trace nrexmitpack_; #number of retransmited packets
# $tcp($i) trace dupacks_($i)
# $tcp0 trace rto_; # che in pratica è t_rtxcur_
# $tcp0 trace rttvar_
# $tcp0 trace srtt_
#
#}
#----------------------------------------DEFINIZIONE DEI LINK-----------------------------------------------------------
#link virtuale tra i nodi IWUin_0 e edge_node_0 con ritardo di propagazione nullo e banda "infinita" per trascurare
#il tempo di trasmissione dello slot ottico tra i due nodi;perche' la IWU fa parte dell' edge node
#con coda sul link di tipo SlotGenerator, che e' il modulo inserito da me
set virtual_link_IWUin_A [$ns simplex-link $IWUs_0 $edge_node_0 9000000000000Mb 0ms SlotGenerator];
#per il ritorno invece uso una politica di tipo FIFO
#set qmon [$ns monitor-queue $IWUin_0 $edge_node_0 [$ns get-ns-traceall] 0.001]
set virtual_link_IWUin_R [$ns simplex-link $edge_node_0 $IWUs_0 9000000000000Mb 0ms DropTail];
#link necessario per ricavare la durata del segmento
set serial_IWUin [$ns duplex-link $IWUin_0 $IWUs_0 [set Bserial]b 0ms DropTail];
#$ns simplex-link-op $IWUin_0 $IWUs_0 queuePos 0.5
#$ns queue-limit $IWUin_0 $IWUs_0 2;
#link ottico a banda ottica Bo = 2.5 Gbit/s ,con ritardo 100ms e code FIFO
set Optical_link_A [$ns simplex-link $edge_node_0 $edge_node_1 [set Bo]b 100ms DropTail]
set Optical_link_R [$ns simplex-link $edge_node_1 $edge_node_0 [set Bo]b 100ms DropTail]
$ns simplex-link-op $edge_node_0 $edge_node_1 queuePos 0.5
#link virtuale dell' edge node di uscita su cui inserire la coda di classe OptSlot_TCP
#(nuovo modulo di uscita definito da me)
set virtual_link_IWUout_A [$ns simplex-link $edge_node_1 $IWUout_1 9000000000000Mb 0ms OptSlot_TCP]
set virtual_link_IWUout_R [$ns simplex-link $IWUout_1 $edge_node_1 9000000000000Mb 0ms DropTail]
#-----------------------------------------------------------------------------------------------------------------------
#----------------------------------MODULO D'ERRORE----------------------------------------------------------------------
#creo un modello di errore di tipo Bernoulliano su pacchetto ottico con parametro p
set loss_module [new ErrorModel]
$loss_module set rate_ $p
$loss_module unit pkt
$loss_module ranvar [new RandomVariable/Uniform]
$loss_module drop-target [new Agent/Null]
#$ns lossmodel $loss_module $edge_node_0 $edge_node_1; #inserisco il modulo d'errore prima della coda
$ns link-lossmodel $loss_module $edge_node_0 $edge_node_1; #inserisco il modulo dopo la coda
#-------------------------------------------------------------------------------
#set queueTCP [$ns monitor-queue $edge_node_0 $edge_node_1 [$ns get-ns-traceall]]
for {set i 1} {$i <= $N} {incr i} {
#agente monitor alla coda sul link s(i) IWUin_0 per contare i pacchetti TCP spediti dall'agent TCP
set queueTCP($i) [$ns monitor-queue $s($i) $IWUin_0 [$ns get-ns-traceall]]
}
for {set i 1} {$i <= $N} {incr i} {
#agente monitor alla coda sul link IWUout_1 d($i) per contare i pacchetti arrivati al client TCP
set queueTCP($i) [$ns monitor-queue $IWUout_1 $d($i) [$ns get-ns-traceall]]
}
$ns at $SIM_TIME "finish"
#PROCEDURA DI CHIUSURA E FINE SIMULAZIONE
proc finish {} {
global ns nf f trace_srtt trace_back trace_sendrate trace_rtt trace_rto trace_cwnd trace_ssthresh trace_seqno N sendrate tempo TCPtracefile;
# f eventfile nf TCPtracefile
$ns flush-trace
close $sendrate
close $tempo
#close $f
#close $nf
#close $TCPtracefile
#close $eventfile
#for {set i 1} {$i <= $N} {incr i} {
#close $trace_sendrate($i)
#}
#exec nam out.nam &
#exec xgraph TCPtracefile.tr-geometry 800x400 &
exit 0
}
#-----------------------------------------------------------------------------------------------------------------------
puts "+-------------------------------------------------------------+"
puts "| Mixed Flow Aggregation |"
puts "+-------------------------------------------------------------+"
puts ""
puts "Riepilogo dati di simulazione - [exec date]"
for {set i 1} {$i <= $N} {incr i} {
puts "Bf($i) = [expr $Bf($i)/1e6] Mbit/s"
}
puts "Dimensione slot = $Payload byte"
puts "Tout = $Timeout sec"
puts "Tp (H incluso) = $Tp sec"
puts "Wm = $Wm seg"
puts "p = $p"
puts "Durata Simulazione = $SIM_TIME sec"
#puts "Partenza casuale = $casuale"
puts "Fine Riepilogo-------------------------------------------------"
$ns run;
_________________________________________________________________
Crea il tuo blog su Spaces, condividi le tue esperienze con il mondo!
http://home.services.spaces.live.com/
More information about the Ns-users
mailing list